VirtualBox

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

Last change on this file since 32055 was 31275, checked in by vboxsync, 14 years ago

vboxnetflt: host-only checksum fix (UDP pseudo)
  • 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 31275 2010-08-02 09:30:15Z 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 */
45typedef 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 */
67DECLINLINE(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 */
148DECLINLINE(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 */
164DECLINLINE(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 */
184DECLINLINE(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 */
225DECLINLINE(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 */
265DECLINLINE(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 */
286DECLINLINE(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 */
320DECLINLINE(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 retriving
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 */
418DECLINLINE(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 */
497DECLINLINE(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 */
562DECLINLINE(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.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette