Ip6Output.c

Last change on this file was 99404, checked in by vboxsync, 21 months ago
Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
Property svn:eol-style set to `native`
File size: 30.4 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/NetworkPkg/Ip6Dxe/Ip6Output.c

Download in other formats: