]> git.proxmox.com Git - mirror_edk2.git/blame - NetworkPkg/Ip6Dxe/Ip6Output.c
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update for NetworkPkg.
[mirror_edk2.git] / NetworkPkg / Ip6Dxe / Ip6Output.c
CommitLineData
a3bcde70
HT		 1/** @file\r
2 The internal functions and routines to transmit the IP6 packet.\r
3\r
129b8b09 4 Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>\r
a3bcde70
HT		 5\r
6 This program and the accompanying materials\r
7 are licensed and made available under the terms and conditions of the BSD License\r
8 which accompanies this distribution. The full text of the license may be found at\r
9 http://opensource.org/licenses/bsd-license.php.\r
10\r
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
13\r
14**/\r
15\r
16#include "Ip6Impl.h"\r
17\r
18UINT32 mIp6Id;\r
19\r
20/**\r
21 Output all the available source addresses to a list entry head SourceList. The\r
22 number of source addresses are also returned.\r
23\r
24 @param[in] IpSb Points to an IP6 service binding instance.\r
25 @param[out] SourceList The list entry head of all source addresses.\r
26 It is the caller's responsiblity to free the\r
27 resources.\r
28 @param[out] SourceCount The number of source addresses.\r
29\r
30 @retval EFI_SUCCESS The source addresses were copied to a list entry head\r
31 SourceList.\r
32 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources to complete the operation.\r
33\r
34**/\r
35EFI_STATUS\r
36Ip6CandidateSource (\r
37 IN IP6_SERVICE *IpSb,\r
38 OUT LIST_ENTRY *SourceList,\r
39 OUT UINT32 *SourceCount\r
40 )\r
41{\r
42 IP6_INTERFACE *IpIf;\r
43 LIST_ENTRY *Entry;\r
44 LIST_ENTRY *Entry2;\r
45 IP6_ADDRESS_INFO *AddrInfo;\r
46 IP6_ADDRESS_INFO *Copy;\r
47\r
48 *SourceCount = 0;\r
49\r
50 if (IpSb->LinkLocalOk) {\r
51 Copy = AllocatePool (sizeof (IP6_ADDRESS_INFO));\r
52 if (Copy == NULL) {\r
53 return EFI_OUT_OF_RESOURCES;\r
54 }\r
55\r
56 Copy->Signature = IP6_ADDR_INFO_SIGNATURE;\r
57 IP6_COPY_ADDRESS (&Copy->Address, &IpSb->LinkLocalAddr);\r
58 Copy->IsAnycast = FALSE;\r
59 Copy->PrefixLength = IP6_LINK_LOCAL_PREFIX_LENGTH;\r
60 Copy->ValidLifetime = (UINT32) IP6_INFINIT_LIFETIME;\r
61 Copy->PreferredLifetime = (UINT32) IP6_INFINIT_LIFETIME;\r
62\r
63 InsertTailList (SourceList, &Copy->Link);\r
64 (*SourceCount)++;\r
65 }\r
66\r
67 NET_LIST_FOR_EACH (Entry, &IpSb->Interfaces) {\r
68 IpIf = NET_LIST_USER_STRUCT (Entry, IP6_INTERFACE, Link);\r
69\r
70 NET_LIST_FOR_EACH (Entry2, &IpIf->AddressList) {\r
71 AddrInfo = NET_LIST_USER_STRUCT_S (Entry2, IP6_ADDRESS_INFO, Link, IP6_ADDR_INFO_SIGNATURE);\r
72\r
73 if (AddrInfo->IsAnycast) {\r
74 //\r
75 // Never use an anycast address.\r
76 //\r
77 continue;\r
78 }\r
79\r
80 Copy = AllocateCopyPool (sizeof (IP6_ADDRESS_INFO), AddrInfo);\r
81 if (Copy == NULL) {\r
82 return EFI_OUT_OF_RESOURCES;\r
83 }\r
84\r
85 InsertTailList (SourceList, &Copy->Link);\r
86 (*SourceCount)++;\r
87 }\r
88 }\r
89\r
90 return EFI_SUCCESS;\r
91}\r
92\r
93/**\r
94 Caculate how many bits are the same between two IPv6 addresses.\r
95\r
96 @param[in] AddressA Points to an IPv6 address.\r
97 @param[in] AddressB Points to another IPv6 address.\r
98\r
99 @return The common bits of the AddressA and AddressB.\r
100\r
101**/\r
102UINT8\r
103Ip6CommonPrefixLen (\r
104 IN EFI_IPv6_ADDRESS *AddressA,\r
105 IN EFI_IPv6_ADDRESS *AddressB\r
106 )\r
107{\r
108 UINT8 Count;\r
109 UINT8 Index;\r
110 UINT8 ByteA;\r
111 UINT8 ByteB;\r
112 UINT8 NumBits;\r
113\r
114 Count = 0;\r
115 Index = 0;\r
116\r
117 while (Index < 16) {\r
118 ByteA = AddressA->Addr[Index];\r
119 ByteB = AddressB->Addr[Index];\r
120\r
121 if (ByteA == ByteB) {\r
122 Count += 8;\r
123 Index++;\r
124 continue;\r
125 }\r
126\r
127 //\r
128 // Check how many bits are common between the two bytes.\r
129 //\r
130 NumBits = 8;\r
131 ByteA = (UINT8) (ByteA ^ ByteB);\r
132\r
133 while (ByteA != 0) {\r
134 NumBits--;\r
135 ByteA = (UINT8) (ByteA >> 1);\r
136 }\r
137\r
138 return (UINT8) (Count + NumBits);\r
139 }\r
140\r
141 return Count;\r
142}\r
143\r
144/**\r
145 Output all the available source addresses to a list entry head SourceList. The\r
146 number of source addresses are also returned.\r
147\r
148 @param[in] IpSb Points to a IP6 service binding instance.\r
149 @param[in] Destination The IPv6 destination address.\r
150 @param[out] Source The selected IPv6 source address according to\r
151 the Destination.\r
152\r
153 @retval EFI_SUCCESS The source addresses were copied to a list entry\r
154 head SourceList.\r
155 @retval EFI_NO_MAPPING The IPv6 stack is not auto configured.\r
156\r
157**/\r
158EFI_STATUS\r
159Ip6SelectSourceAddress (\r
160 IN IP6_SERVICE *IpSb,\r
161 IN EFI_IPv6_ADDRESS *Destination,\r
162 OUT EFI_IPv6_ADDRESS *Source\r
163 )\r
164{\r
165 EFI_STATUS Status;\r
166 LIST_ENTRY SourceList;\r
167 UINT32 SourceCount;\r
168 UINT8 ScopeD;\r
169 LIST_ENTRY *Entry;\r
170 IP6_ADDRESS_INFO *AddrInfo;\r
171 IP6_PREFIX_LIST_ENTRY *Prefix;\r
172 UINT8 LastCommonLength;\r
173 UINT8 CurrentCommonLength;\r
174 EFI_IPv6_ADDRESS *TmpAddress;\r
175\r
176 NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);\r
177\r
178 Status = EFI_SUCCESS;\r
179 InitializeListHead (&SourceList);\r
180\r
181 if (!IpSb->LinkLocalOk) {\r
182 return EFI_NO_MAPPING;\r
183 }\r
184\r
185 //\r
186 // Rule 1: Prefer same address.\r
187 //\r
188 if (Ip6IsOneOfSetAddress (IpSb, Destination, NULL, NULL)) {\r
189 IP6_COPY_ADDRESS (Source, Destination);\r
190 goto Exit;\r
191 }\r
192\r
193 //\r
194 // Rule 2: Prefer appropriate scope.\r
195 //\r
196 if (IP6_IS_MULTICAST (Destination)) {\r
197 ScopeD = (UINT8) (Destination->Addr[1] >> 4);\r
198 } else if (NetIp6IsLinkLocalAddr (Destination)) {\r
199 ScopeD = 0x2;\r
200 } else {\r
201 ScopeD = 0xE;\r
202 }\r
203\r
204 if (ScopeD <= 0x2) {\r
205 //\r
206 // Return the link-local address if it exists\r
207 // One IP6_SERVICE only has one link-local address.\r
208 //\r
209 IP6_COPY_ADDRESS (Source, &IpSb->LinkLocalAddr);\r
210 goto Exit;\r
211 }\r
212\r
213 //\r
214 // All candidate source addresses are global unicast address.\r
215 //\r
216 Ip6CandidateSource (IpSb, &SourceList, &SourceCount);\r
217\r
218 if (SourceCount == 0) {\r
219 Status = EFI_NO_MAPPING;\r
220 goto Exit;\r
221 }\r
222\r
223 IP6_COPY_ADDRESS (Source, &IpSb->LinkLocalAddr);\r
224\r
225 if (SourceCount == 1) {\r
226 goto Exit;\r
227 }\r
228\r
229 //\r
230 // Rule 3: Avoid deprecated addresses.\r
231 // TODO: check the "deprecated" state of the stateful configured address\r
232 //\r
233 NET_LIST_FOR_EACH (Entry, &IpSb->AutonomousPrefix) {\r
234 Prefix = NET_LIST_USER_STRUCT (Entry, IP6_PREFIX_LIST_ENTRY, Link);\r
235 if (Prefix->PreferredLifetime == 0) {\r
236 Ip6RemoveAddr (NULL, &SourceList, &SourceCount, &Prefix->Prefix, Prefix->PrefixLength);\r
237\r
238 if (SourceCount == 1) {\r
239 goto Exit;\r
240 }\r
241 }\r
242 }\r
243\r
244 //\r
245 // TODO: Rule 4: Prefer home addresses.\r
246 // TODO: Rule 5: Prefer outgoing interface.\r
247 // TODO: Rule 6: Prefer matching label.\r
248 // TODO: Rule 7: Prefer public addresses.\r
249 //\r
250\r
251 //\r
252 // Rule 8: Use longest matching prefix.\r
253 //\r
254 LastCommonLength = Ip6CommonPrefixLen (Source, Destination);\r
255 TmpAddress = NULL;\r
256\r
257 for (Entry = SourceList.ForwardLink; Entry != &SourceList; Entry = Entry->ForwardLink) {\r
258 AddrInfo = NET_LIST_USER_STRUCT_S (Entry, IP6_ADDRESS_INFO, Link, IP6_ADDR_INFO_SIGNATURE);\r
259\r
260 CurrentCommonLength = Ip6CommonPrefixLen (&AddrInfo->Address, Destination);\r
261 if (CurrentCommonLength > LastCommonLength) {\r
262 LastCommonLength = CurrentCommonLength;\r
263 TmpAddress = &AddrInfo->Address;\r
264 }\r
265 }\r
266\r
267 if (TmpAddress != NULL) {\r
268 IP6_COPY_ADDRESS (Source, TmpAddress);\r
269 }\r
270\r
271Exit:\r
272\r
273 Ip6RemoveAddr (NULL, &SourceList, &SourceCount, NULL, 0);\r
274\r
275 return Status;\r
276}\r
277\r
278/**\r
279 Select an interface to send the packet generated in the IP6 driver\r
280 itself: that is, not by the requests of the IP6 child's consumer. Such\r
281 packets include the ICMPv6 echo replies and other ICMPv6 error packets.\r
282\r
283 @param[in] IpSb The IP4 service that wants to send the packets.\r
284 @param[in] Destination The destination of the packet.\r
285 @param[in, out] Source The source of the packet.\r
286\r
287 @return NULL if no proper interface is found, otherwise, the interface that\r
288 can be used to send the system packet from.\r
289\r
290**/\r
291IP6_INTERFACE *\r
292Ip6SelectInterface (\r
293 IN IP6_SERVICE *IpSb,\r
294 IN EFI_IPv6_ADDRESS *Destination,\r
295 IN OUT EFI_IPv6_ADDRESS *Source\r
296 )\r
297{\r
298 EFI_STATUS Status;\r
299 EFI_IPv6_ADDRESS SelectedSource;\r
300 IP6_INTERFACE *IpIf;\r
301 BOOLEAN Exist;\r
302\r
303 NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);\r
304 ASSERT (Destination != NULL && Source != NULL);\r
305\r
306 if (NetIp6IsUnspecifiedAddr (Destination)) {\r
307 return NULL;\r
308 }\r
309\r
310 if (!NetIp6IsUnspecifiedAddr (Source)) {\r
311 Exist = Ip6IsOneOfSetAddress (IpSb, Source, &IpIf, NULL);\r
312 ASSERT (Exist);\r
313\r
314 return IpIf;\r
315 }\r
316\r
317 //\r
318 // If source is unspecified, select a source according to the destination.\r
319 //\r
320 Status = Ip6SelectSourceAddress (IpSb, Destination, &SelectedSource);\r
321 if (EFI_ERROR (Status)) {\r
322 return IpSb->DefaultInterface;\r
323 }\r
324\r
325 Ip6IsOneOfSetAddress (IpSb, &SelectedSource, &IpIf, NULL);\r
326 IP6_COPY_ADDRESS (Source, &SelectedSource);\r
327\r
328 return IpIf;\r
329}\r
330\r
331/**\r
332 The default callback function for the system generated packet.\r
333 It will free the packet.\r
334\r
335 @param[in] Packet The packet that transmitted.\r
336 @param[in] IoStatus The result of the transmission, succeeded or failed.\r
337 @param[in] LinkFlag Not used when transmitted. Check IP6_FRAME_CALLBACK\r
338 for reference.\r
339 @param[in] Context The context provided by us.\r
340\r
341**/\r
342VOID\r
343Ip6SysPacketSent (\r
344 NET_BUF *Packet,\r
345 EFI_STATUS IoStatus,\r
346 UINT32 LinkFlag,\r
347 VOID *Context\r
348 )\r
349{\r
350 NetbufFree (Packet);\r
351 Packet = NULL;\r
352}\r
353\r
354/**\r
355 Prefix an IP6 basic head and unfragmentable extension headers and a fragment header\r
356 to the Packet. Used for IP6 fragmentation.\r
357\r
358 @param[in] IpSb The IP6 service instance to transmit the packet.\r
359 @param[in] Packet The packet to prefix the IP6 header to.\r
360 @param[in] Head The caller supplied header.\r
361 @param[in] FragmentOffset The fragment offset of the data following the header.\r
362 @param[in] ExtHdrs The length of the original extension header.\r
363 @param[in] ExtHdrsLen The length of the extension headers.\r
364 @param[in] LastHeader The pointer of next header of last extension header.\r
365 @param[in] HeadLen The length of the unfragmented part of the IP6 header.\r
366\r
367 @retval EFI_BAD_BUFFER_SIZE There is no enought room in the head space of\r
368 Packet.\r
369 @retval EFI_SUCCESS The operation performed successfully.\r
370\r
371**/\r
372EFI_STATUS\r
373Ip6PrependHead (\r
374 IN IP6_SERVICE *IpSb,\r
375 IN NET_BUF *Packet,\r
376 IN EFI_IP6_HEADER *Head,\r
377 IN UINT16 FragmentOffset,\r
378 IN UINT8 *ExtHdrs,\r
379 IN UINT32 ExtHdrsLen,\r
380 IN UINT8 LastHeader,\r
381 IN UINT32 HeadLen\r
382 )\r
383{\r
384 UINT32 Len;\r
385 UINT32 UnFragExtHdrsLen;\r
386 EFI_IP6_HEADER *PacketHead;\r
387 UINT8 *UpdatedExtHdrs;\r
388 EFI_STATUS Status;\r
389 UINT8 NextHeader;\r
390\r
391 //\r
392 // HeadLen is the length of the fixed part of the sequences of fragments, i.e.\r
393 // the unfragment part.\r
394 //\r
395 PacketHead = (EFI_IP6_HEADER *) NetbufAllocSpace (Packet, HeadLen, NET_BUF_HEAD);\r
396 if (PacketHead == NULL) {\r
397 return EFI_BAD_BUFFER_SIZE;\r
398 }\r
399\r
400 //\r
401 // Set the head up, convert the host byte order to network byte order\r
402 //\r
403 CopyMem (PacketHead, Head, sizeof (EFI_IP6_HEADER));\r
404 PacketHead->PayloadLength = HTONS ((UINT16) (Packet->TotalSize - sizeof (EFI_IP6_HEADER)));\r
405 Packet->Ip.Ip6 = PacketHead;\r
406\r
407 Len = HeadLen - sizeof (EFI_IP6_HEADER);\r
408 UnFragExtHdrsLen = Len - sizeof (IP6_FRAGMENT_HEADER);\r
409\r
410 if (UnFragExtHdrsLen == 0) {\r
411 PacketHead->NextHeader = IP6_FRAGMENT;\r
412 }\r
413\r
414 //\r
415 // Append the extension headers: firstly copy the unfragmentable headers, then append\r
416 // fragmentation header.\r
417 //\r
418 if ((FragmentOffset & IP6_FRAGMENT_OFFSET_MASK) == 0) {\r
419 NextHeader = Head->NextHeader;\r
420 } else {\r
421 NextHeader = PacketHead->NextHeader;\r
422 }\r
423\r
424 Status = Ip6FillFragmentHeader (\r
425 IpSb,\r
426 NextHeader,\r
427 LastHeader,\r
428 ExtHdrs,\r
429 ExtHdrsLen,\r
430 FragmentOffset,\r
431 &UpdatedExtHdrs\r
432 );\r
433 if (EFI_ERROR (Status)) {\r
434 return Status;\r
435 }\r
436\r
437 CopyMem (\r
438 (UINT8 *) (PacketHead + 1),\r
439 UpdatedExtHdrs,\r
440 UnFragExtHdrsLen + sizeof (IP6_FRAGMENT_HEADER)\r
441 );\r
442\r
443 FreePool (UpdatedExtHdrs);\r
444 return EFI_SUCCESS;\r
445}\r
446\r
447/**\r
448 Transmit an IP6 packet. The packet comes either from the IP6\r
449 child's consumer (IpInstance != NULL) or the IP6 driver itself\r
450 (IpInstance == NULL). It will route the packet, fragment it,\r
451 then transmit all the fragments through an interface.\r
452\r
453 @param[in] IpSb The IP6 service instance to transmit the packet.\r
454 @param[in] Interface The IP6 interface to transmit the packet. Ignored\r
455 if NULL.\r
456 @param[in] IpInstance The IP6 child that issues the transmission. It is\r
457 NULL if the packet is from the system.\r
458 @param[in] Packet The user data to send, excluding the IP header.\r
459 @param[in] Head The caller supplied header. The caller should set\r
460 the following header fields: NextHeader, HopLimit,\r
461 Src, Dest, FlowLabel, PayloadLength. This function\r
462 will fill in the Ver, TrafficClass.\r
463 @param[in] ExtHdrs The extension headers to append to the IPv6 basic\r
464 header.\r
465 @param[in] ExtHdrsLen The length of the extension headers.\r
466 @param[in] Callback The callback function to issue when transmission\r
467 completed.\r
468 @param[in] Context The opaque context for the callback.\r
469\r
470 @retval EFI_INVALID_PARAMETER Any input parameter or the packet is invalid.\r
471 @retval EFI_NO_MAPPING There is no interface to the destination.\r
472 @retval EFI_NOT_FOUND There is no route to the destination.\r
473 @retval EFI_SUCCESS The packet successfully transmitted.\r
474 @retval EFI_OUT_OF_RESOURCES Failed to finish the operation due to lack of\r
475 resources.\r
476 @retval Others Failed to transmit the packet.\r
477\r
478**/\r
479EFI_STATUS\r
480Ip6Output (\r
481 IN IP6_SERVICE *IpSb,\r
482 IN IP6_INTERFACE *Interface OPTIONAL,\r
483 IN IP6_PROTOCOL *IpInstance OPTIONAL,\r
484 IN NET_BUF *Packet,\r
485 IN EFI_IP6_HEADER *Head,\r
486 IN UINT8 *ExtHdrs,\r
487 IN UINT32 ExtHdrsLen,\r
488 IN IP6_FRAME_CALLBACK Callback,\r
489 IN VOID *Context\r
490 )\r
491{\r
492 IP6_INTERFACE *IpIf;\r
493 EFI_IPv6_ADDRESS NextHop;\r
494 IP6_NEIGHBOR_ENTRY *NeighborCache;\r
495 IP6_ROUTE_CACHE_ENTRY *RouteCache;\r
496 EFI_STATUS Status;\r
497 UINT32 Mtu;\r
498 UINT32 HeadLen;\r
499 UINT16 FragmentOffset;\r
500 UINT8 *LastHeader;\r
501 UINT32 UnFragmentLen;\r
502 UINT32 UnFragmentHdrsLen;\r
503 UINT32 FragmentHdrsLen;\r
504 UINT16 *Checksum;\r
505 UINT16 PacketChecksum;\r
506 UINT16 PseudoChecksum;\r
507 UINT32 Index;\r
508 UINT32 PacketLen;\r
509 UINT32 RealExtLen;\r
510 UINT32 Offset;\r
511 NET_BUF *TmpPacket;\r
512 NET_BUF *Fragment;\r
513 UINT32 Num;\r
514 UINT8 *Buf;\r
515 EFI_IP6_HEADER *PacketHead;\r
516 IP6_ICMP_HEAD *IcmpHead;\r
517 IP6_TXTOKEN_WRAP *Wrap;\r
518 IP6_ROUTE_ENTRY *RouteEntry;\r
519 UINT8 *UpdatedExtHdrs;\r
520 UINT8 NextHeader;\r
521 UINT8 LastHeaderBackup;\r
522 BOOLEAN FragmentHeadInserted;\r
523 UINT8 *ExtHdrsBackup;\r
524 UINT8 NextHeaderBackup;\r
525 EFI_IPv6_ADDRESS Source;\r
526 EFI_IPv6_ADDRESS Destination;\r
527\r
528 NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);\r
529\r
530 //\r
531 // RFC2460: Each extension header is an integer multiple of 8 octets long,\r
532 // in order to retain 8-octet alignment for subsequent headers.\r
533 //\r
534 if ((ExtHdrsLen & 0x7) != 0) {\r
535 return EFI_INVALID_PARAMETER;\r
536 }\r
537\r
538 LastHeader = NULL;\r
539\r
540 Ip6IsExtsValid (\r
541 NULL,\r
542 NULL,\r
543 &Head->NextHeader,\r
544 ExtHdrs,\r
545 ExtHdrsLen,\r
546 FALSE,\r
547 NULL,\r
548 &LastHeader,\r
549 NULL,\r
550 NULL,\r
551 NULL\r
552 );\r
553\r
554 //\r
555 // Select an interface/source for system packet, application\r
556 // should select them itself.\r
557 //\r
558 IpIf = Interface;\r
559 if (IpIf == NULL) {\r
560 //\r
561 // IpInstance->Interface is NULL when IpInstance is configured with both stationaddress\r
562 // and destinationaddress is unspecified.\r
563 //\r
564 if (IpInstance == NULL || IpInstance->Interface == NULL) {\r
565 IpIf = Ip6SelectInterface (IpSb, &Head->DestinationAddress, &Head->SourceAddress);\r
566 if (IpInstance != NULL) {\r
567 IpInstance->Interface = IpIf;\r
568 }\r
569 } else {\r
570 IpIf = IpInstance->Interface;\r
571 }\r
572 }\r
573\r
574 if (IpIf == NULL) {\r
575 return EFI_NO_MAPPING;\r
576 }\r
577\r
578 //\r
579 // Update the common field in Head here.\r
580 //\r
581 Head->Version = 6;\r
582 Head->TrafficClassL = 0;\r
583 Head->TrafficClassH = 0;\r
584\r
585 Checksum = NULL;\r
586 NextHeader = *LastHeader;\r
587\r
588 switch (NextHeader) {\r
589 case EFI_IP_PROTO_UDP:\r
590 Packet->Udp = (EFI_UDP_HEADER *) NetbufGetByte (Packet, 0, NULL);\r
591 ASSERT (Packet->Udp != NULL);\r
592 if (Packet->Udp->Checksum == 0) {\r
593 Checksum = &Packet->Udp->Checksum;\r
594 }\r
595 break;\r
596\r
597 case EFI_IP_PROTO_TCP:\r
598 Packet->Tcp = (TCP_HEAD *) NetbufGetByte (Packet, 0, NULL);\r
599 ASSERT (Packet->Tcp != NULL);\r
600 if (Packet->Tcp->Checksum == 0) {\r
601 Checksum = &Packet->Tcp->Checksum;\r
602 }\r
603 break;\r
604\r
605 case IP6_ICMP:\r
606 //\r
607 // Don't send ICMP packet to an IPv6 anycast address.\r
608 //\r
609 if (Ip6IsAnycast (IpSb, &Head->DestinationAddress)) {\r
610 return EFI_INVALID_PARAMETER;\r
611 }\r
612\r
613 IcmpHead = (IP6_ICMP_HEAD *) NetbufGetByte (Packet, 0, NULL);\r
614 ASSERT (IcmpHead != NULL);\r
615 if (IcmpHead->Checksum == 0) {\r
616 Checksum = &IcmpHead->Checksum;\r
617 }\r
618 break;\r
619\r
620 default:\r
621 break;\r
622 }\r
623\r
624 if (Checksum != NULL) {\r
625 //\r
626 // Calculate the checksum for upper layer protocol if it is not calculated due to lack of\r
627 // IPv6 source address.\r
628 //\r
629 PacketChecksum = NetbufChecksum (Packet);\r
630 PseudoChecksum = NetIp6PseudoHeadChecksum (\r
631 &Head->SourceAddress,\r
632 &Head->DestinationAddress,\r
633 NextHeader,\r
634 Packet->TotalSize\r
635 );\r
636 *Checksum = (UINT16) ~NetAddChecksum (PacketChecksum, PseudoChecksum);\r
637 }\r
638\r
639 Status = Ip6IpSecProcessPacket (\r
640 IpSb,\r
68d3f2fb 641 &Head,\r
a3bcde70
HT		 642 LastHeader, // no need get the lasthead value for output\r
643 &Packet,\r
68d3f2fb 644 &ExtHdrs,\r
645 &ExtHdrsLen,\r
a3bcde70
HT		 646 EfiIPsecOutBound,\r
647 Context\r
648 );\r
649\r
650 if (EFI_ERROR(Status)) {\r
651 return Status;\r
652 }\r
653\r
654 LastHeader = NULL;\r
655 //\r
656 // Check incoming parameters.\r
657 //\r
658 if (!Ip6IsExtsValid (\r
659 IpSb,\r
660 Packet,\r
661 &Head->NextHeader,\r
662 ExtHdrs,\r
663 ExtHdrsLen,\r
664 FALSE,\r
665 NULL,\r
666 &LastHeader,\r
667 &RealExtLen,\r
668 &UnFragmentHdrsLen,\r
669 NULL\r
670 )) {\r
671 return EFI_INVALID_PARAMETER;\r
672 }\r
673\r
674 if ((RealExtLen & 0x7) != 0) {\r
675 return EFI_INVALID_PARAMETER;\r
676 }\r
677\r
678 LastHeaderBackup = *LastHeader;\r
679\r
680 //\r
681 // Perform next hop determination:\r
682 // For multicast packets, the next-hop is always the destination address and\r
683 // is considered to be on-link.\r
684 //\r
685 if (IP6_IS_MULTICAST (&Head->DestinationAddress)) {\r
686 IP6_COPY_ADDRESS (&NextHop, &Head->DestinationAddress);\r
687 } else {\r
688 //\r
689 // For unicast packets, use a combination of the Destination Cache, the Prefix List\r
690 // and the Default Router List to determine the IP address of the appropriate next hop.\r
691 //\r
a3bcde70 692\r
129b8b09 693 NeighborCache = Ip6FindNeighborEntry (IpSb, &Head->DestinationAddress);\r
694 if (NeighborCache != NULL) {\r
695 //\r
696 // Hit Neighbor Cache.\r
697 //\r
698 IP6_COPY_ADDRESS (&NextHop, &Head->DestinationAddress);\r
699 } else {\r
700 //\r
701 // Not in Neighbor Cache, check Router cache\r
702 //\r
703 RouteCache = Ip6Route (IpSb, &Head->DestinationAddress, &Head->SourceAddress);\r
704 if (RouteCache == NULL) {\r
705 return EFI_NOT_FOUND;\r
706 }\r
707\r
708 IP6_COPY_ADDRESS (&NextHop, &RouteCache->NextHop);\r
709 Ip6FreeRouteCacheEntry (RouteCache);\r
710 }\r
a3bcde70
HT		 711 }\r
712\r
713 //\r
714 // Examines the Neighbor Cache for link-layer information about that neighbor.\r
715 // DO NOT create neighbor cache if neighbor is itself - when reporting ICMP error.\r
716 //\r
717 if (!IP6_IS_MULTICAST (&NextHop) && !EFI_IP6_EQUAL (&Head->DestinationAddress, &Head->SourceAddress)) {\r
718 NeighborCache = Ip6FindNeighborEntry (IpSb, &NextHop);\r
719 if (NeighborCache == NULL) {\r
720 NeighborCache = Ip6CreateNeighborEntry (IpSb, Ip6OnArpResolved, &NextHop, NULL);\r
721\r
722 if (NeighborCache == NULL) {\r
723 return EFI_OUT_OF_RESOURCES;\r
724 }\r
725\r
726 //\r
727 // Send out multicast neighbor solicitation for address resolution immediatly.\r
728 //\r
729 Ip6CreateSNMulticastAddr (&NeighborCache->Neighbor, &Destination);\r
730 Status = Ip6SelectSourceAddress (IpSb, &NeighborCache->Neighbor, &Source);\r
731 if (EFI_ERROR (Status)) {\r
732 return Status;\r
733 }\r
734\r
735 Status = Ip6SendNeighborSolicit (\r
736 IpSb,\r
737 &Source,\r
738 &Destination,\r
739 &NeighborCache->Neighbor,\r
740 &IpSb->SnpMode.CurrentAddress\r
741 );\r
742 if (EFI_ERROR (Status)) {\r
743 return Status;\r
744 }\r
745\r
746 --NeighborCache->Transmit;\r
747 NeighborCache->Ticks = IP6_GET_TICKS (IpSb->RetransTimer) + 1;\r
748 }\r
749\r
750 NeighborCache->Interface = IpIf;\r
751 }\r
752\r
753 UpdatedExtHdrs = NULL;\r
754 ExtHdrsBackup = NULL;\r
755 NextHeaderBackup = 0;\r
756 FragmentHeadInserted = FALSE;\r
757\r
758 //\r
759 // Check whether we received Packet Too Big message for the packet sent to the\r
760 // Destination. If yes include a Fragment Header in the subsequent packets.\r
761 //\r
762 RouteEntry = Ip6FindRouteEntry (\r
763 IpSb->RouteTable,\r
764 &Head->DestinationAddress,\r
765 NULL\r
766 );\r
767 if (RouteEntry != NULL) {\r
768 if ((RouteEntry->Flag & IP6_PACKET_TOO_BIG) == IP6_PACKET_TOO_BIG) {\r
769\r
770 //\r
771 // FragmentHead is inserted after Hop-by-Hop Options header, Destination\r
772 // Options header (first occur), Routing header, and before Fragment header,\r
773 // Authentication header, Encapsulating Security Payload header, and\r
774 // Destination Options header (last occur), and upper-layer header.\r
775 //\r
776 Status = Ip6FillFragmentHeader (\r
777 IpSb,\r
778 Head->NextHeader,\r
779 LastHeaderBackup,\r
780 ExtHdrs,\r
781 ExtHdrsLen,\r
782 0,\r
783 &UpdatedExtHdrs\r
784 );\r
785 if (EFI_ERROR (Status)) {\r
786 return Status;\r
787 }\r
788\r
789 if ((ExtHdrs == NULL) && (ExtHdrsLen == 0)) {\r
790 NextHeaderBackup = Head->NextHeader;\r
791 Head->NextHeader = IP6_FRAGMENT;\r
792 }\r
793\r
794 ExtHdrsBackup = ExtHdrs;\r
795 ExtHdrs = UpdatedExtHdrs;\r
796 ExtHdrsLen = ExtHdrsLen + sizeof (IP6_FRAGMENT_HEADER);\r
797 RealExtLen = RealExtLen + sizeof (IP6_FRAGMENT_HEADER);\r
798\r
799 mIp6Id++;\r
800\r
801 FragmentHeadInserted = TRUE;\r
802 }\r
803\r
804 Ip6FreeRouteEntry (RouteEntry);\r
805 }\r
806\r
807 //\r
808 // OK, selected the source and route, fragment the packet then send\r
809 // them. Tag each fragment other than the first one as spawn from it.\r
810 // Each extension header is an integar multiple of 8 octets long, in\r
811 // order to retain 8-octet alignment for subsequent headers.\r
812 //\r
813 Mtu = IpSb->MaxPacketSize + sizeof (EFI_IP6_HEADER);\r
814 HeadLen = sizeof (EFI_IP6_HEADER) + RealExtLen;\r
815\r
816 if (Packet->TotalSize + HeadLen > Mtu) {\r
817 //\r
818 // Remove the inserted Fragment Header since we need fragment the packet.\r
819 //\r
820 if (FragmentHeadInserted) {\r
821 ExtHdrs = ExtHdrsBackup;\r
822 ExtHdrsLen = ExtHdrsLen - sizeof (IP6_FRAGMENT_HEADER);\r
823\r
824 if ((ExtHdrs == NULL) && (ExtHdrsLen == 0)) {\r
825 Head->NextHeader = NextHeaderBackup;\r
826 }\r
827 }\r
828\r
829 FragmentHdrsLen = ExtHdrsLen - UnFragmentHdrsLen;\r
830\r
831 //\r
832 // The packet is beyond the maximum which can be described through the\r
833 // fragment offset field in Fragment header.\r
834 //\r
835 if ((((Packet->TotalSize + FragmentHdrsLen) >> 3) & (~0x1fff)) != 0) {\r
836 Status = EFI_BAD_BUFFER_SIZE;\r
837 goto Error;\r
838 }\r
839\r
840 if (FragmentHdrsLen != 0) {\r
841 //\r
842 // Append the fragmentable extension hdrs before the upper layer payload\r
843 // to form a new NET_BUF. This NET_BUF contains all the buffer which will\r
844 // be fragmented below.\r
845 //\r
846 TmpPacket = NetbufGetFragment (Packet, 0, Packet->TotalSize, FragmentHdrsLen);\r
847 ASSERT (TmpPacket != NULL);\r
848\r
849 //\r
850 // Allocate the space to contain the fragmentable hdrs and copy the data.\r
851 //\r
852 Buf = NetbufAllocSpace (TmpPacket, FragmentHdrsLen, TRUE);\r
853 ASSERT (Buf != NULL);\r
854 CopyMem (Buf, ExtHdrs + UnFragmentHdrsLen, FragmentHdrsLen);\r
855\r
856 //\r
857 // Free the old Packet.\r
858 //\r
859 NetbufFree (Packet);\r
860 Packet = TmpPacket;\r
861 }\r
862\r
863 //\r
864 // The unfragment part which appears in every fragmented IPv6 packet includes\r
865 // the IPv6 header, the unfragmentable extension hdrs and the fragment header.\r
866 //\r
867 UnFragmentLen = sizeof (EFI_IP6_HEADER) + UnFragmentHdrsLen + sizeof (IP6_FRAGMENT_HEADER);\r
868\r
869 //\r
870 // Mtu now is the length of the fragment part in a full-length fragment.\r
871 //\r
872 Mtu = (Mtu - UnFragmentLen) & (~0x07);\r
873 Num = (Packet->TotalSize + Mtu - 1) / Mtu;\r
874\r
875 for (Index = 0, Offset = 0, PacketLen = Mtu; Index < Num; Index++) {\r
876 //\r
877 // Get fragment from the Packet, append UnFragnmentLen spare buffer\r
878 // before the fragmented data, the corresponding data is filled in later.\r
879 //\r
880 Fragment = NetbufGetFragment (Packet, Offset, PacketLen, UnFragmentLen);\r
881 if (Fragment == NULL) {\r
882 Status = EFI_OUT_OF_RESOURCES;\r
883 goto Error;\r
884 }\r
885\r
886 FragmentOffset = (UINT16) ((UINT16) Offset | 0x1);\r
887 if (Index == Num - 1){\r
888 //\r
889 // The last fragment, clear the M flag.\r
890 //\r
891 FragmentOffset &= (~0x1);\r
892 }\r
893\r
894 Status = Ip6PrependHead (\r
895 IpSb,\r
896 Fragment,\r
897 Head,\r
898 FragmentOffset,\r
899 ExtHdrs,\r
900 ExtHdrsLen,\r
901 LastHeaderBackup,\r
902 UnFragmentLen\r
903 );\r
904 ASSERT (Status == EFI_SUCCESS);\r
905\r
906 Status = Ip6SendFrame (\r
907 IpIf,\r
908 IpInstance,\r
909 Fragment,\r
910 &NextHop,\r
911 Ip6SysPacketSent,\r
912 Packet\r
913 );\r
914 if (EFI_ERROR (Status)) {\r
915 goto Error;\r
916 }\r
917\r
918 //\r
919 // The last fragment of upper layer packet, update the IP6 token status.\r
920 //\r
921 if ((Index == Num -1) && (Context != NULL)) {\r
922 Wrap = (IP6_TXTOKEN_WRAP *) Context;\r
923 Wrap->Token->Status = Status;\r
924 }\r
925\r
926 Offset += PacketLen;\r
927 PacketLen = Packet->TotalSize - Offset;\r
928 if (PacketLen > Mtu) {\r
929 PacketLen = Mtu;\r
930 }\r
931 }\r
932\r
933 NetbufFree (Packet);\r
934 mIp6Id++;\r
935\r
936 if (UpdatedExtHdrs != NULL) {\r
937 FreePool (UpdatedExtHdrs);\r
938 }\r
939\r
940 return EFI_SUCCESS;\r
941 }\r
942\r
943 //\r
944 // Need not fragment the packet, send it in one frame.\r
945 //\r
946 PacketHead = (EFI_IP6_HEADER *) NetbufAllocSpace (Packet, HeadLen, NET_BUF_HEAD);\r
947 if (PacketHead == NULL) {\r
948 Status = EFI_BAD_BUFFER_SIZE;\r
949 goto Error;\r
950 }\r
951\r
952 CopyMem (PacketHead, Head, sizeof (EFI_IP6_HEADER));\r
953 Packet->Ip.Ip6 = PacketHead;\r
954\r
955 if (ExtHdrs != NULL) {\r
956 Buf = (UINT8 *) (PacketHead + 1);\r
957 CopyMem (Buf, ExtHdrs, ExtHdrsLen);\r
958 }\r
959\r
960 if (UpdatedExtHdrs != NULL) {\r
961 //\r
962 // A Fragment Header is inserted to the packet, update the payload length.\r
963 //\r
964 PacketHead->PayloadLength = (UINT16) (NTOHS (PacketHead->PayloadLength) +\r
965 sizeof (IP6_FRAGMENT_HEADER));\r
966 PacketHead->PayloadLength = HTONS (PacketHead->PayloadLength);\r
967 FreePool (UpdatedExtHdrs);\r
968 }\r
969\r
970 return Ip6SendFrame (\r
971 IpIf,\r
972 IpInstance,\r
973 Packet,\r
974 &NextHop,\r
975 Callback,\r
976 Context\r
977 );\r
978\r
979Error:\r
980 if (UpdatedExtHdrs != NULL) {\r
981 FreePool (UpdatedExtHdrs);\r
982 }\r
983 Ip6CancelPacket (IpIf, Packet, Status);\r
984 return Status;\r
985}\r
986\r
987/**\r
988 The filter function to find a packet and all its fragments.\r
989 The packet's fragments have their Context set to the packet.\r
990\r
991 @param[in] Frame The frames hold by the low level interface.\r
992 @param[in] Context Context to the function, which is the packet.\r
993\r
994 @retval TRUE This is the packet to cancel or its fragments.\r
995 @retval FALSE This is an unrelated packet.\r
996\r
997**/\r
998BOOLEAN\r
999Ip6CancelPacketFragments (\r
1000 IN IP6_LINK_TX_TOKEN *Frame,\r
1001 IN VOID *Context\r
1002 )\r
1003{\r
1004 if ((Frame->Packet == (NET_BUF *) Context) || (Frame->Context == Context)) {\r
1005 return TRUE;\r
1006 }\r
1007\r
1008 return FALSE;\r
1009}\r
1010\r
1011/**\r
1012 Remove all the frames on the interface that pass the FrameToCancel,\r
1013 either queued on ARP queues or that have already been delivered to\r
1014 MNP and not yet recycled.\r
1015\r
1016 @param[in] Interface Interface to remove the frames from.\r
1017 @param[in] IoStatus The transmit status returned to the frames' callback.\r
1018 @param[in] FrameToCancel Function to select the frame to cancel; NULL to select all.\r
1019 @param[in] Context Opaque parameters passed to FrameToCancel. Ignored if\r
1020 FrameToCancel is NULL.\r
1021\r
1022**/\r
1023VOID\r
1024Ip6CancelFrames (\r
1025 IN IP6_INTERFACE *Interface,\r
1026 IN EFI_STATUS IoStatus,\r
1027 IN IP6_FRAME_TO_CANCEL FrameToCancel OPTIONAL,\r
1028 IN VOID *Context OPTIONAL\r
1029 )\r
1030{\r
1031 LIST_ENTRY *Entry;\r
1032 LIST_ENTRY *Next;\r
1033 IP6_LINK_TX_TOKEN *Token;\r
1034 IP6_SERVICE *IpSb;\r
1035 IP6_NEIGHBOR_ENTRY *ArpQue;\r
1036 EFI_STATUS Status;\r
1037\r
1038 IpSb = Interface->Service;\r
1039 NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);\r
1040\r
1041 //\r
1042 // Cancel all the pending frames on ARP requests\r
1043 //\r
1044 NET_LIST_FOR_EACH_SAFE (Entry, Next, &Interface->ArpQues) {\r
1045 ArpQue = NET_LIST_USER_STRUCT (Entry, IP6_NEIGHBOR_ENTRY, ArpList);\r
1046\r
1047 Status = Ip6FreeNeighborEntry (\r
1048 IpSb,\r
1049 ArpQue,\r
1050 FALSE,\r
1051 FALSE,\r
1052 IoStatus,\r
1053 FrameToCancel,\r
1054 Context\r
1055 );\r
1056 ASSERT_EFI_ERROR (Status);\r
1057 }\r
1058\r
1059 //\r
1060 // Cancel all the frames that have been delivered to MNP\r
1061 // but not yet recycled.\r
1062 //\r
1063 NET_LIST_FOR_EACH_SAFE (Entry, Next, &Interface->SentFrames) {\r
1064 Token = NET_LIST_USER_STRUCT (Entry, IP6_LINK_TX_TOKEN, Link);\r
1065\r
1066 if ((FrameToCancel == NULL) || FrameToCancel (Token, Context)) {\r
1067 IpSb->Mnp->Cancel (IpSb->Mnp, &Token->MnpToken);\r
1068 }\r
1069 }\r
1070}\r
1071\r
1072/**\r
1073 Cancel the Packet and all its fragments.\r
1074\r
1075 @param[in] IpIf The interface from which the Packet is sent.\r
1076 @param[in] Packet The Packet to cancel.\r
1077 @param[in] IoStatus The status returns to the sender.\r
1078\r
1079**/\r
1080VOID\r
1081Ip6CancelPacket (\r
1082 IN IP6_INTERFACE *IpIf,\r
1083 IN NET_BUF *Packet,\r
1084 IN EFI_STATUS IoStatus\r
1085 )\r
1086{\r
1087 Ip6CancelFrames (IpIf, IoStatus, Ip6CancelPacketFragments, Packet);\r
1088}\r
1089\r
EFI Development Kit II mirror for PVE