Ip6Impl.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: 58.5 KB

Line
1	/** @file
2	Implementation of EFI_IP6_PROTOCOL protocol interfaces.
3
4	(C) Copyright 2014 Hewlett-Packard Development Company, L.P.<BR>
5	Copyright (c) 2009 - 2016, Intel Corporation. All rights reserved.<BR>
6
7	SPDX-License-Identifier: BSD-2-Clause-Patent
8
9	**/
10
11	#include "Ip6Impl.h"
12
13	EFI_IPSEC2_PROTOCOL *mIpSec = NULL;
14
15	EFI_IP6_PROTOCOL mEfiIp6ProtocolTemplete = {
16	EfiIp6GetModeData,
17	EfiIp6Configure,
18	EfiIp6Groups,
19	EfiIp6Routes,
20	EfiIp6Neighbors,
21	EfiIp6Transmit,
22	EfiIp6Receive,
23	EfiIp6Cancel,
24	EfiIp6Poll
25	};
26
27	/**
28	Gets the current operational settings for this instance of the EFI IPv6 Protocol driver.
29
30	The GetModeData() function returns the current operational mode data for this driver instance.
31	The data fields in EFI_IP6_MODE_DATA are read only. This function is used optionally to
32	retrieve the operational mode data of underlying networks or drivers.
33
34	@param[in] This Pointer to the EFI_IP6_PROTOCOL instance.
35	@param[out] Ip6ModeData Pointer to the EFI IPv6 Protocol mode data structure.
36	@param[out] MnpConfigData Pointer to the managed network configuration data structure.
37	@param[out] SnpModeData Pointer to the simple network mode data structure.
38
39	@retval EFI_SUCCESS The operation completed successfully.
40	@retval EFI_INVALID_PARAMETER This is NULL.
41	@retval EFI_OUT_OF_RESOURCES The required mode data could not be allocated.
42
43	**/
44	EFI_STATUS
45	EFIAPI
46	EfiIp6GetModeData (
47	IN EFI_IP6_PROTOCOL *This,
48	OUT EFI_IP6_MODE_DATA *Ip6ModeData OPTIONAL,
49	OUT EFI_MANAGED_NETWORK_CONFIG_DATA *MnpConfigData OPTIONAL,
50	OUT EFI_SIMPLE_NETWORK_MODE *SnpModeData OPTIONAL
51	)
52	{
53	IP6_PROTOCOL *IpInstance;
54	IP6_SERVICE *IpSb;
55	IP6_INTERFACE *IpIf;
56	EFI_IP6_CONFIG_DATA *Config;
57	EFI_STATUS Status;
58	EFI_TPL OldTpl;
59
60	if (This == NULL) {
61	return EFI_INVALID_PARAMETER;
62	}
63
64	OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
65	IpInstance = IP6_INSTANCE_FROM_PROTOCOL (This);
66	IpSb = IpInstance->Service;
67	IpIf = IpInstance->Interface;
68
69	if (IpSb->LinkLocalDadFail) {
70	return EFI_INVALID_PARAMETER;
71	}
72
73	if (Ip6ModeData != NULL) {
74	//
75	// IsStarted is "whether the EfiIp6Configure has been called".
76	// IsConfigured is "whether the station address has been configured"
77	//
78	Ip6ModeData->IsStarted = (BOOLEAN)(IpInstance->State == IP6_STATE_CONFIGED);
79	Ip6ModeData->MaxPacketSize = IpSb->MaxPacketSize;
80	CopyMem (&Ip6ModeData->ConfigData, &IpInstance->ConfigData, sizeof (EFI_IP6_CONFIG_DATA));
81	Ip6ModeData->IsConfigured = FALSE;
82
83	Ip6ModeData->AddressCount = 0;
84	Ip6ModeData->AddressList = NULL;
85
86	Ip6ModeData->GroupCount = IpInstance->GroupCount;
87	Ip6ModeData->GroupTable = NULL;
88
89	Ip6ModeData->RouteCount = 0;
90	Ip6ModeData->RouteTable = NULL;
91
92	Ip6ModeData->NeighborCount = 0;
93	Ip6ModeData->NeighborCache = NULL;
94
95	Ip6ModeData->PrefixCount = 0;
96	Ip6ModeData->PrefixTable = NULL;
97
98	Ip6ModeData->IcmpTypeCount = 23;
99	Ip6ModeData->IcmpTypeList = AllocateCopyPool (
100	Ip6ModeData->IcmpTypeCount * sizeof (EFI_IP6_ICMP_TYPE),
101	mIp6SupportedIcmp
102	);
103	if (Ip6ModeData->IcmpTypeList == NULL) {
104	Status = EFI_OUT_OF_RESOURCES;
105	goto Error;
106	}
107
108	//
109	// Return the currently configured IPv6 addresses and corresponding prefix lengths.
110	//
111	Status = Ip6BuildEfiAddressList (
112	IpSb,
113	&Ip6ModeData->AddressCount,
114	&Ip6ModeData->AddressList
115	);
116	if (EFI_ERROR (Status)) {
117	goto Error;
118	}
119
120	//
121	// Return the current station address for this IP child.
122	// If UseAnyStationAddress is set to TRUE, IP6 driver will
123	// select a source address from its address list. Otherwise use the
124	// StationAddress in config data.
125	//
126	if (Ip6ModeData->IsStarted) {
127	Config = &Ip6ModeData->ConfigData;
128
129	if (IpIf->Configured \|\| NetIp6IsUnspecifiedAddr (&Config->DestinationAddress)) {
130	Ip6ModeData->IsConfigured = TRUE;
131	} else {
132	Ip6ModeData->IsConfigured = FALSE;
133	}
134
135	//
136	// Build a EFI route table for user from the internal route table.
137	//
138	Status = Ip6BuildEfiRouteTable (
139	IpSb->RouteTable,
140	&Ip6ModeData->RouteCount,
141	&Ip6ModeData->RouteTable
142	);
143
144	if (EFI_ERROR (Status)) {
145	goto Error;
146	}
147	}
148
149	if (Ip6ModeData->IsConfigured) {
150	//
151	// Return the joined multicast group addresses.
152	//
153	if (IpInstance->GroupCount != 0) {
154	Ip6ModeData->GroupTable = AllocateCopyPool (
155	IpInstance->GroupCount * sizeof (EFI_IPv6_ADDRESS),
156	IpInstance->GroupList
157	);
158	if (Ip6ModeData->GroupTable == NULL) {
159	Status = EFI_OUT_OF_RESOURCES;
160	goto Error;
161	}
162	}
163
164	//
165	// Return the neighbor cache entries
166	//
167	Status = Ip6BuildEfiNeighborCache (
168	IpInstance,
169	&Ip6ModeData->NeighborCount,
170	&Ip6ModeData->NeighborCache
171	);
172	if (EFI_ERROR (Status)) {
173	goto Error;
174	}
175
176	//
177	// Return the prefix table entries
178	//
179	Status = Ip6BuildPrefixTable (
180	IpInstance,
181	&Ip6ModeData->PrefixCount,
182	&Ip6ModeData->PrefixTable
183	);
184	if (EFI_ERROR (Status)) {
185	goto Error;
186	}
187	}
188	}
189
190	//
191	// Get fresh mode data from MNP, since underlying media status may change
192	//
193	Status = IpSb->Mnp->GetModeData (IpSb->Mnp, MnpConfigData, SnpModeData);
194
195	goto Exit;
196
197	Error:
198	if (Ip6ModeData != NULL) {
199	if (Ip6ModeData->AddressList != NULL) {
200	FreePool (Ip6ModeData->AddressList);
201	}
202
203	if (Ip6ModeData->GroupTable != NULL) {
204	FreePool (Ip6ModeData->GroupTable);
205	}
206
207	if (Ip6ModeData->RouteTable != NULL) {
208	FreePool (Ip6ModeData->RouteTable);
209	}
210
211	if (Ip6ModeData->NeighborCache != NULL) {
212	FreePool (Ip6ModeData->NeighborCache);
213	}
214
215	if (Ip6ModeData->PrefixTable != NULL) {
216	FreePool (Ip6ModeData->PrefixTable);
217	}
218
219	if (Ip6ModeData->IcmpTypeList != NULL) {
220	FreePool (Ip6ModeData->IcmpTypeList);
221	}
222	}
223
224	Exit:
225	gBS->RestoreTPL (OldTpl);
226	return Status;
227	}
228
229	/**
230	Validate that Ipv6 address is OK to be used as station address or next hop address/ neighbor.
231
232	@param[in] IpSb The IP6 service instance.
233	@param[in] Ip The IPv6 address to validate.
234	@param[in] Flag If TRUE, validate if the address is OK to be used
235	as station address. If FALSE, validate if the
236	address is OK to be used as the next hop address/
237	neighbor.
238
239	@retval TRUE The Ip address is valid and could be used.
240	@retval FALSE Invalid Ip address.
241
242	**/
243	BOOLEAN
244	Ip6IsValidAddress (
245	IN IP6_SERVICE *IpSb,
246	IN EFI_IPv6_ADDRESS *Ip,
247	IN BOOLEAN Flag
248	)
249	{
250	if (!NetIp6IsUnspecifiedAddr (Ip)) {
251	if (!NetIp6IsValidUnicast (Ip)) {
252	return FALSE;
253	}
254
255	if (Ip6IsOneOfSetAddress (IpSb, Ip, NULL, NULL)) {
256	return Flag;
257	}
258	} else {
259	return Flag;
260	}
261
262	return (BOOLEAN) !Flag;
263	}
264
265	/**
266	Validate whether the value of protocol is illegal or not. Protocol is the 'Next Header' field
267	in the last IPv6 extension header, or basic IPv6 header is there's no extension header.
268
269	@param[in] Protocol Default value of 'Next Header'
270
271	@retval TRUE The protocol is illegal.
272	@retval FALSE The protocol is legal.
273
274	**/
275	BOOLEAN
276	Ip6IsIllegalProtocol (
277	IN UINT8 Protocol
278	)
279	{
280	if ((Protocol == IP6_HOP_BY_HOP) \|\| (Protocol == EFI_IP_PROTO_ICMP) \|\| (Protocol == IP4_PROTO_IGMP)) {
281	return TRUE;
282	}
283
284	if ((Protocol == 41) \|\| (Protocol == 43) \|\| (Protocol == 44) \|\| (Protocol == 59) \|\| (Protocol == 60) \|\| (Protocol == 124)) {
285	return TRUE;
286	}
287
288	return FALSE;
289	}
290
291	/**
292	Initialize the IP6_PROTOCOL structure to the unconfigured states.
293
294	@param[in] IpSb The IP6 service instance.
295	@param[in, out] IpInstance The IP6 child instance.
296
297	**/
298	VOID
299	Ip6InitProtocol (
300	IN IP6_SERVICE *IpSb,
301	IN OUT IP6_PROTOCOL *IpInstance
302	)
303	{
304	ASSERT ((IpSb != NULL) && (IpInstance != NULL));
305
306	ZeroMem (IpInstance, sizeof (IP6_PROTOCOL));
307
308	IpInstance->Signature = IP6_PROTOCOL_SIGNATURE;
309	IpInstance->State = IP6_STATE_UNCONFIGED;
310	IpInstance->Service = IpSb;
311	IpInstance->GroupList = NULL;
312	CopyMem (&IpInstance->Ip6Proto, &mEfiIp6ProtocolTemplete, sizeof (EFI_IP6_PROTOCOL));
313
314	NetMapInit (&IpInstance->RxTokens);
315	NetMapInit (&IpInstance->TxTokens);
316	InitializeListHead (&IpInstance->Received);
317	InitializeListHead (&IpInstance->Delivered);
318
319	EfiInitializeLock (&IpInstance->RecycleLock, TPL_NOTIFY);
320	}
321
322	/**
323	Configure the IP6 child. If the child is already configured,
324	change the configuration parameter. Otherwise, configure it
325	for the first time. The caller should validate the configuration
326	before deliver them to it. It also don't do configure NULL.
327
328	@param[in, out] IpInstance The IP6 child to configure.
329	@param[in] Config The configure data.
330
331	@retval EFI_SUCCESS The IP6 child is successfully configured.
332	@retval EFI_DEVICE_ERROR Failed to free the pending transive or to
333	configure underlying MNP, or other errors.
334	@retval EFI_NO_MAPPING The IP6 child is configured to use the default
335	address, but the default address hasn't been
336	configured. The IP6 child doesn't need to be
337	reconfigured when the default address is configured.
338	@retval EFI_OUT_OF_RESOURCES No more memory space is available.
339	@retval other Other error occurs.
340
341	**/
342	EFI_STATUS
343	Ip6ConfigProtocol (
344	IN OUT IP6_PROTOCOL *IpInstance,
345	IN EFI_IP6_CONFIG_DATA *Config
346	)
347	{
348	IP6_SERVICE *IpSb;
349	IP6_INTERFACE *IpIf;
350	EFI_STATUS Status;
351	EFI_IP6_CONFIG_DATA *Current;
352	IP6_ADDRESS_INFO *AddressInfo;
353	BOOLEAN StationZero;
354	BOOLEAN DestZero;
355	EFI_IPv6_ADDRESS Source;
356	BOOLEAN AddrOk;
357
358	IpSb = IpInstance->Service;
359	Current = &IpInstance->ConfigData;
360
361	//
362	// User is changing packet filters. It must be stopped
363	// before the station address can be changed.
364	//
365	if (IpInstance->State == IP6_STATE_CONFIGED) {
366	//
367	// Cancel all the pending transmit/receive from upper layer
368	//
369	Status = Ip6Cancel (IpInstance, NULL);
370
371	if (EFI_ERROR (Status)) {
372	return EFI_DEVICE_ERROR;
373	}
374
375	CopyMem (Current, Config, sizeof (EFI_IP6_CONFIG_DATA));
376	return EFI_SUCCESS;
377	}
378
379	//
380	// Set up the interface.
381	//
382	StationZero = NetIp6IsUnspecifiedAddr (&Config->StationAddress);
383	DestZero = NetIp6IsUnspecifiedAddr (&Config->DestinationAddress);
384
385	if (StationZero && DestZero) {
386	//
387	// StationAddress is still zero.
388	//
389
390	NET_GET_REF (IpSb->DefaultInterface);
391	IpInstance->Interface = IpSb->DefaultInterface;
392	InsertTailList (&IpSb->DefaultInterface->IpInstances, &IpInstance->AddrLink);
393
394	CopyMem (Current, Config, sizeof (EFI_IP6_CONFIG_DATA));
395	IpInstance->State = IP6_STATE_CONFIGED;
396
397	return EFI_SUCCESS;
398	}
399
400	if (StationZero && !DestZero) {
401	Status = Ip6SelectSourceAddress (IpSb, &Config->DestinationAddress, &Source);
402	if (EFI_ERROR (Status)) {
403	return Status;
404	}
405	} else {
406	IP6_COPY_ADDRESS (&Source, &Config->StationAddress);
407	}
408
409	AddrOk = Ip6IsOneOfSetAddress (IpSb, &Source, &IpIf, &AddressInfo);
410	if (AddrOk) {
411	if (AddressInfo != NULL) {
412	IpInstance->PrefixLength = AddressInfo->PrefixLength;
413	} else {
414	IpInstance->PrefixLength = IP6_LINK_LOCAL_PREFIX_LENGTH;
415	}
416	} else {
417	//
418	// The specified source address is not one of the addresses IPv6 maintains.
419	//
420	return EFI_INVALID_PARAMETER;
421	}
422
423	NET_GET_REF (IpIf);
424	IpInstance->Interface = IpIf;
425	InsertTailList (&IpIf->IpInstances, &IpInstance->AddrLink);
426
427	CopyMem (Current, Config, sizeof (EFI_IP6_CONFIG_DATA));
428	IP6_COPY_ADDRESS (&Current->StationAddress, &Source);
429	IpInstance->State = IP6_STATE_CONFIGED;
430
431	return EFI_SUCCESS;
432	}
433
434	/**
435	Clean up the IP6 child, and release all the resources used by it.
436
437	@param[in, out] IpInstance The IP6 child to clean up.
438
439	@retval EFI_SUCCESS The IP6 child is cleaned up.
440	@retval EFI_DEVICE_ERROR Some resources failed to be released.
441
442	**/
443	EFI_STATUS
444	Ip6CleanProtocol (
445	IN OUT IP6_PROTOCOL *IpInstance
446	)
447	{
448	if (EFI_ERROR (Ip6Cancel (IpInstance, NULL))) {
449	return EFI_DEVICE_ERROR;
450	}
451
452	if (EFI_ERROR (Ip6Groups (IpInstance, FALSE, NULL))) {
453	return EFI_DEVICE_ERROR;
454	}
455
456	//
457	// Some packets haven't been recycled. It is because either the
458	// user forgets to recycle the packets, or because the callback
459	// hasn't been called. Just leave it alone.
460	//
461	if (!IsListEmpty (&IpInstance->Delivered)) {
462	}
463
464	if (IpInstance->Interface != NULL) {
465	RemoveEntryList (&IpInstance->AddrLink);
466	Ip6CleanInterface (IpInstance->Interface, IpInstance);
467	IpInstance->Interface = NULL;
468	}
469
470	if (IpInstance->GroupList != NULL) {
471	FreePool (IpInstance->GroupList);
472	IpInstance->GroupList = NULL;
473	IpInstance->GroupCount = 0;
474	}
475
476	NetMapClean (&IpInstance->TxTokens);
477
478	NetMapClean (&IpInstance->RxTokens);
479
480	return EFI_SUCCESS;
481	}
482
483	/**
484	Configure the MNP parameter used by IP. The IP driver uses one MNP
485	child to transmit/receive frames. By default, it configures MNP
486	to receive unicast/multicast/broadcast. Also, it will enable/disable
487	the promiscuous receive according to whether there is IP child
488	enable that or not. If Force is FALSE, it will iterate through
489	all the IP children to check whether the promiscuous receive
490	setting has been changed. If it hasn't been changed, it won't
491	reconfigure the MNP. If Force is TRUE, the MNP is configured
492	whether that is changed or not.
493
494	@param[in] IpSb The IP6 service instance that is to be changed.
495	@param[in] Force Force the configuration or not.
496
497	@retval EFI_SUCCESS The MNP successfully configured/reconfigured.
498	@retval Others Configuration failed.
499
500	**/
501	EFI_STATUS
502	Ip6ServiceConfigMnp (
503	IN IP6_SERVICE *IpSb,
504	IN BOOLEAN Force
505	)
506	{
507	LIST_ENTRY *Entry;
508	LIST_ENTRY *ProtoEntry;
509	IP6_INTERFACE *IpIf;
510	IP6_PROTOCOL *IpInstance;
511	BOOLEAN Reconfig;
512	BOOLEAN PromiscReceive;
513	EFI_STATUS Status;
514
515	Reconfig = FALSE;
516	PromiscReceive = FALSE;
517
518	if (!Force) {
519	//
520	// Iterate through the IP children to check whether promiscuous
521	// receive setting has been changed. Update the interface's receive
522	// filter also.
523	//
524	NET_LIST_FOR_EACH (Entry, &IpSb->Interfaces) {
525	IpIf = NET_LIST_USER_STRUCT (Entry, IP6_INTERFACE, Link);
526	IpIf->PromiscRecv = FALSE;
527
528	NET_LIST_FOR_EACH (ProtoEntry, &IpIf->IpInstances) {
529	IpInstance = NET_LIST_USER_STRUCT (ProtoEntry, IP6_PROTOCOL, AddrLink);
530
531	if (IpInstance->ConfigData.AcceptPromiscuous) {
532	IpIf->PromiscRecv = TRUE;
533	PromiscReceive = TRUE;
534	}
535	}
536	}
537
538	//
539	// If promiscuous receive isn't changed, it isn't necessary to reconfigure.
540	//
541	if (PromiscReceive == IpSb->MnpConfigData.EnablePromiscuousReceive) {
542	return EFI_SUCCESS;
543	}
544
545	Reconfig = TRUE;
546	IpSb->MnpConfigData.EnablePromiscuousReceive = PromiscReceive;
547	}
548
549	Status = IpSb->Mnp->Configure (IpSb->Mnp, &IpSb->MnpConfigData);
550
551	//
552	// recover the original configuration if failed to set the configure.
553	//
554	if (EFI_ERROR (Status) && Reconfig) {
555	IpSb->MnpConfigData.EnablePromiscuousReceive = (BOOLEAN) !PromiscReceive;
556	}
557
558	return Status;
559	}
560
561	/**
562	Assigns an IPv6 address and subnet mask to this EFI IPv6 Protocol driver instance.
563
564	The Configure() function is used to set, change, or reset the operational parameters and filter
565	settings for this EFI IPv6 Protocol instance. Until these parameters have been set, no network traffic
566	can be sent or received by this instance. Once the parameters have been reset (by calling this
567	function with Ip6ConfigData set to NULL), no more traffic can be sent or received until these
568	parameters have been set again. Each EFI IPv6 Protocol instance can be started and stopped
569	independently of each other by enabling or disabling their receive filter settings with the
570	Configure() function.
571
572	If Ip6ConfigData.StationAddress is a valid non-zero IPv6 unicast address, it is required
573	to be one of the currently configured IPv6 addresses listed in the EFI IPv6 drivers, or else
574	EFI_INVALID_PARAMETER will be returned. If Ip6ConfigData.StationAddress is
575	unspecified, the IPv6 driver will bind a source address according to the source address selection
576	algorithm. Clients could frequently call GetModeData() to check get currently configured IPv6
577	address list in the EFI IPv6 driver. If both Ip6ConfigData.StationAddress and
578	Ip6ConfigData.Destination are unspecified, when transmitting the packet afterwards, the
579	source address filled in each outgoing IPv6 packet is decided based on the destination of this packet.
580
581	If operational parameters are reset or changed, any pending transmit and receive requests will be
582	cancelled. Their completion token status will be set to EFI_ABORTED and their events will be
583	signaled.
584
585	@param[in] This Pointer to the EFI_IP6_PROTOCOL instance.
586	@param[in] Ip6ConfigData Pointer to the EFI IPv6 Protocol configuration data structure.
587	If NULL, reset the configuration data.
588
589	@retval EFI_SUCCESS The driver instance was successfully opened.
590	@retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
591	- This is NULL.
592	- Ip6ConfigData.StationAddress is neither zero nor
593	a unicast IPv6 address.
594	- Ip6ConfigData.StationAddress is neither zero nor
595	one of the configured IP addresses in the EFI IPv6 driver.
596	- Ip6ConfigData.DefaultProtocol is illegal.
597	@retval EFI_OUT_OF_RESOURCES The EFI IPv6 Protocol driver instance data could not be allocated.
598	@retval EFI_NO_MAPPING The IPv6 driver was responsible for choosing a source address for
599	this instance, but no source address was available for use.
600	@retval EFI_ALREADY_STARTED The interface is already open and must be stopped before the IPv6
601	address or prefix length can be changed.
602	@retval EFI_DEVICE_ERROR An unexpected system or network error occurred. The EFI IPv6
603	Protocol driver instance was not opened.
604	@retval EFI_UNSUPPORTED Default protocol specified through
605	Ip6ConfigData.DefaultProtocol isn't supported.
606
607	**/
608	EFI_STATUS
609	EFIAPI
610	EfiIp6Configure (
611	IN EFI_IP6_PROTOCOL *This,
612	IN EFI_IP6_CONFIG_DATA *Ip6ConfigData OPTIONAL
613	)
614	{
615	IP6_PROTOCOL *IpInstance;
616	EFI_IP6_CONFIG_DATA *Current;
617	EFI_TPL OldTpl;
618	EFI_STATUS Status;
619	IP6_SERVICE *IpSb;
620
621	//
622	// First, validate the parameters
623	//
624	if (This == NULL) {
625	return EFI_INVALID_PARAMETER;
626	}
627
628	IpInstance = IP6_INSTANCE_FROM_PROTOCOL (This);
629	IpSb = IpInstance->Service;
630
631	if (IpSb->LinkLocalDadFail && (Ip6ConfigData != NULL)) {
632	return EFI_DEVICE_ERROR;
633	}
634
635	OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
636
637	Status = EFI_INVALID_PARAMETER;
638
639	//
640	// Validate the configuration first.
641	//
642	if (Ip6ConfigData != NULL) {
643	//
644	// Check whether the station address is valid.
645	//
646	if (!Ip6IsValidAddress (IpSb, &Ip6ConfigData->StationAddress, TRUE)) {
647	goto Exit;
648	}
649
650	//
651	// Check whether the default protocol is valid.
652	//
653	if (Ip6IsIllegalProtocol (Ip6ConfigData->DefaultProtocol)) {
654	goto Exit;
655	}
656
657	//
658	// User can only update packet filters when already configured.
659	// If it wants to change the station address, it must configure(NULL)
660	// the instance firstly.
661	//
662	if (IpInstance->State == IP6_STATE_CONFIGED) {
663	Current = &IpInstance->ConfigData;
664
665	if (!EFI_IP6_EQUAL (&Current->StationAddress, &Ip6ConfigData->StationAddress)) {
666	Status = EFI_ALREADY_STARTED;
667	goto Exit;
668	}
669
670	if (NetIp6IsUnspecifiedAddr (&Current->StationAddress) && IP6_NO_MAPPING (IpInstance)) {
671	Status = EFI_NO_MAPPING;
672	goto Exit;
673	}
674	}
675	}
676
677	//
678	// Configure the instance or clean it up.
679	//
680	if (Ip6ConfigData != NULL) {
681	Status = Ip6ConfigProtocol (IpInstance, Ip6ConfigData);
682	} else {
683	Status = Ip6CleanProtocol (IpInstance);
684
685	//
686	// Don't change the state if it is DESTROY, consider the following
687	// valid sequence: Mnp is unloaded-->Ip Stopped-->Udp Stopped,
688	// Configure (ThisIp, NULL). If the state is changed to UNCONFIGED,
689	// the unload fails miserably.
690	//
691	if (IpInstance->State == IP6_STATE_CONFIGED) {
692	IpInstance->State = IP6_STATE_UNCONFIGED;
693	}
694	}
695
696	//
697	// Update the MNP's configure data. Ip6ServiceConfigMnp will check
698	// whether it is necessary to reconfigure the MNP.
699	//
700	Ip6ServiceConfigMnp (IpInstance->Service, FALSE);
701
702	Exit:
703	gBS->RestoreTPL (OldTpl);
704	return Status;
705	}
706
707	/**
708	Joins and leaves multicast groups.
709
710	The Groups() function is used to join and leave multicast group sessions. Joining a group will
711	enable reception of matching multicast packets. Leaving a group will disable reception of matching
712	multicast packets. Source-Specific Multicast isn't required to be supported.
713
714	If JoinFlag is FALSE and GroupAddress is NULL, all joined groups will be left.
715
716	@param[in] This Pointer to the EFI_IP6_PROTOCOL instance.
717	@param[in] JoinFlag Set to TRUE to join the multicast group session, and FALSE to leave.
718	@param[in] GroupAddress Pointer to the IPv6 multicast address.
719	This is an optional parameter that may be NULL.
720
721	@retval EFI_SUCCESS The operation completed successfully.
722	@retval EFI_INVALID_PARAMETER One or more of the following is TRUE:
723	- This is NULL.
724	- JoinFlag is TRUE and GroupAddress is NULL.
725	- GroupAddress is not NULL and *GroupAddress is
726	not a multicast IPv6 address.
727	- GroupAddress is not NULL and *GroupAddress is in the
728	range of SSM destination address.
729	@retval EFI_NOT_STARTED This instance has not been started.
730	@retval EFI_OUT_OF_RESOURCES System resources could not be allocated.
731	@retval EFI_UNSUPPORTED This EFI IPv6 Protocol implementation does not support multicast groups.
732	@retval EFI_ALREADY_STARTED The group address is already in the group table (when
733	JoinFlag is TRUE).
734	@retval EFI_NOT_FOUND The group address is not in the group table (when JoinFlag is FALSE).
735	@retval EFI_DEVICE_ERROR An unexpected system or network error occurred.
736
737	**/
738	EFI_STATUS
739	EFIAPI
740	EfiIp6Groups (
741	IN EFI_IP6_PROTOCOL *This,
742	IN BOOLEAN JoinFlag,
743	IN EFI_IPv6_ADDRESS *GroupAddress OPTIONAL
744	)
745	{
746	EFI_TPL OldTpl;
747	EFI_STATUS Status;
748	IP6_PROTOCOL *IpInstance;
749	IP6_SERVICE *IpSb;
750
751	if ((This == NULL) \|\| (JoinFlag && (GroupAddress == NULL))) {
752	return EFI_INVALID_PARAMETER;
753	}
754
755	if ((GroupAddress != NULL) && !IP6_IS_MULTICAST (GroupAddress)) {
756	return EFI_INVALID_PARAMETER;
757	}
758
759	IpInstance = IP6_INSTANCE_FROM_PROTOCOL (This);
760	IpSb = IpInstance->Service;
761
762	if (IpSb->LinkLocalDadFail) {
763	return EFI_DEVICE_ERROR;
764	}
765
766	OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
767
768	if (IpInstance->State != IP6_STATE_CONFIGED) {
769	Status = EFI_NOT_STARTED;
770	goto ON_EXIT;
771	}
772
773	Status = Ip6Groups (IpInstance, JoinFlag, GroupAddress);
774
775	ON_EXIT:
776	gBS->RestoreTPL (OldTpl);
777	return Status;
778	}
779
780	/**
781	Adds and deletes routing table entries.
782
783	The Routes() function adds a route to, or deletes a route from, the routing table.
784
785	Routes are determined by comparing the leftmost PrefixLength bits of Destination with
786	the destination IPv6 address arithmetically. The gateway address must be on the same subnet as the
787	configured station address.
788
789	The default route is added with Destination and PrefixLength both set to all zeros. The
790	default route matches all destination IPv6 addresses that do not match any other routes.
791
792	All EFI IPv6 Protocol instances share a routing table.
793
794	@param[in] This Pointer to the EFI_IP6_PROTOCOL instance.
795	@param[in] DeleteRoute Set to TRUE to delete this route from the routing table. Set to
796	FALSE to add this route to the routing table. Destination,
797	PrefixLength and Gateway are used as the key to each
798	route entry.
799	@param[in] Destination The address prefix of the subnet that needs to be routed.
800	This is an optional parameter that may be NULL.
801	@param[in] PrefixLength The prefix length of Destination. Ignored if Destination
802	is NULL.
803	@param[in] GatewayAddress The unicast gateway IPv6 address for this route.
804	This is an optional parameter that may be NULL.
805
806	@retval EFI_SUCCESS The operation completed successfully.
807	@retval EFI_NOT_STARTED The driver instance has not been started.
808	@retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
809	- This is NULL.
810	- When DeleteRoute is TRUE, both Destination and
811	GatewayAddress are NULL.
812	- When DeleteRoute is FALSE, either Destination or
813	GatewayAddress is NULL.
814	- *GatewayAddress is not a valid unicast IPv6 address.
815	- *GatewayAddress is one of the local configured IPv6
816	addresses.
817	@retval EFI_OUT_OF_RESOURCES Could not add the entry to the routing table.
818	@retval EFI_NOT_FOUND This route is not in the routing table (when DeleteRoute is TRUE).
819	@retval EFI_ACCESS_DENIED The route is already defined in the routing table (when
820	DeleteRoute is FALSE).
821
822	**/
823	EFI_STATUS
824	EFIAPI
825	EfiIp6Routes (
826	IN EFI_IP6_PROTOCOL *This,
827	IN BOOLEAN DeleteRoute,
828	IN EFI_IPv6_ADDRESS *Destination OPTIONAL,
829	IN UINT8 PrefixLength,
830	IN EFI_IPv6_ADDRESS *GatewayAddress OPTIONAL
831	)
832	{
833	IP6_PROTOCOL *IpInstance;
834	EFI_STATUS Status;
835	EFI_TPL OldTpl;
836	IP6_SERVICE *IpSb;
837
838	if ((This == NULL) \|\| (PrefixLength > IP6_PREFIX_MAX)) {
839	return EFI_INVALID_PARAMETER;
840	}
841
842	IpInstance = IP6_INSTANCE_FROM_PROTOCOL (This);
843	IpSb = IpInstance->Service;
844
845	if (IpSb->LinkLocalDadFail) {
846	return EFI_DEVICE_ERROR;
847	}
848
849	if (IpInstance->State != IP6_STATE_CONFIGED) {
850	return EFI_NOT_STARTED;
851	}
852
853	if (DeleteRoute && (Destination == NULL) && (GatewayAddress == NULL)) {
854	return EFI_INVALID_PARAMETER;
855	}
856
857	if (!DeleteRoute && ((Destination == NULL) \|\| (GatewayAddress == NULL))) {
858	return EFI_INVALID_PARAMETER;
859	}
860
861	if (GatewayAddress != NULL) {
862	if (!Ip6IsValidAddress (IpSb, GatewayAddress, FALSE)) {
863	return EFI_INVALID_PARAMETER;
864	}
865
866	if (!NetIp6IsUnspecifiedAddr (GatewayAddress) &&
867	!NetIp6IsNetEqual (GatewayAddress, &IpInstance->ConfigData.StationAddress, PrefixLength)
868	)
869	{
870	return EFI_INVALID_PARAMETER;
871	}
872	}
873
874	OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
875
876	//
877	// Update the route table
878	//
879	if (DeleteRoute) {
880	Status = Ip6DelRoute (IpSb->RouteTable, Destination, PrefixLength, GatewayAddress);
881	} else {
882	Status = Ip6AddRoute (IpSb->RouteTable, Destination, PrefixLength, GatewayAddress);
883	}
884
885	gBS->RestoreTPL (OldTpl);
886	return Status;
887	}
888
889	/**
890	Add or delete Neighbor cache entries.
891
892	The Neighbors() function is used to add, update, or delete an entry from neighbor cache.
893	IPv6 neighbor cache entries are typically inserted and updated by the network protocol driver as
894	network traffic is processed. Most neighbor cache entries will timeout and be deleted if the network
895	traffic stops. Neighbor cache entries that were inserted by Neighbors() may be static (will not
896	timeout) or dynamic (will timeout).
897
898	The implementation should follow the neighbor cache timeout mechanism which is defined in
899	RFC4861. The default neighbor cache timeout value should be tuned for the expected network
900	environment
901
902	@param[in] This Pointer to the EFI_IP6_PROTOCOL instance.
903	@param[in] DeleteFlag Set to TRUE to delete the specified cache entry, set to FALSE to
904	add (or update, if it already exists and Override is TRUE) the
905	specified cache entry. TargetIp6Address is used as the key
906	to find the requested cache entry.
907	@param[in] TargetIp6Address Pointer to the Target IPv6 address.
908	@param[in] TargetLinkAddress Pointer to the link-layer address of the target. Ignored if NULL.
909	@param[in] Timeout Time in 100-ns units that this entry will remain in the neighbor
910	cache, it will be deleted after Timeout. A value of zero means that
911	the entry is permanent. A non-zero value means that the entry is
912	dynamic.
913	@param[in] Override If TRUE, the cached link-layer address of the matching entry will
914	be overridden and updated; if FALSE, EFI_ACCESS_DENIED
915	will be returned if a corresponding cache entry already existed.
916
917	@retval EFI_SUCCESS The data has been queued for transmission.
918	@retval EFI_NOT_STARTED This instance has not been started.
919	@retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
920	- This is NULL.
921	- TargetIpAddress is NULL.
922	- *TargetLinkAddress is invalid when not NULL.
923	- *TargetIpAddress is not a valid unicast IPv6 address.
924	- *TargetIpAddress is one of the local configured IPv6
925	addresses.
926	@retval EFI_OUT_OF_RESOURCES Could not add the entry to the neighbor cache.
927	@retval EFI_NOT_FOUND This entry is not in the neighbor cache (when DeleteFlag is
928	TRUE or when DeleteFlag is FALSE while
929	TargetLinkAddress is NULL.).
930	@retval EFI_ACCESS_DENIED The to-be-added entry is already defined in the neighbor cache,
931	and that entry is tagged as un-overridden (when Override
932	is FALSE).
933
934	**/
935	EFI_STATUS
936	EFIAPI
937	EfiIp6Neighbors (
938	IN EFI_IP6_PROTOCOL *This,
939	IN BOOLEAN DeleteFlag,
940	IN EFI_IPv6_ADDRESS *TargetIp6Address,
941	IN EFI_MAC_ADDRESS *TargetLinkAddress OPTIONAL,
942	IN UINT32 Timeout,
943	IN BOOLEAN Override
944	)
945	{
946	EFI_TPL OldTpl;
947	EFI_STATUS Status;
948	IP6_PROTOCOL *IpInstance;
949	IP6_SERVICE *IpSb;
950
951	if ((This == NULL) \|\| (TargetIp6Address == NULL)) {
952	return EFI_INVALID_PARAMETER;
953	}
954
955	if (NetIp6IsUnspecifiedAddr (TargetIp6Address)) {
956	return EFI_INVALID_PARAMETER;
957	}
958
959	IpInstance = IP6_INSTANCE_FROM_PROTOCOL (This);
960	IpSb = IpInstance->Service;
961
962	if (IpSb->LinkLocalDadFail) {
963	return EFI_DEVICE_ERROR;
964	}
965
966	if (!Ip6IsValidAddress (IpSb, TargetIp6Address, FALSE)) {
967	return EFI_INVALID_PARAMETER;
968	}
969
970	if (TargetLinkAddress != NULL) {
971	if (!Ip6IsValidLinkAddress (IpSb, TargetLinkAddress)) {
972	return EFI_INVALID_PARAMETER;
973	}
974	}
975
976	if (Ip6IsOneOfSetAddress (IpSb, TargetIp6Address, NULL, NULL)) {
977	return EFI_INVALID_PARAMETER;
978	}
979
980	OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
981	if (IpInstance->State != IP6_STATE_CONFIGED) {
982	Status = EFI_NOT_STARTED;
983	goto Exit;
984	}
985
986	if (DeleteFlag) {
987	Status = Ip6DelNeighbor (IpInstance->Service, TargetIp6Address, TargetLinkAddress, Timeout, Override);
988	} else {
989	Status = Ip6AddNeighbor (IpInstance->Service, TargetIp6Address, TargetLinkAddress, Timeout, Override);
990	}
991
992	Exit:
993	gBS->RestoreTPL (OldTpl);
994	return Status;
995	}
996
997	/**
998	Check whether the user's token or event has already
999	been enqueue on IP6's list.
1000
1001	@param[in] Map The container of either user's transmit or receive
1002	token.
1003	@param[in] Item Current item to check against.
1004	@param[in] Context The Token to check against.
1005
1006	@retval EFI_ACCESS_DENIED The token or event has already been enqueued in IP
1007	@retval EFI_SUCCESS The current item isn't the same token/event as the
1008	context.
1009
1010	**/
1011	EFI_STATUS
1012	EFIAPI
1013	Ip6TokenExist (
1014	IN NET_MAP *Map,
1015	IN NET_MAP_ITEM *Item,
1016	IN VOID *Context
1017	)
1018	{
1019	EFI_IP6_COMPLETION_TOKEN *Token;
1020	EFI_IP6_COMPLETION_TOKEN *TokenInItem;
1021
1022	Token = (EFI_IP6_COMPLETION_TOKEN *)Context;
1023	TokenInItem = (EFI_IP6_COMPLETION_TOKEN *)Item->Key;
1024
1025	if ((Token == TokenInItem) \|\| (Token->Event == TokenInItem->Event)) {
1026	return EFI_ACCESS_DENIED;
1027	}
1028
1029	return EFI_SUCCESS;
1030	}
1031
1032	/**
1033	Validate the user's token against the current station address.
1034
1035	@param[in] Token User's token to validate.
1036
1037	@retval EFI_INVALID_PARAMETER Some parameters are invalid.
1038	@retval EFI_BAD_BUFFER_SIZE The user's option/data is too long.
1039	@retval EFI_SUCCESS The token is OK.
1040
1041	**/
1042	EFI_STATUS
1043	Ip6TxTokenValid (
1044	IN EFI_IP6_COMPLETION_TOKEN *Token
1045	)
1046	{
1047	EFI_IP6_TRANSMIT_DATA *TxData;
1048	UINT32 Index;
1049	UINT32 DataLength;
1050
1051	if ((Token == NULL) \|\| (Token->Event == NULL)) {
1052	return EFI_INVALID_PARAMETER;
1053	}
1054
1055	TxData = Token->Packet.TxData;
1056
1057	if ((TxData == NULL) \|\| ((TxData->ExtHdrsLength != 0) && (TxData->ExtHdrs == NULL))) {
1058	return EFI_INVALID_PARAMETER;
1059	}
1060
1061	if ((TxData->FragmentCount == 0) \|\| (TxData->DataLength == 0)) {
1062	return EFI_INVALID_PARAMETER;
1063	}
1064
1065	for (DataLength = 0, Index = 0; Index < TxData->FragmentCount; Index++) {
1066	if ((TxData->FragmentTable[Index].FragmentLength == 0) \|\| (TxData->FragmentTable[Index].FragmentBuffer == NULL)) {
1067	return EFI_INVALID_PARAMETER;
1068	}
1069
1070	DataLength += TxData->FragmentTable[Index].FragmentLength;
1071	}
1072
1073	if (TxData->DataLength != DataLength) {
1074	return EFI_INVALID_PARAMETER;
1075	}
1076
1077	//
1078	// TODO: Token.Packet.TxData.DataLength is too short to transmit.
1079	// return EFI_BUFFER_TOO_SMALL;
1080	//
1081
1082	//
1083	// If Token.Packet.TxData.DataLength is beyond the maximum that which can be
1084	// described through the Fragment Offset field in Fragment header when performing
1085	// fragmentation.
1086	//
1087	if (TxData->DataLength > 64 * 1024) {
1088	return EFI_BAD_BUFFER_SIZE;
1089	}
1090
1091	return EFI_SUCCESS;
1092	}
1093
1094	/**
1095	The callback function for the net buffer which wraps the user's
1096	transmit token. Although this function seems simple, there
1097	are some subtle aspects.
1098	When user requests the IP to transmit a packet by passing it a
1099	token, the token is wrapped in an IP6_TXTOKEN_WRAP and the data
1100	is wrapped in an net buffer. The net buffer's Free function is
1101	set to Ip6FreeTxToken. The Token and token wrap are added to the
1102	IP child's TxToken map. Then the buffer is passed to Ip6Output for
1103	transmission. If an error happened before that, the buffer
1104	is freed, which in turn frees the token wrap. The wrap may
1105	have been added to the TxToken map or not, and the user's event
1106	shouldn't be fired because we are still in the EfiIp6Transmit. If
1107	the buffer has been sent by Ip6Output, it should be removed from
1108	the TxToken map and user's event signaled. The token wrap and buffer
1109	are bound together. Check the comments in Ip6Output for information
1110	about IP fragmentation.
1111
1112	@param[in] Context The token's wrap.
1113
1114	**/
1115	VOID
1116	EFIAPI
1117	Ip6FreeTxToken (
1118	IN VOID *Context
1119	)
1120	{
1121	IP6_TXTOKEN_WRAP *Wrap;
1122	NET_MAP_ITEM *Item;
1123
1124	Wrap = (IP6_TXTOKEN_WRAP *)Context;
1125
1126	//
1127	// Signal IpSecRecycleEvent to inform IPsec free the memory
1128	//
1129	if (Wrap->IpSecRecycleSignal != NULL) {
1130	gBS->SignalEvent (Wrap->IpSecRecycleSignal);
1131	}
1132
1133	//
1134	// Find the token in the instance's map. EfiIp6Transmit put the
1135	// token to the map. If that failed, NetMapFindKey will return NULL.
1136	//
1137	Item = NetMapFindKey (&Wrap->IpInstance->TxTokens, Wrap->Token);
1138
1139	if (Item != NULL) {
1140	NetMapRemoveItem (&Wrap->IpInstance->TxTokens, Item, NULL);
1141	}
1142
1143	if (Wrap->Sent) {
1144	gBS->SignalEvent (Wrap->Token->Event);
1145
1146	//
1147	// Dispatch the DPC queued by the NotifyFunction of Token->Event.
1148	//
1149	DispatchDpc ();
1150	}
1151
1152	FreePool (Wrap);
1153	}
1154
1155	/**
1156	The callback function to Ip6Output to update the transmit status.
1157
1158	@param[in] Packet The user's transmit packet.
1159	@param[in] IoStatus The result of the transmission.
1160	@param[in] Flag Not used during transmission.
1161	@param[in] Context The token's wrap.
1162
1163	**/
1164	VOID
1165	Ip6OnPacketSent (
1166	IN NET_BUF *Packet,
1167	IN EFI_STATUS IoStatus,
1168	IN UINT32 Flag,
1169	IN VOID *Context
1170	)
1171	{
1172	IP6_TXTOKEN_WRAP *Wrap;
1173
1174	//
1175	// This is the transmission request from upper layer,
1176	// not the IP6 driver itself.
1177	//
1178	Wrap = (IP6_TXTOKEN_WRAP *)Context;
1179	Wrap->Token->Status = IoStatus;
1180
1181	NetbufFree (Wrap->Packet);
1182	}
1183
1184	/**
1185	Places outgoing data packets into the transmit queue.
1186
1187	The Transmit() function places a sending request in the transmit queue of this
1188	EFI IPv6 Protocol instance. Whenever the packet in the token is sent out or some
1189	errors occur, the event in the token will be signaled, and the status is updated.
1190
1191	@param[in] This Pointer to the EFI_IP6_PROTOCOL instance.
1192	@param[in] Token Pointer to the transmit token.
1193
1194	@retval EFI_SUCCESS The data has been queued for transmission.
1195	@retval EFI_NOT_STARTED This instance has not been started.
1196	@retval EFI_NO_MAPPING The IPv6 driver was responsible for choosing
1197	a source address for this transmission,
1198	but no source address was available for use.
1199	@retval EFI_INVALID_PARAMETER One or more of the following is TRUE:
1200	- This is NULL.
1201	- Token is NULL.
1202	- Token.Event is NULL.
1203	- Token.Packet.TxData is NULL.
1204	- Token.Packet.ExtHdrsLength is not zero and
1205	Token.Packet.ExtHdrs is NULL.
1206	- Token.Packet.FragmentCount is zero.
1207	- One or more of the Token.Packet.TxData.
1208	FragmentTable[].FragmentLength fields is zero.
1209	- One or more of the Token.Packet.TxData.
1210	FragmentTable[].FragmentBuffer fields is NULL.
1211	- Token.Packet.TxData.DataLength is zero or not
1212	equal to the sum of fragment lengths.
1213	- Token.Packet.TxData.DestinationAddress is non
1214	zero when DestinationAddress is configured as
1215	non-zero when doing Configure() for this
1216	EFI IPv6 protocol instance.
1217	- Token.Packet.TxData.DestinationAddress is
1218	unspecified when DestinationAddress is unspecified
1219	when doing Configure() for this EFI IPv6 protocol
1220	instance.
1221	@retval EFI_ACCESS_DENIED The transmit completion token with the same Token.
1222	Event was already in the transmit queue.
1223	@retval EFI_NOT_READY The completion token could not be queued because
1224	the transmit queue is full.
1225	@retval EFI_NOT_FOUND Not route is found to destination address.
1226	@retval EFI_OUT_OF_RESOURCES Could not queue the transmit data.
1227	@retval EFI_BUFFER_TOO_SMALL Token.Packet.TxData.TotalDataLength is too
1228	short to transmit.
1229	@retval EFI_BAD_BUFFER_SIZE If Token.Packet.TxData.DataLength is beyond the
1230	maximum that which can be described through the
1231	Fragment Offset field in Fragment header when
1232	performing fragmentation.
1233	@retval EFI_DEVICE_ERROR An unexpected system or network error occurred.
1234
1235	**/
1236	EFI_STATUS
1237	EFIAPI
1238	EfiIp6Transmit (
1239	IN EFI_IP6_PROTOCOL *This,
1240	IN EFI_IP6_COMPLETION_TOKEN *Token
1241	)
1242	{
1243	IP6_SERVICE *IpSb;
1244	IP6_PROTOCOL *IpInstance;
1245	EFI_IP6_CONFIG_DATA *Config;
1246	EFI_STATUS Status;
1247	EFI_TPL OldTpl;
1248	EFI_IP6_HEADER Head;
1249	EFI_IP6_TRANSMIT_DATA *TxData;
1250	EFI_IP6_OVERRIDE_DATA *Override;
1251	IP6_TXTOKEN_WRAP *Wrap;
1252	UINT8 *ExtHdrs;
1253
1254	//
1255	// Check input parameters.
1256	//
1257	if (This == NULL) {
1258	return EFI_INVALID_PARAMETER;
1259	}
1260
1261	ExtHdrs = NULL;
1262
1263	Status = Ip6TxTokenValid (Token);
1264	if (EFI_ERROR (Status)) {
1265	return Status;
1266	}
1267
1268	IpInstance = IP6_INSTANCE_FROM_PROTOCOL (This);
1269	IpSb = IpInstance->Service;
1270
1271	if (IpSb->LinkLocalDadFail) {
1272	return EFI_DEVICE_ERROR;
1273	}
1274
1275	OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1276
1277	if (IpInstance->State != IP6_STATE_CONFIGED) {
1278	Status = EFI_NOT_STARTED;
1279	goto Exit;
1280	}
1281
1282	Config = &IpInstance->ConfigData;
1283
1284	//
1285	// Check whether the token or signal already existed.
1286	//
1287	if (EFI_ERROR (NetMapIterate (&IpInstance->TxTokens, Ip6TokenExist, Token))) {
1288	Status = EFI_ACCESS_DENIED;
1289	goto Exit;
1290	}
1291
1292	//
1293	// Build the IP header, fill in the information from ConfigData or OverrideData
1294	//
1295	ZeroMem (&Head, sizeof (EFI_IP6_HEADER));
1296	TxData = Token->Packet.TxData;
1297	IP6_COPY_ADDRESS (&Head.SourceAddress, &Config->StationAddress);
1298	IP6_COPY_ADDRESS (&Head.DestinationAddress, &Config->DestinationAddress);
1299
1300	Status = EFI_INVALID_PARAMETER;
1301
1302	if (NetIp6IsUnspecifiedAddr (&TxData->DestinationAddress)) {
1303	if (NetIp6IsUnspecifiedAddr (&Config->DestinationAddress)) {
1304	goto Exit;
1305	}
1306
1307	ASSERT (!NetIp6IsUnspecifiedAddr (&Config->StationAddress));
1308	} else {
1309	//
1310	// StationAddress is unspecified only when ConfigData.Dest is unspecified.
1311	// Use TxData.Dest to override the DestinationAddress.
1312	//
1313	if (!NetIp6IsUnspecifiedAddr (&Config->DestinationAddress)) {
1314	goto Exit;
1315	}
1316
1317	if (NetIp6IsUnspecifiedAddr (&Config->StationAddress)) {
1318	Status = Ip6SelectSourceAddress (
1319	IpSb,
1320	&TxData->DestinationAddress,
1321	&Head.SourceAddress
1322	);
1323	if (EFI_ERROR (Status)) {
1324	goto Exit;
1325	}
1326	}
1327
1328	IP6_COPY_ADDRESS (&Head.DestinationAddress, &TxData->DestinationAddress);
1329	}
1330
1331	//
1332	// Fill in Head infos.
1333	//
1334	Head.NextHeader = Config->DefaultProtocol;
1335	if (TxData->ExtHdrsLength != 0) {
1336	Head.NextHeader = TxData->NextHeader;
1337	}
1338
1339	if (TxData->OverrideData != NULL) {
1340	Override = TxData->OverrideData;
1341	Head.NextHeader = Override->Protocol;
1342	Head.HopLimit = Override->HopLimit;
1343	Head.FlowLabelL = HTONS ((UINT16)Override->FlowLabel);
1344	Head.FlowLabelH = (UINT8)((Override->FlowLabel >> 16) & 0x0F);
1345	} else {
1346	Head.HopLimit = Config->HopLimit;
1347	Head.FlowLabelL = HTONS ((UINT16)Config->FlowLabel);
1348	Head.FlowLabelH = (UINT8)((Config->FlowLabel >> 16) & 0x0F);
1349	}
1350
1351	Head.PayloadLength = HTONS ((UINT16)(TxData->ExtHdrsLength + TxData->DataLength));
1352
1353	//
1354	// OK, it survives all the validation check. Wrap the token in
1355	// a IP6_TXTOKEN_WRAP and the data in a netbuf
1356	//
1357	Status = EFI_OUT_OF_RESOURCES;
1358	Wrap = AllocateZeroPool (sizeof (IP6_TXTOKEN_WRAP));
1359	if (Wrap == NULL) {
1360	goto Exit;
1361	}
1362
1363	Wrap->IpInstance = IpInstance;
1364	Wrap->Token = Token;
1365	Wrap->Sent = FALSE;
1366	Wrap->Life = IP6_US_TO_SEC (Config->TransmitTimeout);
1367	Wrap->Packet = NetbufFromExt (
1368	(NET_FRAGMENT *)TxData->FragmentTable,
1369	TxData->FragmentCount,
1370	IP6_MAX_HEADLEN,
1371	0,
1372	Ip6FreeTxToken,
1373	Wrap
1374	);
1375
1376	if (Wrap->Packet == NULL) {
1377	FreePool (Wrap);
1378	goto Exit;
1379	}
1380
1381	Token->Status = EFI_NOT_READY;
1382
1383	Status = NetMapInsertTail (&IpInstance->TxTokens, Token, Wrap);
1384	if (EFI_ERROR (Status)) {
1385	//
1386	// NetbufFree will call Ip6FreeTxToken, which in turn will
1387	// free the IP6_TXTOKEN_WRAP. Now, the token wrap hasn't been
1388	// enqueued.
1389	//
1390	NetbufFree (Wrap->Packet);
1391	goto Exit;
1392	}
1393
1394	//
1395	// Allocate a new buffer to store IPv6 extension headers to avoid updating
1396	// the original data in EFI_IP6_COMPLETION_TOKEN.
1397	//
1398	if ((TxData->ExtHdrsLength != 0) && (TxData->ExtHdrs != NULL)) {
1399	ExtHdrs = (UINT8 *)AllocateCopyPool (TxData->ExtHdrsLength, TxData->ExtHdrs);
1400	if (ExtHdrs == NULL) {
1401	Status = EFI_OUT_OF_RESOURCES;
1402	goto Exit;
1403	}
1404	}
1405
1406	//
1407	// Mark the packet sent before output it. Mark it not sent again if the
1408	// returned status is not EFI_SUCCESS;
1409	//
1410	Wrap->Sent = TRUE;
1411
1412	Status = Ip6Output (
1413	IpSb,
1414	NULL,
1415	IpInstance,
1416	Wrap->Packet,
1417	&Head,
1418	ExtHdrs,
1419	TxData->ExtHdrsLength,
1420	Ip6OnPacketSent,
1421	Wrap
1422	);
1423	if (EFI_ERROR (Status)) {
1424	Wrap->Sent = FALSE;
1425	NetbufFree (Wrap->Packet);
1426	}
1427
1428	Exit:
1429	gBS->RestoreTPL (OldTpl);
1430
1431	if (ExtHdrs != NULL) {
1432	FreePool (ExtHdrs);
1433	}
1434
1435	return Status;
1436	}
1437
1438	/**
1439	Places a receiving request into the receiving queue.
1440
1441	The Receive() function places a completion token into the receive packet queue.
1442	This function is always asynchronous.
1443
1444	The Token.Event field in the completion token must be filled in by the caller
1445	and cannot be NULL. When the receive operation completes, the EFI IPv6 Protocol
1446	driver updates the Token.Status and Token.Packet.RxData fields and the Token.Event
1447	is signaled.
1448
1449	Current Udp implementation creates an IP child for each Udp child.
1450	It initiates a asynchronous receive immediately no matter whether
1451	there is no mapping or not. Therefore, disable the returning EFI_NO_MAPPING for now.
1452	To enable it, the following check must be performed:
1453
1454	if (NetIp6IsUnspecifiedAddr (&Config->StationAddress) && IP6_NO_MAPPING (IpInstance)) {
1455	Status = EFI_NO_MAPPING;
1456	goto Exit;
1457	}
1458
1459	@param[in] This Pointer to the EFI_IP6_PROTOCOL instance.
1460	@param[in] Token Pointer to a token that is associated with the receive data descriptor.
1461
1462	@retval EFI_SUCCESS The receive completion token was cached.
1463	@retval EFI_NOT_STARTED This EFI IPv6 Protocol instance has not been started.
1464	@retval EFI_NO_MAPPING When IP6 driver responsible for binding source address to this instance,
1465	while no source address is available for use.
1466	@retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
1467	- This is NULL.
1468	- Token is NULL.
1469	- Token.Event is NULL.
1470	@retval EFI_OUT_OF_RESOURCES The receive completion token could not be queued due to a lack of system
1471	resources (usually memory).
1472	@retval EFI_DEVICE_ERROR An unexpected system or network error occurred.
1473	The EFI IPv6 Protocol instance has been reset to startup defaults.
1474	@retval EFI_ACCESS_DENIED The receive completion token with the same Token.Event was already
1475	in the receive queue.
1476	@retval EFI_NOT_READY The receive request could not be queued because the receive queue is full.
1477
1478	**/
1479	EFI_STATUS
1480	EFIAPI
1481	EfiIp6Receive (
1482	IN EFI_IP6_PROTOCOL *This,
1483	IN EFI_IP6_COMPLETION_TOKEN *Token
1484	)
1485	{
1486	IP6_PROTOCOL *IpInstance;
1487	EFI_STATUS Status;
1488	EFI_TPL OldTpl;
1489	IP6_SERVICE *IpSb;
1490
1491	if ((This == NULL) \|\| (Token == NULL) \|\| (Token->Event == NULL)) {
1492	return EFI_INVALID_PARAMETER;
1493	}
1494
1495	IpInstance = IP6_INSTANCE_FROM_PROTOCOL (This);
1496	IpSb = IpInstance->Service;
1497
1498	if (IpSb->LinkLocalDadFail) {
1499	return EFI_DEVICE_ERROR;
1500	}
1501
1502	OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1503
1504	if (IpInstance->State != IP6_STATE_CONFIGED) {
1505	Status = EFI_NOT_STARTED;
1506	goto Exit;
1507	}
1508
1509	//
1510	// Check whether the toke is already on the receive queue.
1511	//
1512	Status = NetMapIterate (&IpInstance->RxTokens, Ip6TokenExist, Token);
1513
1514	if (EFI_ERROR (Status)) {
1515	Status = EFI_ACCESS_DENIED;
1516	goto Exit;
1517	}
1518
1519	//
1520	// Queue the token then check whether there is pending received packet.
1521	//
1522	Status = NetMapInsertTail (&IpInstance->RxTokens, Token, NULL);
1523
1524	if (EFI_ERROR (Status)) {
1525	goto Exit;
1526	}
1527
1528	Status = Ip6InstanceDeliverPacket (IpInstance);
1529
1530	//
1531	// Dispatch the DPC queued by the NotifyFunction of this instane's receive
1532	// event.
1533	//
1534	DispatchDpc ();
1535
1536	Exit:
1537	gBS->RestoreTPL (OldTpl);
1538	return Status;
1539	}
1540
1541	/**
1542	Cancel the transmitted but not recycled packet. If a matching
1543	token is found, it will call Ip6CancelPacket to cancel the
1544	packet. Ip6CancelPacket cancels all the fragments of the
1545	packet. When all the fragments are freed, the IP6_TXTOKEN_WRAP
1546	is deleted from the Map, and user's event is signalled.
1547	Because Ip6CancelPacket and other functions are all called in
1548	line, after Ip6CancelPacket returns, the Item has been freed.
1549
1550	@param[in] Map The IP6 child's transmit queue.
1551	@param[in] Item The current transmitted packet to test.
1552	@param[in] Context The user's token to cancel.
1553
1554	@retval EFI_SUCCESS Continue to check the next Item.
1555	@retval EFI_ABORTED The user's Token (Token != NULL) is cancelled.
1556
1557	**/
1558	EFI_STATUS
1559	EFIAPI
1560	Ip6CancelTxTokens (
1561	IN NET_MAP *Map,
1562	IN NET_MAP_ITEM *Item,
1563	IN VOID *Context
1564	)
1565	{
1566	EFI_IP6_COMPLETION_TOKEN *Token;
1567	IP6_TXTOKEN_WRAP *Wrap;
1568
1569	Token = (EFI_IP6_COMPLETION_TOKEN *)Context;
1570
1571	//
1572	// Return EFI_SUCCESS to check the next item in the map if
1573	// this one doesn't match.
1574	//
1575	if ((Token != NULL) && (Token != Item->Key)) {
1576	return EFI_SUCCESS;
1577	}
1578
1579	Wrap = (IP6_TXTOKEN_WRAP *)Item->Value;
1580	ASSERT (Wrap != NULL);
1581
1582	//
1583	// Don't access the Item, Wrap and Token's members after this point.
1584	// Item and wrap has been freed. And we no longer own the Token.
1585	//
1586	Ip6CancelPacket (Wrap->IpInstance->Interface, Wrap->Packet, EFI_ABORTED);
1587
1588	//
1589	// If only one item is to be cancel, return EFI_ABORTED to stop
1590	// iterating the map any more.
1591	//
1592	if (Token != NULL) {
1593	return EFI_ABORTED;
1594	}
1595
1596	return EFI_SUCCESS;
1597	}
1598
1599	/**
1600	Cancel the receive request. This is simple, because
1601	it is only enqueued in our local receive map.
1602
1603	@param[in] Map The IP6 child's receive queue.
1604	@param[in] Item Current receive request to cancel.
1605	@param[in] Context The user's token to cancel.
1606
1607
1608	@retval EFI_SUCCESS Continue to check the next receive request on the
1609	queue.
1610	@retval EFI_ABORTED The user's token (token != NULL) has been
1611	cancelled.
1612
1613	**/
1614	EFI_STATUS
1615	EFIAPI
1616	Ip6CancelRxTokens (
1617	IN NET_MAP *Map,
1618	IN NET_MAP_ITEM *Item,
1619	IN VOID *Context
1620	)
1621	{
1622	EFI_IP6_COMPLETION_TOKEN *Token;
1623	EFI_IP6_COMPLETION_TOKEN *This;
1624
1625	Token = (EFI_IP6_COMPLETION_TOKEN *)Context;
1626	This = Item->Key;
1627
1628	if ((Token != NULL) && (Token != This)) {
1629	return EFI_SUCCESS;
1630	}
1631
1632	NetMapRemoveItem (Map, Item, NULL);
1633
1634	This->Status = EFI_ABORTED;
1635	This->Packet.RxData = NULL;
1636	gBS->SignalEvent (This->Event);
1637
1638	if (Token != NULL) {
1639	return EFI_ABORTED;
1640	}
1641
1642	return EFI_SUCCESS;
1643	}
1644
1645	/**
1646	Cancel the user's receive/transmit request. It is the worker function of
1647	EfiIp6Cancel API.
1648
1649	@param[in] IpInstance The IP6 child.
1650	@param[in] Token The token to cancel. If NULL, all token will be
1651	cancelled.
1652
1653	@retval EFI_SUCCESS The token is cancelled.
1654	@retval EFI_NOT_FOUND The token isn't found on either the
1655	transmit/receive queue.
1656	@retval EFI_DEVICE_ERROR Not all tokens are cancelled when Token is NULL.
1657
1658	**/
1659	EFI_STATUS
1660	Ip6Cancel (
1661	IN IP6_PROTOCOL *IpInstance,
1662	IN EFI_IP6_COMPLETION_TOKEN *Token OPTIONAL
1663	)
1664	{
1665	EFI_STATUS Status;
1666
1667	//
1668	// First check the transmitted packet. Ip6CancelTxTokens returns
1669	// EFI_ABORTED to mean that the token has been cancelled when
1670	// token != NULL. So, return EFI_SUCCESS for this condition.
1671	//
1672	Status = NetMapIterate (&IpInstance->TxTokens, Ip6CancelTxTokens, Token);
1673	if (EFI_ERROR (Status)) {
1674	if ((Token != NULL) && (Status == EFI_ABORTED)) {
1675	return EFI_SUCCESS;
1676	}
1677
1678	return Status;
1679	}
1680
1681	//
1682	// Check the receive queue. Ip6CancelRxTokens also returns EFI_ABORT
1683	// for Token!=NULL and it is cancelled.
1684	//
1685	Status = NetMapIterate (&IpInstance->RxTokens, Ip6CancelRxTokens, Token);
1686	//
1687	// Dispatch the DPCs queued by the NotifyFunction of the canceled rx token's
1688	// events.
1689	//
1690	DispatchDpc ();
1691	if (EFI_ERROR (Status)) {
1692	if ((Token != NULL) && (Status == EFI_ABORTED)) {
1693	return EFI_SUCCESS;
1694	}
1695
1696	return Status;
1697	}
1698
1699	//
1700	// OK, if the Token is found when Token != NULL, the NetMapIterate
1701	// will return EFI_ABORTED, which has been interrupted as EFI_SUCCESS.
1702	//
1703	if (Token != NULL) {
1704	return EFI_NOT_FOUND;
1705	}
1706
1707	//
1708	// If Token == NULL, cancel all the tokens. return error if not
1709	// all of them are cancelled.
1710	//
1711	if (!NetMapIsEmpty (&IpInstance->TxTokens) \|\| !NetMapIsEmpty (&IpInstance->RxTokens)) {
1712	return EFI_DEVICE_ERROR;
1713	}
1714
1715	return EFI_SUCCESS;
1716	}
1717
1718	/**
1719	Abort an asynchronous transmit or receive request.
1720
1721	The Cancel() function is used to abort a pending transmit or receive request.
1722	If the token is in the transmit or receive request queues, after calling this
1723	function, Token->Status will be set to EFI_ABORTED, and then Token->Event will
1724	be signaled. If the token is not in one of the queues, which usually means the
1725	asynchronous operation has completed, this function will not signal the token,
1726	and EFI_NOT_FOUND is returned.
1727
1728	@param[in] This Pointer to the EFI_IP6_PROTOCOL instance.
1729	@param[in] Token Pointer to a token that has been issued by
1730	EFI_IP6_PROTOCOL.Transmit() or
1731	EFI_IP6_PROTOCOL.Receive(). If NULL, all pending
1732	tokens are aborted. Type EFI_IP6_COMPLETION_TOKEN is
1733	defined in EFI_IP6_PROTOCOL.Transmit().
1734
1735	@retval EFI_SUCCESS The asynchronous I/O request was aborted and
1736	Token->Event was signaled. When Token is NULL, all
1737	pending requests were aborted, and their events were signaled.
1738	@retval EFI_INVALID_PARAMETER This is NULL.
1739	@retval EFI_NOT_STARTED This instance has not been started.
1740	@retval EFI_NOT_FOUND When Token is not NULL, the asynchronous I/O request was
1741	not found in the transmit or receive queue. It has either completed
1742	or was not issued by Transmit() and Receive().
1743	@retval EFI_DEVICE_ERROR An unexpected system or network error occurred.
1744
1745	**/
1746	EFI_STATUS
1747	EFIAPI
1748	EfiIp6Cancel (
1749	IN EFI_IP6_PROTOCOL *This,
1750	IN EFI_IP6_COMPLETION_TOKEN *Token OPTIONAL
1751	)
1752	{
1753	IP6_PROTOCOL *IpInstance;
1754	EFI_STATUS Status;
1755	EFI_TPL OldTpl;
1756
1757	if (This == NULL) {
1758	return EFI_INVALID_PARAMETER;
1759	}
1760
1761	IpInstance = IP6_INSTANCE_FROM_PROTOCOL (This);
1762
1763	OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1764
1765	if (IpInstance->State != IP6_STATE_CONFIGED) {
1766	Status = EFI_NOT_STARTED;
1767	goto Exit;
1768	}
1769
1770	Status = Ip6Cancel (IpInstance, Token);
1771
1772	Exit:
1773	gBS->RestoreTPL (OldTpl);
1774	return Status;
1775	}
1776
1777	/**
1778	Polls for incoming data packets, and processes outgoing data packets.
1779
1780	The Poll() function polls for incoming data packets and processes outgoing data
1781	packets. Network drivers and applications can call the EFI_IP6_PROTOCOL.Poll()
1782	function to increase the rate that data packets are moved between the communications
1783	device and the transmit and receive queues.
1784
1785	In some systems the periodic timer event may not poll the underlying communications
1786	device fast enough to transmit and/or receive all data packets without missing
1787	incoming packets or dropping outgoing packets. Drivers and applications that are
1788	experiencing packet loss should try calling the EFI_IP6_PROTOCOL.Poll() function
1789	more often.
1790
1791	@param[in] This Pointer to the EFI_IP6_PROTOCOL instance.
1792
1793	@retval EFI_SUCCESS Incoming or outgoing data was processed.
1794	@retval EFI_NOT_STARTED This EFI IPv6 Protocol instance has not been started.
1795	@retval EFI_INVALID_PARAMETER This is NULL.
1796	@retval EFI_DEVICE_ERROR An unexpected system error or network error occurred.
1797	@retval EFI_NOT_READY No incoming or outgoing data was processed.
1798	@retval EFI_TIMEOUT Data was dropped out of the transmit and/or receive queue.
1799	Consider increasing the polling rate.
1800
1801	**/
1802	EFI_STATUS
1803	EFIAPI
1804	EfiIp6Poll (
1805	IN EFI_IP6_PROTOCOL *This
1806	)
1807	{
1808	IP6_PROTOCOL *IpInstance;
1809	IP6_SERVICE *IpSb;
1810	EFI_MANAGED_NETWORK_PROTOCOL *Mnp;
1811
1812	if (This == NULL) {
1813	return EFI_INVALID_PARAMETER;
1814	}
1815
1816	IpInstance = IP6_INSTANCE_FROM_PROTOCOL (This);
1817	IpSb = IpInstance->Service;
1818
1819	if (IpSb->LinkLocalDadFail) {
1820	return EFI_DEVICE_ERROR;
1821	}
1822
1823	if (IpInstance->State == IP6_STATE_UNCONFIGED) {
1824	return EFI_NOT_STARTED;
1825	}
1826
1827	Mnp = IpInstance->Service->Mnp;
1828
1829	//
1830	// Don't lock the Poll function to enable the deliver of
1831	// the packet polled up.
1832	//
1833	return Mnp->Poll (Mnp);
1834	}

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

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

Download in other formats: