]> git.proxmox.com Git - mirror_edk2.git/blame_incremental - MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.c
projects / mirror_edk2.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
refine the code and add more security check.
[mirror_edk2.git] / MdeModulePkg / Library / DxeUdpIoLib / DxeUdpIoLib.c
... / ...
CommitLineData
1/** @file\r
2 Help functions to access UDP service, it is used by both the DHCP and MTFTP.\r
3\r
4Copyright (c) 2005 - 2009, Intel Corporation.<BR>\r
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
7which accompanies this distribution. The full text of the license may be found at<BR>\r
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
12**/\r
13\r
14#include <Uefi.h>\r
15\r
16#include <Protocol/Udp4.h>\r
17#include <Protocol/Udp6.h>\r
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
24#include <Library/BaseMemoryLib.h>\r
25#include <Library/DpcLib.h>\r
26\r
27\r
28/**\r
29 Free a UDP_TX_TOKEN. The TX event is closed.\r
30\r
31 @param[in] TxToken The UDP_TX_TOKEN to release.\r
32\r
33**/\r
34VOID\r
35UdpIoFreeTxToken (\r
36 IN UDP_TX_TOKEN *TxToken\r
37 )\r
38{\r
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
49}\r
50\r
51/**\r
52 Free a UDP_RX_TOKEN. The RX event is closed.\r
53\r
54 @param[in] RxToken The UDP_RX_TOKEN to release.\r
55\r
56**/\r
57VOID\r
58UdpIoFreeRxToken (\r
59 IN UDP_RX_TOKEN *RxToken\r
60 )\r
61{\r
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
71}\r
72\r
73/**\r
74 The callback function when the packet is sent by UDP.\r
75\r
76 It will remove the packet from the local list then call\r
77 the packet owner's callback function set by UdpIoSendDatagram.\r
78\r
79 @param[in] Context The UDP TX Token.\r
80\r
81**/\r
82VOID\r
83EFIAPI\r
84UdpIoOnDgramSentDpc (\r
85 IN VOID *Context\r
86 )\r
87{\r
88 UDP_TX_TOKEN *TxToken;\r
89\r
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
96\r
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
102\r
103 UdpIoFreeTxToken (TxToken);\r
104}\r
105\r
106/**\r
107 Request UdpIoOnDgramSentDpc as a DPC at TPL_CALLBACK.\r
108\r
109 @param[in] Event The event signaled.\r
110 @param[in] Context The UDP TX Token.\r
111\r
112**/\r
113VOID\r
114EFIAPI\r
115UdpIoOnDgramSent (\r
116 IN EFI_EVENT Event,\r
117 IN VOID *Context\r
118 )\r
119{\r
120 //\r
121 // Request UdpIoOnDgramSentDpc as a DPC at TPL_CALLBACK\r
122 //\r
123 QueueDpc (TPL_CALLBACK, UdpIoOnDgramSentDpc, Context);\r
124}\r
125\r
126/**\r
127 Recycle the received UDP data.\r
128\r
129 @param[in] Context The UDP_RX_TOKEN.\r
130\r
131**/\r
132VOID\r
133UdpIoRecycleDgram (\r
134 IN VOID *Context\r
135 )\r
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
148\r
149 UdpIoFreeRxToken (RxToken);\r
150}\r
151\r
152/**\r
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
156 to the receiver.\r
157\r
158 @param[in] Context The UDP RX token.\r
159\r
160**/\r
161VOID\r
162EFIAPI\r
163UdpIoOnDgramRcvdDpc (\r
164 IN VOID *Context\r
165 )\r
166{\r
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
173 NET_BUF *Netbuf;\r
174\r
175 RxToken = (UDP_RX_TOKEN *) Context;\r
176\r
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
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
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
200\r
201 if (EFI_ERROR (Status) || RxData == NULL) {\r
202 if (Status != EFI_ABORTED) {\r
203 //\r
204 // Invoke the CallBack only if the reception is not actively aborted.\r
205 //\r
206 RxToken->CallBack (NULL, NULL, Status, RxToken->Context);\r
207 }\r
208\r
209 UdpIoFreeRxToken (RxToken);\r
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
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
234\r
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
291\r
292 RxToken->CallBack (Netbuf, &EndPoint, EFI_SUCCESS, RxToken->Context);\r
293}\r
294\r
295/**\r
296 Request UdpIoOnDgramRcvdDpc() as a DPC at TPL_CALLBACK.\r
297\r
298 @param[in] Event The UDP receive request event.\r
299 @param[in] Context The UDP RX token.\r
300\r
301**/\r
302VOID\r
303EFIAPI\r
304UdpIoOnDgramRcvd (\r
305 IN EFI_EVENT Event,\r
306 IN VOID *Context\r
307 )\r
308{\r
309 //\r
310 // Request UdpIoOnDgramRcvdDpc as a DPC at TPL_CALLBACK\r
311 //\r
312 QueueDpc (TPL_CALLBACK, UdpIoOnDgramRcvdDpc, Context);\r
313}\r
314\r
315/**\r
316 Create a UDP_RX_TOKEN to wrap the request.\r
317\r
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
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
328 IN UDP_IO *UdpIo,\r
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
337 ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||\r
338 (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));\r
339\r
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
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
377\r
378\r
379 if (EFI_ERROR (Status)) {\r
380 FreePool (Token);\r
381 return NULL;\r
382 }\r
383\r
384 return Token;\r
385}\r
386\r
387/**\r
388 Wrap a transmit request into a new created UDP_TX_TOKEN.\r
389\r
390 @param[in] UdpIo The UdpIo to send packet to.\r
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
396\r
397 @return The wrapped transmission request or NULL if failed to allocate resources\r
398 or for some errors.\r
399\r
400**/\r
401UDP_TX_TOKEN *\r
402UdpIoCreateTxToken (\r
403 IN UDP_IO *UdpIo,\r
404 IN NET_BUF *Packet,\r
405 IN UDP_END_POINT *EndPoint OPTIONAL,\r
406 IN EFI_IP_ADDRESS *Gateway OPTIONAL,\r
407 IN UDP_IO_CALLBACK CallBack,\r
408 IN VOID *Context\r
409 )\r
410{\r
411 UDP_TX_TOKEN *TxToken;\r
412 VOID *Token;\r
413 VOID *Data;\r
414 EFI_STATUS Status;\r
415 UINT32 Count;\r
416 UINTN Size;\r
417 IP4_ADDR Ip;\r
418\r
419 ASSERT (Packet != NULL);\r
420 ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||\r
421 (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));\r
422\r
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
427 }\r
428\r
429 TxToken = AllocatePool (Size);\r
430\r
431 if (TxToken == NULL) {\r
432 return NULL;\r
433 }\r
434\r
435 TxToken->Signature = UDP_IO_TX_SIGNATURE;\r
436 InitializeListHead (&TxToken->Link);\r
437\r
438 TxToken->UdpIo = UdpIo;\r
439 TxToken->CallBack = CallBack;\r
440 TxToken->Packet = Packet;\r
441 TxToken->Context = Context;\r
442\r
443 Token = &(TxToken->Token);\r
444 Count = Packet->BlockOpNum;\r
445\r
446 if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
447\r
448 ((EFI_UDP4_COMPLETION_TOKEN *) Token)->Status = EFI_NOT_READY;\r
449\r
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
457\r
458 if (EFI_ERROR (Status)) {\r
459 FreePool (TxToken);\r
460 return NULL;\r
461 }\r
462\r
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
497\r
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
503\r
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
551 }\r
552\r
553 return TxToken;\r
554}\r
555\r
556/**\r
557 Creates a UDP_IO to access the UDP service. It creates and configures\r
558 a UDP child.\r
559\r
560 It locates the UDP service binding prototype on the Controller parameter\r
561 uses the UDP service binding prototype to create a UDP child (also known as\r
562 a UDP instance) configures the UDP child by calling Configure function prototype.\r
563 Any failures in creating or configuring the UDP child return NULL for failure.\r
564\r
565 @param[in] Controller The controller that has the UDP service binding.\r
566 protocol installed.\r
567 @param[in] ImageHandle The image handle for the driver.\r
568 @param[in] Configure The function to configure the created UDP child.\r
569 @param[in] UdpVersion The UDP protocol version, UDP4 or UDP6.\r
570 @param[in] Context The opaque parameter for the Configure funtion.\r
571\r
572 @return Newly-created UDP_IO or NULL if failed.\r
573\r
574**/\r
575UDP_IO *\r
576EFIAPI\r
577UdpIoCreateIo (\r
578 IN EFI_HANDLE Controller,\r
579 IN EFI_HANDLE ImageHandle,\r
580 IN UDP_IO_CONFIG Configure,\r
581 IN UINT8 UdpVersion,\r
582 IN VOID *Context\r
583 )\r
584{\r
585 UDP_IO *UdpIo;\r
586 EFI_STATUS Status;\r
587\r
588 ASSERT (Configure != NULL);\r
589 ASSERT ((UdpVersion == UDP_IO_UDP4_VERSION) || (UdpVersion == UDP_IO_UDP6_VERSION));\r
590\r
591 UdpIo = AllocatePool (sizeof (UDP_IO));\r
592\r
593 if (UdpIo == NULL) {\r
594 return NULL;\r
595 }\r
596\r
597 UdpIo->UdpVersion = UdpVersion;\r
598 UdpIo->Signature = UDP_IO_SIGNATURE;\r
599 InitializeListHead (&UdpIo->Link);\r
600 UdpIo->RefCnt = 1;\r
601\r
602 UdpIo->Controller = Controller;\r
603 UdpIo->Image = ImageHandle;\r
604\r
605 InitializeListHead (&UdpIo->SentDatagram);\r
606 UdpIo->RecvRequest = NULL;\r
607 UdpIo->UdpHandle = NULL;\r
608\r
609 if (UdpVersion == UDP_IO_UDP4_VERSION) {\r
610 //\r
611 // Create a UDP child then open and configure it\r
612 //\r
613 Status = NetLibCreateServiceChild (\r
614 Controller,\r
615 ImageHandle,\r
616 &gEfiUdp4ServiceBindingProtocolGuid,\r
617 &UdpIo->UdpHandle\r
618 );\r
619\r
620 if (EFI_ERROR (Status)) {\r
621 goto FREE_MEM;\r
622 }\r
623\r
624 Status = gBS->OpenProtocol (\r
625 UdpIo->UdpHandle,\r
626 &gEfiUdp4ProtocolGuid,\r
627 (VOID **) &UdpIo->Protocol.Udp4,\r
628 ImageHandle,\r
629 Controller,\r
630 EFI_OPEN_PROTOCOL_BY_DRIVER\r
631 );\r
632\r
633 if (EFI_ERROR (Status)) {\r
634 goto FREE_CHILD;\r
635 }\r
636\r
637 if (EFI_ERROR (Configure (UdpIo, Context))) {\r
638 goto CLOSE_PROTOCOL;\r
639 }\r
640\r
641 Status = UdpIo->Protocol.Udp4->GetModeData (\r
642 UdpIo->Protocol.Udp4,\r
643 NULL,\r
644 NULL,\r
645 NULL,\r
646 &UdpIo->SnpMode\r
647 );\r
648\r
649 if (EFI_ERROR (Status)) {\r
650 goto CLOSE_PROTOCOL;\r
651 }\r
652\r
653 } else {\r
654\r
655 Status = NetLibCreateServiceChild (\r
656 Controller,\r
657 ImageHandle,\r
658 &gEfiUdp6ServiceBindingProtocolGuid,\r
659 &UdpIo->UdpHandle\r
660 );\r
661\r
662 if (EFI_ERROR (Status)) {\r
663 goto FREE_MEM;\r
664 }\r
665\r
666 Status = gBS->OpenProtocol (\r
667 UdpIo->UdpHandle,\r
668 &gEfiUdp6ProtocolGuid,\r
669 (VOID **) &UdpIo->Protocol.Udp6,\r
670 ImageHandle,\r
671 Controller,\r
672 EFI_OPEN_PROTOCOL_BY_DRIVER\r
673 );\r
674\r
675 if (EFI_ERROR (Status)) {\r
676 goto FREE_CHILD;\r
677 }\r
678\r
679 if (EFI_ERROR (Configure (UdpIo, Context))) {\r
680 goto CLOSE_PROTOCOL;\r
681 }\r
682\r
683 Status = UdpIo->Protocol.Udp6->GetModeData (\r
684 UdpIo->Protocol.Udp6,\r
685 NULL,\r
686 NULL,\r
687 NULL,\r
688 &UdpIo->SnpMode\r
689 );\r
690\r
691 if (EFI_ERROR (Status)) {\r
692 goto CLOSE_PROTOCOL;\r
693 }\r
694 }\r
695\r
696 return UdpIo;\r
697\r
698CLOSE_PROTOCOL:\r
699 if (UdpVersion == UDP_IO_UDP4_VERSION) {\r
700 gBS->CloseProtocol (UdpIo->UdpHandle, &gEfiUdp4ProtocolGuid, ImageHandle, Controller);\r
701 } else {\r
702 gBS->CloseProtocol (UdpIo->UdpHandle, &gEfiUdp6ProtocolGuid, ImageHandle, Controller);\r
703 }\r
704\r
705FREE_CHILD:\r
706 if (UdpVersion == UDP_IO_UDP4_VERSION) {\r
707 NetLibDestroyServiceChild (\r
708 Controller,\r
709 ImageHandle,\r
710 &gEfiUdp4ServiceBindingProtocolGuid,\r
711 UdpIo->UdpHandle\r
712 );\r
713 } else {\r
714 NetLibDestroyServiceChild (\r
715 Controller,\r
716 ImageHandle,\r
717 &gEfiUdp6ServiceBindingProtocolGuid,\r
718 UdpIo->UdpHandle\r
719 );\r
720 }\r
721\r
722FREE_MEM:\r
723 FreePool (UdpIo);\r
724 return NULL;\r
725}\r
726\r
727/**\r
728 Cancel all the sent datagram that pass the selection criteria of ToCancel.\r
729 If ToCancel is NULL, all the datagrams are cancelled.\r
730\r
731 @param[in] UdpIo The UDP_IO to cancel packet.\r
732 @param[in] IoStatus The IoStatus to return to the packet owners.\r
733 @param[in] ToCancel The select funtion to test whether to cancel this\r
734 packet or not.\r
735 @param[in] Context The opaque parameter to the ToCancel.\r
736\r
737**/\r
738VOID\r
739EFIAPI\r
740UdpIoCancelDgrams (\r
741 IN UDP_IO *UdpIo,\r
742 IN EFI_STATUS IoStatus,\r
743 IN UDP_IO_TO_CANCEL ToCancel, OPTIONAL\r
744 IN VOID *Context\r
745 )\r
746{\r
747 LIST_ENTRY *Entry;\r
748 LIST_ENTRY *Next;\r
749 UDP_TX_TOKEN *TxToken;\r
750\r
751 ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||\r
752 (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));\r
753\r
754 NET_LIST_FOR_EACH_SAFE (Entry, Next, &UdpIo->SentDatagram) {\r
755 TxToken = NET_LIST_USER_STRUCT (Entry, UDP_TX_TOKEN, Link);\r
756\r
757 if ((ToCancel == NULL) || (ToCancel (TxToken, Context))) {\r
758\r
759 if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
760 UdpIo->Protocol.Udp4->Cancel (UdpIo->Protocol.Udp4, &TxToken->Token.Udp4);\r
761 } else {\r
762 UdpIo->Protocol.Udp6->Cancel (UdpIo->Protocol.Udp6, &TxToken->Token.Udp6);\r
763 }\r
764 }\r
765 }\r
766}\r
767\r
768/**\r
769 Free the UDP_IO and all its related resources.\r
770\r
771 The function will cancel all sent datagram and receive request.\r
772\r
773 @param[in] UdpIo The UDP_IO to free.\r
774\r
775 @retval EFI_SUCCESS The UDP_IO is freed.\r
776\r
777**/\r
778EFI_STATUS\r
779EFIAPI\r
780UdpIoFreeIo (\r
781 IN UDP_IO *UdpIo\r
782 )\r
783{\r
784 UDP_RX_TOKEN *RxToken;\r
785\r
786 ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||\r
787 (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));\r
788\r
789 //\r
790 // Cancel all the sent datagram and receive requests. The\r
791 // callbacks of transmit requests are executed to allow the\r
792 // caller to release the resource. The callback of receive\r
793 // request are NOT executed. This is because it is most\r
794 // likely that the current user of the UDP IO port is closing\r
795 // itself.\r
796 //\r
797 UdpIoCancelDgrams (UdpIo, EFI_ABORTED, NULL, NULL);\r
798\r
799 if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
800\r
801 if ((RxToken = UdpIo->RecvRequest) != NULL) {\r
802 UdpIo->Protocol.Udp4->Cancel (UdpIo->Protocol.Udp4, &RxToken->Token.Udp4);\r
803 }\r
804\r
805 //\r
806 // Close then destory the Udp4 child\r
807 //\r
808 gBS->CloseProtocol (\r
809 UdpIo->UdpHandle,\r
810 &gEfiUdp4ProtocolGuid,\r
811 UdpIo->Image,\r
812 UdpIo->Controller\r
813 );\r
814\r
815 NetLibDestroyServiceChild (\r
816 UdpIo->Controller,\r
817 UdpIo->Image,\r
818 &gEfiUdp4ServiceBindingProtocolGuid,\r
819 UdpIo->UdpHandle\r
820 );\r
821\r
822 } else {\r
823\r
824 if ((RxToken = UdpIo->RecvRequest) != NULL) {\r
825 UdpIo->Protocol.Udp6->Cancel (UdpIo->Protocol.Udp6, &RxToken->Token.Udp6);\r
826 }\r
827\r
828 //\r
829 // Close then destory the Udp6 child\r
830 //\r
831 gBS->CloseProtocol (\r
832 UdpIo->UdpHandle,\r
833 &gEfiUdp6ProtocolGuid,\r
834 UdpIo->Image,\r
835 UdpIo->Controller\r
836 );\r
837\r
838 NetLibDestroyServiceChild (\r
839 UdpIo->Controller,\r
840 UdpIo->Image,\r
841 &gEfiUdp6ServiceBindingProtocolGuid,\r
842 UdpIo->UdpHandle\r
843 );\r
844 }\r
845\r
846 if (!IsListEmpty(&UdpIo->Link)) {\r
847 RemoveEntryList (&UdpIo->Link);\r
848 }\r
849\r
850 FreePool (UdpIo);\r
851 return EFI_SUCCESS;\r
852}\r
853\r
854\r
855/**\r
856 Clean up the UDP_IO without freeing it. The function is called when\r
857 user wants to re-use the UDP_IO later.\r
858\r
859 It will release all the transmitted datagrams and receive request. It will\r
860 also configure NULL for the UDP instance.\r
861\r
862 @param[in] UdpIo The UDP_IO to clean up.\r
863\r
864**/\r
865VOID\r
866EFIAPI\r
867UdpIoCleanIo (\r
868 IN UDP_IO *UdpIo\r
869 )\r
870{\r
871 UDP_RX_TOKEN *RxToken;\r
872\r
873 ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||\r
874 (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));\r
875\r
876 //\r
877 // Cancel all the sent datagram and receive requests.\r
878 //\r
879 UdpIoCancelDgrams (UdpIo, EFI_ABORTED, NULL, NULL);\r
880\r
881 if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
882 if ((RxToken = UdpIo->RecvRequest) != NULL) {\r
883 UdpIo->Protocol.Udp4->Cancel (UdpIo->Protocol.Udp4, &RxToken->Token.Udp4);\r
884 }\r
885\r
886 UdpIo->Protocol.Udp4->Configure (UdpIo->Protocol.Udp4, NULL);\r
887\r
888 } else {\r
889 if ((RxToken = UdpIo->RecvRequest) != NULL) {\r
890 UdpIo->Protocol.Udp6->Cancel (UdpIo->Protocol.Udp6, &RxToken->Token.Udp6);\r
891 }\r
892\r
893 UdpIo->Protocol.Udp6->Configure (UdpIo->Protocol.Udp6, NULL);\r
894 }\r
895}\r
896\r
897/**\r
898 Send a packet through the UDP_IO.\r
899\r
900 The packet will be wrapped in UDP_TX_TOKEN. Function Callback will be called\r
901 when the packet is sent. The optional parameter EndPoint overrides the default\r
902 address pair if specified.\r
903\r
904 @param[in] UdpIo The UDP_IO to send the packet through.\r
905 @param[in] Packet The packet to send.\r
906 @param[in] EndPoint The local and remote access point. Override the\r
907 default address pair set during configuration.\r
908 @param[in] Gateway The gateway to use.\r
909 @param[in] CallBack The function being called when packet is\r
910 transmitted or failed.\r
911 @param[in] Context The opaque parameter passed to CallBack.\r
912\r
913 @retval EFI_OUT_OF_RESOURCES Failed to allocate resource for the packet.\r
914 @retval EFI_SUCCESS The packet is successfully delivered to UDP for\r
915 transmission.\r
916\r
917**/\r
918EFI_STATUS\r
919EFIAPI\r
920UdpIoSendDatagram (\r
921 IN UDP_IO *UdpIo,\r
922 IN NET_BUF *Packet,\r
923 IN UDP_END_POINT *EndPoint OPTIONAL,\r
924 IN EFI_IP_ADDRESS *Gateway OPTIONAL,\r
925 IN UDP_IO_CALLBACK CallBack,\r
926 IN VOID *Context\r
927 )\r
928{\r
929 UDP_TX_TOKEN *TxToken;\r
930 EFI_STATUS Status;\r
931\r
932 ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||\r
933 (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));\r
934\r
935 TxToken = UdpIoCreateTxToken (UdpIo, Packet, EndPoint, Gateway, CallBack, Context);\r
936\r
937 if (TxToken == NULL) {\r
938 return EFI_OUT_OF_RESOURCES;\r
939 }\r
940\r
941 //\r
942 // Insert the tx token into SendDatagram list before transmitting it. Remove\r
943 // it from the list if the returned status is not EFI_SUCCESS.\r
944 //\r
945 InsertHeadList (&UdpIo->SentDatagram, &TxToken->Link);\r
946\r
947 if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
948 Status = UdpIo->Protocol.Udp4->Transmit (UdpIo->Protocol.Udp4, &TxToken->Token.Udp4);\r
949 } else {\r
950 Status = UdpIo->Protocol.Udp6->Transmit (UdpIo->Protocol.Udp6, &TxToken->Token.Udp6);\r
951 }\r
952\r
953 if (EFI_ERROR (Status)) {\r
954 RemoveEntryList (&TxToken->Link);\r
955 UdpIoFreeTxToken (TxToken);\r
956 return Status;\r
957 }\r
958\r
959 return EFI_SUCCESS;\r
960}\r
961\r
962\r
963/**\r
964 The select function to cancel a single sent datagram.\r
965\r
966 @param[in] Token The UDP_TX_TOKEN to test against\r
967 @param[in] Context The NET_BUF of the sent datagram\r
968\r
969 @retval TRUE The packet is to be cancelled.\r
970 @retval FALSE The packet is not to be cancelled.\r
971**/\r
972BOOLEAN\r
973UdpIoCancelSingleDgram (\r
974 IN UDP_TX_TOKEN *Token,\r
975 IN VOID *Context\r
976 )\r
977{\r
978 NET_BUF *Packet;\r
979\r
980 Packet = (NET_BUF *) Context;\r
981\r
982 if (Token->Packet == Packet) {\r
983 return TRUE;\r
984 }\r
985\r
986 return FALSE;\r
987}\r
988\r
989/**\r
990 Cancel a single sent datagram.\r
991\r
992 @param[in] UdpIo The UDP_IO to cancel the packet from\r
993 @param[in] Packet The packet to cancel\r
994\r
995**/\r
996VOID\r
997EFIAPI\r
998UdpIoCancelSentDatagram (\r
999 IN UDP_IO *UdpIo,\r
1000 IN NET_BUF *Packet\r
1001 )\r
1002{\r
1003 UdpIoCancelDgrams (UdpIo, EFI_ABORTED, UdpIoCancelSingleDgram, Packet);\r
1004}\r
1005\r
1006/**\r
1007 Issue a receive request to the UDP_IO.\r
1008\r
1009 This function is called when upper-layer needs packet from UDP for processing.\r
1010 Only one receive request is acceptable at a time so a common usage model is\r
1011 to invoke this function inside its Callback function when the former packet\r
1012 is processed.\r
1013\r
1014 @param[in] UdpIo The UDP_IO to receive the packet from.\r
1015 @param[in] CallBack The call back function to execute when the packet\r
1016 is received.\r
1017 @param[in] Context The opaque context passed to Callback.\r
1018 @param[in] HeadLen The length of the upper-layer's protocol header.\r
1019\r
1020 @retval EFI_ALREADY_STARTED There is already a pending receive request. Only\r
1021 one receive request is supported at a time.\r
1022 @retval EFI_OUT_OF_RESOURCES Failed to allocate needed resources.\r
1023 @retval EFI_SUCCESS The receive request is issued successfully.\r
1024 @retval EFI_UNSUPPORTED The UDP version in UDP_IO is not supported.\r
1025\r
1026**/\r
1027EFI_STATUS\r
1028EFIAPI\r
1029UdpIoRecvDatagram (\r
1030 IN UDP_IO *UdpIo,\r
1031 IN UDP_IO_CALLBACK CallBack,\r
1032 IN VOID *Context,\r
1033 IN UINT32 HeadLen\r
1034 )\r
1035{\r
1036 UDP_RX_TOKEN *RxToken;\r
1037 EFI_STATUS Status;\r
1038\r
1039 ASSERT ((UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||\r
1040 (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION));\r
1041\r
1042 if (UdpIo->RecvRequest != NULL) {\r
1043 return EFI_ALREADY_STARTED;\r
1044 }\r
1045\r
1046 RxToken = UdpIoCreateRxToken (UdpIo, CallBack, Context, HeadLen);\r
1047\r
1048 if (RxToken == NULL) {\r
1049 return EFI_OUT_OF_RESOURCES;\r
1050 }\r
1051\r
1052 UdpIo->RecvRequest = RxToken;\r
1053 if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {\r
1054 Status = UdpIo->Protocol.Udp4->Receive (UdpIo->Protocol.Udp4, &RxToken->Token.Udp4);\r
1055 } else {\r
1056 Status = UdpIo->Protocol.Udp6->Receive (UdpIo->Protocol.Udp6, &RxToken->Token.Udp6);\r
1057 }\r
1058\r
1059 if (EFI_ERROR (Status)) {\r
1060 UdpIo->RecvRequest = NULL;\r
1061 UdpIoFreeRxToken (RxToken);\r
1062 }\r
1063\r
1064 return Status;\r
1065}\r
EFI Development Kit II mirror for PVE