WifiConnectionMgrMisc.c@ 80721

Last change on this file since 80721 was 80721, checked in by vboxsync, 5 years ago
Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), bugref:4643
Property svn:eol-style set to `native`
File size: 20.9 KB

Line
1	/** @file
2	The Miscellaneous Routines for WiFi Connection Manager.
3
4	Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
5
6	SPDX-License-Identifier: BSD-2-Clause-Patent
7
8	**/
9
10	#include "WifiConnectionMgrDxe.h"
11
12	/**
13	Empty function for event process function.
14
15	@param Event The Event need to be process
16	@param Context The context of the event.
17
18	**/
19	VOID
20	EFIAPI
21	WifiMgrInternalEmptyFunction (
22	IN EFI_EVENT Event,
23	IN VOID *Context
24	)
25	{
26	return;
27	}
28
29	/**
30	Convert the mac address into a hexadecimal encoded ":" seperated string.
31
32	@param[in] Mac The mac address.
33	@param[in] StrSize The size, in bytes, of the output buffer specified by Str.
34	@param[out] Str The storage to return the mac string.
35
36	**/
37	VOID
38	WifiMgrMacAddrToStr (
39	IN EFI_80211_MAC_ADDRESS *Mac,
40	IN UINT32 StrSize,
41	OUT CHAR16 *Str
42	)
43	{
44	if (Mac == NULL \|\| Str == NULL) {
45	return;
46	}
47
48	UnicodeSPrint (
49	Str,
50	StrSize,
51	L"%02X:%02X:%02X:%02X:%02X:%02X",
52	Mac->Addr[0], Mac->Addr[1], Mac->Addr[2],
53	Mac->Addr[3], Mac->Addr[4], Mac->Addr[5]
54	);
55	}
56
57	/**
58	Read private key file to buffer.
59
60	@param[in] FileContext The file context of private key file.
61	@param[out] PrivateKeyDataAddr The buffer address to restore private key file, should be
62	freed by caller.
63	@param[out] PrivateKeyDataSize The size of read private key file.
64
65	@retval EFI_SUCCESS Successfully read the private key file.
66	@retval EFI_INVALID_PARAMETER One or more of the parameters is invalid.
67
68	**/
69	EFI_STATUS
70	WifiMgrReadFileToBuffer (
71	IN WIFI_MGR_FILE_CONTEXT *FileContext,
72	OUT VOID **DataAddr,
73	OUT UINTN *DataSize
74	)
75	{
76	EFI_STATUS Status;
77
78	if (FileContext != NULL && FileContext->FHandle != NULL) {
79
80	Status = ReadFileContent (
81	FileContext->FHandle,
82	DataAddr,
83	DataSize,
84	0
85	);
86
87	if (FileContext->FHandle != NULL) {
88	FileContext->FHandle->Close (FileContext->FHandle);
89	}
90	FileContext->FHandle = NULL;
91	return Status;
92	}
93
94	return EFI_INVALID_PARAMETER;
95	}
96
97	/**
98	Get the Nic data by the NicIndex.
99
100	@param[in] Private The pointer to the global private data structure.
101	@param[in] NicIndex The index indicates the position of wireless NIC.
102
103	@return Pointer to the Nic data, or NULL if not found.
104
105	**/
106	WIFI_MGR_DEVICE_DATA *
107	WifiMgrGetNicByIndex (
108	IN WIFI_MGR_PRIVATE_DATA *Private,
109	IN UINT32 NicIndex
110	)
111	{
112	LIST_ENTRY *Entry;
113	WIFI_MGR_DEVICE_DATA *Nic;
114
115	if (Private == NULL) {
116	return NULL;
117	}
118
119	NET_LIST_FOR_EACH (Entry, &Private->NicList) {
120	Nic = NET_LIST_USER_STRUCT_S (Entry, WIFI_MGR_DEVICE_DATA,
121	Link, WIFI_MGR_DEVICE_DATA_SIGNATURE);
122	if (Nic->NicIndex == NicIndex) {
123	return Nic;
124	}
125	}
126
127	return NULL;
128	}
129
130	/**
131	Find a network profile through its' SSId and securit type, and the SSId is an unicode string.
132
133	@param[in] SSId The target network's SSId.
134	@param[in] SecurityType The target network's security type.
135	@param[in] ProfileList The profile list on a Nic.
136
137	@return Pointer to a network profile, or NULL if not found.
138
139	**/
140	WIFI_MGR_NETWORK_PROFILE *
141	WifiMgrGetProfileByUnicodeSSId (
142	IN CHAR16 *SSId,
143	IN UINT8 SecurityType,
144	IN LIST_ENTRY *ProfileList
145	)
146	{
147	LIST_ENTRY *Entry;
148	WIFI_MGR_NETWORK_PROFILE *Profile;
149
150	if (SSId == NULL \|\| ProfileList == NULL) {
151	return NULL;
152	}
153
154	NET_LIST_FOR_EACH (Entry, ProfileList) {
155	Profile = NET_LIST_USER_STRUCT_S (Entry, WIFI_MGR_NETWORK_PROFILE,
156	Link, WIFI_MGR_PROFILE_SIGNATURE);
157	if (StrCmp (SSId, Profile->SSId) == 0 && SecurityType == Profile->SecurityType) {
158	return Profile;
159	}
160	}
161
162	return NULL;
163	}
164
165	/**
166	Find a network profile through its' SSId and securit type, and the SSId is an ascii string.
167
168	@param[in] SSId The target network's SSId.
169	@param[in] SecurityType The target network's security type.
170	@param[in] ProfileList The profile list on a Nic.
171
172	@return Pointer to a network profile, or NULL if not found.
173
174	**/
175	WIFI_MGR_NETWORK_PROFILE *
176	WifiMgrGetProfileByAsciiSSId (
177	IN CHAR8 *SSId,
178	IN UINT8 SecurityType,
179	IN LIST_ENTRY *ProfileList
180	)
181	{
182	CHAR16 SSIdUniCode[SSID_STORAGE_SIZE];
183
184	if (SSId == NULL) {
185	return NULL;
186	}
187	if (AsciiStrToUnicodeStrS (SSId, SSIdUniCode, SSID_STORAGE_SIZE) != RETURN_SUCCESS) {
188	return NULL;
189	}
190
191	return WifiMgrGetProfileByUnicodeSSId (SSIdUniCode, SecurityType, ProfileList);
192	}
193
194	/**
195	Find a network profile through its' profile index.
196
197	@param[in] ProfileIndex The target network's profile index.
198	@param[in] ProfileList The profile list on a Nic.
199
200	@return Pointer to a network profile, or NULL if not found.
201
202	**/
203	WIFI_MGR_NETWORK_PROFILE *
204	WifiMgrGetProfileByProfileIndex (
205	IN UINT32 ProfileIndex,
206	IN LIST_ENTRY *ProfileList
207	)
208	{
209	WIFI_MGR_NETWORK_PROFILE *Profile;
210	LIST_ENTRY *Entry;
211
212	if (ProfileList == NULL) {
213	return NULL;
214	}
215	NET_LIST_FOR_EACH (Entry, ProfileList) {
216	Profile = NET_LIST_USER_STRUCT_S (Entry, WIFI_MGR_NETWORK_PROFILE,
217	Link, WIFI_MGR_PROFILE_SIGNATURE);
218	if (Profile->ProfileIndex == ProfileIndex) {
219	return Profile;
220	}
221	}
222	return NULL;
223	}
224
225	/**
226	To test if the AKMSuite is in supported AKMSuite list.
227
228	@param[in] SupportedAKMSuiteCount The count of the supported AKMSuites.
229	@param[in] SupportedAKMSuiteList The supported AKMSuite list.
230	@param[in] AKMSuite The AKMSuite to be tested.
231
232	@return True if this AKMSuite is supported, or False if not.
233
234	**/
235	BOOLEAN
236	WifiMgrSupportAKMSuite (
237	IN UINT16 SupportedAKMSuiteCount,
238	IN UINT32 *SupportedAKMSuiteList,
239	IN UINT32 *AKMSuite
240	)
241	{
242	UINT16 Index;
243
244	if (AKMSuite == NULL \|\| SupportedAKMSuiteList == NULL \|\|
245	SupportedAKMSuiteCount == 0) {
246	return FALSE;
247	}
248
249	for (Index = 0; Index < SupportedAKMSuiteCount; Index ++) {
250	if (SupportedAKMSuiteList[Index] == *AKMSuite) {
251	return TRUE;
252	}
253	}
254
255	return FALSE;
256	}
257
258	/**
259	To check if the CipherSuite is in supported CipherSuite list.
260
261	@param[in] SupportedCipherSuiteCount The count of the supported CipherSuites.
262	@param[in] SupportedCipherSuiteList The supported CipherSuite list.
263	@param[in] CipherSuite The CipherSuite to be tested.
264
265	@return True if this CipherSuite is supported, or False if not.
266
267	**/
268	BOOLEAN
269	WifiMgrSupportCipherSuite (
270	IN UINT16 SupportedCipherSuiteCount,
271	IN UINT32 *SupportedCipherSuiteList,
272	IN UINT32 *CipherSuite
273	)
274	{
275	UINT16 Index;
276
277	if (CipherSuite == NULL \|\| SupportedCipherSuiteCount == 0 \|\|
278	SupportedCipherSuiteList == NULL) {
279	return FALSE;
280	}
281
282	for (Index = 0; Index < SupportedCipherSuiteCount; Index ++) {
283	if (SupportedCipherSuiteList[Index] == *CipherSuite) {
284	return TRUE;
285	}
286	}
287
288	return FALSE;
289	}
290
291	/**
292	Check an AKM suite list and a Cipher suite list to see if one or more AKM suites or Cipher suites
293	are supported and find the matchable security type.
294
295	@param[in] AKMList The target AKM suite list to be checked.
296	@param[in] CipherList The target Cipher suite list to be checked
297	@param[in] Nic The Nic to operate, contains the supported AKMSuite list
298	and supported CipherSuite list
299	@param[out] SecurityType To identify a security type from the AKM suite list and
300	Cipher suite list
301	@param[out] AKMSuiteSupported To identify if this security type is supported. If it is
302	NULL, overcome this field
303	@param[out] CipherSuiteSupported To identify if this security type is supported. If it is
304	NULL, overcome this field
305
306	@retval EFI_SUCCESS This operation has completed successfully.
307	@retval EFI_INVALID_PARAMETER No Nic found or the suite list is null.
308
309	**/
310	EFI_STATUS
311	WifiMgrCheckRSN (
312	IN EFI_80211_AKM_SUITE_SELECTOR *AKMList,
313	IN EFI_80211_CIPHER_SUITE_SELECTOR *CipherList,
314	IN WIFI_MGR_DEVICE_DATA *Nic,
315	OUT UINT8 *SecurityType,
316	OUT BOOLEAN *AKMSuiteSupported,
317	OUT BOOLEAN *CipherSuiteSupported
318	)
319	{
320	EFI_80211_AKM_SUITE_SELECTOR *SupportedAKMSuites;
321	EFI_80211_CIPHER_SUITE_SELECTOR *SupportedSwCipherSuites;
322	EFI_80211_CIPHER_SUITE_SELECTOR *SupportedHwCipherSuites;
323	EFI_80211_SUITE_SELECTOR *AKMSuite;
324	EFI_80211_SUITE_SELECTOR *CipherSuite;
325	UINT16 AKMIndex;
326	UINT16 CipherIndex;
327
328	if (Nic == NULL \|\| AKMList == NULL \|\| CipherList == NULL\|\| SecurityType == NULL) {
329	return EFI_INVALID_PARAMETER;
330	}
331
332	SupportedAKMSuites = Nic->SupportedSuites.SupportedAKMSuites;
333	SupportedSwCipherSuites = Nic->SupportedSuites.SupportedSwCipherSuites;
334	SupportedHwCipherSuites = Nic->SupportedSuites.SupportedHwCipherSuites;
335
336	*SecurityType = SECURITY_TYPE_UNKNOWN;
337	if (AKMSuiteSupported != NULL && CipherSuiteSupported != NULL) {
338	*AKMSuiteSupported = FALSE;
339	*CipherSuiteSupported = FALSE;
340	}
341
342	if (AKMList->AKMSuiteCount == 0) {
343	if (CipherList->CipherSuiteCount == 0) {
344	*SecurityType = SECURITY_TYPE_NONE;
345	if (AKMSuiteSupported != NULL && CipherSuiteSupported != NULL) {
346	*AKMSuiteSupported = TRUE;
347	*CipherSuiteSupported = TRUE;
348	}
349	}
350
351	return EFI_SUCCESS;
352	}
353
354	for (AKMIndex = 0; AKMIndex < AKMList->AKMSuiteCount; AKMIndex ++) {
355
356	AKMSuite = AKMList->AKMSuiteList + AKMIndex;
357	if (WifiMgrSupportAKMSuite(SupportedAKMSuites->AKMSuiteCount,
358	(UINT32) SupportedAKMSuites->AKMSuiteList, (UINT32) AKMSuite)) {
359
360	if (AKMSuiteSupported != NULL && CipherSuiteSupported != NULL) {
361	*AKMSuiteSupported = TRUE;
362	}
363	for (CipherIndex = 0; CipherIndex < CipherList->CipherSuiteCount; CipherIndex ++) {
364
365	CipherSuite = CipherList->CipherSuiteList + CipherIndex;
366
367	if (SupportedSwCipherSuites != NULL) {
368
369	if (WifiMgrSupportCipherSuite(SupportedSwCipherSuites->CipherSuiteCount,
370	(UINT32) SupportedSwCipherSuites->CipherSuiteList, (UINT32) CipherSuite)) {
371
372	SecurityType = WifiMgrGetSecurityType ((UINT32) AKMSuite, (UINT32*) CipherSuite);
373
374	if (*SecurityType != SECURITY_TYPE_UNKNOWN) {
375
376	if (AKMSuiteSupported != NULL && CipherSuiteSupported != NULL) {
377	*CipherSuiteSupported = TRUE;
378	}
379	return EFI_SUCCESS;
380	}
381	}
382	}
383
384	if (SupportedHwCipherSuites != NULL) {
385
386	if (WifiMgrSupportCipherSuite(SupportedHwCipherSuites->CipherSuiteCount,
387	(UINT32) SupportedHwCipherSuites->CipherSuiteList, (UINT32) CipherSuite)) {
388
389	SecurityType = WifiMgrGetSecurityType ((UINT32) AKMSuite, (UINT32*) CipherSuite);
390
391	if (*SecurityType != SECURITY_TYPE_UNKNOWN) {
392
393	if (AKMSuiteSupported != NULL && CipherSuiteSupported != NULL) {
394	*CipherSuiteSupported = TRUE;
395	}
396	return EFI_SUCCESS;
397	}
398	}
399	}
400	}
401	}
402	}
403
404	SecurityType = WifiMgrGetSecurityType ((UINT32) AKMList->AKMSuiteList,
405	(UINT32*) CipherList->CipherSuiteList);
406
407	return EFI_SUCCESS;
408	}
409
410	/**
411	Get the security type for a certain AKMSuite and CipherSuite.
412
413	@param[in] AKMSuite An certain AKMSuite.
414	@param[in] CipherSuite An certain CipherSuite.
415
416	@return a security type if found, or SECURITY_TYPE_UNKNOWN.
417
418	**/
419	UINT8
420	WifiMgrGetSecurityType (
421	IN UINT32 *AKMSuite,
422	IN UINT32 *CipherSuite
423	)
424	{
425	if (CipherSuite == NULL) {
426
427	if (AKMSuite == NULL) {
428	return SECURITY_TYPE_NONE;
429	} else {
430	return SECURITY_TYPE_UNKNOWN;
431	}
432	} else if (*CipherSuite == IEEE_80211_PAIRWISE_CIPHER_SUITE_USE_GROUP) {
433
434	if (AKMSuite == NULL) {
435	return SECURITY_TYPE_NONE;
436	} else {
437	return SECURITY_TYPE_UNKNOWN;
438	}
439	} else if (*CipherSuite == IEEE_80211_PAIRWISE_CIPHER_SUITE_WEP40 \|\|
440	*CipherSuite == IEEE_80211_PAIRWISE_CIPHER_SUITE_WEP104) {
441
442	return SECURITY_TYPE_WEP;
443	} else if (*CipherSuite == IEEE_80211_PAIRWISE_CIPHER_SUITE_CCMP) {
444
445	if (AKMSuite == NULL) {
446	return SECURITY_TYPE_UNKNOWN;
447	}
448
449	if (*AKMSuite == IEEE_80211_AKM_SUITE_8021X_OR_PMKSA \|\|
450	*AKMSuite == IEEE_80211_AKM_SUITE_8021X_OR_PMKSA_SHA256) {
451
452	return SECURITY_TYPE_WPA2_ENTERPRISE;
453	} else if (*AKMSuite == IEEE_80211_AKM_SUITE_PSK \|\|
454	*AKMSuite == IEEE_80211_AKM_SUITE_PSK_SHA256){
455
456	return SECURITY_TYPE_WPA2_PERSONAL;
457	}else {
458	return SECURITY_TYPE_UNKNOWN;
459	}
460	} else if (*CipherSuite == IEEE_80211_PAIRWISE_CIPHER_SUITE_TKIP) {
461
462	if (AKMSuite == NULL) {
463	return SECURITY_TYPE_UNKNOWN;
464	}
465
466	if (*AKMSuite == IEEE_80211_AKM_SUITE_8021X_OR_PMKSA \|\|
467	*AKMSuite == IEEE_80211_AKM_SUITE_8021X_OR_PMKSA_SHA256) {
468
469	return SECURITY_TYPE_WPA_ENTERPRISE;
470	} else if (*AKMSuite == IEEE_80211_AKM_SUITE_PSK \|\|
471	*AKMSuite == IEEE_80211_AKM_SUITE_PSK_SHA256){
472
473	return SECURITY_TYPE_WPA_PERSONAL;
474	}else {
475	return SECURITY_TYPE_UNKNOWN;
476	}
477	} else {
478	return SECURITY_TYPE_UNKNOWN;
479	}
480	}
481
482	/**
483	Get supported AKMSuites and CipherSuites from supplicant for a Nic.
484
485	@param[in] Nic The Nic to operate.
486
487	@retval EFI_SUCCESS Get the supported suite list successfully.
488	@retval EFI_INVALID_PARAMETER No Nic found or supplicant is NULL.
489
490	**/
491	EFI_STATUS
492	WifiMgrGetSupportedSuites (
493	IN WIFI_MGR_DEVICE_DATA *Nic
494	)
495	{
496	EFI_STATUS Status;
497	EFI_SUPPLICANT_PROTOCOL *Supplicant;
498	EFI_80211_AKM_SUITE_SELECTOR *SupportedAKMSuites;
499	EFI_80211_CIPHER_SUITE_SELECTOR *SupportedSwCipherSuites;
500	EFI_80211_CIPHER_SUITE_SELECTOR *SupportedHwCipherSuites;
501	UINTN DataSize;
502
503	SupportedAKMSuites = NULL;
504	SupportedSwCipherSuites = NULL;
505	SupportedHwCipherSuites = NULL;
506
507	if (Nic == NULL \|\| Nic->Supplicant == NULL) {
508	return EFI_INVALID_PARAMETER;
509	}
510
511	Supplicant = Nic->Supplicant;
512
513	DataSize = 0;
514	Status = Supplicant->GetData (Supplicant, EfiSupplicant80211SupportedAKMSuites, NULL, &DataSize);
515	if (Status == EFI_BUFFER_TOO_SMALL && DataSize > 0) {
516
517	SupportedAKMSuites = AllocateZeroPool(DataSize);
518	if (SupportedAKMSuites == NULL) {
519	return EFI_OUT_OF_RESOURCES;
520	}
521	Status = Supplicant->GetData (Supplicant, EfiSupplicant80211SupportedAKMSuites,
522	(UINT8 *) SupportedAKMSuites, &DataSize);
523	if (!EFI_ERROR (Status)) {
524	Nic->SupportedSuites.SupportedAKMSuites = SupportedAKMSuites;
525	} else {
526	FreePool (SupportedAKMSuites);
527	}
528	} else {
529	SupportedAKMSuites = NULL;
530	}
531
532	DataSize = 0;
533	Status = Supplicant->GetData (Supplicant, EfiSupplicant80211SupportedSoftwareCipherSuites, NULL, &DataSize);
534	if (Status == EFI_BUFFER_TOO_SMALL && DataSize > 0) {
535
536
537	SupportedSwCipherSuites = AllocateZeroPool(DataSize);
538	if (SupportedSwCipherSuites == NULL) {
539	return EFI_OUT_OF_RESOURCES;
540	}
541	Status = Supplicant->GetData (Supplicant, EfiSupplicant80211SupportedSoftwareCipherSuites,
542	(UINT8 *) SupportedSwCipherSuites, &DataSize);
543	if (!EFI_ERROR (Status)) {
544	Nic->SupportedSuites.SupportedSwCipherSuites = SupportedSwCipherSuites;
545	} else {
546	FreePool (SupportedSwCipherSuites);
547	}
548	} else {
549	SupportedSwCipherSuites = NULL;
550	}
551
552	DataSize = 0;
553	Status = Supplicant->GetData (Supplicant, EfiSupplicant80211SupportedHardwareCipherSuites, NULL, &DataSize);
554	if (Status == EFI_BUFFER_TOO_SMALL && DataSize > 0) {
555
556	SupportedHwCipherSuites = AllocateZeroPool(DataSize);
557	if (SupportedHwCipherSuites == NULL) {
558	return EFI_OUT_OF_RESOURCES;
559	}
560	Status = Supplicant->GetData (Supplicant, EfiSupplicant80211SupportedHardwareCipherSuites,
561	(UINT8 *) SupportedHwCipherSuites, &DataSize);
562	if (!EFI_ERROR (Status)) {
563	Nic->SupportedSuites.SupportedHwCipherSuites = SupportedHwCipherSuites;
564	} else {
565	FreePool (SupportedHwCipherSuites);
566	}
567	} else {
568	SupportedHwCipherSuites = NULL;
569	}
570
571	return EFI_SUCCESS;
572	}
573
574	/**
575	Clean secrets from a network profile.
576
577	@param[in] Profile The profile to be cleanned.
578
579	**/
580	VOID
581	WifiMgrCleanProfileSecrets (
582	IN WIFI_MGR_NETWORK_PROFILE *Profile
583	)
584	{
585	ZeroMem (Profile->Password, sizeof (CHAR16) * PASSWORD_STORAGE_SIZE);
586	ZeroMem (Profile->EapPassword, sizeof (CHAR16) * PASSWORD_STORAGE_SIZE);
587	ZeroMem (Profile->PrivateKeyPassword, sizeof (CHAR16) * PASSWORD_STORAGE_SIZE);
588
589	if (Profile->CACertData != NULL) {
590
591	ZeroMem (Profile->CACertData, Profile->CACertSize);
592	FreePool (Profile->CACertData);
593	}
594	Profile->CACertData = NULL;
595	Profile->CACertSize = 0;
596
597	if (Profile->ClientCertData != NULL) {
598
599	ZeroMem (Profile->ClientCertData, Profile->ClientCertSize);
600	FreePool (Profile->ClientCertData);
601	}
602	Profile->ClientCertData = NULL;
603	Profile->ClientCertSize = 0;
604
605	if (Profile->PrivateKeyData != NULL) {
606
607	ZeroMem (Profile->PrivateKeyData, Profile->PrivateKeyDataSize);
608	FreePool (Profile->PrivateKeyData);
609	}
610	Profile->PrivateKeyData = NULL;
611	Profile->PrivateKeyDataSize = 0;
612	}
613
614	/**
615	Free all network profiles in a profile list.
616
617	@param[in] ProfileList The profile list to be freed.
618
619	**/
620	VOID
621	WifiMgrFreeProfileList (
622	IN LIST_ENTRY *ProfileList
623	)
624	{
625	WIFI_MGR_NETWORK_PROFILE *Profile;
626	LIST_ENTRY *Entry;
627	LIST_ENTRY *NextEntry;
628
629	if (ProfileList == NULL) {
630	return;
631	}
632
633	NET_LIST_FOR_EACH_SAFE (Entry, NextEntry, ProfileList) {
634
635	Profile = NET_LIST_USER_STRUCT_S (Entry, WIFI_MGR_NETWORK_PROFILE,
636	Link, WIFI_MGR_PROFILE_SIGNATURE);
637
638	WifiMgrCleanProfileSecrets (Profile);
639
640	if (Profile->Network.AKMSuite != NULL) {
641	FreePool(Profile->Network.AKMSuite);
642	}
643
644	if (Profile->Network.CipherSuite != NULL) {
645	FreePool(Profile->Network.CipherSuite);
646	}
647
648	FreePool (Profile);
649	}
650	}
651
652	/**
653	Free user configured hidden network list.
654
655	@param[in] HiddenList The hidden network list to be freed.
656
657	**/
658	VOID
659	WifiMgrFreeHiddenList (
660	IN LIST_ENTRY *HiddenList
661	)
662	{
663	WIFI_HIDDEN_NETWORK_DATA *HiddenNetwork;
664	LIST_ENTRY *Entry;
665	LIST_ENTRY *NextEntry;
666
667	if (HiddenList == NULL) {
668	return;
669	}
670
671	NET_LIST_FOR_EACH_SAFE (Entry, NextEntry, HiddenList) {
672
673	HiddenNetwork = NET_LIST_USER_STRUCT_S (Entry, WIFI_HIDDEN_NETWORK_DATA,
674	Link, WIFI_MGR_HIDDEN_NETWORK_SIGNATURE);
675	FreePool (HiddenNetwork);
676	}
677	}
678
679
680	/**
681	Free the resources of a config token.
682
683	@param[in] ConfigToken The config token to be freed.
684	**/
685	VOID
686	WifiMgrFreeToken (
687	IN WIFI_MGR_MAC_CONFIG_TOKEN *ConfigToken
688	)
689	{
690	EFI_80211_GET_NETWORKS_RESULT *Result;
691
692	if (ConfigToken == NULL) {
693	return;
694	}
695
696	switch (ConfigToken->Type) {
697
698	case TokenTypeGetNetworksToken:
699
700	if (ConfigToken->Token.GetNetworksToken != NULL) {
701
702	gBS->CloseEvent (ConfigToken->Token.GetNetworksToken->Event);
703	if (ConfigToken->Token.GetNetworksToken->Data != NULL) {
704	FreePool(ConfigToken->Token.GetNetworksToken->Data);
705	}
706
707	Result = ConfigToken->Token.GetNetworksToken->Result;
708	if (Result != NULL) {
709	FreePool (Result);
710	}
711
712	FreePool(ConfigToken->Token.GetNetworksToken);
713	}
714
715	FreePool (ConfigToken);
716	break;
717
718	case TokenTypeConnectNetworkToken:
719
720	if (ConfigToken->Token.ConnectNetworkToken != NULL) {
721
722	gBS->CloseEvent (ConfigToken->Token.ConnectNetworkToken->Event);
723	if (ConfigToken->Token.ConnectNetworkToken->Data != NULL) {
724	FreePool(ConfigToken->Token.ConnectNetworkToken->Data);
725	}
726	FreePool(ConfigToken->Token.ConnectNetworkToken);
727	}
728	FreePool (ConfigToken);
729	break;
730
731	case TokenTypeDisconnectNetworkToken:
732
733	if (ConfigToken->Token.DisconnectNetworkToken != NULL) {
734
735	FreePool(ConfigToken->Token.DisconnectNetworkToken);
736	}
737
738	FreePool (ConfigToken);
739	break;
740
741	default :
742	break;
743	}
744	}

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

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/WifiConnectionManagerDxe/WifiConnectionMgrMisc.c@ 80721

Download in other formats: