VirtualBox

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

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

pdmnetinline.h: endian bug fix in pdmNetGsoUpdateIPv4Hdr.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 19.7 KB
Line 
1/* $Id: pdmnetinline.h 28055 2010-04-07 17:22:43Z 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). C++ only because of
7 * mixed code and variables.
8 */
9
10/*
11 * Copyright (C) 2010 Sun Microsystems, Inc.
12 *
13 * This file is part of VirtualBox Open Source Edition (OSE), as
14 * available from http://www.virtualbox.org. This file is free software;
15 * you can redistribute it and/or modify it under the terms of the GNU
16 * General Public License (GPL) as published by the Free Software
17 * Foundation, in version 2 as it comes in the "COPYING" file of the
18 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
19 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
20 *
21 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
22 * Clara, CA 95054 USA or visit http://www.sun.com if you need
23 * additional information or have any questions.
24 */
25
26
27/*******************************************************************************
28* Header Files *
29*******************************************************************************/
30#include <VBox/log.h>
31#include <VBox/types.h>
32#include <iprt/asm.h>
33#include <iprt/assert.h>
34#include <iprt/net.h>
35#include <iprt/string.h>
36
37
38
39/**
40 * Validates the GSO context.
41 *
42 * @returns true if valid, false if not (not asserted or logged).
43 * @param pGso The GSO context.
44 * @param cbGsoMax The max size of the GSO context.
45 * @param cbFrame The max size of the GSO frame (use to validate
46 * the MSS).
47 */
48DECLINLINE(bool) PDMNetGsoIsValid(PCPDMNETWORKGSO pGso, size_t cbGsoMax, size_t cbFrame)
49{
50 if (RT_UNLIKELY(cbGsoMax < sizeof(*pGso)))
51 return false;
52
53 PDMNETWORKGSOTYPE const enmType = (PDMNETWORKGSOTYPE)pGso->u8Type;
54 if (RT_UNLIKELY( enmType <= PDMNETWORKGSOTYPE_INVALID || enmType >= PDMNETWORKGSOTYPE_END ))
55 return false;
56
57 /* all types requires both headers. */
58 if (RT_UNLIKELY( pGso->offHdr1 < sizeof(RTNETETHERHDR) ))
59 return false;
60 if (RT_UNLIKELY( pGso->offHdr2 <= pGso->offHdr1 ))
61 return false;
62 if (RT_UNLIKELY( pGso->cbHdrs <= pGso->offHdr2 ))
63 return false;
64
65 /* min size of the 1st header(s). */
66 switch (enmType)
67 {
68 case PDMNETWORKGSOTYPE_IPV4_TCP:
69 case PDMNETWORKGSOTYPE_IPV4_UDP:
70 if (RT_UNLIKELY( (unsigned)pGso->offHdr2 - pGso->offHdr1 < RTNETIPV4_MIN_LEN ))
71 return false;
72 break;
73 case PDMNETWORKGSOTYPE_IPV6_TCP:
74 case PDMNETWORKGSOTYPE_IPV6_UDP:
75 if (RT_UNLIKELY( (unsigned)pGso->offHdr2 - pGso->offHdr1 < RTNETIPV6_MIN_LEN ))
76 return false;
77 break;
78 case PDMNETWORKGSOTYPE_IPV4_IPV6_TCP:
79 case PDMNETWORKGSOTYPE_IPV4_IPV6_UDP:
80 if (RT_UNLIKELY( (unsigned)pGso->offHdr2 - pGso->offHdr1 < RTNETIPV4_MIN_LEN + RTNETIPV6_MIN_LEN ))
81 return false;
82 break;
83 case PDMNETWORKGSOTYPE_INVALID:
84 case PDMNETWORKGSOTYPE_END:
85 break;
86 /* no default case! want gcc warnings. */
87 }
88
89 /* min size of the 2nd header. */
90 switch (enmType)
91 {
92 case PDMNETWORKGSOTYPE_IPV4_TCP:
93 case PDMNETWORKGSOTYPE_IPV6_TCP:
94 case PDMNETWORKGSOTYPE_IPV4_IPV6_TCP:
95 if (RT_UNLIKELY( (unsigned)pGso->cbHdrs - pGso->offHdr2 < RTNETTCP_MIN_LEN ))
96 return false;
97 break;
98 case PDMNETWORKGSOTYPE_IPV4_UDP:
99 case PDMNETWORKGSOTYPE_IPV6_UDP:
100 case PDMNETWORKGSOTYPE_IPV4_IPV6_UDP:
101 if (RT_UNLIKELY( (unsigned)pGso->cbHdrs - pGso->offHdr2 < RTNETUDP_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 /* There must be at more than one segment. */
111 if (RT_UNLIKELY( cbFrame <= pGso->cbHdrs ))
112 return false;
113 if (RT_UNLIKELY( cbFrame - pGso->cbHdrs < pGso->cbMaxSeg ))
114 return false;
115
116 return true;
117}
118
119
120/**
121 * Calculates the number of segments a GSO frame will be segmented into.
122 *
123 * @returns Segment count.
124 * @param pGso The GSO context.
125 * @param cbFrame The GSO frame size (header proto + payload).
126 */
127DECLINLINE(uint32_t) PDMNetGsoCalcSegmentCount(PCPDMNETWORKGSO pGso, size_t cbFrame)
128{
129 Assert(PDMNetGsoIsValid(pGso, sizeof(*pGso), cbFrame));
130 size_t cbPayload = cbFrame - pGso->cbHdrs;
131 return (uint32_t)((cbPayload + pGso->cbMaxSeg - 1) / pGso->cbMaxSeg);
132}
133
134
135/**
136 * Used to find the IPv6 header when handling 4to6 tunneling.
137 *
138 * @returns Offset of the IPv6 header.
139 * @param pbSegHdrs The headers / frame start.
140 * @param offIpHdr The offset of the IPv4 header.
141 */
142DECLINLINE(uint8_t) pgmNetGsoCalcIpv6Offset(uint8_t *pbSegHdrs, uint8_t offIPv4Hdr)
143{
144 PCRTNETIPV4 pIPv4Hdr = (PCRTNETIPV4)&pbSegHdrs[offIPv4Hdr];
145 return offIPv4Hdr + pIPv4Hdr->ip_hl * 4;
146}
147
148
149/**
150 * Update an UDP header after carving out a segment
151 *
152 * @param u32PsudoSum The pseudo checksum.
153 * @param pbSegHdrs Pointer to the header bytes / frame start.
154 * @param offUdpHdr The offset into @a pbSegHdrs of the UDP header.
155 * @param pbPayload Pointer to the payload bytes.
156 * @param cbPayload The amount of payload.
157 * @param cbHdrs The size of all the headers.
158 * @internal
159 */
160DECLINLINE(void) pdmNetGsoUpdateUdpHdr(uint32_t u32PsudoSum, uint8_t *pbSegHdrs, uint8_t offUdpHdr,
161 uint8_t const *pbPayload, uint32_t cbPayload, uint8_t cbHdrs)
162{
163 PRTNETUDP pUdpHdr = (PRTNETUDP)&pbSegHdrs[offUdpHdr];
164 pUdpHdr->uh_ulen = cbPayload + cbHdrs - offUdpHdr;
165 pUdpHdr->uh_sum = RTNetUDPChecksum(u32PsudoSum, pUdpHdr);
166}
167
168
169/**
170 * Update a TCP header after carving out a segment.
171 *
172 * @param u32PsudoSum The pseudo checksum.
173 * @param pbSegHdrs Pointer to the header bytes / frame start.
174 * @param offTcpHdr The offset into @a pbSegHdrs of the TCP header.
175 * @param pbPayload Pointer to the payload bytes.
176 * @param cbPayload The amount of payload.
177 * @param offPayload The offset into the payload that we're splitting
178 * up. We're ASSUMING that the payload follows
179 * immediately after the TCP header w/ options.
180 * @param cbHdrs The size of all the headers.
181 * @param fLastSeg Set if this is the last segment.
182 * @internal
183 */
184DECLINLINE(void) pdmNetGsoUpdateTcpHdr(uint32_t u32PsudoSum, uint8_t *pbSegHdrs, uint8_t offTcpHdr,
185 uint8_t const *pbPayload, uint32_t cbPayload, uint32_t offPayload, uint8_t cbHdrs, bool fLastSeg)
186{
187 PRTNETTCP pTcpHdr = (PRTNETTCP)&pbSegHdrs[offTcpHdr];
188 pTcpHdr->th_seq = RT_H2N_U32(RT_N2H_U32(pTcpHdr->th_seq) + offPayload);
189 if (!fLastSeg)
190 pTcpHdr->th_flags &= ~(RTNETTCP_F_FIN | RTNETTCP_F_PSH);
191 pTcpHdr->th_sum = RTNetTCPChecksum(u32PsudoSum, pTcpHdr, pbPayload, cbPayload);
192}
193
194
195/**
196 * Updates a IPv6 header after carving out a segment.
197 *
198 * @returns 32-bit intermediary checksum value for the pseudo header.
199 * @param pbSegHdrs Pointer to the header bytes.
200 * @param offIpHdr The offset into @a pbSegHdrs of the IP header.
201 * @param cbSegPayload The amount of segmented payload. Not to be
202 * confused with the IP payload.
203 * @param cbHdrs The size of all the headers.
204 * @param offPktHdr Offset of the protocol packet header. For the
205 * pseudo header checksum calulation.
206 * @param bProtocol The protocol type. For the pseudo header.
207 * @internal
208 */
209DECLINLINE(uint32_t) pdmNetGsoUpdateIPv6Hdr(uint8_t *pbSegHdrs, uint8_t offIpHdr, uint32_t cbSegPayload, uint8_t cbHdrs,
210 uint8_t offPktHdr, uint8_t bProtocol)
211{
212 PRTNETIPV6 pIpHdr = (PRTNETIPV6)&pbSegHdrs[offIpHdr];
213 uint16_t cbPayload = (uint16_t)(cbHdrs - (offIpHdr + sizeof(RTNETIPV6)) + cbSegPayload);
214 pIpHdr->ip6_plen = RT_H2N_U16(cbPayload);
215 return RTNetIPv6PseudoChecksumEx(pIpHdr, bProtocol, (uint16_t)(cbHdrs - offPktHdr + cbSegPayload));
216}
217
218
219/**
220 * Updates a IPv4 header after carving out a segment.
221 *
222 * @returns 32-bit intermediary checksum value for the pseudo header.
223 * @param pbSegHdrs Pointer to the header bytes.
224 * @param offIpHdr The offset into @a pbSegHdrs of the IP header.
225 * @param cbSegPayload The amount of segmented payload.
226 * @param iSeg The segment index.
227 * @param cbHdrs The size of all the headers.
228 * @internal
229 */
230DECLINLINE(uint32_t) pdmNetGsoUpdateIPv4Hdr(uint8_t *pbSegHdrs, uint8_t offIpHdr, uint32_t cbSegPayload,
231 uint32_t iSeg, uint8_t cbHdrs)
232{
233 PRTNETIPV4 pIpHdr = (PRTNETIPV4)&pbSegHdrs[offIpHdr];
234 pIpHdr->ip_len = RT_H2N_U16(cbHdrs - offIpHdr + cbSegPayload);
235 pIpHdr->ip_id = RT_H2N_U16(RT_N2H_U16(pIpHdr->ip_id) + iSeg);
236 pIpHdr->ip_sum = RTNetIPv4HdrChecksum(pIpHdr);
237 return RTNetIPv4PseudoChecksum(pIpHdr);
238}
239
240
241/**
242 * Carves out the specified segment in a destructive manner.
243 *
244 * This is for sequentially carving out segments and pushing them along for
245 * processing or sending. To avoid allocating a temporary buffer for
246 * constructing the segment in, we trash the previous frame by putting the
247 * header at the end of it.
248 *
249 * @returns Pointer to the segment frame that we've carved out.
250 * @param pGso The GSO context data.
251 * @param pbFrame Pointer to the GSO frame.
252 * @param cbFrame The size of the GSO frame.
253 * @param pbHdrScatch Pointer to a pGso->cbHdrs sized area where we
254 * can save the original header prototypes on the
255 * first call (@a iSeg is 0) and retrieve it on
256 * susequent calls. (Just use a 256 bytes
257 * buffer to make life easy.)
258 * @param iSeg The segment that we're carving out (0-based).
259 * @param cSegs The number of segments in the GSO frame. Use
260 * PDMNetGsoCalcSegmentCount to find this.
261 * @param pcbSegFrame Where to return the size of the returned segment
262 * frame.
263 */
264DECLINLINE(void *) PDMNetGsoCarveSegmentQD(PCPDMNETWORKGSO pGso, uint8_t *pbFrame, size_t cbFrame, uint8_t *pbHdrScatch,
265 uint32_t iSeg, uint32_t cSegs, uint32_t *pcbSegFrame)
266{
267 /*
268 * Check assumptions.
269 */
270 Assert(iSeg < cSegs);
271 Assert(cSegs == PDMNetGsoCalcSegmentCount(pGso, cbFrame));
272 Assert(PDMNetGsoIsValid(pGso, sizeof(*pGso), cbFrame));
273
274 /*
275 * Figure out where the payload is and where the header starts before we
276 * do the protocol specific carving.
277 */
278 uint8_t * const pbSegHdrs = pbFrame + pGso->cbMaxSeg * iSeg;
279 uint8_t * const pbSegPayload = pbSegHdrs + pGso->cbHdrs;
280 uint32_t const cbSegPayload = iSeg + 1 != cSegs
281 ? pGso->cbMaxSeg
282 : (uint32_t)(cbFrame - iSeg * pGso->cbMaxSeg - pGso->cbHdrs);
283 uint32_t const cbSegFrame = cbSegPayload + pGso->cbHdrs;
284
285 /*
286 * Copy the header and do the protocol specific massaging of it.
287 */
288 if (iSeg != 0)
289 memcpy(pbSegHdrs, pbHdrScatch, pGso->cbHdrs);
290 else
291 memcpy(pbHdrScatch, pbSegHdrs, pGso->cbHdrs);
292
293 switch ((PDMNETWORKGSOTYPE)pGso->u8Type)
294 {
295 case PDMNETWORKGSOTYPE_IPV4_TCP:
296 pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs),
297 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, iSeg * pGso->cbMaxSeg,
298 pGso->cbHdrs, iSeg + 1 == cSegs);
299 break;
300 case PDMNETWORKGSOTYPE_IPV4_UDP:
301 pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs),
302 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, pGso->cbHdrs);
303 break;
304 case PDMNETWORKGSOTYPE_IPV6_TCP:
305 pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, pGso->cbHdrs,
306 pGso->offHdr2, RTNETIPV4_PROT_TCP),
307 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, iSeg * pGso->cbMaxSeg,
308 pGso->cbHdrs, iSeg + 1 == cSegs);
309 break;
310 case PDMNETWORKGSOTYPE_IPV6_UDP:
311 pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, pGso->cbHdrs,
312 pGso->offHdr2, RTNETIPV4_PROT_UDP),
313 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, pGso->cbHdrs);
314 break;
315 case PDMNETWORKGSOTYPE_IPV4_IPV6_TCP:
316 pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs);
317 pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pgmNetGsoCalcIpv6Offset(pbSegHdrs, pGso->offHdr1),
318 cbSegPayload, pGso->cbHdrs, pGso->offHdr2, RTNETIPV4_PROT_TCP),
319 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, iSeg * pGso->cbMaxSeg,
320 pGso->cbHdrs, iSeg + 1 == cSegs);
321 break;
322 case PDMNETWORKGSOTYPE_IPV4_IPV6_UDP:
323 pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs);
324 pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pgmNetGsoCalcIpv6Offset(pbSegHdrs, pGso->offHdr1),
325 cbSegPayload, pGso->cbHdrs, pGso->offHdr2, RTNETIPV4_PROT_UDP),
326 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, pGso->cbHdrs);
327 break;
328 case PDMNETWORKGSOTYPE_INVALID:
329 case PDMNETWORKGSOTYPE_END:
330 /* no default! wnat gcc warnings. */
331 break;
332 }
333
334 *pcbSegFrame = cbSegPayload + pGso->cbHdrs;
335 return pbSegHdrs;
336}
337
338
339/**
340 * Carves out the specified segment in a non-destructive manner.
341 *
342 * The segment headers and segment payload is kept separate here. The GSO frame
343 * is still expected to be one linear chunk of data, but we don't modify any of
344 * it.
345 *
346 * @returns The offset into the GSO frame of the payload.
347 * @param pGso The GSO context data.
348 * @param pbFrame Pointer to the GSO frame. Used for retriving
349 * the header prototype and for checksumming the
350 * payload. The buffer is not modified.
351 * @param cbFrame The size of the GSO frame.
352 * @param iSeg The segment that we're carving out (0-based).
353 * @param cSegs The number of segments in the GSO frame. Use
354 * PDMNetGsoCalcSegmentCount to find this.
355 * @param pbSegHdrs Where to return the headers for the segment
356 * that's been carved out. The buffer must be at
357 * least pGso->cbHdrs in size, using a 256 byte
358 * buffer is a recommended simplification.
359 * @param pcbSegPayload Where to return the size of the returned
360 * segment payload.
361 */
362DECLINLINE(uint32_t) PDMNetGsoCarveSegment(PCPDMNETWORKGSO pGso, const uint8_t *pbFrame, size_t cbFrame,
363 uint32_t iSeg, uint32_t cSegs, uint8_t *pbSegHdrs, uint32_t *pcbSegPayload)
364{
365 /*
366 * Check assumptions.
367 */
368 Assert(iSeg < cSegs);
369 Assert(cSegs == PDMNetGsoCalcSegmentCount(pGso, cbFrame));
370 Assert(PDMNetGsoIsValid(pGso, sizeof(*pGso), cbFrame));
371
372 /*
373 * Figure out where the payload is and where the header starts before we
374 * do the protocol specific carving.
375 */
376 uint8_t const * const pbSegPayload = pbFrame + pGso->cbHdrs + iSeg * pGso->cbMaxSeg;
377 uint32_t const cbSegPayload = iSeg + 1 != cSegs
378 ? pGso->cbMaxSeg
379 : (uint32_t)(cbFrame - iSeg * pGso->cbMaxSeg - pGso->cbHdrs);
380
381 /*
382 * Copy the header and do the protocol specific massaging of it.
383 */
384 memcpy(pbSegHdrs, pbFrame, pGso->cbHdrs);
385
386 switch ((PDMNETWORKGSOTYPE)pGso->u8Type)
387 {
388 case PDMNETWORKGSOTYPE_IPV4_TCP:
389 pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs),
390 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, iSeg * pGso->cbMaxSeg,
391 pGso->cbHdrs, iSeg + 1 == cSegs);
392 break;
393 case PDMNETWORKGSOTYPE_IPV4_UDP:
394 pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs),
395 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, pGso->cbHdrs);
396 break;
397 case PDMNETWORKGSOTYPE_IPV6_TCP:
398 pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, pGso->cbHdrs,
399 pGso->offHdr2, RTNETIPV4_PROT_TCP),
400 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, iSeg * pGso->cbMaxSeg,
401 pGso->cbHdrs, iSeg + 1 == cSegs);
402 break;
403 case PDMNETWORKGSOTYPE_IPV6_UDP:
404 pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, pGso->cbHdrs,
405 pGso->offHdr2, RTNETIPV4_PROT_UDP),
406 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, pGso->cbHdrs);
407 break;
408 case PDMNETWORKGSOTYPE_IPV4_IPV6_TCP:
409 pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs);
410 pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pgmNetGsoCalcIpv6Offset(pbSegHdrs, pGso->offHdr1),
411 cbSegPayload, pGso->cbHdrs, pGso->offHdr2, RTNETIPV4_PROT_TCP),
412 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, iSeg * pGso->cbMaxSeg,
413 pGso->cbHdrs, iSeg + 1 == cSegs);
414 break;
415 case PDMNETWORKGSOTYPE_IPV4_IPV6_UDP:
416 pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrs);
417 pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pgmNetGsoCalcIpv6Offset(pbSegHdrs, pGso->offHdr1),
418 cbSegPayload, pGso->cbHdrs, pGso->offHdr2, RTNETIPV4_PROT_UDP),
419 pbSegHdrs, pGso->offHdr2, pbSegPayload, cbSegPayload, pGso->cbHdrs);
420 break;
421 case PDMNETWORKGSOTYPE_INVALID:
422 case PDMNETWORKGSOTYPE_END:
423 /* no default! wnat gcc warnings. */
424 break;
425 }
426
427 *pcbSegPayload = cbSegPayload;
428 return pGso->cbHdrs + iSeg * pGso->cbMaxSeg;
429}
430
431
432
433
434DECLINLINE(void) PDMNetGsoPrepForDirectUse(PCPDMNETWORKGSO pGso, void *pvFrame, size_t cbFrame,
435 bool fHeaderChecskum, bool fPayloadChecksum)
436{
437/** @todo Need to implement this eventually, not important yet as it's only use
438 * by DHCP where GSO isn't normally used. */
439}
440
441
442
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