NetworkPkg/TlsAuthConfigDxe/TlsAuthConfigImpl.c

   1 /** @file
   2   The Miscellaneous Routines for TlsAuthConfigDxe driver.
   3
   4 Copyright (c) 2016 - 2017, Intel Corporation. All rights reserved.<BR>
   5
   6 This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "TlsAuthConfigImpl.h"
  17
  18 VOID                    *mStartOpCodeHandle = NULL;
  19 VOID                    *mEndOpCodeHandle   = NULL;
  20 EFI_IFR_GUID_LABEL      *mStartLabel        = NULL;
  21 EFI_IFR_GUID_LABEL      *mEndLabel          = NULL;
  22
  23
  24 CHAR16                  mTlsAuthConfigStorageName[] = L"TLS_AUTH_CONFIG_IFR_NVDATA";
  25
  26 TLS_AUTH_CONFIG_PRIVATE_DATA      *mTlsAuthPrivateData = NULL;
  27
  28 HII_VENDOR_DEVICE_PATH  mTlsAuthConfigHiiVendorDevicePath = {
  29   {
  30     {
  31       HARDWARE_DEVICE_PATH,
  32       HW_VENDOR_DP,
  33       {
  34         (UINT8) (sizeof (VENDOR_DEVICE_PATH)),
  35         (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)
  36       }
  37     },
  38     TLS_AUTH_CONFIG_GUID
  39   },
  40   {
  41     END_DEVICE_PATH_TYPE,
  42     END_ENTIRE_DEVICE_PATH_SUBTYPE,
  43     {
  44       (UINT8) (END_DEVICE_PATH_LENGTH),
  45       (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)
  46     }
  47   }
  48 };
  49
  50 //
  51 // Possible DER-encoded certificate file suffixes, end with NULL pointer.
  52 //
  53 CHAR16* mDerPemEncodedSuffix[] = {
  54   L".cer",
  55   L".der",
  56   L".crt",
  57   L".pem",
  58   NULL
  59 };
  60
  61 /**
  62   This code checks if the FileSuffix is one of the possible DER/PEM-encoded certificate suffix.
  63
  64   @param[in] FileSuffix            The suffix of the input certificate file
  65
  66   @retval    TRUE           It's a DER/PEM-encoded certificate.
  67   @retval    FALSE          It's NOT a DER/PEM-encoded certificate.
  68
  69 **/
  70 BOOLEAN
  71 IsDerPemEncodeCertificate (
  72   IN CONST CHAR16         *FileSuffix
  73 )
  74 {
  75   UINTN     Index;
  76   for (Index = 0; mDerPemEncodedSuffix[Index] != NULL; Index++) {
  77     if (StrCmp (FileSuffix, mDerPemEncodedSuffix[Index]) == 0) {
  78       return TRUE;
  79     }
  80   }
  81   return FALSE;
  82 }
  83
  84 /**
  85   Worker function that prints an EFI_GUID into specified Buffer.
  86
  87   @param[in]     Guid          Pointer to GUID to print.
  88   @param[in]     Buffer        Buffer to print Guid into.
  89   @param[in]     BufferSize    Size of Buffer.
  90
  91   @retval    Number of characters printed.
  92
  93 **/
  94 UINTN
  95 GuidToString (
  96   IN  EFI_GUID  *Guid,
  97   IN  CHAR16    *Buffer,
  98   IN  UINTN     BufferSize
  99   )
 100 {
 101   return UnicodeSPrint (
 102            Buffer,
 103            BufferSize,
 104            L"%g",
 105            Guid
 106            );
 107 }
 108
 109 /**
 110   List all cert in specified database by GUID in the page
 111   for user to select and delete as needed.
 112
 113   @param[in]    PrivateData         Module's private data.
 114   @param[in]    VariableName        The variable name of the vendor's signature database.
 115   @param[in]    VendorGuid          A unique identifier for the vendor.
 116   @param[in]    LabelNumber         Label number to insert opcodes.
 117   @param[in]    FormId              Form ID of current page.
 118   @param[in]    QuestionIdBase      Base question id of the signature list.
 119
 120   @retval   EFI_SUCCESS             Success to update the signature list page
 121   @retval   EFI_OUT_OF_RESOURCES    Unable to allocate required resources.
 122
 123 **/
 124 EFI_STATUS
 125 UpdateDeletePage (
 126   IN TLS_AUTH_CONFIG_PRIVATE_DATA     *Private,
 127   IN CHAR16                           *VariableName,
 128   IN EFI_GUID                         *VendorGuid,
 129   IN UINT16                           LabelNumber,
 130   IN EFI_FORM_ID                      FormId,
 131   IN EFI_QUESTION_ID                  QuestionIdBase
 132   )
 133 {
 134   EFI_STATUS                  Status;
 135   UINT32                      Index;
 136   UINTN                       CertCount;
 137   UINTN                       GuidIndex;
 138   VOID                        *StartOpCodeHandle;
 139   VOID                        *EndOpCodeHandle;
 140   EFI_IFR_GUID_LABEL          *StartLabel;
 141   EFI_IFR_GUID_LABEL          *EndLabel;
 142   UINTN                       DataSize;
 143   UINT8                       *Data;
 144   EFI_SIGNATURE_LIST          *CertList;
 145   EFI_SIGNATURE_DATA          *Cert;
 146   UINT32                      ItemDataSize;
 147   CHAR16                      *GuidStr;
 148   EFI_STRING_ID               GuidID;
 149   EFI_STRING_ID               Help;
 150
 151   Data     = NULL;
 152   CertList = NULL;
 153   Cert     = NULL;
 154   GuidStr  = NULL;
 155   StartOpCodeHandle = NULL;
 156   EndOpCodeHandle   = NULL;
 157
 158   //
 159   // Initialize the container for dynamic opcodes.
 160   //
 161   StartOpCodeHandle = HiiAllocateOpCodeHandle ();
 162   if (StartOpCodeHandle == NULL) {
 163     Status = EFI_OUT_OF_RESOURCES;
 164     goto ON_EXIT;
 165   }
 166
 167   EndOpCodeHandle = HiiAllocateOpCodeHandle ();
 168   if (EndOpCodeHandle == NULL) {
 169     Status = EFI_OUT_OF_RESOURCES;
 170     goto ON_EXIT;
 171   }
 172
 173   //
 174   // Create Hii Extend Label OpCode.
 175   //
 176   StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
 177                                         StartOpCodeHandle,
 178                                         &gEfiIfrTianoGuid,
 179                                         NULL,
 180                                         sizeof (EFI_IFR_GUID_LABEL)
 181                                         );
 182   StartLabel->ExtendOpCode  = EFI_IFR_EXTEND_OP_LABEL;
 183   StartLabel->Number        = LabelNumber;
 184
 185   EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
 186                                       EndOpCodeHandle,
 187                                       &gEfiIfrTianoGuid,
 188                                       NULL,
 189                                       sizeof (EFI_IFR_GUID_LABEL)
 190                                       );
 191   EndLabel->ExtendOpCode  = EFI_IFR_EXTEND_OP_LABEL;
 192   EndLabel->Number        = LABEL_END;
 193
 194   //
 195   // Read Variable.
 196   //
 197   DataSize = 0;
 198   Status = gRT->GetVariable (VariableName, VendorGuid, NULL, &DataSize, Data);
 199   if (EFI_ERROR (Status) && Status != EFI_BUFFER_TOO_SMALL) {
 200     goto ON_EXIT;
 201   }
 202
 203   Data = (UINT8 *) AllocateZeroPool (DataSize);
 204   if (Data == NULL) {
 205     Status = EFI_OUT_OF_RESOURCES;
 206     goto ON_EXIT;
 207   }
 208
 209   Status = gRT->GetVariable (VariableName, VendorGuid, NULL, &DataSize, Data);
 210   if (EFI_ERROR (Status)) {
 211     goto ON_EXIT;
 212   }
 213
 214   GuidStr = AllocateZeroPool (100);
 215   if (GuidStr == NULL) {
 216     Status = EFI_OUT_OF_RESOURCES;
 217     goto ON_EXIT;
 218   }
 219
 220   //
 221   // Enumerate all data.
 222   //
 223   ItemDataSize = (UINT32) DataSize;
 224   CertList = (EFI_SIGNATURE_LIST *) Data;
 225   GuidIndex = 0;
 226
 227   while ((ItemDataSize > 0) && (ItemDataSize >= CertList->SignatureListSize)) {
 228
 229     if (CompareGuid (&CertList->SignatureType, &gEfiCertX509Guid)) {
 230       Help = STRING_TOKEN (STR_CERT_TYPE_PCKS_GUID);
 231     } else {
 232       //
 233       // The signature type is not supported in current implementation.
 234       //
 235       ItemDataSize -= CertList->SignatureListSize;
 236       CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);
 237       continue;
 238     }
 239
 240     CertCount  = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;
 241     for (Index = 0; Index < CertCount; Index++) {
 242       Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList
 243                                               + sizeof (EFI_SIGNATURE_LIST)
 244                                               + CertList->SignatureHeaderSize
 245                                               + Index * CertList->SignatureSize);
 246       //
 247       // Display GUID and help
 248       //
 249       GuidToString (&Cert->SignatureOwner, GuidStr, 100);
 250       GuidID  = HiiSetString (Private->RegisteredHandle, 0, GuidStr, NULL);
 251       HiiCreateCheckBoxOpCode (
 252         StartOpCodeHandle,
 253         (EFI_QUESTION_ID) (QuestionIdBase + GuidIndex++),
 254         0,
 255         0,
 256         GuidID,
 257         Help,
 258         EFI_IFR_FLAG_CALLBACK,
 259         0,
 260         NULL
 261         );
 262     }
 263
 264     ItemDataSize -= CertList->SignatureListSize;
 265     CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);
 266   }
 267
 268 ON_EXIT:
 269   HiiUpdateForm (
 270     Private->RegisteredHandle,
 271     &gTlsAuthConfigGuid,
 272     FormId,
 273     StartOpCodeHandle,
 274     EndOpCodeHandle
 275     );
 276
 277   if (StartOpCodeHandle != NULL) {
 278     HiiFreeOpCodeHandle (StartOpCodeHandle);
 279   }
 280
 281   if (EndOpCodeHandle != NULL) {
 282     HiiFreeOpCodeHandle (EndOpCodeHandle);
 283   }
 284
 285   if (Data != NULL) {
 286     FreePool (Data);
 287   }
 288
 289   if (GuidStr != NULL) {
 290     FreePool (GuidStr);
 291   }
 292
 293   return EFI_SUCCESS;
 294 }
 295
 296 /**
 297   Delete one entry from cert database.
 298
 299   @param[in]    Private             Module's private data.
 300   @param[in]    VariableName        The variable name of the database.
 301   @param[in]    VendorGuid          A unique identifier for the vendor.
 302   @param[in]    LabelNumber         Label number to insert opcodes.
 303   @param[in]    FormId              Form ID of current page.
 304   @param[in]    QuestionIdBase      Base question id of the cert list.
 305   @param[in]    DeleteIndex         Cert index to delete.
 306
 307   @retval   EFI_SUCCESS             Delete siganture successfully.
 308   @retval   EFI_NOT_FOUND           Can't find the signature item,
 309   @retval   EFI_OUT_OF_RESOURCES    Could not allocate needed resources.
 310 **/
 311 EFI_STATUS
 312 DeleteCert (
 313   IN TLS_AUTH_CONFIG_PRIVATE_DATA     *Private,
 314   IN CHAR16                           *VariableName,
 315   IN EFI_GUID                         *VendorGuid,
 316   IN UINT16                           LabelNumber,
 317   IN EFI_FORM_ID                      FormId,
 318   IN EFI_QUESTION_ID                  QuestionIdBase,
 319   IN UINTN                            DeleteIndex
 320   )
 321 {
 322   EFI_STATUS                  Status;
 323   UINTN                       DataSize;
 324   UINT8                       *Data;
 325   UINT8                       *OldData;
 326   UINT32                      Attr;
 327   UINT32                      Index;
 328   EFI_SIGNATURE_LIST          *CertList;
 329   EFI_SIGNATURE_LIST          *NewCertList;
 330   EFI_SIGNATURE_DATA          *Cert;
 331   UINTN                       CertCount;
 332   UINT32                      Offset;
 333   BOOLEAN                     IsItemFound;
 334   UINT32                      ItemDataSize;
 335   UINTN                       GuidIndex;
 336
 337   Data            = NULL;
 338   OldData         = NULL;
 339   CertList        = NULL;
 340   Cert            = NULL;
 341   Attr            = 0;
 342
 343   //
 344   // Get original signature list data.
 345   //
 346   DataSize = 0;
 347   Status = gRT->GetVariable (VariableName, VendorGuid, NULL, &DataSize, NULL);
 348   if (EFI_ERROR (Status) && Status != EFI_BUFFER_TOO_SMALL) {
 349     goto ON_EXIT;
 350   }
 351
 352   OldData = (UINT8 *) AllocateZeroPool (DataSize);
 353   if (OldData == NULL) {
 354     Status = EFI_OUT_OF_RESOURCES;
 355     goto ON_EXIT;
 356   }
 357
 358   Status = gRT->GetVariable (VariableName, VendorGuid, &Attr, &DataSize, OldData);
 359   if (EFI_ERROR(Status)) {
 360     goto ON_EXIT;
 361   }
 362
 363   //
 364   // Allocate space for new variable.
 365   //
 366   Data = (UINT8*) AllocateZeroPool (DataSize);
 367   if (Data == NULL) {
 368     Status  =  EFI_OUT_OF_RESOURCES;
 369     goto ON_EXIT;
 370   }
 371
 372   //
 373   // Enumerate all data and erasing the target item.
 374   //
 375   IsItemFound = FALSE;
 376   ItemDataSize = (UINT32) DataSize;
 377   CertList = (EFI_SIGNATURE_LIST *) OldData;
 378   Offset = 0;
 379   GuidIndex = 0;
 380   while ((ItemDataSize > 0) && (ItemDataSize >= CertList->SignatureListSize)) {
 381     if (CompareGuid (&CertList->SignatureType, &gEfiCertX509Guid)) {
 382       //
 383       // Copy EFI_SIGNATURE_LIST header then calculate the signature count in this list.
 384       //
 385       CopyMem (Data + Offset, CertList, (sizeof(EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize));
 386       NewCertList = (EFI_SIGNATURE_LIST*) (Data + Offset);
 387       Offset += (sizeof(EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);
 388       Cert      = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);
 389       CertCount  = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;
 390       for (Index = 0; Index < CertCount; Index++) {
 391         if (GuidIndex == DeleteIndex) {
 392           //
 393           // Find it! Skip it!
 394           //
 395           NewCertList->SignatureListSize -= CertList->SignatureSize;
 396           IsItemFound = TRUE;
 397         } else {
 398           //
 399           // This item doesn't match. Copy it to the Data buffer.
 400           //
 401           CopyMem (Data + Offset, (UINT8*)(Cert), CertList->SignatureSize);
 402           Offset += CertList->SignatureSize;
 403         }
 404         GuidIndex++;
 405         Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) Cert + CertList->SignatureSize);
 406       }
 407     } else {
 408       //
 409       // This List doesn't match. Just copy it to the Data buffer.
 410       //
 411       CopyMem (Data + Offset, (UINT8*)(CertList), CertList->SignatureListSize);
 412       Offset += CertList->SignatureListSize;
 413     }
 414
 415     ItemDataSize -= CertList->SignatureListSize;
 416     CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);
 417   }
 418
 419   if (!IsItemFound) {
 420     //
 421     // Doesn't find the signature Item!
 422     //
 423     Status = EFI_NOT_FOUND;
 424     goto ON_EXIT;
 425   }
 426
 427   //
 428   // Delete the EFI_SIGNATURE_LIST header if there is no signature in the list.
 429   //
 430   ItemDataSize = Offset;
 431   CertList = (EFI_SIGNATURE_LIST *) Data;
 432   Offset = 0;
 433   ZeroMem (OldData, ItemDataSize);
 434   while ((ItemDataSize > 0) && (ItemDataSize >= CertList->SignatureListSize)) {
 435     CertCount  = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;
 436     DEBUG ((DEBUG_INFO, "       CertCount = %x\n", CertCount));
 437     if (CertCount != 0) {
 438       CopyMem (OldData + Offset, (UINT8*)(CertList), CertList->SignatureListSize);
 439       Offset += CertList->SignatureListSize;
 440     }
 441     ItemDataSize -= CertList->SignatureListSize;
 442     CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);
 443   }
 444
 445   DataSize = Offset;
 446
 447   Status = gRT->SetVariable(
 448                   VariableName,
 449                   VendorGuid,
 450                   Attr,
 451                   DataSize,
 452                   OldData
 453                   );
 454   if (EFI_ERROR (Status)) {
 455     DEBUG ((DEBUG_ERROR, "Failed to set variable, Status = %r\n", Status));
 456     goto ON_EXIT;
 457   }
 458
 459 ON_EXIT:
 460   if (Data != NULL) {
 461     FreePool(Data);
 462   }
 463
 464   if (OldData != NULL) {
 465     FreePool(OldData);
 466   }
 467
 468   return UpdateDeletePage (
 469            Private,
 470            VariableName,
 471            VendorGuid,
 472            LabelNumber,
 473            FormId,
 474            QuestionIdBase
 475            );
 476 }
 477
 478
 479 /**
 480   Clean the file related resource.
 481
 482   @param[in]    Private             Module's private data.
 483
 484 **/
 485 VOID
 486 CleanFileContext (
 487   IN TLS_AUTH_CONFIG_PRIVATE_DATA     *Private
 488   )
 489 {
 490   if (Private->FileContext->FHandle != NULL) {
 491     Private->FileContext->FHandle->Close (Private->FileContext->FHandle);
 492     Private->FileContext->FHandle = NULL;
 493     if (Private->FileContext->FileName!= NULL){
 494       FreePool(Private->FileContext->FileName);
 495       Private->FileContext->FileName = NULL;
 496     }
 497   }
 498 }
 499
 500 /**
 501   Read file content into BufferPtr, the size of the allocate buffer
 502   is *FileSize plus AddtionAllocateSize.
 503
 504   @param[in]       FileHandle            The file to be read.
 505   @param[in, out]  BufferPtr             Pointers to the pointer of allocated buffer.
 506   @param[out]      FileSize              Size of input file
 507   @param[in]       AddtionAllocateSize   Addtion size the buffer need to be allocated.
 508                                          In case the buffer need to contain others besides the file content.
 509
 510   @retval   EFI_SUCCESS                  The file was read into the buffer.
 511   @retval   EFI_INVALID_PARAMETER        A parameter was invalid.
 512   @retval   EFI_OUT_OF_RESOURCES         A memory allocation failed.
 513   @retval   others                       Unexpected error.
 514
 515 **/
 516 EFI_STATUS
 517 ReadFileContent (
 518   IN      EFI_FILE_HANDLE           FileHandle,
 519   IN OUT  VOID                      **BufferPtr,
 520      OUT  UINTN                     *FileSize,
 521   IN      UINTN                     AddtionAllocateSize
 522   )
 523
 524 {
 525   UINTN      BufferSize;
 526   UINT64     SourceFileSize;
 527   VOID       *Buffer;
 528   EFI_STATUS Status;
 529
 530   if ((FileHandle == NULL) || (FileSize == NULL)) {
 531     return EFI_INVALID_PARAMETER;
 532   }
 533
 534   Buffer = NULL;
 535
 536   //
 537   // Get the file size
 538   //
 539   Status = FileHandle->SetPosition (FileHandle, (UINT64) -1);
 540   if (EFI_ERROR (Status)) {
 541     goto ON_EXIT;
 542   }
 543
 544   Status = FileHandle->GetPosition (FileHandle, &SourceFileSize);
 545   if (EFI_ERROR (Status)) {
 546     goto ON_EXIT;
 547   }
 548
 549   Status = FileHandle->SetPosition (FileHandle, 0);
 550   if (EFI_ERROR (Status)) {
 551     goto ON_EXIT;
 552   }
 553
 554   BufferSize = (UINTN) SourceFileSize + AddtionAllocateSize;
 555   Buffer =  AllocateZeroPool(BufferSize);
 556   if (Buffer == NULL) {
 557     return EFI_OUT_OF_RESOURCES;
 558   }
 559
 560   BufferSize = (UINTN) SourceFileSize;
 561   *FileSize  = BufferSize;
 562
 563   Status = FileHandle->Read (FileHandle, &BufferSize, Buffer);
 564   if (EFI_ERROR (Status) || BufferSize != *FileSize) {
 565     FreePool (Buffer);
 566     Buffer = NULL;
 567     Status  = EFI_BAD_BUFFER_SIZE;
 568     goto ON_EXIT;
 569   }
 570
 571 ON_EXIT:
 572
 573   *BufferPtr = Buffer;
 574   return Status;
 575 }
 576
 577 /**
 578   This function will open a file or directory referenced by DevicePath.
 579
 580   This function opens a file with the open mode according to the file path. The
 581   Attributes is valid only for EFI_FILE_MODE_CREATE.
 582
 583   @param[in, out]  FilePath        On input, the device path to the file.
 584                                    On output, the remaining device path.
 585   @param[out]      FileHandle      Pointer to the file handle.
 586   @param[in]       OpenMode        The mode to open the file with.
 587   @param[in]       Attributes      The file's file attributes.
 588
 589   @retval EFI_SUCCESS              The information was set.
 590   @retval EFI_INVALID_PARAMETER    One of the parameters has an invalid value.
 591   @retval EFI_UNSUPPORTED          Could not open the file path.
 592   @retval EFI_NOT_FOUND            The specified file could not be found on the
 593                                    device or the file system could not be found on
 594                                    the device.
 595   @retval EFI_NO_MEDIA             The device has no medium.
 596   @retval EFI_MEDIA_CHANGED        The device has a different medium in it or the
 597                                    medium is no longer supported.
 598   @retval EFI_DEVICE_ERROR         The device reported an error.
 599   @retval EFI_VOLUME_CORRUPTED     The file system structures are corrupted.
 600   @retval EFI_WRITE_PROTECTED      The file or medium is write protected.
 601   @retval EFI_ACCESS_DENIED        The file was opened read only.
 602   @retval EFI_OUT_OF_RESOURCES     Not enough resources were available to open the
 603                                    file.
 604   @retval EFI_VOLUME_FULL          The volume is full.
 605 **/
 606 EFI_STATUS
 607 EFIAPI
 608 OpenFileByDevicePath (
 609   IN OUT EFI_DEVICE_PATH_PROTOCOL     **FilePath,
 610   OUT EFI_FILE_HANDLE                 *FileHandle,
 611   IN UINT64                           OpenMode,
 612   IN UINT64                           Attributes
 613   )
 614 {
 615   EFI_STATUS                      Status;
 616   EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *EfiSimpleFileSystemProtocol;
 617   EFI_FILE_PROTOCOL               *Handle1;
 618   EFI_FILE_PROTOCOL               *Handle2;
 619   EFI_HANDLE                      DeviceHandle;
 620
 621   if ((FilePath == NULL || FileHandle == NULL)) {
 622     return EFI_INVALID_PARAMETER;
 623   }
 624
 625   Status = gBS->LocateDevicePath (
 626                   &gEfiSimpleFileSystemProtocolGuid,
 627                   FilePath,
 628                   &DeviceHandle
 629                   );
 630   if (EFI_ERROR (Status)) {
 631     return Status;
 632   }
 633
 634   Status = gBS->OpenProtocol(
 635                   DeviceHandle,
 636                   &gEfiSimpleFileSystemProtocolGuid,
 637                   (VOID**)&EfiSimpleFileSystemProtocol,
 638                   gImageHandle,
 639                   NULL,
 640                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 641                   );
 642   if (EFI_ERROR (Status)) {
 643     return Status;
 644   }
 645
 646   Status = EfiSimpleFileSystemProtocol->OpenVolume(EfiSimpleFileSystemProtocol, &Handle1);
 647   if (EFI_ERROR (Status)) {
 648     FileHandle = NULL;
 649     return Status;
 650   }
 651
 652   //
 653   // go down directories one node at a time.
 654   //
 655   while (!IsDevicePathEnd (*FilePath)) {
 656     //
 657     // For file system access each node should be a file path component
 658     //
 659     if (DevicePathType    (*FilePath) != MEDIA_DEVICE_PATH ||
 660         DevicePathSubType (*FilePath) != MEDIA_FILEPATH_DP
 661        ) {
 662       FileHandle = NULL;
 663       return (EFI_INVALID_PARAMETER);
 664     }
 665     //
 666     // Open this file path node
 667     //
 668     Handle2  = Handle1;
 669     Handle1 = NULL;
 670
 671     //
 672     // Try to test opening an existing file
 673     //
 674     Status = Handle2->Open (
 675                         Handle2,
 676                         &Handle1,
 677                         ((FILEPATH_DEVICE_PATH*)*FilePath)->PathName,
 678                         OpenMode &~EFI_FILE_MODE_CREATE,
 679                         0
 680                         );
 681
 682     //
 683     // see if the error was that it needs to be created
 684     //
 685     if ((EFI_ERROR (Status)) && (OpenMode != (OpenMode &~EFI_FILE_MODE_CREATE))) {
 686       Status = Handle2->Open (
 687                           Handle2,
 688                           &Handle1,
 689                           ((FILEPATH_DEVICE_PATH*)*FilePath)->PathName,
 690                           OpenMode,
 691                           Attributes
 692                           );
 693     }
 694     //
 695     // Close the last node
 696     //
 697     Handle2->Close (Handle2);
 698
 699     if (EFI_ERROR(Status)) {
 700       return (Status);
 701     }
 702
 703     //
 704     // Get the next node
 705     //
 706     *FilePath = NextDevicePathNode (*FilePath);
 707   }
 708
 709   //
 710   // This is a weak spot since if the undefined SHELL_FILE_HANDLE format changes this must change also!
 711   //
 712   *FileHandle = (VOID*)Handle1;
 713   return EFI_SUCCESS;
 714 }
 715
 716 /**
 717   This function converts an input device structure to a Unicode string.
 718
 719   @param[in] DevPath                  A pointer to the device path structure.
 720
 721   @return A new allocated Unicode string that represents the device path.
 722
 723 **/
 724 CHAR16 *
 725 EFIAPI
 726 DevicePathToStr (
 727   IN EFI_DEVICE_PATH_PROTOCOL     *DevPath
 728   )
 729 {
 730   return ConvertDevicePathToText (
 731            DevPath,
 732            FALSE,
 733            TRUE
 734            );
 735 }
 736
 737
 738 /**
 739   Extract filename from device path. The returned buffer is allocated using AllocateCopyPool.
 740   The caller is responsible for freeing the allocated buffer using FreePool(). If return NULL
 741   means not enough memory resource.
 742
 743   @param DevicePath       Device path.
 744
 745   @retval NULL            Not enough memory resourece for AllocateCopyPool.
 746   @retval Other           A new allocated string that represents the file name.
 747
 748 **/
 749 CHAR16 *
 750 ExtractFileNameFromDevicePath (
 751   IN   EFI_DEVICE_PATH_PROTOCOL *DevicePath
 752   )
 753 {
 754   CHAR16          *String;
 755   CHAR16          *MatchString;
 756   CHAR16          *LastMatch;
 757   CHAR16          *FileName;
 758   UINTN           Length;
 759
 760   ASSERT(DevicePath != NULL);
 761
 762   String = DevicePathToStr(DevicePath);
 763   MatchString = String;
 764   LastMatch   = String;
 765   FileName    = NULL;
 766
 767   while(MatchString != NULL){
 768     LastMatch   = MatchString + 1;
 769     MatchString = StrStr(LastMatch,L"\\");
 770   }
 771
 772   Length = StrLen(LastMatch);
 773   FileName = AllocateCopyPool ((Length + 1) * sizeof(CHAR16), LastMatch);
 774   if (FileName != NULL) {
 775     *(FileName + Length) = 0;
 776   }
 777
 778   FreePool(String);
 779
 780   return FileName;
 781 }
 782
 783 /**
 784   Enroll a new X509 certificate into Variable.
 785
 786   @param[in] PrivateData     The module's private data.
 787   @param[in] VariableName    Variable name of CA database.
 788
 789   @retval   EFI_SUCCESS            New X509 is enrolled successfully.
 790   @retval   EFI_OUT_OF_RESOURCES   Could not allocate needed resources.
 791
 792 **/
 793 EFI_STATUS
 794 EnrollX509toVariable (
 795   IN TLS_AUTH_CONFIG_PRIVATE_DATA   *Private,
 796   IN CHAR16                         *VariableName
 797   )
 798 {
 799   EFI_STATUS                        Status;
 800   UINTN                             X509DataSize;
 801   VOID                              *X509Data;
 802   EFI_SIGNATURE_LIST                *CACert;
 803   EFI_SIGNATURE_DATA                *CACertData;
 804   VOID                              *Data;
 805   UINTN                             DataSize;
 806   UINTN                             SigDataSize;
 807   UINT32                            Attr;
 808
 809   X509DataSize  = 0;
 810   SigDataSize   = 0;
 811   DataSize      = 0;
 812   X509Data      = NULL;
 813   CACert        = NULL;
 814   CACertData    = NULL;
 815   Data          = NULL;
 816
 817   Status = ReadFileContent (
 818              Private->FileContext->FHandle,
 819              &X509Data,
 820              &X509DataSize,
 821              0
 822              );
 823   if (EFI_ERROR (Status)) {
 824     goto ON_EXIT;
 825   }
 826   ASSERT (X509Data != NULL);
 827
 828   SigDataSize = sizeof(EFI_SIGNATURE_LIST) + sizeof(EFI_SIGNATURE_DATA) - 1 + X509DataSize;
 829
 830   Data = AllocateZeroPool (SigDataSize);
 831   if (Data == NULL) {
 832     Status = EFI_OUT_OF_RESOURCES;
 833     goto ON_EXIT;
 834   }
 835
 836   //
 837   // Fill Certificate Database parameters.
 838   //
 839   CACert = (EFI_SIGNATURE_LIST*) Data;
 840   CACert->SignatureListSize   = (UINT32) SigDataSize;
 841   CACert->SignatureHeaderSize = 0;
 842   CACert->SignatureSize = (UINT32) (sizeof(EFI_SIGNATURE_DATA) - 1 + X509DataSize);
 843   CopyGuid (&CACert->SignatureType, &gEfiCertX509Guid);
 844
 845   CACertData = (EFI_SIGNATURE_DATA*) ((UINT8* ) CACert + sizeof (EFI_SIGNATURE_LIST));
 846   CopyGuid (&CACertData->SignatureOwner, Private->CertGuid);
 847   CopyMem ((UINT8* ) (CACertData->SignatureData), X509Data, X509DataSize);
 848
 849   //
 850   // Check if signature database entry has been already existed.
 851   // If true, use EFI_VARIABLE_APPEND_WRITE attribute to append the
 852   // new signature data to original variable
 853   //
 854   Attr = TLS_AUTH_CONFIG_VAR_BASE_ATTR;
 855
 856   Status = gRT->GetVariable(
 857                   VariableName,
 858                   &gEfiTlsCaCertificateGuid,
 859                   NULL,
 860                   &DataSize,
 861                   NULL
 862                   );
 863   if (Status == EFI_BUFFER_TOO_SMALL) {
 864     Attr |= EFI_VARIABLE_APPEND_WRITE;
 865   } else if (Status != EFI_NOT_FOUND) {
 866     goto ON_EXIT;
 867   }
 868
 869   Status = gRT->SetVariable(
 870                   VariableName,
 871                   &gEfiTlsCaCertificateGuid,
 872                   Attr,
 873                   SigDataSize,
 874                   Data
 875                   );
 876   if (EFI_ERROR (Status)) {
 877     goto ON_EXIT;
 878   }
 879
 880 ON_EXIT:
 881   CleanFileContext (Private);
 882
 883   if (Private->CertGuid != NULL) {
 884     FreePool (Private->CertGuid);
 885     Private->CertGuid = NULL;
 886   }
 887
 888   if (Data != NULL) {
 889     FreePool (Data);
 890   }
 891
 892   if (X509Data != NULL) {
 893     FreePool (X509Data);
 894   }
 895
 896   return Status;
 897 }
 898
 899 /**
 900   Enroll Cert into TlsCaCertificate. The GUID will be Private->CertGuid.
 901
 902   @param[in] PrivateData     The module's private data.
 903   @param[in] VariableName    Variable name of signature database.
 904
 905   @retval   EFI_SUCCESS            New Cert enrolled successfully.
 906   @retval   EFI_INVALID_PARAMETER  The parameter is invalid.
 907   @retval   EFI_UNSUPPORTED        The Cert file is unsupported type.
 908   @retval   others                 Fail to enroll Cert data.
 909
 910 **/
 911 EFI_STATUS
 912 EnrollCertDatabase (
 913   IN TLS_AUTH_CONFIG_PRIVATE_DATA  *Private,
 914   IN CHAR16                        *VariableName
 915   )
 916 {
 917   UINT16*      FilePostFix;
 918   UINTN        NameLength;
 919
 920   if ((Private->FileContext->FileName == NULL) || (Private->FileContext->FHandle == NULL) || (Private->CertGuid == NULL)) {
 921     return EFI_INVALID_PARAMETER;
 922   }
 923
 924   //
 925   // Parse the file's postfix.
 926   //
 927   NameLength = StrLen (Private->FileContext->FileName);
 928   if (NameLength <= 4) {
 929     return EFI_INVALID_PARAMETER;
 930   }
 931   FilePostFix = Private->FileContext->FileName + NameLength - 4;
 932
 933   if (IsDerPemEncodeCertificate (FilePostFix)) {
 934     //
 935     // Supports DER-encoded X509 certificate.
 936     //
 937     return EnrollX509toVariable (Private, VariableName);
 938   }
 939
 940   return EFI_UNSUPPORTED;
 941 }
 942
 943 /**
 944   Refresh the global UpdateData structure.
 945
 946 **/
 947 VOID
 948 RefreshUpdateData (
 949   VOID
 950   )
 951 {
 952   //
 953   // Free current updated date
 954   //
 955   if (mStartOpCodeHandle != NULL) {
 956     HiiFreeOpCodeHandle (mStartOpCodeHandle);
 957   }
 958
 959   //
 960   // Create new OpCode Handle
 961   //
 962   mStartOpCodeHandle = HiiAllocateOpCodeHandle ();
 963
 964   //
 965   // Create Hii Extend Label OpCode as the start opcode
 966   //
 967   mStartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
 968                                          mStartOpCodeHandle,
 969                                          &gEfiIfrTianoGuid,
 970                                          NULL,
 971                                          sizeof (EFI_IFR_GUID_LABEL)
 972                                          );
 973   mStartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
 974 }
 975
 976 /**
 977   Clean up the dynamic opcode at label and form specified by both LabelId.
 978
 979   @param[in] LabelId         It is both the Form ID and Label ID for opcode deletion.
 980   @param[in] PrivateData     Module private data.
 981
 982 **/
 983 VOID
 984 CleanUpPage (
 985   IN UINT16                           LabelId,
 986   IN TLS_AUTH_CONFIG_PRIVATE_DATA     *PrivateData
 987   )
 988 {
 989   RefreshUpdateData ();
 990
 991   //
 992   // Remove all op-codes from dynamic page
 993   //
 994   mStartLabel->Number = LabelId;
 995   HiiUpdateForm (
 996     PrivateData->RegisteredHandle,
 997     &gTlsAuthConfigGuid,
 998     LabelId,
 999     mStartOpCodeHandle, // Label LabelId
1000     mEndOpCodeHandle    // LABEL_END
1001     );
1002 }
1003
1004 /**
1005   Update the form base on the selected file.
1006
1007   @param FilePath   Point to the file path.
1008   @param FormId     The form need to display.
1009
1010   @retval TRUE   Exit caller function.
1011   @retval FALSE  Not exit caller function.
1012
1013 **/
1014 BOOLEAN
1015 UpdatePage(
1016   IN  EFI_DEVICE_PATH_PROTOCOL  *FilePath,
1017   IN  EFI_FORM_ID               FormId
1018   )
1019 {
1020   CHAR16                *FileName;
1021   EFI_STRING_ID         StringToken;
1022
1023   FileName = NULL;
1024
1025   if (FilePath != NULL) {
1026     FileName = ExtractFileNameFromDevicePath(FilePath);
1027   }
1028   if (FileName == NULL) {
1029     //
1030     // FileName = NULL has two case:
1031     // 1. FilePath == NULL, not select file.
1032     // 2. FilePath != NULL, but ExtractFileNameFromDevicePath return NULL not enough memory resource.
1033     // In these two case, no need to update the form, and exit the caller function.
1034     //
1035     return TRUE;
1036   }
1037   StringToken =  HiiSetString (mTlsAuthPrivateData->RegisteredHandle, 0, FileName, NULL);
1038
1039   mTlsAuthPrivateData->FileContext->FileName = FileName;
1040
1041   OpenFileByDevicePath (
1042     &FilePath,
1043     &mTlsAuthPrivateData->FileContext->FHandle,
1044     EFI_FILE_MODE_READ,
1045     0
1046     );
1047   //
1048   // Create Subtitle op-code for the display string of the option.
1049   //
1050   RefreshUpdateData ();
1051   mStartLabel->Number = FormId;
1052
1053   HiiCreateSubTitleOpCode (
1054     mStartOpCodeHandle,
1055     StringToken,
1056     0,
1057     0,
1058     0
1059    );
1060
1061   HiiUpdateForm (
1062     mTlsAuthPrivateData->RegisteredHandle,
1063     &gTlsAuthConfigGuid,
1064     FormId,
1065     mStartOpCodeHandle, /// Label FormId
1066     mEndOpCodeHandle    /// LABEL_END
1067     );
1068
1069   return TRUE;
1070 }
1071
1072 /**
1073   Update the form base on the input file path info.
1074
1075   @param FilePath    Point to the file path.
1076
1077   @retval TRUE   Exit caller function.
1078   @retval FALSE  Not exit caller function.
1079 **/
1080 BOOLEAN
1081 EFIAPI
1082 UpdateCAFromFile (
1083   IN EFI_DEVICE_PATH_PROTOCOL    *FilePath
1084   )
1085 {
1086   return UpdatePage(FilePath, TLS_AUTH_CONFIG_FORMID4_FORM);
1087 }
1088
1089 /**
1090   Unload the configuration form, this includes: delete all the configuration
1091   entries, uninstall the form callback protocol, and free the resources used.
1092
1093   @param[in]  Private             Pointer to the driver private data.
1094
1095   @retval EFI_SUCCESS             The configuration form is unloaded.
1096   @retval Others                  Failed to unload the form.
1097
1098 **/
1099 EFI_STATUS
1100 TlsAuthConfigFormUnload (
1101   IN TLS_AUTH_CONFIG_PRIVATE_DATA     *Private
1102   )
1103 {
1104   if (Private->DriverHandle != NULL) {
1105     //
1106     // Uninstall EFI_HII_CONFIG_ACCESS_PROTOCOL
1107     //
1108     gBS->UninstallMultipleProtocolInterfaces (
1109            Private->DriverHandle,
1110            &gEfiDevicePathProtocolGuid,
1111            &mTlsAuthConfigHiiVendorDevicePath,
1112            &gEfiHiiConfigAccessProtocolGuid,
1113            &Private->ConfigAccess,
1114            NULL
1115            );
1116     Private->DriverHandle = NULL;
1117   }
1118
1119   if (Private->RegisteredHandle != NULL) {
1120     //
1121     // Remove HII package list
1122     //
1123     HiiRemovePackages (Private->RegisteredHandle);
1124     Private->RegisteredHandle = NULL;
1125   }
1126
1127   if (Private->CertGuid != NULL) {
1128     FreePool (Private->CertGuid);
1129   }
1130
1131   if (Private->FileContext != NULL) {
1132     FreePool (Private->FileContext);
1133   }
1134
1135   FreePool (Private);
1136
1137   if (mStartOpCodeHandle != NULL) {
1138     HiiFreeOpCodeHandle (mStartOpCodeHandle);
1139   }
1140
1141   if (mEndOpCodeHandle != NULL) {
1142     HiiFreeOpCodeHandle (mEndOpCodeHandle);
1143   }
1144
1145   return EFI_SUCCESS;
1146 }
1147
1148
1149 /**
1150   Initialize the configuration form.
1151
1152   @param[in]  Private             Pointer to the driver private data.
1153
1154   @retval EFI_SUCCESS             The configuration form is initialized.
1155   @retval EFI_OUT_OF_RESOURCES    Failed to allocate memory.
1156
1157 **/
1158 EFI_STATUS
1159 TlsAuthConfigFormInit (
1160   IN TLS_AUTH_CONFIG_PRIVATE_DATA     *Private
1161   )
1162 {
1163   EFI_STATUS                        Status;
1164
1165   Private->Signature = TLS_AUTH_CONFIG_PRIVATE_DATA_SIGNATURE;
1166
1167   Private->ConfigAccess.ExtractConfig = TlsAuthConfigAccessExtractConfig;
1168   Private->ConfigAccess.RouteConfig   = TlsAuthConfigAccessRouteConfig;
1169   Private->ConfigAccess.Callback      = TlsAuthConfigAccessCallback;
1170
1171   //
1172   // Install Device Path Protocol and Config Access protocol to driver handle.
1173   //
1174   Status = gBS->InstallMultipleProtocolInterfaces (
1175                   &Private->DriverHandle,
1176                   &gEfiDevicePathProtocolGuid,
1177                   &mTlsAuthConfigHiiVendorDevicePath,
1178                   &gEfiHiiConfigAccessProtocolGuid,
1179                   &Private->ConfigAccess,
1180                   NULL
1181                   );
1182   if (EFI_ERROR (Status)) {
1183     return Status;
1184   }
1185
1186   //
1187   // Publish our HII data.
1188   //
1189   Private->RegisteredHandle = HiiAddPackages (
1190                                 &gTlsAuthConfigGuid,
1191                                 Private->DriverHandle,
1192                                 TlsAuthConfigDxeStrings,
1193                                 TlsAuthConfigVfrBin,
1194                                 NULL
1195                                 );
1196   if (Private->RegisteredHandle == NULL) {
1197     Status = EFI_OUT_OF_RESOURCES;
1198     goto Error;
1199   }
1200
1201   Private->FileContext = AllocateZeroPool (sizeof (TLS_AUTH_CONFIG_FILE_CONTEXT));
1202   if (Private->FileContext == NULL) {
1203     Status = EFI_OUT_OF_RESOURCES;
1204     goto Error;
1205   }
1206
1207   //
1208   // Init OpCode Handle and Allocate space for creation of Buffer
1209   //
1210   mStartOpCodeHandle = HiiAllocateOpCodeHandle ();
1211   if (mStartOpCodeHandle == NULL) {
1212     Status = EFI_OUT_OF_RESOURCES;
1213     goto Error;
1214   }
1215
1216   mEndOpCodeHandle = HiiAllocateOpCodeHandle ();
1217   if (mEndOpCodeHandle == NULL) {
1218     Status = EFI_OUT_OF_RESOURCES;
1219     goto Error;
1220   }
1221
1222   //
1223   // Create Hii Extend Label OpCode as the start opcode
1224   //
1225   mStartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
1226                                          mStartOpCodeHandle,
1227                                          &gEfiIfrTianoGuid,
1228                                          NULL,
1229                                          sizeof (EFI_IFR_GUID_LABEL)
1230                                          );
1231   mStartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1232
1233   //
1234   // Create Hii Extend Label OpCode as the end opcode
1235   //
1236   mEndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
1237                                        mEndOpCodeHandle,
1238                                        &gEfiIfrTianoGuid,
1239                                        NULL,
1240                                        sizeof (EFI_IFR_GUID_LABEL)
1241                                        );
1242   mEndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1243   mEndLabel->Number       = LABEL_END;
1244
1245   return EFI_SUCCESS;
1246
1247 Error:
1248   TlsAuthConfigFormUnload (Private);
1249   return Status;
1250 }
1251
1252 /**
1253
1254   This function allows the caller to request the current
1255   configuration for one or more named elements. The resulting
1256   string is in <ConfigAltResp> format. Any and all alternative
1257   configuration strings shall also be appended to the end of the
1258   current configuration string. If they are, they must appear
1259   after the current configuration. They must contain the same
1260   routing (GUID, NAME, PATH) as the current configuration string.
1261   They must have an additional description indicating the type of
1262   alternative configuration the string represents,
1263   "ALTCFG=<StringToken>". That <StringToken> (when
1264   converted from Hex UNICODE to binary) is a reference to a
1265   string in the associated string pack.
1266
1267   @param This       Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1268
1269   @param Request    A null-terminated Unicode string in
1270                     <ConfigRequest> format. Note that this
1271                     includes the routing information as well as
1272                     the configurable name / value pairs. It is
1273                     invalid for this string to be in
1274                     <MultiConfigRequest> format.
1275                     If a NULL is passed in for the Request field,
1276                     all of the settings being abstracted by this function
1277                     will be returned in the Results field.  In addition,
1278                     if a ConfigHdr is passed in with no request elements,
1279                     all of the settings being abstracted for that particular
1280                     ConfigHdr reference will be returned in the Results Field.
1281
1282   @param Progress   On return, points to a character in the
1283                     Request string. Points to the string's null
1284                     terminator if request was successful. Points
1285                     to the most recent "&" before the first
1286                     failing name / value pair (or the beginning
1287                     of the string if the failure is in the first
1288                     name / value pair) if the request was not
1289                     successful.
1290
1291   @param Results    A null-terminated Unicode string in
1292                     <MultiConfigAltResp> format which has all values
1293                     filled in for the names in the Request string.
1294                     String to be allocated by the called function.
1295
1296   @retval EFI_SUCCESS             The Results string is filled with the
1297                                   values corresponding to all requested
1298                                   names.
1299
1300   @retval EFI_OUT_OF_RESOURCES    Not enough memory to store the
1301                                   parts of the results that must be
1302                                   stored awaiting possible future
1303                                   protocols.
1304
1305   @retval EFI_NOT_FOUND           Routing data doesn't match any
1306                                   known driver. Progress set to the
1307                                   first character in the routing header.
1308                                   Note: There is no requirement that the
1309                                   driver validate the routing data. It
1310                                   must skip the <ConfigHdr> in order to
1311                                   process the names.
1312
1313   @retval EFI_INVALID_PARAMETER   Illegal syntax. Progress set
1314                                   to most recent "&" before the
1315                                   error or the beginning of the
1316                                   string.
1317
1318   @retval EFI_INVALID_PARAMETER   Unknown name. Progress points
1319                                   to the & before the name in
1320                                   question.
1321
1322 **/
1323 EFI_STATUS
1324 EFIAPI
1325 TlsAuthConfigAccessExtractConfig (
1326   IN CONST  EFI_HII_CONFIG_ACCESS_PROTOCOL  *This,
1327   IN CONST  EFI_STRING                      Request,
1328   OUT       EFI_STRING                      *Progress,
1329   OUT       EFI_STRING                      *Results
1330   )
1331 {
1332   EFI_STATUS                        Status;
1333   UINTN                             BufferSize;
1334   UINTN                             Size;
1335   EFI_STRING                        ConfigRequest;
1336   EFI_STRING                        ConfigRequestHdr;
1337   TLS_AUTH_CONFIG_PRIVATE_DATA      *Private;
1338   BOOLEAN                           AllocatedRequest;
1339
1340   if (Progress == NULL || Results == NULL) {
1341     return EFI_INVALID_PARAMETER;
1342   }
1343
1344   AllocatedRequest = FALSE;
1345   ConfigRequestHdr = NULL;
1346   ConfigRequest    = NULL;
1347   Size             = 0;
1348
1349   Private          = TLS_AUTH_CONFIG_PRIVATE_FROM_THIS (This);
1350
1351   BufferSize       = sizeof (TLS_AUTH_CONFIG_IFR_NVDATA);
1352   ZeroMem (&Private->TlsAuthConfigNvData, BufferSize);
1353
1354   *Progress        = Request;
1355
1356   if ((Request != NULL) && !HiiIsConfigHdrMatch (Request, &gTlsAuthConfigGuid, mTlsAuthConfigStorageName)) {
1357     return EFI_NOT_FOUND;
1358   }
1359
1360   ConfigRequest = Request;
1361   if ((Request == NULL) || (StrStr (Request, L"OFFSET") == NULL)) {
1362     //
1363     // Request is set to NULL or OFFSET is NULL, construct full request string.
1364     //
1365     // Allocate and fill a buffer large enough to hold the <ConfigHdr> template
1366     // followed by "&OFFSET=0&WIDTH=WWWWWWWWWWWWWWWW" followed by a Null-terminator
1367     //
1368     ConfigRequestHdr = HiiConstructConfigHdr (&gTlsAuthConfigGuid, mTlsAuthConfigStorageName, Private->DriverHandle);
1369     Size = (StrLen (ConfigRequestHdr) + 32 + 1) * sizeof (CHAR16);
1370     ConfigRequest = AllocateZeroPool (Size);
1371     ASSERT (ConfigRequest != NULL);
1372     AllocatedRequest = TRUE;
1373     UnicodeSPrint (ConfigRequest, Size, L"%s&OFFSET=0&WIDTH=%016LX", ConfigRequestHdr, (UINT64)BufferSize);
1374     FreePool (ConfigRequestHdr);
1375     ConfigRequestHdr = NULL;
1376   }
1377
1378   Status = gHiiConfigRouting->BlockToConfig (
1379                                 gHiiConfigRouting,
1380                                 ConfigRequest,
1381                                 (UINT8 *) &Private->TlsAuthConfigNvData,
1382                                 BufferSize,
1383                                 Results,
1384                                 Progress
1385                                 );
1386
1387   //
1388   // Free the allocated config request string.
1389   //
1390   if (AllocatedRequest) {
1391     FreePool (ConfigRequest);
1392   }
1393
1394   //
1395   // Set Progress string to the original request string.
1396   //
1397   if (Request == NULL) {
1398     *Progress = NULL;
1399   } else if (StrStr (Request, L"OFFSET") == NULL) {
1400     *Progress = Request + StrLen (Request);
1401   }
1402
1403   return Status;
1404 }
1405
1406 /**
1407
1408   This function applies changes in a driver's configuration.
1409   Input is a Configuration, which has the routing data for this
1410   driver followed by name / value configuration pairs. The driver
1411   must apply those pairs to its configurable storage. If the
1412   driver's configuration is stored in a linear block of data
1413   and the driver's name / value pairs are in <BlockConfig>
1414   format, it may use the ConfigToBlock helper function (above) to
1415   simplify the job.
1416
1417   @param This           Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1418
1419   @param Configuration  A null-terminated Unicode string in
1420                         <ConfigString> format.
1421
1422   @param Progress       A pointer to a string filled in with the
1423                         offset of the most recent '&' before the
1424                         first failing name / value pair (or the
1425                         beginn ing of the string if the failure
1426                         is in the first name / value pair) or
1427                         the terminating NULL if all was
1428                         successful.
1429
1430   @retval EFI_SUCCESS             The results have been distributed or are
1431                                   awaiting distribution.
1432
1433   @retval EFI_OUT_OF_RESOURCES    Not enough memory to store the
1434                                   parts of the results that must be
1435                                   stored awaiting possible future
1436                                   protocols.
1437
1438   @retval EFI_INVALID_PARAMETERS  Passing in a NULL for the
1439                                   Results parameter would result
1440                                   in this type of error.
1441
1442   @retval EFI_NOT_FOUND           Target for the specified routing data
1443                                   was not found
1444
1445 **/
1446 EFI_STATUS
1447 EFIAPI
1448 TlsAuthConfigAccessRouteConfig (
1449   IN CONST  EFI_HII_CONFIG_ACCESS_PROTOCOL  *This,
1450   IN CONST  EFI_STRING                      Configuration,
1451   OUT       EFI_STRING                      *Progress
1452   )
1453 {
1454   EFI_STATUS                       Status;
1455   UINTN                            BufferSize;
1456   TLS_AUTH_CONFIG_PRIVATE_DATA     *Private;
1457
1458   if (Progress == NULL) {
1459     return EFI_INVALID_PARAMETER;
1460   }
1461   *Progress = Configuration;
1462
1463   if (Configuration == NULL) {
1464     return EFI_INVALID_PARAMETER;
1465   }
1466
1467   //
1468   // Check routing data in <ConfigHdr>.
1469   // Note: there is no name for Name/Value storage, only GUID will be checked
1470   //
1471   if (!HiiIsConfigHdrMatch (Configuration, &gTlsAuthConfigGuid, mTlsAuthConfigStorageName)) {
1472     return EFI_NOT_FOUND;
1473   }
1474
1475   Private = TLS_AUTH_CONFIG_PRIVATE_FROM_THIS (This);
1476
1477   BufferSize = sizeof (TLS_AUTH_CONFIG_IFR_NVDATA);
1478   ZeroMem (&Private->TlsAuthConfigNvData, BufferSize);
1479
1480   Status = gHiiConfigRouting->ConfigToBlock (
1481                                 gHiiConfigRouting,
1482                                 Configuration,
1483                                 (UINT8 *) &Private->TlsAuthConfigNvData,
1484                                 &BufferSize,
1485                                 Progress
1486                                 );
1487   if (EFI_ERROR (Status)) {
1488     return Status;
1489   }
1490
1491   return Status;
1492 }
1493
1494 /**
1495
1496   This function is called to provide results data to the driver.
1497   This data consists of a unique key that is used to identify
1498   which data is either being passed back or being asked for.
1499
1500   @param  This                   Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1501   @param  Action                 Specifies the type of action taken by the browser.
1502   @param  QuestionId             A unique value which is sent to the original
1503                                  exporting driver so that it can identify the type
1504                                  of data to expect. The format of the data tends to
1505                                  vary based on the opcode that generated the callback.
1506   @param  Type                   The type of value for the question.
1507   @param  Value                  A pointer to the data being sent to the original
1508                                  exporting driver.
1509   @param  ActionRequest          On return, points to the action requested by the
1510                                  callback function.
1511
1512   @retval EFI_SUCCESS            The callback successfully handled the action.
1513   @retval EFI_OUT_OF_RESOURCES   Not enough storage is available to hold the
1514                                  variable and its data.
1515   @retval EFI_DEVICE_ERROR       The variable could not be saved.
1516   @retval EFI_UNSUPPORTED        The specified Action is not supported by the
1517                                  callback.
1518 **/
1519 EFI_STATUS
1520 EFIAPI
1521 TlsAuthConfigAccessCallback (
1522   IN     CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
1523   IN     EFI_BROWSER_ACTION                     Action,
1524   IN     EFI_QUESTION_ID                        QuestionId,
1525   IN     UINT8                                  Type,
1526   IN OUT EFI_IFR_TYPE_VALUE                     *Value,
1527   OUT    EFI_BROWSER_ACTION_REQUEST             *ActionRequest
1528   )
1529 {
1530   EFI_INPUT_KEY                   Key;
1531   EFI_STATUS                      Status;
1532   RETURN_STATUS                   RStatus;
1533   TLS_AUTH_CONFIG_PRIVATE_DATA    *Private;
1534   UINTN                           BufferSize;
1535   TLS_AUTH_CONFIG_IFR_NVDATA      *IfrNvData;
1536   UINT16                          LabelId;
1537   EFI_DEVICE_PATH_PROTOCOL        *File;
1538
1539   Status           = EFI_SUCCESS;
1540   File             = NULL;
1541
1542   if ((This == NULL) || (Value == NULL) || (ActionRequest == NULL)) {
1543     return EFI_INVALID_PARAMETER;
1544   }
1545
1546   Private = TLS_AUTH_CONFIG_PRIVATE_FROM_THIS (This);
1547
1548   mTlsAuthPrivateData = Private;
1549
1550   //
1551   // Retrieve uncommitted data from Browser
1552   //
1553   BufferSize = sizeof (TLS_AUTH_CONFIG_IFR_NVDATA);
1554   IfrNvData = AllocateZeroPool (BufferSize);
1555   if (IfrNvData == NULL) {
1556     return EFI_OUT_OF_RESOURCES;
1557   }
1558
1559   HiiGetBrowserData (&gTlsAuthConfigGuid, mTlsAuthConfigStorageName, BufferSize, (UINT8 *) IfrNvData);
1560
1561   if ((Action != EFI_BROWSER_ACTION_CHANGED) &&
1562       (Action != EFI_BROWSER_ACTION_CHANGING) &&
1563       (Action != EFI_BROWSER_ACTION_FORM_CLOSE)) {
1564     Status = EFI_UNSUPPORTED;
1565     goto EXIT;
1566   }
1567
1568   if (Action == EFI_BROWSER_ACTION_CHANGING) {
1569     switch (QuestionId) {
1570     case KEY_TLS_AUTH_CONFIG_CLIENT_CERT:
1571     case KEY_TLS_AUTH_CONFIG_SERVER_CA:
1572       //
1573       // Clear Cert GUID.
1574       //
1575       ZeroMem (IfrNvData->CertGuid, sizeof (IfrNvData->CertGuid));
1576       if (Private->CertGuid == NULL) {
1577         Private->CertGuid = (EFI_GUID *) AllocateZeroPool (sizeof (EFI_GUID));
1578         if (Private->CertGuid == NULL) {
1579           return EFI_OUT_OF_RESOURCES;
1580         }
1581       }
1582       if (QuestionId == KEY_TLS_AUTH_CONFIG_CLIENT_CERT) {
1583         LabelId = TLS_AUTH_CONFIG_FORMID3_FORM;
1584       } else {
1585         LabelId = TLS_AUTH_CONFIG_FORMID4_FORM;
1586       }
1587
1588       //
1589       // Refresh selected file.
1590       //
1591       CleanUpPage (LabelId, Private);
1592       break;
1593     case KEY_TLS_AUTH_CONFIG_ENROLL_CERT_FROM_FILE:
1594       //
1595       // If the file is already opened, clean the file related resource first.
1596       //
1597       CleanFileContext (Private);
1598
1599       ChooseFile( NULL, NULL, UpdateCAFromFile, &File);
1600       break;
1601
1602     case KEY_TLS_AUTH_CONFIG_VALUE_SAVE_AND_EXIT:
1603       Status = EnrollCertDatabase (Private, EFI_TLS_CA_CERTIFICATE_VARIABLE);
1604       if (EFI_ERROR (Status)) {
1605         CleanFileContext (Private);
1606
1607         CreatePopUp (
1608           EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
1609           &Key,
1610           L"ERROR: Enroll Cert Failure!",
1611           NULL
1612           );
1613       }
1614       break;
1615
1616     case KEY_TLS_AUTH_CONFIG_VALUE_NO_SAVE_AND_EXIT:
1617       CleanFileContext (Private);
1618
1619       if (Private->CertGuid!= NULL) {
1620         FreePool (Private->CertGuid);
1621         Private->CertGuid = NULL;
1622       }
1623       break;
1624
1625     case KEY_TLS_AUTH_CONFIG_DELETE_CERT:
1626       UpdateDeletePage (
1627         Private,
1628         EFI_TLS_CA_CERTIFICATE_VARIABLE,
1629         &gEfiTlsCaCertificateGuid,
1630         LABEL_CA_DELETE,
1631         TLS_AUTH_CONFIG_FORMID5_FORM,
1632         OPTION_DEL_CA_ESTION_ID
1633         );
1634        break;
1635
1636     default:
1637       if ((QuestionId >= OPTION_DEL_CA_ESTION_ID) &&
1638                  (QuestionId < (OPTION_DEL_CA_ESTION_ID + OPTION_CONFIG_RANGE)))  {
1639         DeleteCert (
1640           Private,
1641           EFI_TLS_CA_CERTIFICATE_VARIABLE,
1642           &gEfiTlsCaCertificateGuid,
1643           LABEL_CA_DELETE,
1644           TLS_AUTH_CONFIG_FORMID5_FORM,
1645           OPTION_DEL_CA_ESTION_ID,
1646           QuestionId - OPTION_DEL_CA_ESTION_ID
1647           );
1648       }
1649       break;
1650     }
1651   } else if (Action == EFI_BROWSER_ACTION_CHANGED) {
1652     switch (QuestionId) {
1653     case KEY_TLS_AUTH_CONFIG_CERT_GUID:
1654       ASSERT (Private->CertGuid != NULL);
1655       RStatus = StrToGuid (
1656                   IfrNvData->CertGuid,
1657                   Private->CertGuid
1658                   );
1659       if (RETURN_ERROR (RStatus) || (IfrNvData->CertGuid[GUID_STRING_LENGTH] != L'\0')) {
1660         Status = EFI_INVALID_PARAMETER;
1661         break;
1662       }
1663
1664       *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY;
1665       break;
1666     default:
1667       break;
1668     }
1669   } else if (Action == EFI_BROWSER_ACTION_FORM_CLOSE) {
1670     CleanFileContext (Private);
1671   }
1672
1673 EXIT:
1674
1675   if (!EFI_ERROR (Status)) {
1676     BufferSize = sizeof (TLS_AUTH_CONFIG_IFR_NVDATA);
1677     HiiSetBrowserData (&gTlsAuthConfigGuid, mTlsAuthConfigStorageName, BufferSize, (UINT8*) IfrNvData, NULL);
1678   }
1679
1680   FreePool (IfrNvData);
1681
1682   if (File != NULL){
1683     FreePool(File);
1684     File = NULL;
1685   }
1686
1687   return EFI_SUCCESS;
1688
1689 }
1690