pdmnetinline.h@ 34801

Last change on this file since 34801 was 33540, checked in by vboxsync, 14 years ago
*: spelling fixes, thanks Timeless!
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 25.7 KB

Line
1	/* $Id: pdmnetinline.h 33540 2010-10-28 09:27:05Z vboxsync $ */
2	/** @file
3	* PDM - Networking Helpers, Inlined Code. (DEV,++)
4	*
5	* This is all inlined because it's too tedious to create 2-3 libraries to
6	* contain it all (same bad excuse as for intnetinline.h).
7	*/
8
9	/*
10	* Copyright (C) 2010 Oracle Corporation
11	*
12	* This file is part of VirtualBox Open Source Edition (OSE), as
13	* available from http://www.virtualbox.org. This file is free software;
14	* you can redistribute it and/or modify it under the terms of the GNU
15	* General Public License (GPL) as published by the Free Software
16	* Foundation, in version 2 as it comes in the "COPYING" file of the
17	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
18	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
19	*
20	* The contents of this file may alternatively be used under the terms
21	* of the Common Development and Distribution License Version 1.0
22	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
23	* VirtualBox OSE distribution, in which case the provisions of the
24	* CDDL are applicable instead of those of the GPL.
25	*
26	* You may elect to license modified versions of this file under the
27	* terms and conditions of either the GPL or the CDDL or both.
28	*/
29
30
31	/*******************************************************************************
32	* Header Files *
33	*******************************************************************************/
34	#include <VBox/log.h>
35	#include <VBox/types.h>
36	#include <iprt/asm.h>
37	#include <iprt/assert.h>
38	#include <iprt/net.h>
39	#include <iprt/string.h>
40
41
42	/**
43	* Checksum type.
44	*/
45	typedef enum PDMNETCSUMTYPE
46	{
47	/** No checksum. */
48	PDMNETCSUMTYPE_NONE = 0,
49	/** Normal TCP checksum. */
50	PDMNETCSUMTYPE_COMPLETE,
51	/** Checksum on pseudo header (used with GSO). */
52	PDMNETCSUMTYPE_PSEUDO,
53	/** The usual 32-bit hack. */
54	PDMNETCSUMTYPE_32_BIT_HACK = 0x7fffffff
55	} PDMNETCSUMTYPE;
56
57
58	/**
59	* Validates the GSO context.
60	*
61	* @returns true if valid, false if not (not asserted or logged).
62	* @param pGso The GSO context.
63	* @param cbGsoMax The max size of the GSO context.
64	* @param cbFrame The max size of the GSO frame (use to validate
65	* the MSS).
66	*/
67	DECLINLINE(bool) PDMNetGsoIsValid(PCPDMNETWORKGSO pGso, size_t cbGsoMax, size_t cbFrame)
68	{
69	PDMNETWORKGSOTYPE enmType;
70
71	if (RT_UNLIKELY(cbGsoMax < sizeof(*pGso)))
72	return false;
73
74	enmType = (PDMNETWORKGSOTYPE)pGso->u8Type;
75	if (RT_UNLIKELY( enmType <= PDMNETWORKGSOTYPE_INVALID \|\| enmType >= PDMNETWORKGSOTYPE_END ))
76	return false;
77
78	/* all types requires both headers. */
79	if (RT_UNLIKELY( pGso->offHdr1 < sizeof(RTNETETHERHDR) ))
80	return false;
81	if (RT_UNLIKELY( pGso->offHdr2 <= pGso->offHdr1 ))
82	return false;
83	if (RT_UNLIKELY( pGso->cbHdrs <= pGso->offHdr2 ))
84	return false;
85
86	/* min size of the 1st header(s). */
87	switch (enmType)
88	{
89	case PDMNETWORKGSOTYPE_IPV4_TCP:
90	case PDMNETWORKGSOTYPE_IPV4_UDP:
91	if (RT_UNLIKELY( (unsigned)pGso->offHdr2 - pGso->offHdr1 < RTNETIPV4_MIN_LEN ))
92	return false;
93	break;
94	case PDMNETWORKGSOTYPE_IPV6_TCP:
95	case PDMNETWORKGSOTYPE_IPV6_UDP:
96	if (RT_UNLIKELY( (unsigned)pGso->offHdr2 - pGso->offHdr1 < RTNETIPV6_MIN_LEN ))
97	return false;
98	break;
99	case PDMNETWORKGSOTYPE_IPV4_IPV6_TCP:
100	case PDMNETWORKGSOTYPE_IPV4_IPV6_UDP:
101	if (RT_UNLIKELY( (unsigned)pGso->offHdr2 - pGso->offHdr1 < RTNETIPV4_MIN_LEN + RTNETIPV6_MIN_LEN ))
102	return false;
103	break;
104	case PDMNETWORKGSOTYPE_INVALID:
105	case PDMNETWORKGSOTYPE_END:
106	break;
107	/* no default case! want gcc warnings. */
108	}
109
110	/* min size of the 2nd header. */
111	switch (enmType)
112	{
113	case PDMNETWORKGSOTYPE_IPV4_TCP:
114	case PDMNETWORKGSOTYPE_IPV6_TCP:
115	case PDMNETWORKGSOTYPE_IPV4_IPV6_TCP:
116	if (RT_UNLIKELY( (unsigned)pGso->cbHdrs - pGso->offHdr2 < RTNETTCP_MIN_LEN ))
117	return false;
118	break;
119	case PDMNETWORKGSOTYPE_IPV4_UDP:
120	case PDMNETWORKGSOTYPE_IPV6_UDP:
121	case PDMNETWORKGSOTYPE_IPV4_IPV6_UDP:
122	if (RT_UNLIKELY( (unsigned)pGso->cbHdrs - pGso->offHdr2 < RTNETUDP_MIN_LEN ))
123	return false;
124	break;
125	case PDMNETWORKGSOTYPE_INVALID:
126	case PDMNETWORKGSOTYPE_END:
127	break;
128	/* no default case! want gcc warnings. */
129	}
130
131	/* There must be at more than one segment. */
132	if (RT_UNLIKELY( cbFrame <= pGso->cbHdrs ))
133	return false;
134	if (RT_UNLIKELY( cbFrame - pGso->cbHdrs < pGso->cbMaxSeg ))
135	return false;
136
137	return true;
138	}
139
140
141	/**
142	* Calculates the number of segments a GSO frame will be segmented into.
143	*
144	* @returns Segment count.
145	* @param pGso The GSO context.
146	* @param cbFrame The GSO frame size (header proto + payload).
147	*/
148	DECLINLINE(uint32_t) PDMNetGsoCalcSegmentCount(PCPDMNETWORKGSO pGso, size_t cbFrame)
149	{
150	size_t cbPayload;
151	Assert(PDMNetGsoIsValid(pGso, sizeof(*pGso), cbFrame));
152	cbPayload = cbFrame - pGso->cbHdrs;
153	return (uint32_t)((cbPayload + pGso->cbMaxSeg - 1) / pGso->cbMaxSeg);
154	}
155
156
157	/**
158	* Used to find the IPv6 header when handling 4to6 tunneling.
159	*
160	* @returns Offset of the IPv6 header.
161	* @param pbSegHdrs The headers / frame start.
162	* @param offIpHdr The offset of the IPv4 header.
163	*/
164	DECLINLINE(uint8_t) pgmNetGsoCalcIpv6Offset(uint8_t *pbSegHdrs, uint8_t offIPv4Hdr)
165	{
166	PCRTNETIPV4 pIPv4Hdr = (PCRTNETIPV4)&pbSegHdrs[offIPv4Hdr];
167	return offIPv4Hdr + pIPv4Hdr->ip_hl * 4;
168	}
169
170
171	/**
172	* Update an UDP header after carving out a segment
173	*
174	* @param u32PseudoSum The pseudo checksum.
175	* @param pbSegHdrs Pointer to the header bytes / frame start.
176	* @param offUdpHdr The offset into @a pbSegHdrs of the UDP header.
177	* @param pbPayload Pointer to the payload bytes.
178	* @param cbPayload The amount of payload.
179	* @param cbHdrs The size of all the headers.
180	* @param enmCsumType Whether to checksum the payload, the pseudo
181	* header or nothing.
182	* @internal
183	*/
184	DECLINLINE(void) pdmNetGsoUpdateUdpHdr(uint32_t u32PseudoSum, uint8_t *pbSegHdrs, uint8_t offUdpHdr,
185	uint8_t const *pbPayload, uint32_t cbPayload, uint8_t cbHdrs,
186	PDMNETCSUMTYPE enmCsumType)
187	{
188	PRTNETUDP pUdpHdr = (PRTNETUDP)&pbSegHdrs[offUdpHdr];
189	pUdpHdr->uh_ulen = cbPayload + cbHdrs - offUdpHdr;
190	switch (enmCsumType)
191	{
192	case PDMNETCSUMTYPE_NONE:
193	pUdpHdr->uh_sum = 0;
194	break;
195	case PDMNETCSUMTYPE_COMPLETE:
196	pUdpHdr->uh_sum = RTNetUDPChecksum(u32PseudoSum, pUdpHdr);
197	break;
198	case PDMNETCSUMTYPE_PSEUDO:
199	pUdpHdr->uh_sum = ~RTNetIPv4FinalizeChecksum(u32PseudoSum);
200	break;
201	default:
202	AssertFailed();
203	break;
204	}
205	}
206
207
208	/**
209	* Update a TCP header after carving out a segment.
210	*
211	* @param u32PseudoSum The pseudo checksum.
212	* @param pbSegHdrs Pointer to the header bytes / frame start.
213	* @param offTcpHdr The offset into @a pbSegHdrs of the TCP header.
214	* @param pbPayload Pointer to the payload bytes.
215	* @param cbPayload The amount of payload.
216	* @param offPayload The offset into the payload that we're splitting
217	* up. We're ASSUMING that the payload follows
218	* immediately after the TCP header w/ options.
219	* @param cbHdrs The size of all the headers.
220	* @param fLastSeg Set if this is the last segment.
221	* @param enmCsumType Whether to checksum the payload, the pseudo
222	* header or nothing.
223	* @internal
224	*/
225	DECLINLINE(void) pdmNetGsoUpdateTcpHdr(uint32_t u32PseudoSum, uint8_t *pbSegHdrs, uint8_t offTcpHdr,
226	uint8_t const *pbPayload, uint32_t cbPayload, uint32_t offPayload, uint8_t cbHdrs,
227	bool fLastSeg, PDMNETCSUMTYPE enmCsumType)
228	{
229	PRTNETTCP pTcpHdr = (PRTNETTCP)&pbSegHdrs[offTcpHdr];
230	pTcpHdr->th_seq = RT_H2N_U32(RT_N2H_U32(pTcpHdr->th_seq) + offPayload);
231	if (!fLastSeg)
232	pTcpHdr->th_flags &= ~(RTNETTCP_F_FIN \| RTNETTCP_F_PSH);
233	switch (enmCsumType)
234	{
235	case PDMNETCSUMTYPE_NONE:
236	pTcpHdr->th_sum = 0;
237	break;
238	case PDMNETCSUMTYPE_COMPLETE:
239	pTcpHdr->th_sum = RTNetTCPChecksum(u32PseudoSum, pTcpHdr, pbPayload, cbPayload);
240	break;
241	case PDMNETCSUMTYPE_PSEUDO:
242	pTcpHdr->th_sum = ~RTNetIPv4FinalizeChecksum(u32PseudoSum);
243	break;
244	default:
245	AssertFailed();
246	break;
247	}
248	}
249
250
251	/**
252	* Updates a IPv6 header after carving out a segment.
253	*
254	* @returns 32-bit intermediary checksum value for the pseudo header.
255	* @param pbSegHdrs Pointer to the header bytes.
256	* @param offIpHdr The offset into @a pbSegHdrs of the IP header.
257	* @param cbSegPayload The amount of segmented payload. Not to be
258	* confused with the IP payload.
259	* @param cbHdrs The size of all the headers.
260	* @param offPktHdr Offset of the protocol packet header. For the
261	* pseudo header checksum calulation.
262	* @param bProtocol The protocol type. For the pseudo header.
263	* @internal
264	*/
265	DECLINLINE(uint32_t) pdmNetGsoUpdateIPv6Hdr(uint8_t *pbSegHdrs, uint8_t offIpHdr, uint32_t cbSegPayload, uint8_t cbHdrs,
266	uint8_t offPktHdr, uint8_t bProtocol)
267	{
268	PRTNETIPV6 pIpHdr = (PRTNETIPV6)&pbSegHdrs[offIpHdr];
269	uint16_t cbPayload = (uint16_t)(cbHdrs - (offIpHdr + sizeof(RTNETIPV6)) + cbSegPayload);
270	pIpHdr->ip6_plen = RT_H2N_U16(cbPayload);
271	return RTNetIPv6PseudoChecksumEx(pIpHdr, bProtocol, (uint16_t)(cbHdrs - offPktHdr + cbSegPayload));
272	}
273
274
275	/**
276	* Updates a IPv4 header after carving out a segment.
277	*
278	* @returns 32-bit intermediary checksum value for the pseudo header.
279	* @param pbSegHdrs Pointer to the header bytes.
280	* @param offIpHdr The offset into @a pbSegHdrs of the IP header.
281	* @param cbSegPayload The amount of segmented payload.
282	* @param iSeg The segment index.
283	* @param cbHdrs The size of all the headers.
284	* @internal
285	*/
286	DECLINLINE(uint32_t) pdmNetGsoUpdateIPv4Hdr(uint8_t *pbSegHdrs, uint8_t offIpHdr, uint32_t cbSegPayload,
287	uint32_t iSeg, uint8_t cbHdrs)
288	{
289	PRTNETIPV4 pIpHdr = (PRTNETIPV4)&pbSegHdrs[offIpHdr];
290	pIpHdr->ip_len = RT_H2N_U16(cbHdrs - offIpHdr + cbSegPayload);
291	pIpHdr->ip_id = RT_H2N_U16(RT_N2H_U16(pIpHdr->ip_id) + iSeg);
292	pIpHdr->ip_sum = RTNetIPv4HdrChecksum(pIpHdr);
293	return RTNetIPv4PseudoChecksum(pIpHdr);
294	}
295
296
297	/**
298	* Carves out the specified segment in a destructive manner.
299	*
300	* This is for sequentially carving out segments and pushing them along for
301	* processing or sending. To avoid allocating a temporary buffer for
302	* constructing the segment in, we trash the previous frame by putting the
303	* header at the end of it.
304	*
305	* @returns Pointer to the segment frame that we've carved out.
306	* @param pGso The GSO context data.
307	* @param pbFrame Pointer to the GSO frame.
308	* @param cbFrame The size of the GSO frame.
309	* @param pbHdrScatch Pointer to a pGso->cbHdrs sized area where we
310	* can save the original header prototypes on the
311	* first call (@a iSeg is 0) and retrieve it on
312	* susequent calls. (Just use a 256 bytes
313	* buffer to make life easy.)
314	* @param iSeg The segment that we're carving out (0-based).
315	* @param cSegs The number of segments in the GSO frame. Use
316	* PDMNetGsoCalcSegmentCount to find this.
317	* @param pcbSegFrame Where to return the size of the returned segment
318	* frame.
319	*/
320	DECLINLINE(void ) PDMNetGsoCarveSegmentQD(PCPDMNETWORKGSO pGso, uint8_t pbFrame, size_t cbFrame, uint8_t *pbHdrScatch,
321	uint32_t iSeg, uint32_t cSegs, uint32_t *pcbSegFrame)
322	{
323	/*
324	* Figure out where the payload is and where the header starts before we
325	* do the protocol specific carving.
326	*/
327	uint8_t * const pbSegHdrs = pbFrame + pGso->cbMaxSeg * iSeg;
328	uint8_t * const pbSegPayload = pbSegHdrs + pGso->cbHdrs;
329	uint32_t const cbSegPayload = iSeg + 1 != cSegs
330	? pGso->cbMaxSeg
331	: (uint32_t)(cbFrame - iSeg * pGso->cbMaxSeg - pGso->cbHdrs);
332	uint32_t const cbSegFrame = cbSegPayload + pGso->cbHdrs;
333
334	/*
335	* Check assumptions (doing it after declaring the variables because of C).
336	*/
337	Assert(iSeg < cSegs);
338	Assert(cSegs == PDMNetGsoCalcSegmentCount(pGso, cbFrame));
339	Assert(PDMNetGsoIsValid(pGso, sizeof(*pGso), cbFrame));
340
341	/*
342	* Copy the header and do the protocol specific massaging of it.
343	*/
344	if (iSeg != 0)
345	memcpy(pbSegHdrs, pbHdrScatch, pGso->cbHdrs);
346	else
347	memcpy(pbHdrScatch, pbSegHdrs, pGso->cbHdrs);
348
349	switch ((PDMNETWORKGSOTYPE)pGso->u8Type)
350	{
351	case PDMNETWORKGSOTYPE_IPV4_TCP:
352	pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs),
353	pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, iSeg * pGso->cbMaxSeg,
354	pGso->cbHdrs, iSeg + 1 == cSegs, PDMNETCSUMTYPE_COMPLETE);
355	break;
356	case PDMNETWORKGSOTYPE_IPV4_UDP:
357	pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs),
358	pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, pGso->cbHdrs, PDMNETCSUMTYPE_COMPLETE);
359	break;
360	case PDMNETWORKGSOTYPE_IPV6_TCP:
361	pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, pGso->cbHdrs,
362	pGso->offHdr2, RTNETIPV4_PROT_TCP),
363	pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, iSeg * pGso->cbMaxSeg,
364	pGso->cbHdrs, iSeg + 1 == cSegs, PDMNETCSUMTYPE_COMPLETE);
365	break;
366	case PDMNETWORKGSOTYPE_IPV6_UDP:
367	pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, pGso->cbHdrs,
368	pGso->offHdr2, RTNETIPV4_PROT_UDP),
369	pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, pGso->cbHdrs, PDMNETCSUMTYPE_COMPLETE);
370	break;
371	case PDMNETWORKGSOTYPE_IPV4_IPV6_TCP:
372	pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs);
373	pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pgmNetGsoCalcIpv6Offset(pbSegHdrs, pGso->offHdr1),
374	cbSegPayload, pGso->cbHdrs, pGso->offHdr2, RTNETIPV4_PROT_TCP),
375	pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, iSeg * pGso->cbMaxSeg,
376	pGso->cbHdrs, iSeg + 1 == cSegs, PDMNETCSUMTYPE_COMPLETE);
377	break;
378	case PDMNETWORKGSOTYPE_IPV4_IPV6_UDP:
379	pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs);
380	pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pgmNetGsoCalcIpv6Offset(pbSegHdrs, pGso->offHdr1),
381	cbSegPayload, pGso->cbHdrs, pGso->offHdr2, RTNETIPV4_PROT_UDP),
382	pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, pGso->cbHdrs, PDMNETCSUMTYPE_COMPLETE);
383	break;
384	case PDMNETWORKGSOTYPE_INVALID:
385	case PDMNETWORKGSOTYPE_END:
386	/* no default! wnat gcc warnings. */
387	break;
388	}
389
390	*pcbSegFrame = cbSegFrame;
391	return pbSegHdrs;
392	}
393
394
395	/**
396	* Carves out the specified segment in a non-destructive manner.
397	*
398	* The segment headers and segment payload is kept separate here. The GSO frame
399	* is still expected to be one linear chunk of data, but we don't modify any of
400	* it.
401	*
402	* @returns The offset into the GSO frame of the payload.
403	* @param pGso The GSO context data.
404	* @param pbFrame Pointer to the GSO frame. Used for retrieving
405	* the header prototype and for checksumming the
406	* payload. The buffer is not modified.
407	* @param cbFrame The size of the GSO frame.
408	* @param iSeg The segment that we're carving out (0-based).
409	* @param cSegs The number of segments in the GSO frame. Use
410	* PDMNetGsoCalcSegmentCount to find this.
411	* @param pbSegHdrs Where to return the headers for the segment
412	* that's been carved out. The buffer must be at
413	* least pGso->cbHdrs in size, using a 256 byte
414	* buffer is a recommended simplification.
415	* @param pcbSegPayload Where to return the size of the returned
416	* segment payload.
417	*/
418	DECLINLINE(uint32_t) PDMNetGsoCarveSegment(PCPDMNETWORKGSO pGso, const uint8_t *pbFrame, size_t cbFrame,
419	uint32_t iSeg, uint32_t cSegs, uint8_t pbSegHdrs, uint32_t pcbSegPayload)
420	{
421	/*
422	* Figure out where the payload is and where the header starts before we
423	* do the protocol specific carving.
424	*/
425	uint8_t const * const pbSegPayload = pbFrame + pGso->cbHdrs + iSeg * pGso->cbMaxSeg;
426	uint32_t const cbSegPayload = iSeg + 1 != cSegs
427	? pGso->cbMaxSeg
428	: (uint32_t)(cbFrame - iSeg * pGso->cbMaxSeg - pGso->cbHdrs);
429
430	/*
431	* Check assumptions (doing it after declaring the variables because of C).
432	*/
433	Assert(iSeg < cSegs);
434	Assert(cSegs == PDMNetGsoCalcSegmentCount(pGso, cbFrame));
435	Assert(PDMNetGsoIsValid(pGso, sizeof(*pGso), cbFrame));
436
437	/*
438	* Copy the header and do the protocol specific massaging of it.
439	*/
440	memcpy(pbSegHdrs, pbFrame, pGso->cbHdrs);
441
442	switch ((PDMNETWORKGSOTYPE)pGso->u8Type)
443	{
444	case PDMNETWORKGSOTYPE_IPV4_TCP:
445	pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs),
446	pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, iSeg * pGso->cbMaxSeg,
447	pGso->cbHdrs, iSeg + 1 == cSegs, PDMNETCSUMTYPE_COMPLETE);
448	break;
449	case PDMNETWORKGSOTYPE_IPV4_UDP:
450	pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs),
451	pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, pGso->cbHdrs, PDMNETCSUMTYPE_COMPLETE);
452	break;
453	case PDMNETWORKGSOTYPE_IPV6_TCP:
454	pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, pGso->cbHdrs,
455	pGso->offHdr2, RTNETIPV4_PROT_TCP),
456	pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, iSeg * pGso->cbMaxSeg,
457	pGso->cbHdrs, iSeg + 1 == cSegs, PDMNETCSUMTYPE_COMPLETE);
458	break;
459	case PDMNETWORKGSOTYPE_IPV6_UDP:
460	pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, pGso->cbHdrs,
461	pGso->offHdr2, RTNETIPV4_PROT_UDP),
462	pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, pGso->cbHdrs, PDMNETCSUMTYPE_COMPLETE);
463	break;
464	case PDMNETWORKGSOTYPE_IPV4_IPV6_TCP:
465	pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs);
466	pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pgmNetGsoCalcIpv6Offset(pbSegHdrs, pGso->offHdr1),
467	cbSegPayload, pGso->cbHdrs, pGso->offHdr2, RTNETIPV4_PROT_TCP),
468	pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, iSeg * pGso->cbMaxSeg,
469	pGso->cbHdrs, iSeg + 1 == cSegs, PDMNETCSUMTYPE_COMPLETE);
470	break;
471	case PDMNETWORKGSOTYPE_IPV4_IPV6_UDP:
472	pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs);
473	pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pgmNetGsoCalcIpv6Offset(pbSegHdrs, pGso->offHdr1),
474	cbSegPayload, pGso->cbHdrs, pGso->offHdr2, RTNETIPV4_PROT_UDP),
475	pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, pGso->cbHdrs, PDMNETCSUMTYPE_COMPLETE);
476	break;
477	case PDMNETWORKGSOTYPE_INVALID:
478	case PDMNETWORKGSOTYPE_END:
479	/* no default! wnat gcc warnings. */
480	break;
481	}
482
483	*pcbSegPayload = cbSegPayload;
484	return pGso->cbHdrs + iSeg * pGso->cbMaxSeg;
485	}
486
487
488	/**
489	* Prepares the GSO frame for direct use without any segmenting.
490	*
491	* @param pGso The GSO context.
492	* @param pvFrame The frame to prepare.
493	* @param cbFrame The frame size.
494	* @param enmCsumType Whether to checksum the payload, the pseudo
495	* header or nothing.
496	*/
497	DECLINLINE(void) PDMNetGsoPrepForDirectUse(PCPDMNETWORKGSO pGso, void *pvFrame, size_t cbFrame, PDMNETCSUMTYPE enmCsumType)
498	{
499	/*
500	* Figure out where the payload is and where the header starts before we
501	* do the protocol bits.
502	*/
503	uint8_t * const pbHdrs = (uint8_t *)pvFrame;
504	uint8_t * const pbPayload = pbHdrs + pGso->cbHdrs;
505	uint32_t const cbFrame32 = (uint32_t)cbFrame;
506	uint32_t const cbPayload = cbFrame32 - pGso->cbHdrs;
507
508	/*
509	* Check assumptions (doing it after declaring the variables because of C).
510	*/
511	Assert(PDMNetGsoIsValid(pGso, sizeof(*pGso), cbFrame));
512
513	/*
514	* Get down to busienss.
515	*/
516	switch ((PDMNETWORKGSOTYPE)pGso->u8Type)
517	{
518	case PDMNETWORKGSOTYPE_IPV4_TCP:
519	pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv4Hdr(pbHdrs, pGso->offHdr1, cbFrame32 - pGso->cbHdrs, 0, pGso->cbHdrs),
520	pbHdrs, pGso->offHdr2, pbPayload, cbPayload, 0, pGso->cbHdrs, true, enmCsumType);
521	break;
522	case PDMNETWORKGSOTYPE_IPV4_UDP:
523	pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv4Hdr(pbHdrs, pGso->offHdr1, cbFrame32 - pGso->cbHdrs, 0, pGso->cbHdrs),
524	pbHdrs, pGso->offHdr2, pbPayload, cbPayload, pGso->cbHdrs, enmCsumType);
525	break;
526	case PDMNETWORKGSOTYPE_IPV6_TCP:
527	pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv6Hdr(pbHdrs, pGso->offHdr1, cbPayload, pGso->cbHdrs,
528	pGso->offHdr2, RTNETIPV4_PROT_TCP),
529	pbHdrs, pGso->offHdr2, pbPayload, cbPayload, 0, pGso->cbHdrs, true, enmCsumType);
530	break;
531	case PDMNETWORKGSOTYPE_IPV6_UDP:
532	pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv6Hdr(pbHdrs, pGso->offHdr1, cbPayload, pGso->cbHdrs,
533	pGso->offHdr2, RTNETIPV4_PROT_UDP),
534	pbHdrs, pGso->offHdr2, pbPayload, cbPayload, pGso->cbHdrs, enmCsumType);
535	break;
536	case PDMNETWORKGSOTYPE_IPV4_IPV6_TCP:
537	pdmNetGsoUpdateIPv4Hdr(pbHdrs, pGso->offHdr1, cbPayload, 0, pGso->cbHdrs);
538	pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv6Hdr(pbHdrs, pgmNetGsoCalcIpv6Offset(pbHdrs, pGso->offHdr1),
539	cbPayload, pGso->cbHdrs, pGso->offHdr2, RTNETIPV4_PROT_TCP),
540	pbHdrs, pGso->offHdr2, pbPayload, cbPayload, 0, pGso->cbHdrs, true, enmCsumType);
541	break;
542	case PDMNETWORKGSOTYPE_IPV4_IPV6_UDP:
543	pdmNetGsoUpdateIPv4Hdr(pbHdrs, pGso->offHdr1, cbPayload, 0, pGso->cbHdrs);
544	pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv6Hdr(pbHdrs, pgmNetGsoCalcIpv6Offset(pbHdrs, pGso->offHdr1),
545	cbPayload, pGso->cbHdrs, pGso->offHdr2, RTNETIPV4_PROT_UDP),
546	pbHdrs, pGso->offHdr2, pbPayload, cbPayload, pGso->cbHdrs, enmCsumType);
547	break;
548	case PDMNETWORKGSOTYPE_INVALID:
549	case PDMNETWORKGSOTYPE_END:
550	/* no default! wnat gcc warnings. */
551	break;
552	}
553	}
554
555
556	/**
557	* Gets the GSO type name string.
558	*
559	* @returns Pointer to read only name string.
560	* @param enmType The type.
561	*/
562	DECLINLINE(const char *) PDMNetGsoTypeName(PDMNETWORKGSOTYPE enmType)
563	{
564	switch (enmType)
565	{
566	case PDMNETWORKGSOTYPE_IPV4_TCP: return "TCPv4";
567	case PDMNETWORKGSOTYPE_IPV6_TCP: return "TCPv6";
568	case PDMNETWORKGSOTYPE_IPV4_UDP: return "UDPv4";
569	case PDMNETWORKGSOTYPE_IPV6_UDP: return "UDPv6";
570	case PDMNETWORKGSOTYPE_IPV4_IPV6_TCP: return "4to6TCP";
571	case PDMNETWORKGSOTYPE_IPV4_IPV6_UDP: return "4to6UDP";
572	case PDMNETWORKGSOTYPE_INVALID: return "invalid";
573	case PDMNETWORKGSOTYPE_END: return "end";
574	}
575	return "bad-gso-type";
576	}
577

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/include/VBox/pdmnetinline.h@ 34801

Download in other formats: