NetworkPkg/WifiConnectionManagerDxe/WifiConnectionMgrMisc.c

   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 }