VirtualBox

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

Last change on this file since 28153 was 28153, checked in by vboxsync, 15 years ago

VBoxNetFlt-linux: Receive GSO frames from the host, save calls into SrvIntNet as well as ring-0 <-> ring-3 context switches on the DrvIntNet receive thread.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 20.5 KB
Line 
1/* $Id: pdmnetinline.h 28153 2010-04-09 17:58:51Z 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 */
47DECLINLINE(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 */
128DECLINLINE(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 */
144DECLINLINE(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 * @internal
161 */
162DECLINLINE(void) pdmNetGsoUpdateUdpHdr(uint32_t u32PseudoSum, uint8_t *pbSegHdrs, uint8_t offUdpHdr,
163 uint8_t const *pbPayload, uint32_t cbPayload, uint8_t cbHdrs)
164{
165 PRTNETUDP pUdpHdr = (PRTNETUDP)&pbSegHdrs[offUdpHdr];
166 pUdpHdr->uh_ulen = cbPayload + cbHdrs - offUdpHdr;
167 pUdpHdr->uh_sum = RTNetUDPChecksum(u32PseudoSum, pUdpHdr);
168}
169
170
171/**
172 * Update a TCP 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 offTcpHdr The offset into @a pbSegHdrs of the TCP header.
177 * @param pbPayload Pointer to the payload bytes.
178 * @param cbPayload The amount of payload.
179 * @param offPayload The offset into the payload that we're splitting
180 * up. We're ASSUMING that the payload follows
181 * immediately after the TCP header w/ options.
182 * @param cbHdrs The size of all the headers.
183 * @param fLastSeg Set if this is the last segment.
184 * @internal
185 */
186DECLINLINE(void) pdmNetGsoUpdateTcpHdr(uint32_t u32PseudoSum, uint8_t *pbSegHdrs, uint8_t offTcpHdr,
187 uint8_t const *pbPayload, uint32_t cbPayload, uint32_t offPayload, uint8_t cbHdrs, bool fLastSeg)
188{
189 PRTNETTCP pTcpHdr = (PRTNETTCP)&pbSegHdrs[offTcpHdr];
190 pTcpHdr->th_seq = RT_H2N_U32(RT_N2H_U32(pTcpHdr->th_seq) + offPayload);
191 if (!fLastSeg)
192 pTcpHdr->th_flags &= ~(RTNETTCP_F_FIN | RTNETTCP_F_PSH);
193 pTcpHdr->th_sum = RTNetTCPChecksum(u32PseudoSum, pTcpHdr, pbPayload, cbPayload);
194}
195
196
197/**
198 * Updates a IPv6 header after carving out a segment.
199 *
200 * @returns 32-bit intermediary checksum value for the pseudo header.
201 * @param pbSegHdrs Pointer to the header bytes.
202 * @param offIpHdr The offset into @a pbSegHdrs of the IP header.
203 * @param cbSegPayload The amount of segmented payload. Not to be
204 * confused with the IP payload.
205 * @param cbHdrs The size of all the headers.
206 * @param offPktHdr Offset of the protocol packet header. For the
207 * pseudo header checksum calulation.
208 * @param bProtocol The protocol type. For the pseudo header.
209 * @internal
210 */
211DECLINLINE(uint32_t) pdmNetGsoUpdateIPv6Hdr(uint8_t *pbSegHdrs, uint8_t offIpHdr, uint32_t cbSegPayload, uint8_t cbHdrs,
212 uint8_t offPktHdr, uint8_t bProtocol)
213{
214 PRTNETIPV6 pIpHdr = (PRTNETIPV6)&pbSegHdrs[offIpHdr];
215 uint16_t cbPayload = (uint16_t)(cbHdrs - (offIpHdr + sizeof(RTNETIPV6)) + cbSegPayload);
216 pIpHdr->ip6_plen = RT_H2N_U16(cbPayload);
217 return RTNetIPv6PseudoChecksumEx(pIpHdr, bProtocol, (uint16_t)(cbHdrs - offPktHdr + cbSegPayload));
218}
219
220
221/**
222 * Updates a IPv4 header after carving out a segment.
223 *
224 * @returns 32-bit intermediary checksum value for the pseudo header.
225 * @param pbSegHdrs Pointer to the header bytes.
226 * @param offIpHdr The offset into @a pbSegHdrs of the IP header.
227 * @param cbSegPayload The amount of segmented payload.
228 * @param iSeg The segment index.
229 * @param cbHdrs The size of all the headers.
230 * @internal
231 */
232DECLINLINE(uint32_t) pdmNetGsoUpdateIPv4Hdr(uint8_t *pbSegHdrs, uint8_t offIpHdr, uint32_t cbSegPayload,
233 uint32_t iSeg, uint8_t cbHdrs)
234{
235 PRTNETIPV4 pIpHdr = (PRTNETIPV4)&pbSegHdrs[offIpHdr];
236 pIpHdr->ip_len = RT_H2N_U16(cbHdrs - offIpHdr + cbSegPayload);
237 pIpHdr->ip_id = RT_H2N_U16(RT_N2H_U16(pIpHdr->ip_id) + iSeg);
238 pIpHdr->ip_sum = RTNetIPv4HdrChecksum(pIpHdr);
239 return RTNetIPv4PseudoChecksum(pIpHdr);
240}
241
242
243/**
244 * Carves out the specified segment in a destructive manner.
245 *
246 * This is for sequentially carving out segments and pushing them along for
247 * processing or sending. To avoid allocating a temporary buffer for
248 * constructing the segment in, we trash the previous frame by putting the
249 * header at the end of it.
250 *
251 * @returns Pointer to the segment frame that we've carved out.
252 * @param pGso The GSO context data.
253 * @param pbFrame Pointer to the GSO frame.
254 * @param cbFrame The size of the GSO frame.
255 * @param pbHdrScatch Pointer to a pGso->cbHdrs sized area where we
256 * can save the original header prototypes on the
257 * first call (@a iSeg is 0) and retrieve it on
258 * susequent calls. (Just use a 256 bytes
259 * buffer to make life easy.)
260 * @param iSeg The segment that we're carving out (0-based).
261 * @param cSegs The number of segments in the GSO frame. Use
262 * PDMNetGsoCalcSegmentCount to find this.
263 * @param pcbSegFrame Where to return the size of the returned segment
264 * frame.
265 */
266DECLINLINE(void *) PDMNetGsoCarveSegmentQD(PCPDMNETWORKGSO pGso, uint8_t *pbFrame, size_t cbFrame, uint8_t *pbHdrScatch,
267 uint32_t iSeg, uint32_t cSegs, uint32_t *pcbSegFrame)
268{
269 /*
270 * Figure out where the payload is and where the header starts before we
271 * do the protocol specific carving.
272 */
273 uint8_t * const pbSegHdrs = pbFrame + pGso->cbMaxSeg * iSeg;
274 uint8_t * const pbSegPayload = pbSegHdrs + pGso->cbHdrs;
275 uint32_t const cbSegPayload = iSeg + 1 != cSegs
276 ? pGso->cbMaxSeg
277 : (uint32_t)(cbFrame - iSeg * pGso->cbMaxSeg - pGso->cbHdrs);
278 uint32_t const cbSegFrame = cbSegPayload + pGso->cbHdrs;
279
280 /*
281 * Check assumptions (doing it after declaring the variables because of C).
282 */
283 Assert(iSeg < cSegs);
284 Assert(cSegs == PDMNetGsoCalcSegmentCount(pGso, cbFrame));
285 Assert(PDMNetGsoIsValid(pGso, sizeof(*pGso), cbFrame));
286
287 /*
288 * Copy the header and do the protocol specific massaging of it.
289 */
290 if (iSeg != 0)
291 memcpy(pbSegHdrs, pbHdrScatch, pGso->cbHdrs);
292 else
293 memcpy(pbHdrScatch, pbSegHdrs, pGso->cbHdrs);
294
295 switch ((PDMNETWORKGSOTYPE)pGso->u8Type)
296 {
297 case PDMNETWORKGSOTYPE_IPV4_TCP:
298 pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs),
299 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, iSeg * pGso->cbMaxSeg,
300 pGso->cbHdrs, iSeg + 1 == cSegs);
301 break;
302 case PDMNETWORKGSOTYPE_IPV4_UDP:
303 pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs),
304 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, pGso->cbHdrs);
305 break;
306 case PDMNETWORKGSOTYPE_IPV6_TCP:
307 pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, pGso->cbHdrs,
308 pGso->offHdr2, RTNETIPV4_PROT_TCP),
309 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, iSeg * pGso->cbMaxSeg,
310 pGso->cbHdrs, iSeg + 1 == cSegs);
311 break;
312 case PDMNETWORKGSOTYPE_IPV6_UDP:
313 pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, pGso->cbHdrs,
314 pGso->offHdr2, RTNETIPV4_PROT_UDP),
315 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, pGso->cbHdrs);
316 break;
317 case PDMNETWORKGSOTYPE_IPV4_IPV6_TCP:
318 pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs);
319 pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pgmNetGsoCalcIpv6Offset(pbSegHdrs, pGso->offHdr1),
320 cbSegPayload, pGso->cbHdrs, pGso->offHdr2, RTNETIPV4_PROT_TCP),
321 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, iSeg * pGso->cbMaxSeg,
322 pGso->cbHdrs, iSeg + 1 == cSegs);
323 break;
324 case PDMNETWORKGSOTYPE_IPV4_IPV6_UDP:
325 pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs);
326 pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pgmNetGsoCalcIpv6Offset(pbSegHdrs, pGso->offHdr1),
327 cbSegPayload, pGso->cbHdrs, pGso->offHdr2, RTNETIPV4_PROT_UDP),
328 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, pGso->cbHdrs);
329 break;
330 case PDMNETWORKGSOTYPE_INVALID:
331 case PDMNETWORKGSOTYPE_END:
332 /* no default! wnat gcc warnings. */
333 break;
334 }
335
336 *pcbSegFrame = cbSegFrame;
337 return pbSegHdrs;
338}
339
340
341/**
342 * Carves out the specified segment in a non-destructive manner.
343 *
344 * The segment headers and segment payload is kept separate here. The GSO frame
345 * is still expected to be one linear chunk of data, but we don't modify any of
346 * it.
347 *
348 * @returns The offset into the GSO frame of the payload.
349 * @param pGso The GSO context data.
350 * @param pbFrame Pointer to the GSO frame. Used for retriving
351 * the header prototype and for checksumming the
352 * payload. The buffer is not modified.
353 * @param cbFrame The size of the GSO frame.
354 * @param iSeg The segment that we're carving out (0-based).
355 * @param cSegs The number of segments in the GSO frame. Use
356 * PDMNetGsoCalcSegmentCount to find this.
357 * @param pbSegHdrs Where to return the headers for the segment
358 * that's been carved out. The buffer must be at
359 * least pGso->cbHdrs in size, using a 256 byte
360 * buffer is a recommended simplification.
361 * @param pcbSegPayload Where to return the size of the returned
362 * segment payload.
363 */
364DECLINLINE(uint32_t) PDMNetGsoCarveSegment(PCPDMNETWORKGSO pGso, const uint8_t *pbFrame, size_t cbFrame,
365 uint32_t iSeg, uint32_t cSegs, uint8_t *pbSegHdrs, uint32_t *pcbSegPayload)
366{
367 /*
368 * Figure out where the payload is and where the header starts before we
369 * do the protocol specific carving.
370 */
371 uint8_t const * const pbSegPayload = pbFrame + pGso->cbHdrs + iSeg * pGso->cbMaxSeg;
372 uint32_t const cbSegPayload = iSeg + 1 != cSegs
373 ? pGso->cbMaxSeg
374 : (uint32_t)(cbFrame - iSeg * pGso->cbMaxSeg - pGso->cbHdrs);
375
376 /*
377 * Check assumptions (doing it after declaring the variables because of C).
378 */
379 Assert(iSeg < cSegs);
380 Assert(cSegs == PDMNetGsoCalcSegmentCount(pGso, cbFrame));
381 Assert(PDMNetGsoIsValid(pGso, sizeof(*pGso), cbFrame));
382
383 /*
384 * Copy the header and do the protocol specific massaging of it.
385 */
386 memcpy(pbSegHdrs, pbFrame, pGso->cbHdrs);
387
388 switch ((PDMNETWORKGSOTYPE)pGso->u8Type)
389 {
390 case PDMNETWORKGSOTYPE_IPV4_TCP:
391 pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs),
392 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, iSeg * pGso->cbMaxSeg,
393 pGso->cbHdrs, iSeg + 1 == cSegs);
394 break;
395 case PDMNETWORKGSOTYPE_IPV4_UDP:
396 pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs),
397 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, pGso->cbHdrs);
398 break;
399 case PDMNETWORKGSOTYPE_IPV6_TCP:
400 pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, pGso->cbHdrs,
401 pGso->offHdr2, RTNETIPV4_PROT_TCP),
402 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, iSeg * pGso->cbMaxSeg,
403 pGso->cbHdrs, iSeg + 1 == cSegs);
404 break;
405 case PDMNETWORKGSOTYPE_IPV6_UDP:
406 pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, pGso->cbHdrs,
407 pGso->offHdr2, RTNETIPV4_PROT_UDP),
408 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, pGso->cbHdrs);
409 break;
410 case PDMNETWORKGSOTYPE_IPV4_IPV6_TCP:
411 pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs);
412 pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pgmNetGsoCalcIpv6Offset(pbSegHdrs, pGso->offHdr1),
413 cbSegPayload, pGso->cbHdrs, pGso->offHdr2, RTNETIPV4_PROT_TCP),
414 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, iSeg * pGso->cbMaxSeg,
415 pGso->cbHdrs, iSeg + 1 == cSegs);
416 break;
417 case PDMNETWORKGSOTYPE_IPV4_IPV6_UDP:
418 pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs);
419 pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pgmNetGsoCalcIpv6Offset(pbSegHdrs, pGso->offHdr1),
420 cbSegPayload, pGso->cbHdrs, pGso->offHdr2, RTNETIPV4_PROT_UDP),
421 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, pGso->cbHdrs);
422 break;
423 case PDMNETWORKGSOTYPE_INVALID:
424 case PDMNETWORKGSOTYPE_END:
425 /* no default! wnat gcc warnings. */
426 break;
427 }
428
429 *pcbSegPayload = cbSegPayload;
430 return pGso->cbHdrs + iSeg * pGso->cbMaxSeg;
431}
432
433
434
435
436DECLINLINE(void) PDMNetGsoPrepForDirectUse(PCPDMNETWORKGSO pGso, void *pvFrame, size_t cbFrame,
437 bool fHeaderChecskum, bool fPayloadChecksum)
438{
439/** @todo Need to implement this eventually, not important yet as it's only use
440 * by DHCP where GSO isn't normally used. */
441}
442
443
444/**
445 * Gets the GSO type name string.
446 *
447 * @returns Pointer to read only name string.
448 * @param enmType The type.
449 */
450DECLINLINE(const char *) PDMNetGsoTypeName(PDMNETWORKGSOTYPE enmType)
451{
452 switch (enmType)
453 {
454 case PDMNETWORKGSOTYPE_IPV4_TCP: return "TCPv4";
455 case PDMNETWORKGSOTYPE_IPV6_TCP: return "TCPv6";
456 case PDMNETWORKGSOTYPE_IPV4_UDP: return "UDPv4";
457 case PDMNETWORKGSOTYPE_IPV6_UDP: return "UDPv6";
458 case PDMNETWORKGSOTYPE_IPV4_IPV6_TCP: return "4to6TCP";
459 case PDMNETWORKGSOTYPE_IPV4_IPV6_UDP: return "4to6UDP";
460 case PDMNETWORKGSOTYPE_INVALID: return "invalid";
461 case PDMNETWORKGSOTYPE_END: return "end";
462 }
463 return "bad-gso-type";
464}
465
Note: See TracBrowser for help on using the repository browser.

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