pdmnetinline.h@ 28208

Last change on this file since 28208 was 28158, checked in by vboxsync, 15 years ago
PDMNetGsoPrepForDirectUse: build fix
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 24.0 KB

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

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

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

Download in other formats: