]> git.proxmox.com Git - mirror_edk2.git/blame - MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.c
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
1. Update the UdpIo to a combined UdpIo to support both v4 and v6 stack.
[mirror_edk2.git] / MdeModulePkg / Library / DxeUdpIoLib / DxeUdpIoLib.c
CommitLineData
cbf316f2 1/** @file\r
9a3293ac 2 Help functions to access UDP service, it is used by both the DHCP and MTFTP.\r
3 \r
b45b45b2 4Copyright (c) 2005 - 2009, Intel Corporation.<BR>\r
cbf316f2 5All rights reserved. This program and the accompanying materials\r
6are licensed and made available under the terms and conditions of the BSD License\r
cab450cc 7which accompanies this distribution. The full text of the license may be found at<BR>\r
cbf316f2 8http://opensource.org/licenses/bsd-license.php\r
9\r
10THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
11WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
cbf316f2 12**/\r
13\r
6c5dc2b0 14#include <Uefi.h>\r
cbf316f2 15\r
16#include <Protocol/Udp4.h>\r
b45b45b2 17#include <Protocol/Udp6.h>\r
cbf316f2 18\r
19#include <Library/UdpIoLib.h>\r
20#include <Library/BaseLib.h>\r
21#include <Library/DebugLib.h>\r
22#include <Library/UefiBootServicesTableLib.h>\r
23#include <Library/MemoryAllocationLib.h>\r
ba0f75a3 24#include <Library/BaseMemoryLib.h>\r
d8d26fb2 25#include <Library/DpcLib.h>\r
cbf316f2 26\r
9a3293ac 27\r
28/**\r
cab450cc 29 Free a UDP_TX_TOKEN. The TX event is closed.\r
9a3293ac 30\r
b45b45b2 31 @param[in] TxToken The UDP_TX_TOKEN to release.\r
9a3293ac 32\r
33**/\r
34VOID\r
35UdpIoFreeTxToken (\r
b45b45b2 36 IN UDP_TX_TOKEN *TxToken\r
9a3293ac 37 )\r
38{\r
b45b45b2 39\r
40 if (TxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
41 gBS->CloseEvent (TxToken->Token.Udp4.Event);\r
42 } else if (TxToken->UdpIo->UdpVersion == UDP_IO_UDP6_VERSION) {\r
43 gBS->CloseEvent (TxToken->Token.Udp6.Event);\r
44 } else {\r
45 ASSERT (FALSE);\r
46 }\r
47 \r
48 FreePool (TxToken);\r
9a3293ac 49}\r
50\r
51/**\r
cab450cc 52 Free a UDP_RX_TOKEN. The RX event is closed.\r
9a3293ac 53\r
b45b45b2 54 @param[in] RxToken The UDP_RX_TOKEN to release.\r
9a3293ac 55\r
56**/\r
57VOID\r
58UdpIoFreeRxToken (\r
b45b45b2 59 IN UDP_RX_TOKEN *RxToken\r
9a3293ac 60 )\r
61{\r
b45b45b2 62 if (RxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
63 gBS->CloseEvent (RxToken->Token.Udp4.Event);\r
64 } else if (RxToken->UdpIo->UdpVersion == UDP_IO_UDP6_VERSION) {\r
65 gBS->CloseEvent (RxToken->Token.Udp6.Event);\r
66 } else {\r
67 ASSERT (FALSE);\r
68 } \r
69\r
70 FreePool (RxToken);\r
9a3293ac 71}\r
72\r
73/**\r
74 The callback function when the packet is sent by UDP.\r
cab450cc 75 \r
9a3293ac 76 It will remove the packet from the local list then call\r
cab450cc 77 the packet owner's callback function set by UdpIoSendDatagram.\r
9a3293ac 78\r
8f5e6151 79 @param[in] Context The UDP TX Token.\r
9a3293ac 80\r
81**/\r
36ee91ca 82VOID\r
83EFIAPI\r
84UdpIoOnDgramSentDpc (\r
85 IN VOID *Context\r
9a3293ac 86 )\r
87{\r
b45b45b2 88 UDP_TX_TOKEN *TxToken;\r
9a3293ac 89\r
b45b45b2 90 TxToken = (UDP_TX_TOKEN *) Context;\r
91 ASSERT (TxToken->Signature == UDP_IO_TX_SIGNATURE);\r
92 ASSERT ((TxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||\r
93 (TxToken->UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));\r
94 \r
95 RemoveEntryList (&TxToken->Link);\r
9a3293ac 96\r
b45b45b2 97 if (TxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
98 TxToken->CallBack (TxToken->Packet, NULL, TxToken->Token.Udp4.Status, TxToken->Context);\r
99 } else {\r
100 TxToken->CallBack (TxToken->Packet, NULL, TxToken->Token.Udp6.Status, TxToken->Context);\r
101 }\r
9a3293ac 102\r
b45b45b2 103 UdpIoFreeTxToken (TxToken);\r
9a3293ac 104}\r
105\r
106/**\r
107 Request UdpIoOnDgramSentDpc as a DPC at TPL_CALLBACK.\r
108 \r
8f5e6151 109 @param[in] Event The event signaled.\r
110 @param[in] Context The UDP TX Token.\r
36ee91ca 111\r
9a3293ac 112**/\r
cbf316f2 113VOID\r
114EFIAPI\r
115UdpIoOnDgramSent (\r
116 IN EFI_EVENT Event,\r
117 IN VOID *Context\r
9a3293ac 118 )\r
119{\r
120 //\r
121 // Request UdpIoOnDgramSentDpc as a DPC at TPL_CALLBACK\r
122 //\r
d8d26fb2 123 QueueDpc (TPL_CALLBACK, UdpIoOnDgramSentDpc, Context);\r
9a3293ac 124}\r
125\r
126/**\r
127 Recycle the received UDP data.\r
128\r
8f5e6151 129 @param[in] Context The UDP_RX_TOKEN.\r
cbf316f2 130\r
9a3293ac 131**/\r
132VOID\r
133UdpIoRecycleDgram (\r
134 IN VOID *Context\r
135 )\r
b45b45b2 136{ \r
137 UDP_RX_TOKEN *RxToken;\r
138\r
139 RxToken = (UDP_RX_TOKEN *) Context;\r
140\r
141 if (RxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
142 gBS->SignalEvent (RxToken->Token.Udp4.Packet.RxData->RecycleSignal);\r
143 } else if (RxToken->UdpIo->UdpVersion == UDP_IO_UDP6_VERSION) {\r
144 gBS->SignalEvent (RxToken->Token.Udp6.Packet.RxData->RecycleSignal);\r
145 } else {\r
146 ASSERT (FALSE);\r
147 }\r
9a3293ac 148\r
b45b45b2 149 UdpIoFreeRxToken (RxToken);\r
9a3293ac 150}\r
151\r
152/**\r
cab450cc 153 The event handle for UDP receive request.\r
154 \r
155 It will build a NET_BUF from the recieved UDP data, then deliver it\r
9a3293ac 156 to the receiver.\r
157\r
8f5e6151 158 @param[in] Context The UDP RX token.\r
9a3293ac 159\r
160**/\r
161VOID\r
162EFIAPI\r
163UdpIoOnDgramRcvdDpc (\r
164 IN VOID *Context\r
165 )\r
166{\r
b45b45b2 167 EFI_STATUS Status;\r
168 VOID *Token;\r
169 VOID *RxData;\r
170 VOID *Session;\r
171 UDP_RX_TOKEN *RxToken;\r
172 UDP_END_POINT EndPoint;\r
9a3293ac 173 NET_BUF *Netbuf;\r
174\r
b45b45b2 175 RxToken = (UDP_RX_TOKEN *) Context;\r
9a3293ac 176\r
b45b45b2 177 ZeroMem (&EndPoint, sizeof(UDP_END_POINT));\r
178\r
179 ASSERT ((RxToken->Signature == UDP_IO_RX_SIGNATURE) && \r
180 (RxToken == RxToken->UdpIo->RecvRequest));\r
181\r
182 ASSERT ((RxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||\r
183 (RxToken->UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));\r
9a3293ac 184\r
185 //\r
186 // Clear the receive request first in case that the caller\r
187 // wants to restart the receive in the callback.\r
188 //\r
b45b45b2 189 RxToken->UdpIo->RecvRequest = NULL;\r
190\r
191 if (RxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
192 Token = &RxToken->Token.Udp4;\r
193 RxData = ((EFI_UDP4_COMPLETION_TOKEN *) Token)->Packet.RxData;\r
194 Status = ((EFI_UDP4_COMPLETION_TOKEN *) Token)->Status;\r
195 } else {\r
196 Token = &RxToken->Token.Udp6;\r
197 RxData = ((EFI_UDP6_COMPLETION_TOKEN *) Token)->Packet.RxData;\r
198 Status = ((EFI_UDP6_COMPLETION_TOKEN *) Token)->Status;\r
199 }\r
9a3293ac 200\r
b45b45b2 201 if (EFI_ERROR (Status) || RxData == NULL) {\r
202 if (Status != EFI_ABORTED) {\r
9a3293ac 203 //\r
204 // Invoke the CallBack only if the reception is not actively aborted.\r
205 //\r
b45b45b2 206 RxToken->CallBack (NULL, NULL, Status, RxToken->Context);\r
9a3293ac 207 }\r
208\r
b45b45b2 209 UdpIoFreeRxToken (RxToken);\r
9a3293ac 210 return;\r
211 }\r
212\r
213 //\r
214 // Build a NET_BUF from the UDP receive data, then deliver it up.\r
215 //\r
b45b45b2 216 if (RxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
217 \r
218 Netbuf = NetbufFromExt (\r
219 (NET_FRAGMENT *)((EFI_UDP4_RECEIVE_DATA *) RxData)->FragmentTable,\r
220 ((EFI_UDP4_RECEIVE_DATA *) RxData)->FragmentCount,\r
221 0,\r
222 (UINT32) RxToken->HeadLen,\r
223 UdpIoRecycleDgram,\r
224 RxToken\r
225 );\r
226\r
227 if (Netbuf == NULL) {\r
228 gBS->SignalEvent (((EFI_UDP4_RECEIVE_DATA *) RxData)->RecycleSignal);\r
229 RxToken->CallBack (NULL, NULL, EFI_OUT_OF_RESOURCES, RxToken->Context);\r
230\r
231 UdpIoFreeRxToken (RxToken);\r
232 return;\r
233 }\r
9a3293ac 234\r
b45b45b2 235 Session = &((EFI_UDP4_RECEIVE_DATA *) RxData)->UdpSession;\r
236 EndPoint.LocalPort = ((EFI_UDP4_SESSION_DATA *) Session)->DestinationPort;\r
237 EndPoint.RemotePort = ((EFI_UDP4_SESSION_DATA *) Session)->SourcePort;\r
238\r
239 CopyMem (\r
240 &EndPoint.LocalAddr,\r
241 &((EFI_UDP4_SESSION_DATA *) Session)->DestinationAddress,\r
242 sizeof (EFI_IPv4_ADDRESS)\r
243 );\r
244\r
245 CopyMem (\r
246 &EndPoint.RemoteAddr,\r
247 &((EFI_UDP4_SESSION_DATA *) Session)->SourceAddress,\r
248 sizeof (EFI_IPv4_ADDRESS)\r
249 );\r
250\r
251 EndPoint.LocalAddr.Addr[0] = NTOHL (EndPoint.LocalAddr.Addr[0]);\r
252 EndPoint.RemoteAddr.Addr[0] = NTOHL (EndPoint.RemoteAddr.Addr[0]);\r
253 } else {\r
254 \r
255 Netbuf = NetbufFromExt (\r
256 (NET_FRAGMENT *)((EFI_UDP6_RECEIVE_DATA *) RxData)->FragmentTable,\r
257 ((EFI_UDP6_RECEIVE_DATA *) RxData)->FragmentCount,\r
258 0,\r
259 (UINT32) RxToken->HeadLen,\r
260 UdpIoRecycleDgram,\r
261 RxToken\r
262 );\r
263 \r
264 if (Netbuf == NULL) {\r
265 gBS->SignalEvent (((EFI_UDP6_RECEIVE_DATA *) RxData)->RecycleSignal);\r
266 RxToken->CallBack (NULL, NULL, EFI_OUT_OF_RESOURCES, RxToken->Context);\r
267 \r
268 UdpIoFreeRxToken (RxToken);\r
269 return;\r
270 }\r
271 \r
272 Session = &((EFI_UDP6_RECEIVE_DATA *) RxData)->UdpSession;\r
273 EndPoint.LocalPort = ((EFI_UDP6_SESSION_DATA *) Session)->DestinationPort;\r
274 EndPoint.RemotePort = ((EFI_UDP6_SESSION_DATA *) Session)->SourcePort;\r
275 \r
276 CopyMem (\r
277 &EndPoint.LocalAddr,\r
278 &((EFI_UDP6_SESSION_DATA *) Session)->DestinationAddress,\r
279 sizeof (EFI_IPv6_ADDRESS)\r
280 );\r
281\r
282 CopyMem (\r
283 &EndPoint.RemoteAddr,\r
284 &((EFI_UDP6_SESSION_DATA *) Session)->SourceAddress,\r
285 sizeof (EFI_IPv6_ADDRESS)\r
286 );\r
287\r
288 Ip6Swap128 (&EndPoint.LocalAddr.v6);\r
289 Ip6Swap128 (&EndPoint.RemoteAddr.v6);\r
290 }\r
9a3293ac 291\r
b45b45b2 292 RxToken->CallBack (Netbuf, &EndPoint, EFI_SUCCESS, RxToken->Context);\r
9a3293ac 293}\r
294\r
295/**\r
ca9d3a9d 296 Request UdpIoOnDgramRcvdDpc() as a DPC at TPL_CALLBACK.\r
9a3293ac 297\r
8f5e6151 298 @param[in] Event The UDP receive request event.\r
299 @param[in] Context The UDP RX token.\r
9a3293ac 300\r
301**/\r
cbf316f2 302VOID\r
303EFIAPI\r
304UdpIoOnDgramRcvd (\r
305 IN EFI_EVENT Event,\r
306 IN VOID *Context\r
9a3293ac 307 )\r
308{\r
309 //\r
310 // Request UdpIoOnDgramRcvdDpc as a DPC at TPL_CALLBACK\r
311 //\r
d8d26fb2 312 QueueDpc (TPL_CALLBACK, UdpIoOnDgramRcvdDpc, Context);\r
9a3293ac 313}\r
cbf316f2 314\r
9a3293ac 315/**\r
316 Create a UDP_RX_TOKEN to wrap the request.\r
317\r
8f5e6151 318 @param[in] UdpIo The UdpIo to receive packets from.\r
319 @param[in] CallBack The function to call when receive finished.\r
320 @param[in] Context The opaque parameter to the CallBack.\r
321 @param[in] HeadLen The head length to reserver for the packet.\r
9a3293ac 322\r
323 @return The Wrapped request or NULL if failed to allocate resources or some errors happened.\r
324\r
325**/\r
326UDP_RX_TOKEN *\r
327UdpIoCreateRxToken (\r
b45b45b2 328 IN UDP_IO *UdpIo,\r
9a3293ac 329 IN UDP_IO_CALLBACK CallBack,\r
330 IN VOID *Context,\r
331 IN UINT32 HeadLen\r
332 )\r
333{\r
334 UDP_RX_TOKEN *Token;\r
335 EFI_STATUS Status;\r
336\r
b45b45b2 337 ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||\r
338 (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));\r
339\r
9a3293ac 340 Token = AllocatePool (sizeof (UDP_RX_TOKEN));\r
341\r
342 if (Token == NULL) {\r
343 return NULL;\r
344 }\r
345\r
346 Token->Signature = UDP_IO_RX_SIGNATURE;\r
347 Token->UdpIo = UdpIo;\r
348 Token->CallBack = CallBack;\r
349 Token->Context = Context;\r
350 Token->HeadLen = HeadLen;\r
351\r
b45b45b2 352 if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
353\r
354 Token->Token.Udp4.Status = EFI_NOT_READY;\r
355 Token->Token.Udp4.Packet.RxData = NULL;\r
356\r
357 Status = gBS->CreateEvent (\r
358 EVT_NOTIFY_SIGNAL,\r
359 TPL_NOTIFY,\r
360 UdpIoOnDgramRcvd,\r
361 Token,\r
362 &Token->Token.Udp4.Event\r
363 );\r
364 } else {\r
365 \r
366 Token->Token.Udp6.Status = EFI_NOT_READY;\r
367 Token->Token.Udp6.Packet.RxData = NULL;\r
368\r
369 Status = gBS->CreateEvent (\r
370 EVT_NOTIFY_SIGNAL,\r
371 TPL_NOTIFY,\r
372 UdpIoOnDgramRcvd,\r
373 Token,\r
374 &Token->Token.Udp6.Event\r
375 );\r
376 } \r
9a3293ac 377\r
9a3293ac 378\r
379 if (EFI_ERROR (Status)) {\r
b45b45b2 380 FreePool (Token);\r
9a3293ac 381 return NULL;\r
382 }\r
383\r
384 return Token;\r
385}\r
cbf316f2 386\r
387/**\r
b45b45b2 388 Wrap a transmit request into a new created UDP_TX_TOKEN.\r
cbf316f2 389\r
b45b45b2 390 @param[in] UdpIo The UdpIo to send packet to.\r
8f5e6151 391 @param[in] Packet The user's packet.\r
392 @param[in] EndPoint The local and remote access point.\r
393 @param[in] Gateway The overrided next hop.\r
394 @param[in] CallBack The function to call when transmission completed.\r
395 @param[in] Context The opaque parameter to the call back.\r
cbf316f2 396\r
9a3293ac 397 @return The wrapped transmission request or NULL if failed to allocate resources \r
398 or for some errors.\r
cbf316f2 399\r
400**/\r
cbf316f2 401UDP_TX_TOKEN *\r
b45b45b2 402UdpIoCreateTxToken (\r
403 IN UDP_IO *UdpIo,\r
cbf316f2 404 IN NET_BUF *Packet,\r
b45b45b2 405 IN UDP_END_POINT *EndPoint OPTIONAL,\r
406 IN EFI_IP_ADDRESS *Gateway OPTIONAL,\r
cbf316f2 407 IN UDP_IO_CALLBACK CallBack,\r
408 IN VOID *Context\r
409 )\r
410{\r
b45b45b2 411 UDP_TX_TOKEN *TxToken;\r
412 VOID *Token;\r
413 VOID *Data;\r
cbf316f2 414 EFI_STATUS Status;\r
415 UINT32 Count;\r
b45b45b2 416 UINTN Size;\r
417 IP4_ADDR Ip; \r
cbf316f2 418\r
b45b45b2 419 ASSERT (Packet != NULL);\r
420 ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||\r
421 (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));\r
cbf316f2 422\r
b45b45b2 423 if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
424 Size = sizeof (UDP_TX_TOKEN) + sizeof (EFI_UDP4_FRAGMENT_DATA) * (Packet->BlockOpNum - 1);\r
425 } else {\r
426 Size = sizeof (UDP_TX_TOKEN) + sizeof (EFI_UDP6_FRAGMENT_DATA) * (Packet->BlockOpNum - 1);\r
cbf316f2 427 }\r
428\r
b45b45b2 429 TxToken = AllocatePool (Size);\r
cbf316f2 430\r
b45b45b2 431 if (TxToken == NULL) {\r
432 return NULL;\r
433 }\r
cbf316f2 434\r
b45b45b2 435 TxToken->Signature = UDP_IO_TX_SIGNATURE;\r
436 InitializeListHead (&TxToken->Link);\r
cbf316f2 437\r
b45b45b2 438 TxToken->UdpIo = UdpIo;\r
439 TxToken->CallBack = CallBack;\r
440 TxToken->Packet = Packet;\r
441 TxToken->Context = Context;\r
cbf316f2 442\r
b45b45b2 443 Token = &(TxToken->Token);\r
444 Count = Packet->BlockOpNum;\r
cbf316f2 445\r
b45b45b2 446 if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
cbf316f2 447\r
b45b45b2 448 ((EFI_UDP4_COMPLETION_TOKEN *) Token)->Status = EFI_NOT_READY;\r
cbf316f2 449\r
b45b45b2 450 Status = gBS->CreateEvent (\r
451 EVT_NOTIFY_SIGNAL,\r
452 TPL_NOTIFY,\r
453 UdpIoOnDgramSent,\r
454 TxToken,\r
455 &((EFI_UDP4_COMPLETION_TOKEN *) Token)->Event\r
456 );\r
b61439a7 457\r
b45b45b2 458 if (EFI_ERROR (Status)) {\r
459 FreePool (TxToken);\r
460 return NULL;\r
461 }\r
b61439a7 462\r
b45b45b2 463 Data = &(TxToken->Data.Udp4);\r
464 ((EFI_UDP4_COMPLETION_TOKEN *) Token)->Packet.TxData = Data;\r
465\r
466 ((EFI_UDP4_TRANSMIT_DATA *) Data)->UdpSessionData = NULL;\r
467 ((EFI_UDP4_TRANSMIT_DATA *) Data)->GatewayAddress = NULL;\r
468 ((EFI_UDP4_TRANSMIT_DATA *) Data)->DataLength = Packet->TotalSize;\r
469\r
470 NetbufBuildExt (\r
471 Packet,\r
472 (NET_FRAGMENT *)((EFI_UDP4_TRANSMIT_DATA *) Data)->FragmentTable,\r
473 &Count\r
474 );\r
475\r
476 ((EFI_UDP4_TRANSMIT_DATA *) Data)->FragmentCount = Count;\r
477\r
478 if (EndPoint != NULL) {\r
479 Ip = HTONL (EndPoint->LocalAddr.Addr[0]);\r
480 CopyMem (\r
481 &TxToken->Session.Udp4.SourceAddress, \r
482 &Ip, \r
483 sizeof (EFI_IPv4_ADDRESS)\r
484 );\r
485\r
486 Ip = HTONL (EndPoint->RemoteAddr.Addr[0]);\r
487 CopyMem (\r
488 &TxToken->Session.Udp4.DestinationAddress, \r
489 &Ip, \r
490 sizeof (EFI_IPv4_ADDRESS)\r
491 );\r
492\r
493 TxToken->Session.Udp4.SourcePort = EndPoint->LocalPort;\r
494 TxToken->Session.Udp4.DestinationPort = EndPoint->RemotePort;\r
495 ((EFI_UDP4_TRANSMIT_DATA *) Data)->UdpSessionData = &(TxToken->Session.Udp4);\r
496 }\r
cbf316f2 497\r
b45b45b2 498 if (Gateway != NULL && (Gateway->Addr[0] != 0)) {\r
499 Ip = HTONL (Gateway->Addr[0]);\r
500 CopyMem (&TxToken->Gateway, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
501 ((EFI_UDP4_TRANSMIT_DATA *) Data)->GatewayAddress = &TxToken->Gateway; \r
502 }\r
b61439a7 503\r
b45b45b2 504 } else {\r
505 \r
506 ((EFI_UDP6_COMPLETION_TOKEN *) Token)->Status = EFI_NOT_READY;\r
507 \r
508 Status = gBS->CreateEvent (\r
509 EVT_NOTIFY_SIGNAL,\r
510 TPL_NOTIFY,\r
511 UdpIoOnDgramSent,\r
512 TxToken,\r
513 &((EFI_UDP6_COMPLETION_TOKEN *) Token)->Event\r
514 );\r
515\r
516 if (EFI_ERROR (Status)) {\r
517 FreePool (TxToken);\r
518 return NULL;\r
519 }\r
520 \r
521 Data = &(TxToken->Data.Udp6);\r
522 ((EFI_UDP6_COMPLETION_TOKEN *) Token)->Packet.TxData = Data;\r
523 ((EFI_UDP6_TRANSMIT_DATA *) Data)->UdpSessionData = NULL;\r
524 ((EFI_UDP6_TRANSMIT_DATA *) Data)->DataLength = Packet->TotalSize;\r
525\r
526 NetbufBuildExt (\r
527 Packet,\r
528 (NET_FRAGMENT *)((EFI_UDP6_TRANSMIT_DATA *) Data)->FragmentTable,\r
529 &Count\r
530 );\r
531\r
532 ((EFI_UDP6_TRANSMIT_DATA *) Data)->FragmentCount = Count;\r
533\r
534 if (EndPoint != NULL) {\r
535 CopyMem (\r
536 &TxToken->Session.Udp6.SourceAddress, \r
537 &EndPoint->LocalAddr.v6, \r
538 sizeof(EFI_IPv6_ADDRESS)\r
539 );\r
540\r
541 CopyMem (\r
542 &TxToken->Session.Udp6.DestinationAddress, \r
543 &EndPoint->RemoteAddr.v6, \r
544 sizeof(EFI_IPv6_ADDRESS)\r
545 );\r
546\r
547 TxToken->Session.Udp6.SourcePort = EndPoint->LocalPort;\r
548 TxToken->Session.Udp6.DestinationPort = EndPoint->RemotePort;\r
549 ((EFI_UDP6_TRANSMIT_DATA *) Data)->UdpSessionData = &(TxToken->Session.Udp6);\r
550 } \r
cbf316f2 551 }\r
552\r
b45b45b2 553 return TxToken;\r
cbf316f2 554}\r
555\r
cbf316f2 556/**\r
b45b45b2 557 Creates a UDP_IO to access the UDP service. It creates and configures\r
cab450cc 558 a UDP child.\r
559 \r
b45b45b2 560 This function:\r
561 # locates the UDP service binding prototype on the Controller parameter\r
562 # uses the UDP service binding prototype to create a UDP child (also known as a UDP instance)\r
563 # configures the UDP child by calling Configure function prototype. \r
564 Any failures in creating or configuring the UDP child return NULL for failure. \r
cbf316f2 565\r
8f5e6151 566 @param[in] Controller The controller that has the UDP service binding.\r
567 protocol installed.\r
b45b45b2 568 @param[in] ImageHandle The image handle for the driver.\r
8f5e6151 569 @param[in] Configure The function to configure the created UDP child.\r
b45b45b2 570 @param[in] UdpVersion The UDP protocol version, UDP4 or UDP6.\r
8f5e6151 571 @param[in] Context The opaque parameter for the Configure funtion.\r
cbf316f2 572\r
b45b45b2 573 @return Newly-created UDP_IO or NULL if failed.\r
cbf316f2 574\r
575**/\r
b45b45b2 576UDP_IO *\r
7b414b4e 577EFIAPI\r
b45b45b2 578UdpIoCreateIo (\r
cbf316f2 579 IN EFI_HANDLE Controller,\r
b45b45b2 580 IN EFI_HANDLE ImageHandle,\r
cbf316f2 581 IN UDP_IO_CONFIG Configure,\r
b45b45b2 582 IN UINT8 UdpVersion,\r
cbf316f2 583 IN VOID *Context\r
584 )\r
585{\r
b45b45b2 586 UDP_IO *UdpIo;\r
cbf316f2 587 EFI_STATUS Status;\r
588\r
589 ASSERT (Configure != NULL);\r
b45b45b2 590 ASSERT ((UdpVersion == UDP_IO_UDP4_VERSION) || (UdpVersion == UDP_IO_UDP6_VERSION));\r
cbf316f2 591\r
b45b45b2 592 UdpIo = AllocatePool (sizeof (UDP_IO));\r
cbf316f2 593\r
594 if (UdpIo == NULL) {\r
595 return NULL;\r
596 }\r
597\r
b45b45b2 598 UdpIo->UdpVersion = UdpVersion;\r
cbf316f2 599 UdpIo->Signature = UDP_IO_SIGNATURE;\r
e48e37fc 600 InitializeListHead (&UdpIo->Link);\r
cbf316f2 601 UdpIo->RefCnt = 1;\r
602\r
603 UdpIo->Controller = Controller;\r
b45b45b2 604 UdpIo->Image = ImageHandle;\r
cbf316f2 605\r
e48e37fc 606 InitializeListHead (&UdpIo->SentDatagram);\r
cbf316f2 607 UdpIo->RecvRequest = NULL;\r
608 UdpIo->UdpHandle = NULL;\r
609\r
b45b45b2 610 if (UdpVersion == UDP_IO_UDP4_VERSION) {\r
611 //\r
612 // Create a UDP child then open and configure it\r
613 //\r
614 Status = NetLibCreateServiceChild (\r
615 Controller,\r
616 ImageHandle,\r
617 &gEfiUdp4ServiceBindingProtocolGuid,\r
618 &UdpIo->UdpHandle\r
619 );\r
620 \r
621 if (EFI_ERROR (Status)) {\r
622 goto FREE_MEM;\r
623 }\r
cbf316f2 624\r
b45b45b2 625 Status = gBS->OpenProtocol (\r
626 UdpIo->UdpHandle,\r
627 &gEfiUdp4ProtocolGuid,\r
628 (VOID **) &UdpIo->Protocol.Udp4,\r
629 ImageHandle,\r
630 Controller,\r
631 EFI_OPEN_PROTOCOL_BY_DRIVER\r
632 );\r
633\r
634 if (EFI_ERROR (Status)) {\r
635 goto FREE_CHILD;\r
636 }\r
cbf316f2 637\r
b45b45b2 638 if (EFI_ERROR (Configure (UdpIo, Context))) {\r
639 goto CLOSE_PROTOCOL;\r
640 }\r
641 \r
642 Status = UdpIo->Protocol.Udp4->GetModeData (\r
643 UdpIo->Protocol.Udp4, \r
644 NULL, \r
645 NULL, \r
646 NULL, \r
647 &UdpIo->SnpMode\r
648 );\r
649 \r
650 if (EFI_ERROR (Status)) {\r
651 goto CLOSE_PROTOCOL;\r
652 }\r
cbf316f2 653\r
b45b45b2 654 } else {\r
655 \r
656 Status = NetLibCreateServiceChild (\r
657 Controller,\r
658 ImageHandle,\r
659 &gEfiUdp6ServiceBindingProtocolGuid,\r
660 &UdpIo->UdpHandle\r
661 );\r
662 \r
663 if (EFI_ERROR (Status)) {\r
664 goto FREE_MEM;\r
665 }\r
666 \r
667 Status = gBS->OpenProtocol (\r
668 UdpIo->UdpHandle,\r
669 &gEfiUdp6ProtocolGuid,\r
670 (VOID **) &UdpIo->Protocol.Udp6,\r
671 ImageHandle,\r
672 Controller,\r
673 EFI_OPEN_PROTOCOL_BY_DRIVER\r
674 );\r
675 \r
676 if (EFI_ERROR (Status)) {\r
677 goto FREE_CHILD;\r
678 }\r
679 \r
680 if (EFI_ERROR (Configure (UdpIo, Context))) {\r
681 goto CLOSE_PROTOCOL;\r
682 }\r
683 \r
684 Status = UdpIo->Protocol.Udp6->GetModeData (\r
685 UdpIo->Protocol.Udp6, \r
686 NULL, \r
687 NULL, \r
688 NULL, \r
689 &UdpIo->SnpMode\r
690 );\r
691 \r
692 if (EFI_ERROR (Status)) {\r
693 goto CLOSE_PROTOCOL;\r
694 }\r
cbf316f2 695 }\r
696\r
697 return UdpIo;\r
698\r
699CLOSE_PROTOCOL:\r
b45b45b2 700 if (UdpVersion == UDP_IO_UDP4_VERSION) {\r
701 gBS->CloseProtocol (UdpIo->UdpHandle, &gEfiUdp4ProtocolGuid, ImageHandle, Controller);\r
702 } else {\r
703 gBS->CloseProtocol (UdpIo->UdpHandle, &gEfiUdp6ProtocolGuid, ImageHandle, Controller);\r
704 }\r
cbf316f2 705\r
706FREE_CHILD:\r
b45b45b2 707 if (UdpVersion == UDP_IO_UDP4_VERSION) {\r
708 NetLibDestroyServiceChild (\r
709 Controller,\r
710 ImageHandle,\r
711 &gEfiUdp4ServiceBindingProtocolGuid,\r
712 UdpIo->UdpHandle\r
713 );\r
714 } else {\r
715 NetLibDestroyServiceChild (\r
716 Controller,\r
717 ImageHandle,\r
718 &gEfiUdp6ServiceBindingProtocolGuid,\r
719 UdpIo->UdpHandle\r
720 );\r
721 }\r
cbf316f2 722\r
723FREE_MEM:\r
b45b45b2 724 FreePool (UdpIo);\r
cbf316f2 725 return NULL;\r
726}\r
727\r
cbf316f2 728/**\r
cab450cc 729 Cancel all the sent datagram that pass the selection criteria of ToCancel.\r
cbf316f2 730 If ToCancel is NULL, all the datagrams are cancelled.\r
731\r
b45b45b2 732 @param[in] UdpIo The UDP_IO to cancel packet.\r
8f5e6151 733 @param[in] IoStatus The IoStatus to return to the packet owners.\r
734 @param[in] ToCancel The select funtion to test whether to cancel this\r
735 packet or not.\r
736 @param[in] Context The opaque parameter to the ToCancel.\r
cbf316f2 737\r
cbf316f2 738**/\r
cbf316f2 739VOID\r
e4b99ad9 740EFIAPI\r
cbf316f2 741UdpIoCancelDgrams (\r
b45b45b2 742 IN UDP_IO *UdpIo,\r
cbf316f2 743 IN EFI_STATUS IoStatus,\r
744 IN UDP_IO_TO_CANCEL ToCancel, OPTIONAL\r
745 IN VOID *Context\r
746 )\r
747{\r
e48e37fc 748 LIST_ENTRY *Entry;\r
749 LIST_ENTRY *Next;\r
b45b45b2 750 UDP_TX_TOKEN *TxToken;\r
751\r
752 ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||\r
753 (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));\r
cbf316f2 754\r
755 NET_LIST_FOR_EACH_SAFE (Entry, Next, &UdpIo->SentDatagram) {\r
b45b45b2 756 TxToken = NET_LIST_USER_STRUCT (Entry, UDP_TX_TOKEN, Link);\r
757\r
758 if ((ToCancel == NULL) || (ToCancel (TxToken, Context))) {\r
cbf316f2 759\r
b45b45b2 760 if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
761 UdpIo->Protocol.Udp4->Cancel (UdpIo->Protocol.Udp4, &TxToken->Token.Udp4);\r
762 } else {\r
763 UdpIo->Protocol.Udp6->Cancel (UdpIo->Protocol.Udp6, &TxToken->Token.Udp6);\r
764 }\r
cbf316f2 765 }\r
b45b45b2 766 } \r
cbf316f2 767}\r
768\r
cbf316f2 769/**\r
b45b45b2 770 Free the UDP_IO and all its related resources.\r
cab450cc 771 \r
772 The function will cancel all sent datagram and receive request.\r
cbf316f2 773\r
b45b45b2 774 @param[in] UdpIo The UDP_IO to free.\r
cbf316f2 775\r
b45b45b2 776 @retval EFI_SUCCESS The UDP_IO is freed.\r
cbf316f2 777\r
778**/\r
779EFI_STATUS\r
7b414b4e 780EFIAPI\r
b45b45b2 781UdpIoFreeIo (\r
782 IN UDP_IO *UdpIo\r
cbf316f2 783 )\r
784{\r
b45b45b2 785 UDP_RX_TOKEN *RxToken;\r
786\r
787 ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||\r
788 (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));\r
cbf316f2 789\r
790 //\r
791 // Cancel all the sent datagram and receive requests. The\r
792 // callbacks of transmit requests are executed to allow the\r
793 // caller to release the resource. The callback of receive\r
794 // request are NOT executed. This is because it is most\r
795 // likely that the current user of the UDP IO port is closing\r
796 // itself.\r
797 //\r
798 UdpIoCancelDgrams (UdpIo, EFI_ABORTED, NULL, NULL);\r
799\r
b45b45b2 800 if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
cbf316f2 801\r
b45b45b2 802 if ((RxToken = UdpIo->RecvRequest) != NULL) {\r
803 UdpIo->Protocol.Udp4->Cancel (UdpIo->Protocol.Udp4, &RxToken->Token.Udp4);\r
804 }\r
805\r
806 //\r
807 // Close then destory the Udp4 child\r
808 //\r
809 gBS->CloseProtocol (\r
810 UdpIo->UdpHandle,\r
811 &gEfiUdp4ProtocolGuid,\r
812 UdpIo->Image,\r
813 UdpIo->Controller\r
814 );\r
815\r
816 NetLibDestroyServiceChild (\r
817 UdpIo->Controller,\r
818 UdpIo->Image,\r
819 &gEfiUdp4ServiceBindingProtocolGuid,\r
820 UdpIo->UdpHandle\r
821 );\r
822\r
823 } else {\r
824\r
825 if ((RxToken = UdpIo->RecvRequest) != NULL) {\r
826 UdpIo->Protocol.Udp6->Cancel (UdpIo->Protocol.Udp6, &RxToken->Token.Udp6);\r
827 }\r
828 \r
829 //\r
830 // Close then destory the Udp6 child\r
831 //\r
832 gBS->CloseProtocol (\r
833 UdpIo->UdpHandle,\r
834 &gEfiUdp6ProtocolGuid,\r
835 UdpIo->Image,\r
836 UdpIo->Controller\r
837 );\r
838 \r
839 NetLibDestroyServiceChild (\r
840 UdpIo->Controller,\r
841 UdpIo->Image,\r
842 &gEfiUdp6ServiceBindingProtocolGuid,\r
843 UdpIo->UdpHandle\r
844 );\r
845 }\r
cbf316f2 846\r
687a2e5f 847 if (!IsListEmpty(&UdpIo->Link)) {\r
e48e37fc 848 RemoveEntryList (&UdpIo->Link);\r
687a2e5f 849 }\r
850\r
b45b45b2 851 FreePool (UdpIo);\r
cbf316f2 852 return EFI_SUCCESS;\r
853}\r
854\r
855\r
856/**\r
b45b45b2 857 Clean up the UDP_IO without freeing it. The function is called when\r
858 user wants to re-use the UDP_IO later.\r
cab450cc 859 \r
860 It will release all the transmitted datagrams and receive request. It will\r
861 also configure NULL for the UDP instance.\r
cbf316f2 862\r
b45b45b2 863 @param[in] UdpIo The UDP_IO to clean up.\r
cbf316f2 864\r
cbf316f2 865**/\r
866VOID\r
7b414b4e 867EFIAPI\r
b45b45b2 868UdpIoCleanIo (\r
869 IN UDP_IO *UdpIo\r
cbf316f2 870 )\r
871{\r
872 UDP_RX_TOKEN *RxToken;\r
873\r
b45b45b2 874 ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||\r
875 (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));\r
876\r
cbf316f2 877 //\r
878 // Cancel all the sent datagram and receive requests.\r
879 //\r
880 UdpIoCancelDgrams (UdpIo, EFI_ABORTED, NULL, NULL);\r
881\r
b45b45b2 882 if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
883 if ((RxToken = UdpIo->RecvRequest) != NULL) {\r
884 UdpIo->Protocol.Udp4->Cancel (UdpIo->Protocol.Udp4, &RxToken->Token.Udp4);\r
885 }\r
886\r
887 UdpIo->Protocol.Udp4->Configure (UdpIo->Protocol.Udp4, NULL);\r
cbf316f2 888\r
b45b45b2 889 } else {\r
890 if ((RxToken = UdpIo->RecvRequest) != NULL) {\r
891 UdpIo->Protocol.Udp6->Cancel (UdpIo->Protocol.Udp6, &RxToken->Token.Udp6);\r
892 }\r
893\r
894 UdpIo->Protocol.Udp6->Configure (UdpIo->Protocol.Udp6, NULL);\r
895 }\r
cbf316f2 896}\r
897\r
cbf316f2 898/**\r
b45b45b2 899 Send a packet through the UDP_IO.\r
cab450cc 900 \r
901 The packet will be wrapped in UDP_TX_TOKEN. Function Callback will be called\r
902 when the packet is sent. The optional parameter EndPoint overrides the default\r
903 address pair if specified.\r
cbf316f2 904\r
b45b45b2 905 @param[in] UdpIo The UDP_IO to send the packet through.\r
8f5e6151 906 @param[in] Packet The packet to send.\r
907 @param[in] EndPoint The local and remote access point. Override the\r
908 default address pair set during configuration.\r
b45b45b2 909 @param[in] Gateway The gateway to use. \r
8f5e6151 910 @param[in] CallBack The function being called when packet is\r
911 transmitted or failed.\r
912 @param[in] Context The opaque parameter passed to CallBack.\r
cbf316f2 913\r
8f5e6151 914 @retval EFI_OUT_OF_RESOURCES Failed to allocate resource for the packet.\r
cbf316f2 915 @retval EFI_SUCCESS The packet is successfully delivered to UDP for\r
916 transmission.\r
917\r
918**/\r
919EFI_STATUS\r
7b414b4e 920EFIAPI\r
cbf316f2 921UdpIoSendDatagram (\r
b45b45b2 922 IN UDP_IO *UdpIo,\r
cbf316f2 923 IN NET_BUF *Packet,\r
b45b45b2 924 IN UDP_END_POINT *EndPoint OPTIONAL,\r
925 IN EFI_IP_ADDRESS *Gateway OPTIONAL,\r
cbf316f2 926 IN UDP_IO_CALLBACK CallBack,\r
927 IN VOID *Context\r
928 )\r
929{\r
b45b45b2 930 UDP_TX_TOKEN *TxToken;\r
cbf316f2 931 EFI_STATUS Status;\r
932\r
b45b45b2 933 ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||\r
934 (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));\r
cbf316f2 935\r
b45b45b2 936 TxToken = UdpIoCreateTxToken (UdpIo, Packet, EndPoint, Gateway, CallBack, Context);\r
937\r
938 if (TxToken == NULL) {\r
cbf316f2 939 return EFI_OUT_OF_RESOURCES;\r
940 }\r
941\r
36ee91ca 942 //\r
943 // Insert the tx token into SendDatagram list before transmitting it. Remove\r
944 // it from the list if the returned status is not EFI_SUCCESS.\r
945 //\r
b45b45b2 946 InsertHeadList (&UdpIo->SentDatagram, &TxToken->Link);\r
947\r
948 if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
949 Status = UdpIo->Protocol.Udp4->Transmit (UdpIo->Protocol.Udp4, &TxToken->Token.Udp4);\r
950 } else {\r
951 Status = UdpIo->Protocol.Udp6->Transmit (UdpIo->Protocol.Udp6, &TxToken->Token.Udp6);\r
952 }\r
953\r
cbf316f2 954 if (EFI_ERROR (Status)) {\r
b45b45b2 955 RemoveEntryList (&TxToken->Link);\r
956 UdpIoFreeTxToken (TxToken);\r
cbf316f2 957 return Status;\r
958 }\r
959\r
cbf316f2 960 return EFI_SUCCESS;\r
961}\r
962\r
963\r
964/**\r
cab450cc 965 The select function to cancel a single sent datagram.\r
cbf316f2 966\r
8f5e6151 967 @param[in] Token The UDP_TX_TOKEN to test against\r
968 @param[in] Context The NET_BUF of the sent datagram\r
cbf316f2 969\r
9a3293ac 970 @retval TRUE The packet is to be cancelled.\r
971 @retval FALSE The packet is not to be cancelled.\r
cbf316f2 972**/\r
cbf316f2 973BOOLEAN\r
974UdpIoCancelSingleDgram (\r
975 IN UDP_TX_TOKEN *Token,\r
976 IN VOID *Context\r
977 )\r
978{\r
979 NET_BUF *Packet;\r
980\r
981 Packet = (NET_BUF *) Context;\r
982\r
983 if (Token->Packet == Packet) {\r
984 return TRUE;\r
985 }\r
986\r
987 return FALSE;\r
988}\r
989\r
cbf316f2 990/**\r
991 Cancel a single sent datagram.\r
992\r
b45b45b2 993 @param[in] UdpIo The UDP_IO to cancel the packet from\r
8f5e6151 994 @param[in] Packet The packet to cancel\r
cbf316f2 995\r
cbf316f2 996**/\r
997VOID\r
7b414b4e 998EFIAPI\r
cbf316f2 999UdpIoCancelSentDatagram (\r
b45b45b2 1000 IN UDP_IO *UdpIo,\r
cbf316f2 1001 IN NET_BUF *Packet\r
1002 )\r
1003{\r
1004 UdpIoCancelDgrams (UdpIo, EFI_ABORTED, UdpIoCancelSingleDgram, Packet);\r
1005}\r
1006\r
cbf316f2 1007/**\r
b45b45b2 1008 Issue a receive request to the UDP_IO.\r
cab450cc 1009 \r
1010 This function is called when upper-layer needs packet from UDP for processing.\r
1011 Only one receive request is acceptable at a time so a common usage model is\r
1012 to invoke this function inside its Callback function when the former packet\r
1013 is processed.\r
cbf316f2 1014\r
b45b45b2 1015 @param[in] UdpIo The UDP_IO to receive the packet from.\r
8f5e6151 1016 @param[in] CallBack The call back function to execute when the packet\r
1017 is received.\r
1018 @param[in] Context The opaque context passed to Callback.\r
b45b45b2 1019 @param[in] HeadLen The length of the upper-layer's protocol header.\r
cbf316f2 1020\r
1021 @retval EFI_ALREADY_STARTED There is already a pending receive request. Only\r
cab450cc 1022 one receive request is supported at a time.\r
1023 @retval EFI_OUT_OF_RESOURCES Failed to allocate needed resources.\r
cbf316f2 1024 @retval EFI_SUCCESS The receive request is issued successfully.\r
b45b45b2 1025 @retval EFI_UNSUPPORTED The UDP version in UDP_IO is not supported.\r
cbf316f2 1026\r
1027**/\r
1028EFI_STATUS\r
7b414b4e 1029EFIAPI\r
cbf316f2 1030UdpIoRecvDatagram (\r
b45b45b2 1031 IN UDP_IO *UdpIo,\r
cbf316f2 1032 IN UDP_IO_CALLBACK CallBack,\r
1033 IN VOID *Context,\r
1034 IN UINT32 HeadLen\r
1035 )\r
1036{\r
b45b45b2 1037 UDP_RX_TOKEN *RxToken;\r
cbf316f2 1038 EFI_STATUS Status;\r
1039\r
b45b45b2 1040 ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||\r
1041 (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));\r
1042\r
cbf316f2 1043 if (UdpIo->RecvRequest != NULL) {\r
1044 return EFI_ALREADY_STARTED;\r
1045 }\r
1046\r
b45b45b2 1047 RxToken = UdpIoCreateRxToken (UdpIo, CallBack, Context, HeadLen);\r
cbf316f2 1048\r
b45b45b2 1049 if (RxToken == NULL) {\r
cbf316f2 1050 return EFI_OUT_OF_RESOURCES;\r
1051 }\r
1052\r
b45b45b2 1053 UdpIo->RecvRequest = RxToken;\r
1054 if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
1055 Status = UdpIo->Protocol.Udp4->Receive (UdpIo->Protocol.Udp4, &RxToken->Token.Udp4);\r
1056 } else {\r
1057 Status = UdpIo->Protocol.Udp6->Receive (UdpIo->Protocol.Udp6, &RxToken->Token.Udp6);\r
1058 }\r
cbf316f2 1059\r
1060 if (EFI_ERROR (Status)) {\r
36ee91ca 1061 UdpIo->RecvRequest = NULL;\r
b45b45b2 1062 UdpIoFreeRxToken (RxToken);\r
cbf316f2 1063 }\r
1064\r
36ee91ca 1065 return Status;\r
cbf316f2 1066}\r
EFI Development Kit II mirror for PVE