]> git.proxmox.com Git - mirror_edk2.git/blame_incremental - MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.c
projects / mirror_edk2.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
MdeModulePkg: Source fixes and cleanup for ARMGCC compiles
[mirror_edk2.git] / MdeModulePkg / Library / DxeIpIoLib / DxeIpIoLib.c
... / ...
CommitLineData
1/** @file\r
2 IpIo Library.\r
3\r
4(C) Copyright 2014 Hewlett-Packard Development Company, L.P.<BR>\r
5Copyright (c) 2005 - 2009, Intel Corporation. All rights reserved.<BR>\r
6This program and the accompanying materials\r
7are licensed and made available under the terms and conditions of the BSD License\r
8which accompanies this distribution. The full text of the license may be found at\r
9http://opensource.org/licenses/bsd-license.php\r
10\r
11THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
12WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
13**/\r
14\r
15#include <Uefi.h>\r
16\r
17#include <Protocol/Udp4.h>\r
18\r
19#include <Library/IpIoLib.h>\r
20#include <Library/BaseLib.h>\r
21#include <Library/DebugLib.h>\r
22#include <Library/BaseMemoryLib.h>\r
23#include <Library/UefiBootServicesTableLib.h>\r
24#include <Library/MemoryAllocationLib.h>\r
25#include <Library/DpcLib.h>\r
26\r
27\r
28GLOBAL_REMOVE_IF_UNREFERENCED LIST_ENTRY mActiveIpIoList = {\r
29 &mActiveIpIoList,\r
30 &mActiveIpIoList\r
31};\r
32\r
33GLOBAL_REMOVE_IF_UNREFERENCED EFI_IP4_CONFIG_DATA mIp4IoDefaultIpConfigData = {\r
34 EFI_IP_PROTO_UDP,\r
35 FALSE,\r
36 TRUE,\r
37 FALSE,\r
38 FALSE,\r
39 FALSE,\r
40 {{0, 0, 0, 0}},\r
41 {{0, 0, 0, 0}},\r
42 0,\r
43 255,\r
44 FALSE,\r
45 FALSE,\r
46 0,\r
47 0\r
48};\r
49\r
50GLOBAL_REMOVE_IF_UNREFERENCED EFI_IP6_CONFIG_DATA mIp6IoDefaultIpConfigData = {\r
51 EFI_IP_PROTO_UDP,\r
52 FALSE,\r
53 TRUE,\r
54 FALSE,\r
55 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},\r
56 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},\r
57 0,\r
58 255,\r
59 0,\r
60 0,\r
61 0\r
62};\r
63\r
64GLOBAL_REMOVE_IF_UNREFERENCED ICMP_ERROR_INFO mIcmpErrMap[10] = {\r
65 {FALSE, TRUE }, // ICMP_ERR_UNREACH_NET\r
66 {FALSE, TRUE }, // ICMP_ERR_UNREACH_HOST\r
67 {TRUE, TRUE }, // ICMP_ERR_UNREACH_PROTOCOL\r
68 {TRUE, TRUE }, // ICMP_ERR_UNREACH_PORT\r
69 {TRUE, TRUE }, // ICMP_ERR_MSGSIZE\r
70 {FALSE, TRUE }, // ICMP_ERR_UNREACH_SRCFAIL\r
71 {FALSE, TRUE }, // ICMP_ERR_TIMXCEED_INTRANS\r
72 {FALSE, TRUE }, // ICMP_ERR_TIMEXCEED_REASS\r
73 {FALSE, FALSE}, // ICMP_ERR_QUENCH\r
74 {FALSE, TRUE } // ICMP_ERR_PARAMPROB\r
75};\r
76\r
77GLOBAL_REMOVE_IF_UNREFERENCED ICMP_ERROR_INFO mIcmp6ErrMap[10] = {\r
78 {FALSE, TRUE}, // ICMP6_ERR_UNREACH_NET\r
79 {FALSE, TRUE}, // ICMP6_ERR_UNREACH_HOST\r
80 {TRUE, TRUE}, // ICMP6_ERR_UNREACH_PROTOCOL\r
81 {TRUE, TRUE}, // ICMP6_ERR_UNREACH_PORT \r
82 {TRUE, TRUE}, // ICMP6_ERR_PACKAGE_TOOBIG\r
83 {FALSE, TRUE}, // ICMP6_ERR_TIMXCEED_HOPLIMIT\r
84 {FALSE, TRUE}, // ICMP6_ERR_TIMXCEED_REASS\r
85 {FALSE, TRUE}, // ICMP6_ERR_PARAMPROB_HEADER \r
86 {FALSE, TRUE}, // ICMP6_ERR_PARAMPROB_NEXHEADER\r
87 {FALSE, TRUE} // ICMP6_ERR_PARAMPROB_IPV6OPTION\r
88};\r
89\r
90\r
91/**\r
92 Notify function for IP transmit token.\r
93\r
94 @param[in] Context The context passed in by the event notifier.\r
95\r
96**/\r
97VOID\r
98EFIAPI\r
99IpIoTransmitHandlerDpc (\r
100 IN VOID *Context\r
101 );\r
102\r
103\r
104/**\r
105 Notify function for IP transmit token.\r
106\r
107 @param[in] Event The event signaled.\r
108 @param[in] Context The context passed in by the event notifier.\r
109\r
110**/\r
111VOID\r
112EFIAPI\r
113IpIoTransmitHandler (\r
114 IN EFI_EVENT Event,\r
115 IN VOID *Context\r
116 );\r
117\r
118\r
119/**\r
120 This function create an IP child ,open the IP protocol, and return the opened\r
121 IP protocol as Interface.\r
122\r
123 @param[in] ControllerHandle The controller handle.\r
124 @param[in] ImageHandle The image handle.\r
125 @param[in] ChildHandle Pointer to the buffer to save the IP child handle.\r
126 @param[in] IpVersion The version of the IP protocol to use, either\r
127 IPv4 or IPv6.\r
128 @param[out] Interface Pointer used to get the IP protocol interface.\r
129\r
130 @retval EFI_SUCCESS The IP child is created and the IP protocol\r
131 interface is retrieved.\r
132 @retval Others The required operation failed.\r
133\r
134**/\r
135EFI_STATUS\r
136IpIoCreateIpChildOpenProtocol (\r
137 IN EFI_HANDLE ControllerHandle,\r
138 IN EFI_HANDLE ImageHandle,\r
139 IN EFI_HANDLE *ChildHandle,\r
140 IN UINT8 IpVersion,\r
141 OUT VOID **Interface\r
142 )\r
143{\r
144 EFI_STATUS Status;\r
145 EFI_GUID *ServiceBindingGuid;\r
146 EFI_GUID *IpProtocolGuid;\r
147\r
148 if (IpVersion == IP_VERSION_4) {\r
149 ServiceBindingGuid = &gEfiIp4ServiceBindingProtocolGuid;\r
150 IpProtocolGuid = &gEfiIp4ProtocolGuid;\r
151 } else if (IpVersion == IP_VERSION_6){\r
152 ServiceBindingGuid = &gEfiIp6ServiceBindingProtocolGuid;\r
153 IpProtocolGuid = &gEfiIp6ProtocolGuid;\r
154 } else {\r
155 return EFI_UNSUPPORTED;\r
156 }\r
157\r
158 //\r
159 // Create an IP child.\r
160 //\r
161 Status = NetLibCreateServiceChild (\r
162 ControllerHandle,\r
163 ImageHandle,\r
164 ServiceBindingGuid,\r
165 ChildHandle\r
166 );\r
167 if (EFI_ERROR (Status)) {\r
168 return Status;\r
169 }\r
170\r
171 //\r
172 // Open the IP protocol installed on the *ChildHandle.\r
173 //\r
174 Status = gBS->OpenProtocol (\r
175 *ChildHandle,\r
176 IpProtocolGuid,\r
177 Interface,\r
178 ImageHandle,\r
179 ControllerHandle,\r
180 EFI_OPEN_PROTOCOL_BY_DRIVER\r
181 );\r
182 if (EFI_ERROR (Status)) {\r
183 //\r
184 // On failure, destroy the IP child.\r
185 //\r
186 NetLibDestroyServiceChild (\r
187 ControllerHandle,\r
188 ImageHandle,\r
189 ServiceBindingGuid,\r
190 *ChildHandle\r
191 );\r
192 }\r
193\r
194 return Status;\r
195}\r
196\r
197\r
198/**\r
199 This function close the previously openned IP protocol and destroy the IP child.\r
200\r
201 @param[in] ControllerHandle The controller handle.\r
202 @param[in] ImageHandle The image handle.\r
203 @param[in] ChildHandle The child handle of the IP child.\r
204 @param[in] IpVersion The version of the IP protocol to use, either\r
205 IPv4 or IPv6.\r
206\r
207 @retval EFI_SUCCESS The IP protocol is closed and the relevant IP child\r
208 is destroyed.\r
209 @retval Others The required operation failed.\r
210\r
211**/\r
212EFI_STATUS\r
213IpIoCloseProtocolDestroyIpChild (\r
214 IN EFI_HANDLE ControllerHandle,\r
215 IN EFI_HANDLE ImageHandle,\r
216 IN EFI_HANDLE ChildHandle,\r
217 IN UINT8 IpVersion\r
218 )\r
219{\r
220 EFI_STATUS Status;\r
221 EFI_GUID *ServiceBindingGuid;\r
222 EFI_GUID *IpProtocolGuid;\r
223\r
224 if (IpVersion == IP_VERSION_4) {\r
225 ServiceBindingGuid = &gEfiIp4ServiceBindingProtocolGuid;\r
226 IpProtocolGuid = &gEfiIp4ProtocolGuid;\r
227 } else if (IpVersion == IP_VERSION_6) {\r
228 ServiceBindingGuid = &gEfiIp6ServiceBindingProtocolGuid;\r
229 IpProtocolGuid = &gEfiIp6ProtocolGuid;\r
230 } else {\r
231 return EFI_UNSUPPORTED;\r
232 }\r
233\r
234 //\r
235 // Close the previously openned IP protocol.\r
236 //\r
237 gBS->CloseProtocol (\r
238 ChildHandle,\r
239 IpProtocolGuid,\r
240 ImageHandle,\r
241 ControllerHandle\r
242 );\r
243\r
244 //\r
245 // Destroy the IP child.\r
246 //\r
247 Status = NetLibDestroyServiceChild (\r
248 ControllerHandle,\r
249 ImageHandle,\r
250 ServiceBindingGuid,\r
251 ChildHandle\r
252 );\r
253\r
254 return Status;\r
255}\r
256\r
257/**\r
258 This function handles ICMPv4 packets. It is the worker function of \r
259 IpIoIcmpHandler.\r
260\r
261 @param[in] IpIo Pointer to the IP_IO instance.\r
262 @param[in, out] Pkt Pointer to the ICMPv4 packet.\r
263 @param[in] Session Pointer to the net session of this ICMPv4 packet.\r
264\r
265 @retval EFI_SUCCESS The ICMPv4 packet is handled successfully.\r
266 @retval EFI_ABORTED This type of ICMPv4 packet is not supported.\r
267\r
268**/\r
269EFI_STATUS\r
270IpIoIcmpv4Handler (\r
271 IN IP_IO *IpIo,\r
272 IN OUT NET_BUF *Pkt,\r
273 IN EFI_NET_SESSION_DATA *Session\r
274 )\r
275{\r
276 IP4_ICMP_ERROR_HEAD *IcmpHdr;\r
277 EFI_IP4_HEADER *IpHdr;\r
278 UINT8 IcmpErr;\r
279 UINT8 *PayLoadHdr;\r
280 UINT8 Type;\r
281 UINT8 Code;\r
282 UINT32 TrimBytes;\r
283\r
284 ASSERT (IpIo->IpVersion == IP_VERSION_4);\r
285\r
286 IcmpHdr = NET_PROTO_HDR (Pkt, IP4_ICMP_ERROR_HEAD);\r
287 IpHdr = (EFI_IP4_HEADER *) (&IcmpHdr->IpHead);\r
288\r
289 //\r
290 // Check the ICMP packet length.\r
291 //\r
292 if (Pkt->TotalSize < ICMP_ERRLEN (IpHdr)) {\r
293\r
294 return EFI_ABORTED;\r
295 }\r
296\r
297 Type = IcmpHdr->Head.Type;\r
298 Code = IcmpHdr->Head.Code;\r
299\r
300 //\r
301 // Analyze the ICMP Error in this ICMP pkt\r
302 //\r
303 switch (Type) {\r
304 case ICMP_TYPE_UNREACH:\r
305 switch (Code) {\r
306 case ICMP_CODE_UNREACH_NET:\r
307 case ICMP_CODE_UNREACH_HOST:\r
308 case ICMP_CODE_UNREACH_PROTOCOL:\r
309 case ICMP_CODE_UNREACH_PORT:\r
310 case ICMP_CODE_UNREACH_SRCFAIL:\r
311 IcmpErr = (UINT8) (ICMP_ERR_UNREACH_NET + Code);\r
312\r
313 break;\r
314\r
315 case ICMP_CODE_UNREACH_NEEDFRAG:\r
316 IcmpErr = ICMP_ERR_MSGSIZE;\r
317\r
318 break;\r
319\r
320 case ICMP_CODE_UNREACH_NET_UNKNOWN:\r
321 case ICMP_CODE_UNREACH_NET_PROHIB:\r
322 case ICMP_CODE_UNREACH_TOSNET:\r
323 IcmpErr = ICMP_ERR_UNREACH_NET;\r
324\r
325 break;\r
326\r
327 case ICMP_CODE_UNREACH_HOST_UNKNOWN:\r
328 case ICMP_CODE_UNREACH_ISOLATED:\r
329 case ICMP_CODE_UNREACH_HOST_PROHIB:\r
330 case ICMP_CODE_UNREACH_TOSHOST:\r
331 IcmpErr = ICMP_ERR_UNREACH_HOST;\r
332\r
333 break;\r
334\r
335 default:\r
336 return EFI_ABORTED;\r
337 }\r
338\r
339 break;\r
340\r
341 case ICMP_TYPE_TIMXCEED:\r
342 if (Code > 1) {\r
343 return EFI_ABORTED;\r
344 }\r
345\r
346 IcmpErr = (UINT8) (Code + ICMP_ERR_TIMXCEED_INTRANS);\r
347\r
348 break;\r
349\r
350 case ICMP_TYPE_PARAMPROB:\r
351 if (Code > 1) {\r
352 return EFI_ABORTED;\r
353 }\r
354\r
355 IcmpErr = ICMP_ERR_PARAMPROB;\r
356\r
357 break;\r
358\r
359 case ICMP_TYPE_SOURCEQUENCH:\r
360 if (Code != 0) {\r
361 return EFI_ABORTED;\r
362 }\r
363\r
364 IcmpErr = ICMP_ERR_QUENCH;\r
365\r
366 break;\r
367\r
368 default:\r
369 return EFI_ABORTED;\r
370 }\r
371\r
372 //\r
373 // Notify user the ICMP pkt only containing payload except\r
374 // IP and ICMP header\r
375 //\r
376 PayLoadHdr = (UINT8 *) ((UINT8 *) IpHdr + EFI_IP4_HEADER_LEN (IpHdr));\r
377 TrimBytes = (UINT32) (PayLoadHdr - (UINT8 *) IcmpHdr);\r
378\r
379 NetbufTrim (Pkt, TrimBytes, TRUE);\r
380\r
381 IpIo->PktRcvdNotify (EFI_ICMP_ERROR, IcmpErr, Session, Pkt, IpIo->RcvdContext);\r
382\r
383 return EFI_SUCCESS; \r
384}\r
385\r
386/**\r
387 This function handles ICMPv6 packets. It is the worker function of \r
388 IpIoIcmpHandler.\r
389\r
390 @param[in] IpIo Pointer to the IP_IO instance.\r
391 @param[in, out] Pkt Pointer to the ICMPv6 packet.\r
392 @param[in] Session Pointer to the net session of this ICMPv6 packet.\r
393\r
394 @retval EFI_SUCCESS The ICMPv6 packet is handled successfully.\r
395 @retval EFI_ABORTED This type of ICMPv6 packet is not supported.\r
396\r
397**/\r
398EFI_STATUS\r
399IpIoIcmpv6Handler (\r
400 IN IP_IO *IpIo,\r
401 IN OUT NET_BUF *Pkt,\r
402 IN EFI_NET_SESSION_DATA *Session\r
403 )\r
404{\r
405 IP6_ICMP_ERROR_HEAD *IcmpHdr;\r
406 EFI_IP6_HEADER *IpHdr;\r
407 UINT8 IcmpErr;\r
408 UINT8 *PayLoadHdr;\r
409 UINT8 Type;\r
410 UINT8 Code;\r
411 UINT8 NextHeader;\r
412 UINT32 TrimBytes;\r
413 BOOLEAN Flag;\r
414\r
415 ASSERT (IpIo->IpVersion == IP_VERSION_6);\r
416\r
417 //\r
418 // Check the ICMPv6 packet length.\r
419 //\r
420 if (Pkt->TotalSize < sizeof (IP6_ICMP_ERROR_HEAD)) {\r
421\r
422 return EFI_ABORTED;\r
423 }\r
424\r
425 IcmpHdr = NET_PROTO_HDR (Pkt, IP6_ICMP_ERROR_HEAD);\r
426 Type = IcmpHdr->Head.Type;\r
427 Code = IcmpHdr->Head.Code;\r
428\r
429 //\r
430 // Analyze the ICMPv6 Error in this ICMPv6 packet\r
431 // \r
432 switch (Type) {\r
433 case ICMP_V6_DEST_UNREACHABLE:\r
434 switch (Code) {\r
435 case ICMP_V6_NO_ROUTE_TO_DEST:\r
436 case ICMP_V6_BEYOND_SCOPE:\r
437 case ICMP_V6_ROUTE_REJECTED:\r
438 IcmpErr = ICMP6_ERR_UNREACH_NET;\r
439\r
440 break;\r
441\r
442 case ICMP_V6_COMM_PROHIBITED:\r
443 case ICMP_V6_ADDR_UNREACHABLE:\r
444 case ICMP_V6_SOURCE_ADDR_FAILED:\r
445 IcmpErr = ICMP6_ERR_UNREACH_HOST;\r
446\r
447 break;\r
448\r
449 case ICMP_V6_PORT_UNREACHABLE:\r
450 IcmpErr = ICMP6_ERR_UNREACH_PORT;\r
451\r
452 break;\r
453\r
454 default:\r
455 return EFI_ABORTED;\r
456 }\r
457\r
458 break;\r
459\r
460 case ICMP_V6_PACKET_TOO_BIG:\r
461 if (Code >= 1) {\r
462 return EFI_ABORTED;\r
463 }\r
464\r
465 IcmpErr = ICMP6_ERR_PACKAGE_TOOBIG;\r
466\r
467 break;\r
468\r
469 case ICMP_V6_TIME_EXCEEDED:\r
470 if (Code > 1) {\r
471 return EFI_ABORTED;\r
472 }\r
473\r
474 IcmpErr = (UINT8) (ICMP6_ERR_TIMXCEED_HOPLIMIT + Code);\r
475\r
476 break;\r
477\r
478 case ICMP_V6_PARAMETER_PROBLEM:\r
479 if (Code > 3) {\r
480 return EFI_ABORTED;\r
481 }\r
482\r
483 IcmpErr = (UINT8) (ICMP6_ERR_PARAMPROB_HEADER + Code);\r
484\r
485 break;\r
486\r
487 default:\r
488\r
489 return EFI_ABORTED;\r
490 } \r
491\r
492 //\r
493 // Notify user the ICMPv6 packet only containing payload except\r
494 // IPv6 basic header, extension header and ICMP header\r
495 //\r
496\r
497 IpHdr = (EFI_IP6_HEADER *) (&IcmpHdr->IpHead);\r
498 NextHeader = IpHdr->NextHeader;\r
499 PayLoadHdr = (UINT8 *) ((UINT8 *) IcmpHdr + sizeof (IP6_ICMP_ERROR_HEAD));\r
500 Flag = TRUE;\r
501 \r
502 do {\r
503 switch (NextHeader) {\r
504 case EFI_IP_PROTO_UDP:\r
505 case EFI_IP_PROTO_TCP:\r
506 case EFI_IP_PROTO_ICMP:\r
507 case IP6_NO_NEXT_HEADER:\r
508 Flag = FALSE;\r
509\r
510 break;\r
511\r
512 case IP6_HOP_BY_HOP:\r
513 case IP6_DESTINATION:\r
514 //\r
515 // The Hdr Ext Len is 8-bit unsigned integer in 8-octet units, not including\r
516 // the first 8 octets.\r
517 //\r
518 NextHeader = *(PayLoadHdr);\r
519 PayLoadHdr = (UINT8 *) (PayLoadHdr + (*(PayLoadHdr + 1) + 1) * 8);\r
520\r
521 break;\r
522\r
523 case IP6_FRAGMENT:\r
524 //\r
525 // The Fragment Header Length is 8 octets.\r
526 //\r
527 NextHeader = *(PayLoadHdr);\r
528 PayLoadHdr = (UINT8 *) (PayLoadHdr + 8);\r
529\r
530 break;\r
531\r
532 default:\r
533\r
534 return EFI_ABORTED;\r
535 }\r
536 } while (Flag);\r
537\r
538 TrimBytes = (UINT32) (PayLoadHdr - (UINT8 *) IcmpHdr);\r
539 \r
540 NetbufTrim (Pkt, TrimBytes, TRUE);\r
541\r
542 IpIo->PktRcvdNotify (EFI_ICMP_ERROR, IcmpErr, Session, Pkt, IpIo->RcvdContext);\r
543\r
544 return EFI_SUCCESS;\r
545}\r
546\r
547/**\r
548 This function handles ICMP packets.\r
549\r
550 @param[in] IpIo Pointer to the IP_IO instance.\r
551 @param[in, out] Pkt Pointer to the ICMP packet.\r
552 @param[in] Session Pointer to the net session of this ICMP packet.\r
553\r
554 @retval EFI_SUCCESS The ICMP packet is handled successfully.\r
555 @retval EFI_ABORTED This type of ICMP packet is not supported.\r
556 @retval EFI_UNSUPPORTED The IP protocol version in IP_IO is not supported.\r
557\r
558**/\r
559EFI_STATUS\r
560IpIoIcmpHandler (\r
561 IN IP_IO *IpIo,\r
562 IN OUT NET_BUF *Pkt,\r
563 IN EFI_NET_SESSION_DATA *Session\r
564 )\r
565{\r
566\r
567 if (IpIo->IpVersion == IP_VERSION_4) {\r
568\r
569 return IpIoIcmpv4Handler (IpIo, Pkt, Session);\r
570\r
571 } else if (IpIo->IpVersion == IP_VERSION_6) {\r
572\r
573 return IpIoIcmpv6Handler (IpIo, Pkt, Session);\r
574\r
575 } else {\r
576\r
577 return EFI_UNSUPPORTED;\r
578 }\r
579}\r
580\r
581\r
582/**\r
583 Free function for receive token of IP_IO. It is used to\r
584 signal the recycle event to notify IP to recycle the\r
585 data buffer.\r
586\r
587 @param[in] Event The event to be signaled.\r
588\r
589**/\r
590VOID\r
591EFIAPI\r
592IpIoExtFree (\r
593 IN VOID *Event\r
594 )\r
595{\r
596 gBS->SignalEvent ((EFI_EVENT) Event);\r
597}\r
598\r
599\r
600/**\r
601 Create a send entry to wrap a packet before sending\r
602 out it through IP.\r
603\r
604 @param[in, out] IpIo Pointer to the IP_IO instance.\r
605 @param[in, out] Pkt Pointer to the packet.\r
606 @param[in] Sender Pointer to the IP sender.\r
607 @param[in] Context Pointer to the context.\r
608 @param[in] NotifyData Pointer to the notify data.\r
609 @param[in] Dest Pointer to the destination IP address.\r
610 @param[in] Override Pointer to the overriden IP_IO data.\r
611\r
612 @return Pointer to the data structure created to wrap the packet. If NULL,\r
613 @return resource limit occurred.\r
614\r
615**/\r
616IP_IO_SEND_ENTRY *\r
617IpIoCreateSndEntry (\r
618 IN OUT IP_IO *IpIo,\r
619 IN OUT NET_BUF *Pkt,\r
620 IN IP_IO_IP_PROTOCOL Sender,\r
621 IN VOID *Context OPTIONAL,\r
622 IN VOID *NotifyData OPTIONAL,\r
623 IN EFI_IP_ADDRESS *Dest OPTIONAL,\r
624 IN IP_IO_OVERRIDE *Override\r
625 )\r
626{\r
627 IP_IO_SEND_ENTRY *SndEntry;\r
628 EFI_EVENT Event; \r
629 EFI_STATUS Status;\r
630 NET_FRAGMENT *ExtFragment;\r
631 UINT32 FragmentCount;\r
632 IP_IO_OVERRIDE *OverrideData;\r
633 IP_IO_IP_TX_DATA *TxData;\r
634 EFI_IP4_TRANSMIT_DATA *Ip4TxData;\r
635 EFI_IP6_TRANSMIT_DATA *Ip6TxData;\r
636\r
637 if ((IpIo->IpVersion != IP_VERSION_4) && (IpIo->IpVersion != IP_VERSION_6)) {\r
638 return NULL;\r
639 }\r
640\r
641 Event = NULL;\r
642 TxData = NULL;\r
643 OverrideData = NULL;\r
644\r
645 //\r
646 // Allocate resource for SndEntry\r
647 //\r
648 SndEntry = AllocatePool (sizeof (IP_IO_SEND_ENTRY));\r
649 if (NULL == SndEntry) {\r
650 return NULL;\r
651 }\r
652\r
653 Status = gBS->CreateEvent (\r
654 EVT_NOTIFY_SIGNAL,\r
655 TPL_NOTIFY,\r
656 IpIoTransmitHandler,\r
657 SndEntry,\r
658 &Event\r
659 );\r
660 if (EFI_ERROR (Status)) {\r
661 goto ON_ERROR;\r
662 }\r
663\r
664 FragmentCount = Pkt->BlockOpNum;\r
665\r
666 //\r
667 // Allocate resource for TxData\r
668 //\r
669 TxData = (IP_IO_IP_TX_DATA *) AllocatePool (\r
670 sizeof (IP_IO_IP_TX_DATA) + sizeof (NET_FRAGMENT) * (FragmentCount - 1)\r
671 );\r
672\r
673 if (NULL == TxData) {\r
674 goto ON_ERROR;\r
675 }\r
676\r
677 //\r
678 // Build a fragment table to contain the fragments in the packet. \r
679 //\r
680 if (IpIo->IpVersion == IP_VERSION_4) {\r
681 ExtFragment = (NET_FRAGMENT *) TxData->Ip4TxData.FragmentTable;\r
682 } else {\r
683 ExtFragment = (NET_FRAGMENT *) TxData->Ip6TxData.FragmentTable;\r
684 }\r
685\r
686 NetbufBuildExt (Pkt, ExtFragment, &FragmentCount);\r
687\r
688\r
689 //\r
690 // Allocate resource for OverrideData if needed\r
691 //\r
692 if (NULL != Override) {\r
693\r
694 OverrideData = AllocateCopyPool (sizeof (IP_IO_OVERRIDE), Override);\r
695 if (NULL == OverrideData) {\r
696 goto ON_ERROR;\r
697 }\r
698 }\r
699\r
700 //\r
701 // Set other fields of TxData except the fragment table\r
702 //\r
703 if (IpIo->IpVersion == IP_VERSION_4) {\r
704\r
705 Ip4TxData = &TxData->Ip4TxData;\r
706\r
707 IP4_COPY_ADDRESS (&Ip4TxData->DestinationAddress, Dest);\r
708\r
709 Ip4TxData->OverrideData = &OverrideData->Ip4OverrideData;\r
710 Ip4TxData->OptionsLength = 0;\r
711 Ip4TxData->OptionsBuffer = NULL;\r
712 Ip4TxData->TotalDataLength = Pkt->TotalSize;\r
713 Ip4TxData->FragmentCount = FragmentCount;\r
714\r
715 //\r
716 // Set the fields of SndToken\r
717 //\r
718 SndEntry->SndToken.Ip4Token.Event = Event;\r
719 SndEntry->SndToken.Ip4Token.Packet.TxData = Ip4TxData;\r
720 } else {\r
721\r
722 Ip6TxData = &TxData->Ip6TxData;\r
723\r
724 if (Dest != NULL) {\r
725 CopyMem (&Ip6TxData->DestinationAddress, Dest, sizeof (EFI_IPv6_ADDRESS));\r
726 } else {\r
727 ZeroMem (&Ip6TxData->DestinationAddress, sizeof (EFI_IPv6_ADDRESS));\r
728 }\r
729\r
730 Ip6TxData->OverrideData = &OverrideData->Ip6OverrideData;\r
731 Ip6TxData->DataLength = Pkt->TotalSize;\r
732 Ip6TxData->FragmentCount = FragmentCount;\r
733 Ip6TxData->ExtHdrsLength = 0;\r
734 Ip6TxData->ExtHdrs = NULL;\r
735 \r
736 //\r
737 // Set the fields of SndToken\r
738 //\r
739 SndEntry->SndToken.Ip6Token.Event = Event;\r
740 SndEntry->SndToken.Ip6Token.Packet.TxData = Ip6TxData;\r
741 }\r
742\r
743 //\r
744 // Set the fields of SndEntry\r
745 //\r
746 SndEntry->IpIo = IpIo;\r
747 SndEntry->Ip = Sender;\r
748 SndEntry->Context = Context;\r
749 SndEntry->NotifyData = NotifyData;\r
750\r
751 SndEntry->Pkt = Pkt;\r
752 NET_GET_REF (Pkt);\r
753\r
754 InsertTailList (&IpIo->PendingSndList, &SndEntry->Entry);\r
755\r
756 return SndEntry;\r
757\r
758ON_ERROR:\r
759\r
760 if (OverrideData != NULL) {\r
761 FreePool (OverrideData);\r
762 }\r
763\r
764 if (TxData != NULL) {\r
765 FreePool (TxData);\r
766 }\r
767\r
768 if (SndEntry != NULL) {\r
769 FreePool (SndEntry);\r
770 }\r
771\r
772 if (Event != NULL) {\r
773 gBS->CloseEvent (Event);\r
774 }\r
775\r
776 return NULL;\r
777}\r
778\r
779\r
780/**\r
781 Destroy the SndEntry.\r
782 \r
783 This function pairs with IpIoCreateSndEntry().\r
784\r
785 @param[in] SndEntry Pointer to the send entry to be destroyed.\r
786\r
787**/\r
788VOID\r
789IpIoDestroySndEntry (\r
790 IN IP_IO_SEND_ENTRY *SndEntry\r
791 )\r
792{\r
793 EFI_EVENT Event;\r
794 IP_IO_IP_TX_DATA *TxData;\r
795 IP_IO_OVERRIDE *Override;\r
796\r
797 if (SndEntry->IpIo->IpVersion == IP_VERSION_4) {\r
798 Event = SndEntry->SndToken.Ip4Token.Event;\r
799 TxData = (IP_IO_IP_TX_DATA *) SndEntry->SndToken.Ip4Token.Packet.TxData;\r
800 Override = (IP_IO_OVERRIDE *) TxData->Ip4TxData.OverrideData;\r
801 } else if (SndEntry->IpIo->IpVersion == IP_VERSION_6) {\r
802 Event = SndEntry->SndToken.Ip6Token.Event;\r
803 TxData = (IP_IO_IP_TX_DATA *) SndEntry->SndToken.Ip6Token.Packet.TxData;\r
804 Override = (IP_IO_OVERRIDE *) TxData->Ip6TxData.OverrideData;\r
805 } else {\r
806 return ;\r
807 }\r
808\r
809 gBS->CloseEvent (Event);\r
810\r
811 FreePool (TxData);\r
812\r
813 if (NULL != Override) {\r
814 FreePool (Override);\r
815 }\r
816\r
817 NetbufFree (SndEntry->Pkt);\r
818\r
819 RemoveEntryList (&SndEntry->Entry);\r
820\r
821 FreePool (SndEntry);\r
822}\r
823\r
824\r
825/**\r
826 Notify function for IP transmit token.\r
827\r
828 @param[in] Context The context passed in by the event notifier.\r
829\r
830**/\r
831VOID\r
832EFIAPI\r
833IpIoTransmitHandlerDpc (\r
834 IN VOID *Context\r
835 )\r
836{\r
837 IP_IO *IpIo;\r
838 IP_IO_SEND_ENTRY *SndEntry;\r
839 EFI_STATUS Status;\r
840\r
841 SndEntry = (IP_IO_SEND_ENTRY *) Context;\r
842\r
843 IpIo = SndEntry->IpIo;\r
844\r
845 if (IpIo->IpVersion == IP_VERSION_4) {\r
846 Status = SndEntry->SndToken.Ip4Token.Status;\r
847 } else if (IpIo->IpVersion == IP_VERSION_6){\r
848 Status = SndEntry->SndToken.Ip6Token.Status;\r
849 } else {\r
850 return ;\r
851 }\r
852\r
853 if ((IpIo->PktSentNotify != NULL) && (SndEntry->NotifyData != NULL)) {\r
854 IpIo->PktSentNotify (\r
855 Status,\r
856 SndEntry->Context,\r
857 SndEntry->Ip,\r
858 SndEntry->NotifyData\r
859 );\r
860 }\r
861\r
862 IpIoDestroySndEntry (SndEntry);\r
863}\r
864\r
865\r
866/**\r
867 Notify function for IP transmit token.\r
868\r
869 @param[in] Event The event signaled.\r
870 @param[in] Context The context passed in by the event notifier.\r
871\r
872**/\r
873VOID\r
874EFIAPI\r
875IpIoTransmitHandler (\r
876 IN EFI_EVENT Event,\r
877 IN VOID *Context\r
878 )\r
879{\r
880 //\r
881 // Request IpIoTransmitHandlerDpc as a DPC at TPL_CALLBACK\r
882 //\r
883 QueueDpc (TPL_CALLBACK, IpIoTransmitHandlerDpc, Context);\r
884}\r
885\r
886\r
887/**\r
888 The dummy handler for the dummy IP receive token.\r
889\r
890 @param[in] Context The context passed in by the event notifier.\r
891\r
892**/\r
893VOID\r
894EFIAPI\r
895IpIoDummyHandlerDpc (\r
896 IN VOID *Context\r
897 )\r
898{\r
899 IP_IO_IP_INFO *IpInfo;\r
900 EFI_STATUS Status;\r
901 EFI_EVENT RecycleEvent;\r
902\r
903 IpInfo = (IP_IO_IP_INFO *) Context;\r
904\r
905 if ((IpInfo->IpVersion != IP_VERSION_4) && (IpInfo->IpVersion != IP_VERSION_6)) {\r
906 return ;\r
907 }\r
908\r
909 RecycleEvent = NULL;\r
910\r
911 if (IpInfo->IpVersion == IP_VERSION_4) {\r
912 Status = IpInfo->DummyRcvToken.Ip4Token.Status;\r
913\r
914 if (IpInfo->DummyRcvToken.Ip4Token.Packet.RxData != NULL) {\r
915 RecycleEvent = IpInfo->DummyRcvToken.Ip4Token.Packet.RxData->RecycleSignal;\r
916 }\r
917 } else {\r
918 Status = IpInfo->DummyRcvToken.Ip6Token.Status;\r
919\r
920 if (IpInfo->DummyRcvToken.Ip6Token.Packet.RxData != NULL) {\r
921 RecycleEvent = IpInfo->DummyRcvToken.Ip6Token.Packet.RxData->RecycleSignal;\r
922 }\r
923 }\r
924\r
925\r
926\r
927 if (EFI_ABORTED == Status) {\r
928 //\r
929 // The reception is actively aborted by the consumer, directly return.\r
930 //\r
931 return;\r
932 } else if (EFI_SUCCESS == Status) {\r
933 //\r
934 // Recycle the RxData.\r
935 //\r
936 ASSERT (RecycleEvent != NULL);\r
937\r
938 gBS->SignalEvent (RecycleEvent);\r
939 }\r
940\r
941 //\r
942 // Continue the receive.\r
943 //\r
944 if (IpInfo->IpVersion == IP_VERSION_4) {\r
945 IpInfo->Ip.Ip4->Receive (\r
946 IpInfo->Ip.Ip4,\r
947 &IpInfo->DummyRcvToken.Ip4Token\r
948 );\r
949 } else {\r
950 IpInfo->Ip.Ip6->Receive (\r
951 IpInfo->Ip.Ip6,\r
952 &IpInfo->DummyRcvToken.Ip6Token\r
953 );\r
954 }\r
955}\r
956\r
957\r
958/**\r
959 This function add IpIoDummyHandlerDpc to the end of the DPC queue.\r
960\r
961 @param[in] Event The event signaled.\r
962 @param[in] Context The context passed in by the event notifier.\r
963\r
964**/\r
965VOID\r
966EFIAPI\r
967IpIoDummyHandler (\r
968 IN EFI_EVENT Event,\r
969 IN VOID *Context\r
970 )\r
971{\r
972 //\r
973 // Request IpIoDummyHandlerDpc as a DPC at TPL_CALLBACK\r
974 //\r
975 QueueDpc (TPL_CALLBACK, IpIoDummyHandlerDpc, Context);\r
976}\r
977\r
978\r
979/**\r
980 Notify function for the IP receive token, used to process\r
981 the received IP packets.\r
982\r
983 @param[in] Context The context passed in by the event notifier.\r
984\r
985**/\r
986VOID\r
987EFIAPI\r
988IpIoListenHandlerDpc (\r
989 IN VOID *Context\r
990 )\r
991{\r
992 IP_IO *IpIo;\r
993 EFI_STATUS Status;\r
994 IP_IO_IP_RX_DATA *RxData;\r
995 EFI_NET_SESSION_DATA Session;\r
996 NET_BUF *Pkt;\r
997\r
998 IpIo = (IP_IO *) Context;\r
999\r
1000 if (IpIo->IpVersion == IP_VERSION_4) {\r
1001 Status = IpIo->RcvToken.Ip4Token.Status;\r
1002 RxData = (IP_IO_IP_RX_DATA *) IpIo->RcvToken.Ip4Token.Packet.RxData;\r
1003 } else if (IpIo->IpVersion == IP_VERSION_6) {\r
1004 Status = IpIo->RcvToken.Ip6Token.Status;\r
1005 RxData = (IP_IO_IP_RX_DATA *) IpIo->RcvToken.Ip6Token.Packet.RxData;\r
1006 } else {\r
1007 return;\r
1008 }\r
1009\r
1010 if (EFI_ABORTED == Status) {\r
1011 //\r
1012 // The reception is actively aborted by the consumer, directly return.\r
1013 //\r
1014 return;\r
1015 }\r
1016\r
1017 if (((EFI_SUCCESS != Status) && (EFI_ICMP_ERROR != Status)) || (NULL == RxData)) {\r
1018 //\r
1019 // @bug Only process the normal packets and the icmp error packets, if RxData is NULL\r
1020 // @bug with Status == EFI_SUCCESS or EFI_ICMP_ERROR, just resume the receive although\r
1021 // @bug this should be a bug of the low layer (IP).\r
1022 //\r
1023 goto Resume;\r
1024 }\r
1025\r
1026 if (NULL == IpIo->PktRcvdNotify) {\r
1027 goto CleanUp;\r
1028 }\r
1029\r
1030 if (IpIo->IpVersion == IP_VERSION_4) {\r
1031 if ((EFI_IP4 (RxData->Ip4RxData.Header->SourceAddress) != 0) &&\r
1032 !NetIp4IsUnicast (EFI_NTOHL (((EFI_IP4_RECEIVE_DATA *) RxData)->Header->SourceAddress), 0)) {\r
1033 //\r
1034 // The source address is not zero and it's not a unicast IP address, discard it.\r
1035 //\r
1036 goto CleanUp;\r
1037 }\r
1038\r
1039 //\r
1040 // Create a netbuffer representing IPv4 packet\r
1041 //\r
1042 Pkt = NetbufFromExt (\r
1043 (NET_FRAGMENT *) RxData->Ip4RxData.FragmentTable,\r
1044 RxData->Ip4RxData.FragmentCount,\r
1045 0,\r
1046 0,\r
1047 IpIoExtFree,\r
1048 RxData->Ip4RxData.RecycleSignal\r
1049 );\r
1050 if (NULL == Pkt) {\r
1051 goto CleanUp;\r
1052 }\r
1053\r
1054 //\r
1055 // Create a net session\r
1056 //\r
1057 Session.Source.Addr[0] = EFI_IP4 (RxData->Ip4RxData.Header->SourceAddress);\r
1058 Session.Dest.Addr[0] = EFI_IP4 (RxData->Ip4RxData.Header->DestinationAddress);\r
1059 Session.IpHdr.Ip4Hdr = RxData->Ip4RxData.Header;\r
1060 Session.IpHdrLen = RxData->Ip4RxData.HeaderLength;\r
1061 Session.IpVersion = IP_VERSION_4;\r
1062 } else {\r
1063\r
1064 if (!NetIp6IsValidUnicast(&RxData->Ip6RxData.Header->SourceAddress)) {\r
1065 goto CleanUp;\r
1066 }\r
1067 \r
1068 //\r
1069 // Create a netbuffer representing IPv6 packet\r
1070 //\r
1071 Pkt = NetbufFromExt (\r
1072 (NET_FRAGMENT *) RxData->Ip6RxData.FragmentTable,\r
1073 RxData->Ip6RxData.FragmentCount,\r
1074 0,\r
1075 0,\r
1076 IpIoExtFree,\r
1077 RxData->Ip6RxData.RecycleSignal\r
1078 );\r
1079 if (NULL == Pkt) {\r
1080 goto CleanUp;\r
1081 }\r
1082\r
1083 //\r
1084 // Create a net session\r
1085 //\r
1086 CopyMem (\r
1087 &Session.Source, \r
1088 &RxData->Ip6RxData.Header->SourceAddress,\r
1089 sizeof(EFI_IPv6_ADDRESS)\r
1090 );\r
1091 CopyMem (\r
1092 &Session.Dest, \r
1093 &RxData->Ip6RxData.Header->DestinationAddress, \r
1094 sizeof(EFI_IPv6_ADDRESS)\r
1095 );\r
1096 Session.IpHdr.Ip6Hdr = RxData->Ip6RxData.Header;\r
1097 Session.IpHdrLen = RxData->Ip6RxData.HeaderLength;\r
1098 Session.IpVersion = IP_VERSION_6;\r
1099 } \r
1100\r
1101 if (EFI_SUCCESS == Status) {\r
1102\r
1103 IpIo->PktRcvdNotify (EFI_SUCCESS, 0, &Session, Pkt, IpIo->RcvdContext);\r
1104 } else {\r
1105 //\r
1106 // Status is EFI_ICMP_ERROR\r
1107 //\r
1108 Status = IpIoIcmpHandler (IpIo, Pkt, &Session);\r
1109 if (EFI_ERROR (Status)) {\r
1110 NetbufFree (Pkt);\r
1111 }\r
1112 }\r
1113\r
1114 goto Resume;\r
1115\r
1116CleanUp:\r
1117\r
1118 if (IpIo->IpVersion == IP_VERSION_4){\r
1119 gBS->SignalEvent (RxData->Ip4RxData.RecycleSignal);\r
1120 } else {\r
1121 gBS->SignalEvent (RxData->Ip6RxData.RecycleSignal); \r
1122 }\r
1123\r
1124Resume:\r
1125\r
1126 if (IpIo->IpVersion == IP_VERSION_4){\r
1127 IpIo->Ip.Ip4->Receive (IpIo->Ip.Ip4, &(IpIo->RcvToken.Ip4Token));\r
1128 } else {\r
1129 IpIo->Ip.Ip6->Receive (IpIo->Ip.Ip6, &(IpIo->RcvToken.Ip6Token));\r
1130 }\r
1131}\r
1132\r
1133/**\r
1134 This function add IpIoListenHandlerDpc to the end of the DPC queue.\r
1135\r
1136 @param[in] Event The event signaled.\r
1137 @param[in] Context The context passed in by the event notifier.\r
1138\r
1139**/\r
1140VOID\r
1141EFIAPI\r
1142IpIoListenHandler (\r
1143 IN EFI_EVENT Event,\r
1144 IN VOID *Context\r
1145 )\r
1146{\r
1147 //\r
1148 // Request IpIoListenHandlerDpc as a DPC at TPL_CALLBACK\r
1149 //\r
1150 QueueDpc (TPL_CALLBACK, IpIoListenHandlerDpc, Context);\r
1151}\r
1152\r
1153\r
1154/**\r
1155 Create a new IP_IO instance.\r
1156 \r
1157 This function uses IP4/IP6 service binding protocol in Controller to create\r
1158 an IP4/IP6 child (aka IP4/IP6 instance).\r
1159\r
1160 @param[in] Image The image handle of the driver or application that\r
1161 consumes IP_IO.\r
1162 @param[in] Controller The controller handle that has IP4 or IP6 service\r
1163 binding protocol installed.\r
1164 @param[in] IpVersion The version of the IP protocol to use, either\r
1165 IPv4 or IPv6. \r
1166\r
1167 @return Pointer to a newly created IP_IO instance, or NULL if failed.\r
1168\r
1169**/\r
1170IP_IO *\r
1171EFIAPI\r
1172IpIoCreate (\r
1173 IN EFI_HANDLE Image,\r
1174 IN EFI_HANDLE Controller,\r
1175 IN UINT8 IpVersion\r
1176 )\r
1177{\r
1178 EFI_STATUS Status;\r
1179 IP_IO *IpIo;\r
1180 EFI_EVENT Event;\r
1181\r
1182 ASSERT ((IpVersion == IP_VERSION_4) || (IpVersion == IP_VERSION_6));\r
1183\r
1184 IpIo = AllocateZeroPool (sizeof (IP_IO));\r
1185 if (NULL == IpIo) {\r
1186 return NULL;\r
1187 }\r
1188\r
1189 InitializeListHead (&(IpIo->PendingSndList));\r
1190 InitializeListHead (&(IpIo->IpList));\r
1191 IpIo->Controller = Controller;\r
1192 IpIo->Image = Image;\r
1193 IpIo->IpVersion = IpVersion;\r
1194 Event = NULL;\r
1195\r
1196 Status = gBS->CreateEvent (\r
1197 EVT_NOTIFY_SIGNAL,\r
1198 TPL_NOTIFY,\r
1199 IpIoListenHandler,\r
1200 IpIo,\r
1201 &Event\r
1202 );\r
1203 if (EFI_ERROR (Status)) {\r
1204 goto ReleaseIpIo;\r
1205 }\r
1206\r
1207 if (IpVersion == IP_VERSION_4) {\r
1208 IpIo->RcvToken.Ip4Token.Event = Event;\r
1209 } else {\r
1210 IpIo->RcvToken.Ip6Token.Event = Event;\r
1211 }\r
1212\r
1213 //\r
1214 // Create an IP child and open IP protocol\r
1215 //\r
1216 Status = IpIoCreateIpChildOpenProtocol (\r
1217 Controller,\r
1218 Image,\r
1219 &IpIo->ChildHandle,\r
1220 IpVersion, \r
1221 (VOID **)&(IpIo->Ip)\r
1222 );\r
1223 if (EFI_ERROR (Status)) {\r
1224 goto ReleaseIpIo;\r
1225 }\r
1226\r
1227 return IpIo;\r
1228\r
1229ReleaseIpIo:\r
1230\r
1231 if (Event != NULL) {\r
1232 gBS->CloseEvent (Event);\r
1233 }\r
1234\r
1235 gBS->FreePool (IpIo);\r
1236\r
1237 return NULL;\r
1238}\r
1239\r
1240\r
1241/**\r
1242 Open an IP_IO instance for use.\r
1243 \r
1244 This function is called after IpIoCreate(). It is used for configuring the IP\r
1245 instance and register the callbacks and their context data for sending and\r
1246 receiving IP packets.\r
1247\r
1248 @param[in, out] IpIo Pointer to an IP_IO instance that needs\r
1249 to open.\r
1250 @param[in] OpenData The configuration data and callbacks for\r
1251 the IP_IO instance.\r
1252\r
1253 @retval EFI_SUCCESS The IP_IO instance opened with OpenData\r
1254 successfully.\r
1255 @retval EFI_ACCESS_DENIED The IP_IO instance is configured, avoid to \r
1256 reopen it.\r
1257 @retval Others Error condition occurred.\r
1258\r
1259**/\r
1260EFI_STATUS\r
1261EFIAPI\r
1262IpIoOpen (\r
1263 IN OUT IP_IO *IpIo,\r
1264 IN IP_IO_OPEN_DATA *OpenData\r
1265 )\r
1266{\r
1267 EFI_STATUS Status;\r
1268 UINT8 IpVersion;\r
1269\r
1270 if (IpIo->IsConfigured) {\r
1271 return EFI_ACCESS_DENIED;\r
1272 }\r
1273\r
1274 IpVersion = IpIo->IpVersion;\r
1275\r
1276 ASSERT ((IpVersion == IP_VERSION_4) || (IpVersion == IP_VERSION_6));\r
1277\r
1278 //\r
1279 // configure ip\r
1280 //\r
1281 if (IpVersion == IP_VERSION_4){\r
1282 Status = IpIo->Ip.Ip4->Configure (\r
1283 IpIo->Ip.Ip4,\r
1284 &OpenData->IpConfigData.Ip4CfgData\r
1285 );\r
1286 } else {\r
1287\r
1288 Status = IpIo->Ip.Ip6->Configure (\r
1289 IpIo->Ip.Ip6, \r
1290 &OpenData->IpConfigData.Ip6CfgData\r
1291 );\r
1292 }\r
1293\r
1294 if (EFI_ERROR (Status)) {\r
1295 return Status;\r
1296 }\r
1297\r
1298 //\r
1299 // @bug To delete the default route entry in this Ip, if it is:\r
1300 // @bug (0.0.0.0, 0.0.0.0, 0.0.0.0). Delete this statement if Ip modified\r
1301 // @bug its code\r
1302 //\r
1303 if (IpVersion == IP_VERSION_4){\r
1304 Status = IpIo->Ip.Ip4->Routes (\r
1305 IpIo->Ip.Ip4,\r
1306 TRUE,\r
1307 &mZeroIp4Addr,\r
1308 &mZeroIp4Addr,\r
1309 &mZeroIp4Addr\r
1310 );\r
1311\r
1312 if (EFI_ERROR (Status) && (EFI_NOT_FOUND != Status)) {\r
1313 return Status;\r
1314 }\r
1315 }\r
1316\r
1317 IpIo->PktRcvdNotify = OpenData->PktRcvdNotify;\r
1318 IpIo->PktSentNotify = OpenData->PktSentNotify;\r
1319\r
1320 IpIo->RcvdContext = OpenData->RcvdContext;\r
1321 IpIo->SndContext = OpenData->SndContext;\r
1322\r
1323 if (IpVersion == IP_VERSION_4){\r
1324 IpIo->Protocol = OpenData->IpConfigData.Ip4CfgData.DefaultProtocol;\r
1325\r
1326 //\r
1327 // start to listen incoming packet\r
1328 //\r
1329 Status = IpIo->Ip.Ip4->Receive (\r
1330 IpIo->Ip.Ip4,\r
1331 &(IpIo->RcvToken.Ip4Token)\r
1332 );\r
1333 if (EFI_ERROR (Status)) {\r
1334 IpIo->Ip.Ip4->Configure (IpIo->Ip.Ip4, NULL);\r
1335 goto ErrorExit;\r
1336 }\r
1337\r
1338 } else {\r
1339\r
1340 IpIo->Protocol = OpenData->IpConfigData.Ip6CfgData.DefaultProtocol;\r
1341 Status = IpIo->Ip.Ip6->Receive (\r
1342 IpIo->Ip.Ip6,\r
1343 &(IpIo->RcvToken.Ip6Token)\r
1344 );\r
1345 if (EFI_ERROR (Status)) {\r
1346 IpIo->Ip.Ip6->Configure (IpIo->Ip.Ip6, NULL);\r
1347 goto ErrorExit;\r
1348 }\r
1349 }\r
1350\r
1351 IpIo->IsConfigured = TRUE;\r
1352 InsertTailList (&mActiveIpIoList, &IpIo->Entry);\r
1353\r
1354ErrorExit:\r
1355\r
1356 return Status;\r
1357}\r
1358\r
1359\r
1360/**\r
1361 Stop an IP_IO instance.\r
1362 \r
1363 This function is paired with IpIoOpen(). The IP_IO will be unconfigured and all\r
1364 the pending send/receive tokens will be canceled.\r
1365\r
1366 @param[in, out] IpIo Pointer to the IP_IO instance that needs to stop.\r
1367\r
1368 @retval EFI_SUCCESS The IP_IO instance stopped successfully.\r
1369 @retval Others Error condition occurred.\r
1370\r
1371**/\r
1372EFI_STATUS\r
1373EFIAPI\r
1374IpIoStop (\r
1375 IN OUT IP_IO *IpIo\r
1376 )\r
1377{\r
1378 EFI_STATUS Status;\r
1379 IP_IO_IP_INFO *IpInfo;\r
1380 UINT8 IpVersion;\r
1381\r
1382 if (!IpIo->IsConfigured) {\r
1383 return EFI_SUCCESS;\r
1384 }\r
1385\r
1386 IpVersion = IpIo->IpVersion;\r
1387\r
1388 ASSERT ((IpVersion == IP_VERSION_4) || (IpVersion == IP_VERSION_6));\r
1389\r
1390 //\r
1391 // Remove the IpIo from the active IpIo list.\r
1392 //\r
1393 RemoveEntryList (&IpIo->Entry);\r
1394\r
1395 //\r
1396 // Configure NULL Ip\r
1397 //\r
1398 if (IpVersion == IP_VERSION_4) {\r
1399 Status = IpIo->Ip.Ip4->Configure (IpIo->Ip.Ip4, NULL);\r
1400 } else {\r
1401 Status = IpIo->Ip.Ip6->Configure (IpIo->Ip.Ip6, NULL);\r
1402 }\r
1403 if (EFI_ERROR (Status)) {\r
1404 return Status;\r
1405 }\r
1406\r
1407 IpIo->IsConfigured = FALSE;\r
1408\r
1409 //\r
1410 // Detroy the Ip List used by IpIo\r
1411 //\r
1412\r
1413 while (!IsListEmpty (&(IpIo->IpList))) {\r
1414 IpInfo = NET_LIST_HEAD (&(IpIo->IpList), IP_IO_IP_INFO, Entry);\r
1415\r
1416 IpIoRemoveIp (IpIo, IpInfo);\r
1417 }\r
1418\r
1419 //\r
1420 // All pending send tokens should be flushed by reseting the IP instances.\r
1421 //\r
1422 ASSERT (IsListEmpty (&IpIo->PendingSndList));\r
1423\r
1424 //\r
1425 // Close the receive event.\r
1426 //\r
1427 if (IpVersion == IP_VERSION_4){\r
1428 gBS->CloseEvent (IpIo->RcvToken.Ip4Token.Event);\r
1429 } else {\r
1430 gBS->CloseEvent (IpIo->RcvToken.Ip6Token.Event);\r
1431 }\r
1432\r
1433 return EFI_SUCCESS;\r
1434}\r
1435\r
1436\r
1437/**\r
1438 Destroy an IP_IO instance.\r
1439 \r
1440 This function is paired with IpIoCreate(). The IP_IO will be closed first.\r
1441 Resource will be freed afterwards. See IpIoCloseProtocolDestroyIpChild().\r
1442\r
1443 @param[in, out] IpIo Pointer to the IP_IO instance that needs to be\r
1444 destroyed.\r
1445\r
1446 @retval EFI_SUCCESS The IP_IO instance destroyed successfully.\r
1447 @retval Others Error condition occurred.\r
1448\r
1449**/\r
1450EFI_STATUS\r
1451EFIAPI\r
1452IpIoDestroy (\r
1453 IN OUT IP_IO *IpIo\r
1454 )\r
1455{\r
1456 //\r
1457 // Stop the IpIo.\r
1458 //\r
1459 IpIoStop (IpIo);\r
1460\r
1461 //\r
1462 // Close the IP protocol and destroy the child.\r
1463 //\r
1464 IpIoCloseProtocolDestroyIpChild (\r
1465 IpIo->Controller,\r
1466 IpIo->Image,\r
1467 IpIo->ChildHandle,\r
1468 IpIo->IpVersion\r
1469 );\r
1470\r
1471 gBS->FreePool (IpIo);\r
1472\r
1473 return EFI_SUCCESS;\r
1474}\r
1475\r
1476\r
1477/**\r
1478 Send out an IP packet.\r
1479 \r
1480 This function is called after IpIoOpen(). The data to be sent are wrapped in\r
1481 Pkt. The IP instance wrapped in IpIo is used for sending by default but can be\r
1482 overriden by Sender. Other sending configs, like source address and gateway\r
1483 address etc., are specified in OverrideData.\r
1484\r
1485 @param[in, out] IpIo Pointer to an IP_IO instance used for sending IP\r
1486 packet.\r
1487 @param[in, out] Pkt Pointer to the IP packet to be sent.\r
1488 @param[in] Sender The IP protocol instance used for sending.\r
1489 @param[in] Context Optional context data.\r
1490 @param[in] NotifyData Optional notify data.\r
1491 @param[in] Dest The destination IP address to send this packet to.\r
1492 @param[in] OverrideData The data to override some configuration of the IP\r
1493 instance used for sending.\r
1494\r
1495 @retval EFI_SUCCESS The operation is completed successfully.\r
1496 @retval EFI_NOT_STARTED The IpIo is not configured.\r
1497 @retval EFI_OUT_OF_RESOURCES Failed due to resource limit.\r
1498\r
1499**/\r
1500EFI_STATUS\r
1501EFIAPI\r
1502IpIoSend (\r
1503 IN OUT IP_IO *IpIo,\r
1504 IN OUT NET_BUF *Pkt,\r
1505 IN IP_IO_IP_INFO *Sender OPTIONAL,\r
1506 IN VOID *Context OPTIONAL,\r
1507 IN VOID *NotifyData OPTIONAL,\r
1508 IN EFI_IP_ADDRESS *Dest,\r
1509 IN IP_IO_OVERRIDE *OverrideData OPTIONAL\r
1510 )\r
1511{\r
1512 EFI_STATUS Status;\r
1513 IP_IO_IP_PROTOCOL Ip;\r
1514 IP_IO_SEND_ENTRY *SndEntry;\r
1515\r
1516 ASSERT ((IpIo->IpVersion != IP_VERSION_4) || (Dest != NULL));\r
1517\r
1518 if (!IpIo->IsConfigured) {\r
1519 return EFI_NOT_STARTED;\r
1520 }\r
1521\r
1522 Ip = (NULL == Sender) ? IpIo->Ip : Sender->Ip;\r
1523\r
1524 //\r
1525 // create a new SndEntry\r
1526 //\r
1527 SndEntry = IpIoCreateSndEntry (IpIo, Pkt, Ip, Context, NotifyData, Dest, OverrideData);\r
1528 if (NULL == SndEntry) {\r
1529 return EFI_OUT_OF_RESOURCES;\r
1530 }\r
1531\r
1532 //\r
1533 // Send this Packet\r
1534 //\r
1535 if (IpIo->IpVersion == IP_VERSION_4){\r
1536 Status = Ip.Ip4->Transmit (\r
1537 Ip.Ip4,\r
1538 &SndEntry->SndToken.Ip4Token\r
1539 );\r
1540 } else {\r
1541 Status = Ip.Ip6->Transmit (\r
1542 Ip.Ip6,\r
1543 &SndEntry->SndToken.Ip6Token\r
1544 );\r
1545 }\r
1546\r
1547 if (EFI_ERROR (Status)) {\r
1548 IpIoDestroySndEntry (SndEntry);\r
1549 }\r
1550\r
1551 return Status;\r
1552}\r
1553\r
1554\r
1555/**\r
1556 Cancel the IP transmit token which wraps this Packet.\r
1557\r
1558 @param[in] IpIo Pointer to the IP_IO instance.\r
1559 @param[in] Packet Pointer to the packet of NET_BUF to cancel.\r
1560\r
1561**/\r
1562VOID\r
1563EFIAPI\r
1564IpIoCancelTxToken (\r
1565 IN IP_IO *IpIo,\r
1566 IN VOID *Packet\r
1567 )\r
1568{\r
1569 LIST_ENTRY *Node;\r
1570 IP_IO_SEND_ENTRY *SndEntry;\r
1571 IP_IO_IP_PROTOCOL Ip;\r
1572\r
1573 ASSERT ((IpIo != NULL) && (Packet != NULL));\r
1574\r
1575 NET_LIST_FOR_EACH (Node, &IpIo->PendingSndList) {\r
1576\r
1577 SndEntry = NET_LIST_USER_STRUCT (Node, IP_IO_SEND_ENTRY, Entry);\r
1578\r
1579 if (SndEntry->Pkt == Packet) {\r
1580\r
1581 Ip = SndEntry->Ip;\r
1582\r
1583 if (IpIo->IpVersion == IP_VERSION_4) {\r
1584 Ip.Ip4->Cancel (\r
1585 Ip.Ip4,\r
1586 &SndEntry->SndToken.Ip4Token\r
1587 );\r
1588 } else {\r
1589 Ip.Ip6->Cancel (\r
1590 Ip.Ip6,\r
1591 &SndEntry->SndToken.Ip6Token\r
1592 );\r
1593 }\r
1594\r
1595 break;\r
1596 }\r
1597 }\r
1598\r
1599}\r
1600\r
1601\r
1602/**\r
1603 Add a new IP instance for sending data.\r
1604 \r
1605 The function is used to add the IP_IO to the IP_IO sending list. The caller\r
1606 can later use IpIoFindSender() to get the IP_IO and call IpIoSend() to send\r
1607 data.\r
1608\r
1609 @param[in, out] IpIo Pointer to a IP_IO instance to add a new IP\r
1610 instance for sending purpose.\r
1611\r
1612 @return Pointer to the created IP_IO_IP_INFO structure, NULL if failed.\r
1613\r
1614**/\r
1615IP_IO_IP_INFO *\r
1616EFIAPI\r
1617IpIoAddIp (\r
1618 IN OUT IP_IO *IpIo\r
1619 )\r
1620{\r
1621 EFI_STATUS Status;\r
1622 IP_IO_IP_INFO *IpInfo;\r
1623 EFI_EVENT Event;\r
1624\r
1625 ASSERT (IpIo != NULL);\r
1626\r
1627 IpInfo = AllocatePool (sizeof (IP_IO_IP_INFO));\r
1628 if (IpInfo == NULL) {\r
1629 return NULL;\r
1630 }\r
1631\r
1632 //\r
1633 // Init this IpInfo, set the Addr and SubnetMask to 0 before we configure the IP\r
1634 // instance.\r
1635 //\r
1636 InitializeListHead (&IpInfo->Entry);\r
1637 IpInfo->ChildHandle = NULL;\r
1638 ZeroMem (&IpInfo->Addr, sizeof (IpInfo->Addr));\r
1639 ZeroMem (&IpInfo->PreMask, sizeof (IpInfo->PreMask));\r
1640\r
1641 IpInfo->RefCnt = 1;\r
1642 IpInfo->IpVersion = IpIo->IpVersion;\r
1643\r
1644 //\r
1645 // Create the IP instance and open the IP protocol.\r
1646 //\r
1647 Status = IpIoCreateIpChildOpenProtocol (\r
1648 IpIo->Controller,\r
1649 IpIo->Image,\r
1650 &IpInfo->ChildHandle,\r
1651 IpInfo->IpVersion,\r
1652 (VOID **) &IpInfo->Ip\r
1653 );\r
1654 if (EFI_ERROR (Status)) {\r
1655 goto ReleaseIpInfo;\r
1656 }\r
1657\r
1658 //\r
1659 // Create the event for the DummyRcvToken.\r
1660 //\r
1661 Status = gBS->CreateEvent (\r
1662 EVT_NOTIFY_SIGNAL,\r
1663 TPL_NOTIFY,\r
1664 IpIoDummyHandler,\r
1665 IpInfo,\r
1666 &Event\r
1667 );\r
1668 if (EFI_ERROR (Status)) {\r
1669 goto ReleaseIpChild;\r
1670 }\r
1671\r
1672 if (IpInfo->IpVersion == IP_VERSION_4) {\r
1673 IpInfo->DummyRcvToken.Ip4Token.Event = Event;\r
1674 } else {\r
1675 IpInfo->DummyRcvToken.Ip6Token.Event = Event;\r
1676 }\r
1677\r
1678 //\r
1679 // Link this IpInfo into the IpIo.\r
1680 //\r
1681 InsertTailList (&IpIo->IpList, &IpInfo->Entry);\r
1682\r
1683 return IpInfo;\r
1684\r
1685ReleaseIpChild:\r
1686\r
1687 IpIoCloseProtocolDestroyIpChild (\r
1688 IpIo->Controller,\r
1689 IpIo->Image,\r
1690 IpInfo->ChildHandle,\r
1691 IpInfo->IpVersion\r
1692 );\r
1693\r
1694ReleaseIpInfo:\r
1695\r
1696 gBS->FreePool (IpInfo);\r
1697\r
1698 return NULL;\r
1699}\r
1700\r
1701\r
1702/**\r
1703 Configure the IP instance of this IpInfo and start the receiving if IpConfigData\r
1704 is not NULL.\r
1705\r
1706 @param[in, out] IpInfo Pointer to the IP_IO_IP_INFO instance.\r
1707 @param[in, out] IpConfigData The IP configure data used to configure the IP\r
1708 instance, if NULL the IP instance is reset. If\r
1709 UseDefaultAddress is set to TRUE, and the configure\r
1710 operation succeeds, the default address information\r
1711 is written back in this IpConfigData.\r
1712\r
1713 @retval EFI_SUCCESS The IP instance of this IpInfo is configured successfully\r
1714 or no need to reconfigure it.\r
1715 @retval Others Configuration fails.\r
1716\r
1717**/\r
1718EFI_STATUS\r
1719EFIAPI\r
1720IpIoConfigIp (\r
1721 IN OUT IP_IO_IP_INFO *IpInfo,\r
1722 IN OUT VOID *IpConfigData OPTIONAL\r
1723 )\r
1724{\r
1725 EFI_STATUS Status;\r
1726 IP_IO_IP_PROTOCOL Ip;\r
1727 UINT8 IpVersion;\r
1728 EFI_IP4_MODE_DATA Ip4ModeData;\r
1729 EFI_IP6_MODE_DATA Ip6ModeData;\r
1730\r
1731 ASSERT (IpInfo != NULL);\r
1732\r
1733 if (IpInfo->RefCnt > 1) {\r
1734 //\r
1735 // This IP instance is shared, don't reconfigure it until it has only one\r
1736 // consumer. Currently, only the tcp children cloned from their passive parent\r
1737 // will share the same IP. So this cases only happens while IpConfigData is NULL,\r
1738 // let the last consumer clean the IP instance.\r
1739 //\r
1740 return EFI_SUCCESS;\r
1741 }\r
1742\r
1743 IpVersion = IpInfo->IpVersion;\r
1744 ASSERT ((IpVersion == IP_VERSION_4) || (IpVersion == IP_VERSION_6));\r
1745\r
1746 Ip = IpInfo->Ip;\r
1747\r
1748 if (IpInfo->IpVersion == IP_VERSION_4) {\r
1749 Status = Ip.Ip4->Configure (Ip.Ip4, IpConfigData);\r
1750 } else {\r
1751 Status = Ip.Ip6->Configure (Ip.Ip6, IpConfigData);\r
1752 }\r
1753\r
1754 if (EFI_ERROR (Status)) {\r
1755 goto OnExit;\r
1756 }\r
1757\r
1758 if (IpConfigData != NULL) {\r
1759 if (IpInfo->IpVersion == IP_VERSION_4){\r
1760\r
1761 if (((EFI_IP4_CONFIG_DATA *) IpConfigData)->UseDefaultAddress) {\r
1762 Ip.Ip4->GetModeData (\r
1763 Ip.Ip4, \r
1764 &Ip4ModeData, \r
1765 NULL, \r
1766 NULL\r
1767 );\r
1768\r
1769 IP4_COPY_ADDRESS (&((EFI_IP4_CONFIG_DATA*) IpConfigData)->StationAddress, &Ip4ModeData.ConfigData.StationAddress);\r
1770 IP4_COPY_ADDRESS (&((EFI_IP4_CONFIG_DATA*) IpConfigData)->SubnetMask, &Ip4ModeData.ConfigData.SubnetMask);\r
1771 }\r
1772\r
1773 CopyMem (\r
1774 &IpInfo->Addr.Addr, \r
1775 &((EFI_IP4_CONFIG_DATA *) IpConfigData)->StationAddress, \r
1776 sizeof (IP4_ADDR)\r
1777 );\r
1778 CopyMem (\r
1779 &IpInfo->PreMask.SubnetMask, \r
1780 &((EFI_IP4_CONFIG_DATA *) IpConfigData)->SubnetMask,\r
1781 sizeof (IP4_ADDR)\r
1782 );\r
1783\r
1784 Status = Ip.Ip4->Receive (\r
1785 Ip.Ip4,\r
1786 &IpInfo->DummyRcvToken.Ip4Token\r
1787 );\r
1788 if (EFI_ERROR (Status)) {\r
1789 Ip.Ip4->Configure (Ip.Ip4, NULL);\r
1790 }\r
1791 } else {\r
1792 Ip.Ip6->GetModeData (\r
1793 Ip.Ip6,\r
1794 &Ip6ModeData,\r
1795 NULL,\r
1796 NULL\r
1797 );\r
1798\r
1799 if (Ip6ModeData.IsConfigured) {\r
1800 CopyMem (\r
1801 &((EFI_IP6_CONFIG_DATA *) IpConfigData)->StationAddress,\r
1802 &Ip6ModeData.ConfigData.StationAddress,\r
1803 sizeof (EFI_IPv6_ADDRESS)\r
1804 );\r
1805\r
1806 if (Ip6ModeData.AddressList != NULL) {\r
1807 FreePool (Ip6ModeData.AddressList);\r
1808 }\r
1809\r
1810 if (Ip6ModeData.GroupTable != NULL) {\r
1811 FreePool (Ip6ModeData.GroupTable);\r
1812 }\r
1813\r
1814 if (Ip6ModeData.RouteTable != NULL) {\r
1815 FreePool (Ip6ModeData.RouteTable);\r
1816 }\r
1817\r
1818 if (Ip6ModeData.NeighborCache != NULL) {\r
1819 FreePool (Ip6ModeData.NeighborCache);\r
1820 }\r
1821\r
1822 if (Ip6ModeData.PrefixTable != NULL) {\r
1823 FreePool (Ip6ModeData.PrefixTable);\r
1824 }\r
1825\r
1826 if (Ip6ModeData.IcmpTypeList != NULL) {\r
1827 FreePool (Ip6ModeData.IcmpTypeList);\r
1828 }\r
1829\r
1830 } else {\r
1831 Status = EFI_NO_MAPPING;\r
1832 goto OnExit;\r
1833 } \r
1834\r
1835 CopyMem (\r
1836 &IpInfo->Addr, \r
1837 &Ip6ModeData.ConfigData.StationAddress, \r
1838 sizeof (EFI_IPv6_ADDRESS)\r
1839 );\r
1840\r
1841 Status = Ip.Ip6->Receive (\r
1842 Ip.Ip6,\r
1843 &IpInfo->DummyRcvToken.Ip6Token\r
1844 );\r
1845 if (EFI_ERROR (Status)) {\r
1846 Ip.Ip6->Configure (Ip.Ip6, NULL);\r
1847 }\r
1848 } \r
1849 } else {\r
1850 //\r
1851 // The IP instance is reset, set the stored Addr and SubnetMask to zero.\r
1852 //\r
1853 ZeroMem (&IpInfo->Addr, sizeof (IpInfo->Addr));\r
1854 ZeroMem (&IpInfo->PreMask, sizeof (IpInfo->PreMask));\r
1855 }\r
1856\r
1857OnExit:\r
1858\r
1859 return Status;\r
1860}\r
1861\r
1862\r
1863/**\r
1864 Destroy an IP instance maintained in IpIo->IpList for\r
1865 sending purpose.\r
1866 \r
1867 This function pairs with IpIoAddIp(). The IpInfo is previously created by\r
1868 IpIoAddIp(). The IP_IO_IP_INFO::RefCnt is decremented and the IP instance\r
1869 will be dstroyed if the RefCnt is zero.\r
1870\r
1871 @param[in] IpIo Pointer to the IP_IO instance.\r
1872 @param[in] IpInfo Pointer to the IpInfo to be removed.\r
1873\r
1874**/\r
1875VOID\r
1876EFIAPI\r
1877IpIoRemoveIp (\r
1878 IN IP_IO *IpIo,\r
1879 IN IP_IO_IP_INFO *IpInfo\r
1880 )\r
1881{\r
1882\r
1883 UINT8 IpVersion;\r
1884\r
1885 ASSERT (IpInfo->RefCnt > 0);\r
1886\r
1887 NET_PUT_REF (IpInfo);\r
1888\r
1889 if (IpInfo->RefCnt > 0) {\r
1890\r
1891 return;\r
1892 }\r
1893\r
1894 IpVersion = IpIo->IpVersion;\r
1895\r
1896 ASSERT ((IpVersion == IP_VERSION_4) || (IpVersion == IP_VERSION_6));\r
1897\r
1898 RemoveEntryList (&IpInfo->Entry);\r
1899\r
1900 if (IpVersion == IP_VERSION_4){\r
1901 IpInfo->Ip.Ip4->Configure (\r
1902 IpInfo->Ip.Ip4,\r
1903 NULL\r
1904 );\r
1905 IpIoCloseProtocolDestroyIpChild (\r
1906 IpIo->Controller,\r
1907 IpIo->Image,\r
1908 IpInfo->ChildHandle,\r
1909 IP_VERSION_4\r
1910 );\r
1911\r
1912 gBS->CloseEvent (IpInfo->DummyRcvToken.Ip4Token.Event);\r
1913\r
1914 } else {\r
1915\r
1916 IpInfo->Ip.Ip6->Configure (\r
1917 IpInfo->Ip.Ip6,\r
1918 NULL\r
1919 );\r
1920\r
1921 IpIoCloseProtocolDestroyIpChild (\r
1922 IpIo->Controller,\r
1923 IpIo->Image,\r
1924 IpInfo->ChildHandle,\r
1925 IP_VERSION_6\r
1926 );\r
1927\r
1928 gBS->CloseEvent (IpInfo->DummyRcvToken.Ip6Token.Event);\r
1929 }\r
1930\r
1931 FreePool (IpInfo);\r
1932}\r
1933\r
1934\r
1935/**\r
1936 Find the first IP protocol maintained in IpIo whose local\r
1937 address is the same as Src.\r
1938 \r
1939 This function is called when the caller needs the IpIo to send data to the\r
1940 specified Src. The IpIo was added previously by IpIoAddIp().\r
1941\r
1942 @param[in, out] IpIo Pointer to the pointer of the IP_IO instance.\r
1943 @param[in] IpVersion The version of the IP protocol to use, either\r
1944 IPv4 or IPv6.\r
1945 @param[in] Src The local IP address.\r
1946\r
1947 @return Pointer to the IP protocol can be used for sending purpose and its local\r
1948 address is the same with Src.\r
1949\r
1950**/\r
1951IP_IO_IP_INFO *\r
1952EFIAPI\r
1953IpIoFindSender (\r
1954 IN OUT IP_IO **IpIo,\r
1955 IN UINT8 IpVersion,\r
1956 IN EFI_IP_ADDRESS *Src\r
1957 )\r
1958{\r
1959 LIST_ENTRY *IpIoEntry;\r
1960 IP_IO *IpIoPtr;\r
1961 LIST_ENTRY *IpInfoEntry;\r
1962 IP_IO_IP_INFO *IpInfo;\r
1963\r
1964 ASSERT ((IpVersion == IP_VERSION_4) || (IpVersion == IP_VERSION_6)); \r
1965\r
1966 NET_LIST_FOR_EACH (IpIoEntry, &mActiveIpIoList) {\r
1967 IpIoPtr = NET_LIST_USER_STRUCT (IpIoEntry, IP_IO, Entry);\r
1968\r
1969 if (((*IpIo != NULL) && (*IpIo != IpIoPtr)) || (IpIoPtr->IpVersion != IpVersion)) {\r
1970 continue;\r
1971 }\r
1972\r
1973 NET_LIST_FOR_EACH (IpInfoEntry, &IpIoPtr->IpList) {\r
1974 IpInfo = NET_LIST_USER_STRUCT (IpInfoEntry, IP_IO_IP_INFO, Entry);\r
1975 if (IpInfo->IpVersion == IP_VERSION_4){\r
1976\r
1977 if (EFI_IP4_EQUAL (&IpInfo->Addr.v4, &Src->v4)) {\r
1978 *IpIo = IpIoPtr;\r
1979 return IpInfo;\r
1980 }\r
1981\r
1982 } else {\r
1983\r
1984 if (EFI_IP6_EQUAL (&IpInfo->Addr.v6, &Src->v6)) {\r
1985 *IpIo = IpIoPtr;\r
1986 return IpInfo; \r
1987 }\r
1988 } \r
1989\r
1990 }\r
1991 }\r
1992\r
1993 //\r
1994 // No match.\r
1995 //\r
1996 return NULL;\r
1997}\r
1998\r
1999\r
2000/**\r
2001 Get the ICMP error map information.\r
2002 \r
2003 The ErrorStatus will be returned. The IsHard and Notify are optional. If they\r
2004 are not NULL, this routine will fill them.\r
2005\r
2006 @param[in] IcmpError IcmpError Type.\r
2007 @param[in] IpVersion The version of the IP protocol to use,\r
2008 either IPv4 or IPv6. \r
2009 @param[out] IsHard If TRUE, indicates that it is a hard error.\r
2010 @param[out] Notify If TRUE, SockError needs to be notified.\r
2011\r
2012 @return ICMP Error Status, such as EFI_NETWORK_UNREACHABLE.\r
2013\r
2014**/\r
2015EFI_STATUS\r
2016EFIAPI\r
2017IpIoGetIcmpErrStatus (\r
2018 IN UINT8 IcmpError,\r
2019 IN UINT8 IpVersion,\r
2020 OUT BOOLEAN *IsHard OPTIONAL,\r
2021 OUT BOOLEAN *Notify OPTIONAL\r
2022 )\r
2023{\r
2024 if (IpVersion == IP_VERSION_4 ) {\r
2025 ASSERT (IcmpError <= ICMP_ERR_PARAMPROB);\r
2026\r
2027 if (IsHard != NULL) {\r
2028 *IsHard = mIcmpErrMap[IcmpError].IsHard;\r
2029 }\r
2030\r
2031 if (Notify != NULL) {\r
2032 *Notify = mIcmpErrMap[IcmpError].Notify;\r
2033 }\r
2034\r
2035 switch (IcmpError) {\r
2036 case ICMP_ERR_UNREACH_NET:\r
2037 return EFI_NETWORK_UNREACHABLE;\r
2038\r
2039 case ICMP_ERR_TIMXCEED_INTRANS:\r
2040 case ICMP_ERR_TIMXCEED_REASS:\r
2041 case ICMP_ERR_UNREACH_HOST:\r
2042 return EFI_HOST_UNREACHABLE;\r
2043\r
2044 case ICMP_ERR_UNREACH_PROTOCOL:\r
2045 return EFI_PROTOCOL_UNREACHABLE;\r
2046\r
2047 case ICMP_ERR_UNREACH_PORT:\r
2048 return EFI_PORT_UNREACHABLE;\r
2049\r
2050 case ICMP_ERR_MSGSIZE:\r
2051 case ICMP_ERR_UNREACH_SRCFAIL:\r
2052 case ICMP_ERR_QUENCH:\r
2053 case ICMP_ERR_PARAMPROB:\r
2054 return EFI_ICMP_ERROR;\r
2055\r
2056 default:\r
2057 ASSERT (FALSE);\r
2058 return EFI_UNSUPPORTED;\r
2059 }\r
2060\r
2061 } else if (IpVersion == IP_VERSION_6) {\r
2062\r
2063 ASSERT (IcmpError <= ICMP6_ERR_PARAMPROB_IPV6OPTION);\r
2064\r
2065 if (IsHard != NULL) {\r
2066 *IsHard = mIcmp6ErrMap[IcmpError].IsHard;\r
2067 }\r
2068\r
2069 if (Notify != NULL) {\r
2070 *Notify = mIcmp6ErrMap[IcmpError].Notify;\r
2071 }\r
2072\r
2073 switch (IcmpError) {\r
2074 case ICMP6_ERR_UNREACH_NET:\r
2075 return EFI_NETWORK_UNREACHABLE;\r
2076\r
2077 case ICMP6_ERR_UNREACH_HOST:\r
2078 case ICMP6_ERR_TIMXCEED_HOPLIMIT:\r
2079 case ICMP6_ERR_TIMXCEED_REASS: \r
2080 return EFI_HOST_UNREACHABLE;\r
2081\r
2082 case ICMP6_ERR_UNREACH_PROTOCOL:\r
2083 return EFI_PROTOCOL_UNREACHABLE;\r
2084 \r
2085 case ICMP6_ERR_UNREACH_PORT:\r
2086 return EFI_PORT_UNREACHABLE;\r
2087\r
2088 case ICMP6_ERR_PACKAGE_TOOBIG:\r
2089 case ICMP6_ERR_PARAMPROB_HEADER:\r
2090 case ICMP6_ERR_PARAMPROB_NEXHEADER:\r
2091 case ICMP6_ERR_PARAMPROB_IPV6OPTION:\r
2092 return EFI_ICMP_ERROR;\r
2093\r
2094 default:\r
2095 ASSERT (FALSE);\r
2096 return EFI_UNSUPPORTED;\r
2097 }\r
2098\r
2099 } else {\r
2100 //\r
2101 // Should never be here\r
2102 //\r
2103 ASSERT (FALSE);\r
2104 return EFI_UNSUPPORTED;\r
2105 }\r
2106}\r
2107\r
2108\r
2109/**\r
2110 Refresh the remote peer's Neighbor Cache entries.\r
2111\r
2112 This function is called when the caller needs the IpIo to refresh the existing\r
2113 IPv6 neighbor cache entries since the neighbor is considered reachable by the \r
2114 node has recently received a confirmation that packets sent recently to the \r
2115 neighbor were received by its IP layer. \r
2116\r
2117 @param[in] IpIo Pointer to an IP_IO instance\r
2118 @param[in] Neighbor The IP address of the neighbor\r
2119 @param[in] Timeout Time in 100-ns units that this entry will\r
2120 remain in the neighbor cache. A value of \r
2121 zero means that the entry is permanent. \r
2122 A value of non-zero means that the entry is \r
2123 dynamic and will be deleted after Timeout.\r
2124\r
2125 @retval EFI_SUCCESS The operation is completed successfully.\r
2126 @retval EFI_NOT_STARTED The IpIo is not configured.\r
2127 @retval EFI_INVALID_PARAMETER Neighbor Address is invalid.\r
2128 @retval EFI_NOT_FOUND The neighbor cache entry is not in the \r
2129 neighbor table. \r
2130 @retval EFI_OUT_OF_RESOURCES Failed due to resource limit.\r
2131\r
2132**/\r
2133EFI_STATUS\r
2134IpIoRefreshNeighbor (\r
2135 IN IP_IO *IpIo,\r
2136 IN EFI_IP_ADDRESS *Neighbor,\r
2137 IN UINT32 Timeout \r
2138 )\r
2139{\r
2140 EFI_IP6_PROTOCOL *Ip;\r
2141\r
2142 if (!IpIo->IsConfigured || IpIo->IpVersion != IP_VERSION_6) {\r
2143 return EFI_NOT_STARTED;\r
2144 }\r
2145\r
2146 Ip = IpIo->Ip.Ip6;\r
2147\r
2148 return Ip->Neighbors (Ip, FALSE, &Neighbor->v6, NULL, Timeout, TRUE);\r
2149}\r
2150\r
EFI Development Kit II mirror for PVE