]> git.proxmox.com Git - mirror_edk2.git/blob - NetworkPkg/Ip6Dxe/Ip6Output.c
projects / mirror_edk2.git / blob
? search:


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