Ip6Impl.c@ 77662

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

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

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/Ip6Dxe/Ip6Impl.c@ 77662

Download in other formats: