NetworkPkg/HttpBootDxe/HttpBootConfig.c

   1 /** @file
   2   Helper functions for configuring or getting the parameters relating to HTTP Boot.
   3
   4 Copyright (c) 2016 - 2018, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "HttpBootDxe.h"
  16 #include <Library/UefiBootManagerLib.h>
  17
  18 CHAR16  mHttpBootConfigStorageName[]     = L"HTTP_BOOT_CONFIG_IFR_NVDATA";
  19
  20 /**
  21   Add new boot option for HTTP boot.
  22
  23   @param[in]  Private             Pointer to the driver private data.
  24   @param[in]  UsingIpv6           Set to TRUE if creating boot option for IPv6.
  25   @param[in]  Description         The description text of the boot option.
  26   @param[in]  Uri                 The URI string of the boot file.
  27
  28   @retval EFI_SUCCESS             The boot option is created successfully.
  29   @retval Others                  Failed to create new boot option.
  30
  31 **/
  32 EFI_STATUS
  33 HttpBootAddBootOption (
  34   IN   HTTP_BOOT_PRIVATE_DATA   *Private,
  35   IN   BOOLEAN                  UsingIpv6,
  36   IN   CHAR16                   *Description,
  37   IN   CHAR16                   *Uri
  38   )
  39 {
  40   EFI_DEV_PATH                      *Node;
  41   EFI_DEVICE_PATH_PROTOCOL          *TmpDevicePath;
  42   EFI_DEVICE_PATH_PROTOCOL          *NewDevicePath;
  43   UINTN                             Length;
  44   CHAR8                             AsciiUri[URI_STR_MAX_SIZE];
  45   EFI_STATUS                        Status;
  46   UINTN                             Index;
  47   EFI_BOOT_MANAGER_LOAD_OPTION      NewOption;
  48
  49   NewDevicePath = NULL;
  50   Node          = NULL;
  51   TmpDevicePath = NULL;
  52
  53   if (StrLen (Description) == 0) {
  54     return EFI_INVALID_PARAMETER;
  55   }
  56
  57   //
  58   // Convert the scheme to all lower case.
  59   //
  60   for (Index = 0; Index < StrLen (Uri); Index++) {
  61     if (Uri[Index] == L':') {
  62       break;
  63     }
  64     if (Uri[Index] >= L'A' && Uri[Index] <= L'Z') {
  65       Uri[Index] -= (CHAR16)(L'A' - L'a');
  66     }
  67   }
  68
  69   //
  70   // Only accept empty URI, or http and https URI.
  71   //
  72   if ((StrLen (Uri) != 0) && (StrnCmp (Uri, L"http://", 7) != 0) && (StrnCmp (Uri, L"https://", 8) != 0)) {
  73     return EFI_INVALID_PARAMETER;
  74   }
  75
  76   //
  77   // Create a new device path by appending the IP node and URI node to
  78   // the driver's parent device path
  79   //
  80   if (!UsingIpv6) {
  81     Node = AllocateZeroPool (sizeof (IPv4_DEVICE_PATH));
  82     if (Node == NULL) {
  83       Status = EFI_OUT_OF_RESOURCES;
  84       goto ON_EXIT;
  85     }
  86     Node->Ipv4.Header.Type    = MESSAGING_DEVICE_PATH;
  87     Node->Ipv4.Header.SubType = MSG_IPv4_DP;
  88     SetDevicePathNodeLength (Node, sizeof (IPv4_DEVICE_PATH));
  89   } else {
  90     Node = AllocateZeroPool (sizeof (IPv6_DEVICE_PATH));
  91     if (Node == NULL) {
  92       Status = EFI_OUT_OF_RESOURCES;
  93       goto ON_EXIT;
  94     }
  95     Node->Ipv6.Header.Type     = MESSAGING_DEVICE_PATH;
  96     Node->Ipv6.Header.SubType  = MSG_IPv6_DP;
  97     SetDevicePathNodeLength (Node, sizeof (IPv6_DEVICE_PATH));
  98   }
  99   TmpDevicePath = AppendDevicePathNode (Private->ParentDevicePath, (EFI_DEVICE_PATH_PROTOCOL*) Node);
 100   FreePool (Node);
 101   if (TmpDevicePath == NULL) {
 102     return EFI_OUT_OF_RESOURCES;
 103   }
 104   //
 105   // Update the URI node with the input boot file URI.
 106   //
 107   UnicodeStrToAsciiStrS (Uri, AsciiUri, sizeof (AsciiUri));
 108   Length = sizeof (EFI_DEVICE_PATH_PROTOCOL) + AsciiStrSize (AsciiUri);
 109   Node = AllocatePool (Length);
 110   if (Node == NULL) {
 111     Status = EFI_OUT_OF_RESOURCES;
 112     FreePool (TmpDevicePath);
 113     goto ON_EXIT;
 114   }
 115   Node->DevPath.Type    = MESSAGING_DEVICE_PATH;
 116   Node->DevPath.SubType = MSG_URI_DP;
 117   SetDevicePathNodeLength (Node, Length);
 118   CopyMem ((UINT8*) Node + sizeof (EFI_DEVICE_PATH_PROTOCOL), AsciiUri, AsciiStrSize (AsciiUri));
 119   NewDevicePath = AppendDevicePathNode (TmpDevicePath, (EFI_DEVICE_PATH_PROTOCOL*) Node);
 120   FreePool (Node);
 121   FreePool (TmpDevicePath);
 122   if (NewDevicePath == NULL) {
 123     Status = EFI_OUT_OF_RESOURCES;
 124     goto ON_EXIT;
 125   }
 126
 127   //
 128   // Add a new load option.
 129   //
 130   Status = EfiBootManagerInitializeLoadOption (
 131                  &NewOption,
 132                  LoadOptionNumberUnassigned,
 133                  LoadOptionTypeBoot,
 134                  LOAD_OPTION_ACTIVE,
 135                  Description,
 136                  NewDevicePath,
 137                  NULL,
 138                  0
 139                  );
 140   if (EFI_ERROR (Status)) {
 141     goto ON_EXIT;
 142   }
 143
 144   Status = EfiBootManagerAddLoadOptionVariable (&NewOption, (UINTN) -1);
 145   EfiBootManagerFreeLoadOption (&NewOption);
 146
 147 ON_EXIT:
 148
 149   if (NewDevicePath != NULL) {
 150     FreePool (NewDevicePath);
 151   }
 152
 153   return Status;
 154 }
 155
 156 /**
 157
 158   This function allows the caller to request the current
 159   configuration for one or more named elements. The resulting
 160   string is in <ConfigAltResp> format. Also, any and all alternative
 161   configuration strings shall be appended to the end of the
 162   current configuration string. If they are, they must appear
 163   after the current configuration. They must contain the same
 164   routing (GUID, NAME, PATH) as the current configuration string.
 165   They must have an additional description indicating the type of
 166   alternative configuration the string represents,
 167   "ALTCFG=<StringToken>". That <StringToken> (when
 168   converted from Hex UNICODE to binary) is a reference to a
 169   string in the associated string pack.
 170
 171   @param[in]  This       Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
 172
 173   @param[in]  Request    A null-terminated Unicode string in
 174                          <ConfigRequest> format. Note that this
 175                          includes the routing information as well as
 176                          the configurable name / value pairs. It is
 177                          invalid for this string to be in
 178                          <MultiConfigRequest> format.
 179
 180   @param[out] Progress   On return, points to a character in the
 181                          Request string. Points to the string's null
 182                          terminator if request was successful. Points
 183                          to the most recent "&" before the first
 184                          failing name / value pair (or the beginning
 185                          of the string if the failure is in the first
 186                          name / value pair) if the request was not successful.
 187
 188   @param[out] Results    A null-terminated Unicode string in
 189                          <ConfigAltResp> format which has all values
 190                          filled in for the names in the Request string.
 191                          String to be allocated by the called function.
 192
 193   @retval EFI_SUCCESS             The Results string is filled with the
 194                                   values corresponding to all requested
 195                                   names.
 196
 197   @retval EFI_OUT_OF_RESOURCES    Not enough memory to store the
 198                                   parts of the results that must be
 199                                   stored awaiting possible future
 200                                   protocols.
 201
 202   @retval EFI_INVALID_PARAMETER   For example, passing in a NULL
 203                                   for the Request parameter
 204                                   would result in this type of
 205                                   error. In this case, the
 206                                   Progress parameter would be
 207                                   set to NULL.
 208
 209   @retval EFI_NOT_FOUND           Routing data doesn't match any
 210                                   known driver. Progress set to the
 211                                   first character in the routing header.
 212                                   Note: There is no requirement that the
 213                                   driver validate the routing data. It
 214                                   must skip the <ConfigHdr> in order to
 215                                   process the names.
 216
 217   @retval EFI_INVALID_PARAMETER   Illegal syntax. Progress set
 218                                   to most recent "&" before the
 219                                   error or the beginning of the
 220                                   string.
 221
 222   @retval EFI_INVALID_PARAMETER   Unknown name. Progress points
 223                                   to the & before the name in
 224                                   question.
 225
 226 **/
 227 EFI_STATUS
 228 EFIAPI
 229 HttpBootFormExtractConfig (
 230   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
 231   IN  CONST EFI_STRING                       Request,
 232   OUT EFI_STRING                             *Progress,
 233   OUT EFI_STRING                             *Results
 234   )
 235 {
 236   EFI_STATUS                       Status;
 237   UINTN                            BufferSize;
 238   HTTP_BOOT_FORM_CALLBACK_INFO     *CallbackInfo;
 239   EFI_STRING                       ConfigRequestHdr;
 240   EFI_STRING                       ConfigRequest;
 241   BOOLEAN                          AllocatedRequest;
 242   UINTN                            Size;
 243
 244   if (Progress == NULL || Results == NULL) {
 245     return EFI_INVALID_PARAMETER;
 246   }
 247
 248   *Progress = Request;
 249   if ((Request != NULL) && !HiiIsConfigHdrMatch (Request, &gHttpBootConfigGuid, mHttpBootConfigStorageName)) {
 250     return EFI_NOT_FOUND;
 251   }
 252
 253   ConfigRequestHdr = NULL;
 254   ConfigRequest    = NULL;
 255   AllocatedRequest = FALSE;
 256   Size             = 0;
 257
 258   CallbackInfo = HTTP_BOOT_FORM_CALLBACK_INFO_FROM_CONFIG_ACCESS (This);
 259   //
 260   // Convert buffer data to <ConfigResp> by helper function BlockToConfig()
 261   //
 262   BufferSize = sizeof (HTTP_BOOT_CONFIG_IFR_NVDATA);
 263   ZeroMem (&CallbackInfo->HttpBootNvData, BufferSize);
 264   StrCpyS (CallbackInfo->HttpBootNvData.Description, DESCRIPTION_STR_MAX_SIZE / sizeof (CHAR16), HTTP_BOOT_DEFAULT_DESCRIPTION_STR);
 265
 266   ConfigRequest = Request;
 267   if ((Request == NULL) || (StrStr (Request, L"OFFSET") == NULL)) {
 268     //
 269     // Request has no request element, construct full request string.
 270     // Allocate and fill a buffer large enough to hold the <ConfigHdr> template
 271     // followed by "&OFFSET=0&WIDTH=WWWWWWWWWWWWWWWW" followed by a Null-terminator
 272     //
 273     ConfigRequestHdr = HiiConstructConfigHdr (&gHttpBootConfigGuid, mHttpBootConfigStorageName, CallbackInfo->ChildHandle);
 274     Size = (StrLen (ConfigRequestHdr) + 32 + 1) * sizeof (CHAR16);
 275     ConfigRequest = AllocateZeroPool (Size);
 276     if (ConfigRequest == NULL) {
 277       return EFI_OUT_OF_RESOURCES;
 278     }
 279     AllocatedRequest = TRUE;
 280     UnicodeSPrint (ConfigRequest, Size, L"%s&OFFSET=0&WIDTH=%016LX", ConfigRequestHdr, (UINT64)BufferSize);
 281     FreePool (ConfigRequestHdr);
 282   }
 283
 284   Status = gHiiConfigRouting->BlockToConfig (
 285                                 gHiiConfigRouting,
 286                                 ConfigRequest,
 287                                 (UINT8 *) &CallbackInfo->HttpBootNvData,
 288                                 BufferSize,
 289                                 Results,
 290                                 Progress
 291                                 );
 292
 293   //
 294   // Free the allocated config request string.
 295   //
 296   if (AllocatedRequest) {
 297     FreePool (ConfigRequest);
 298     ConfigRequest = NULL;
 299   }
 300   //
 301   // Set Progress string to the original request string.
 302   //
 303   if (Request == NULL) {
 304     *Progress = NULL;
 305   } else if (StrStr (Request, L"OFFSET") == NULL) {
 306     *Progress = Request + StrLen (Request);
 307   }
 308
 309   return Status;
 310 }
 311
 312 /**
 313
 314   This function applies changes in a driver's configuration.
 315   Input is a Configuration, which has the routing data for this
 316   driver followed by name / value configuration pairs. The driver
 317   must apply those pairs to its configurable storage. If the
 318   driver's configuration is stored in a linear block of data
 319   and the driver's name / value pairs are in <BlockConfig>
 320   format, it may use the ConfigToBlock helper function (above) to
 321   simplify the job.
 322
 323   @param[in]  This           Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
 324
 325   @param[in]  Configuration  A null-terminated Unicode string in
 326                              <ConfigString> format.
 327
 328   @param[out] Progress       A pointer to a string filled in with the
 329                              offset of the most recent '&' before the
 330                              first failing name / value pair (or the
 331                              beginning of the string if the failure
 332                              is in the first name / value pair) or
 333                              the terminating NULL if all was
 334                              successful.
 335
 336   @retval EFI_SUCCESS             The results have been distributed or are
 337                                   awaiting distribution.
 338
 339   @retval EFI_OUT_OF_RESOURCES    Not enough memory to store the
 340                                   parts of the results that must be
 341                                   stored awaiting possible future
 342                                   protocols.
 343
 344   @retval EFI_INVALID_PARAMETERS  Passing in a NULL for the
 345                                   Results parameter would result
 346                                   in this type of error.
 347
 348   @retval EFI_NOT_FOUND           Target for the specified routing data
 349                                   was not found.
 350
 351 **/
 352 EFI_STATUS
 353 EFIAPI
 354 HttpBootFormRouteConfig (
 355   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
 356   IN  CONST EFI_STRING                       Configuration,
 357   OUT EFI_STRING                             *Progress
 358   )
 359 {
 360   EFI_STATUS                       Status;
 361   UINTN                            BufferSize;
 362   HTTP_BOOT_FORM_CALLBACK_INFO     *CallbackInfo;
 363   HTTP_BOOT_PRIVATE_DATA           *Private;
 364
 365   if (Progress == NULL) {
 366     return EFI_INVALID_PARAMETER;
 367   }
 368   *Progress = Configuration;
 369
 370   if (Configuration == NULL) {
 371     return EFI_INVALID_PARAMETER;
 372   }
 373
 374   //
 375   // Check routing data in <ConfigHdr>.
 376   // Note: there is no name for Name/Value storage, only GUID will be checked
 377   //
 378   if (!HiiIsConfigHdrMatch (Configuration, &gHttpBootConfigGuid, mHttpBootConfigStorageName)) {
 379     return EFI_NOT_FOUND;
 380   }
 381
 382   CallbackInfo = HTTP_BOOT_FORM_CALLBACK_INFO_FROM_CONFIG_ACCESS (This);
 383   Private      = HTTP_BOOT_PRIVATE_DATA_FROM_CALLBACK_INFO (CallbackInfo);
 384
 385   BufferSize = sizeof (HTTP_BOOT_CONFIG_IFR_NVDATA);
 386   ZeroMem (&CallbackInfo->HttpBootNvData, BufferSize);
 387
 388   Status = gHiiConfigRouting->ConfigToBlock (
 389                             gHiiConfigRouting,
 390                             Configuration,
 391                             (UINT8 *) &CallbackInfo->HttpBootNvData,
 392                             &BufferSize,
 393                             Progress
 394                             );
 395   if (EFI_ERROR (Status)) {
 396     return Status;
 397   }
 398
 399   //
 400   // Create a new boot option according to the configuration data.
 401   //
 402   HttpBootAddBootOption (
 403     Private,
 404     (CallbackInfo->HttpBootNvData.IpVersion == HTTP_BOOT_IP_VERSION_6) ? TRUE : FALSE,
 405     CallbackInfo->HttpBootNvData.Description,
 406     CallbackInfo->HttpBootNvData.Uri
 407     );
 408
 409   return EFI_SUCCESS;
 410 }
 411
 412 /**
 413
 414   This function is called to provide results data to the driver.
 415   This data consists of a unique key that is used to identify
 416   which data is either being passed back or being asked for.
 417
 418   @param[in]       This          Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
 419   @param[in]       Action        Specifies the type of action taken by the browser.
 420   @param[in]       QuestionId    A unique value which is sent to the original
 421                                  exporting driver so that it can identify the type
 422                                  of data to expect. The format of the data tends to
 423                                  vary based on the opcode that generated the callback.
 424   @param[in]       Type          The type of value for the question.
 425   @param[in, out]  Value         A pointer to the data being sent to the original
 426                                  exporting driver.
 427   @param[out]      ActionRequest On return, points to the action requested by the
 428                                  callback function.
 429
 430   @retval EFI_SUCCESS            The callback successfully handled the action.
 431   @retval EFI_OUT_OF_RESOURCES   Not enough storage is available to hold the
 432                                  variable and its data.
 433   @retval EFI_DEVICE_ERROR       The variable could not be saved.
 434   @retval EFI_UNSUPPORTED        The specified Action is not supported by the
 435                                  callback.
 436 **/
 437 EFI_STATUS
 438 EFIAPI
 439 HttpBootFormCallback (
 440   IN CONST  EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
 441   IN        EFI_BROWSER_ACTION               Action,
 442   IN        EFI_QUESTION_ID                  QuestionId,
 443   IN        UINT8                            Type,
 444   IN OUT    EFI_IFR_TYPE_VALUE               *Value,
 445   OUT       EFI_BROWSER_ACTION_REQUEST       *ActionRequest
 446   )
 447 {
 448   EFI_INPUT_KEY                   Key;
 449   CHAR16                          *Uri;
 450   UINTN                           UriLen;
 451   CHAR8                           *AsciiUri;
 452   HTTP_BOOT_FORM_CALLBACK_INFO    *CallbackInfo;
 453   EFI_STATUS                      Status;
 454
 455   Uri      = NULL;
 456   UriLen   = 0;
 457   AsciiUri = NULL;
 458   Status   = EFI_SUCCESS;
 459
 460   if (This == NULL || Value == NULL) {
 461     return EFI_INVALID_PARAMETER;
 462   }
 463
 464   CallbackInfo = HTTP_BOOT_FORM_CALLBACK_INFO_FROM_CONFIG_ACCESS (This);
 465
 466   if (Action != EFI_BROWSER_ACTION_CHANGING) {
 467     return EFI_UNSUPPORTED;
 468   }
 469
 470   switch (QuestionId) {
 471   case KEY_INITIATOR_URI:
 472     //
 473     // Get user input URI string
 474     //
 475     Uri = HiiGetString (CallbackInfo->RegisteredHandle, Value->string, NULL);
 476     if(Uri == NULL) {
 477       return EFI_INVALID_PARAMETER;
 478     }
 479
 480     //
 481     // The URI should be either an empty string (for corporate environment) ,or http(s) for home environment.
 482     // Pop up a message box for the unsupported URI.
 483     //
 484     if (StrLen (Uri) != 0) {
 485       UriLen = StrLen (Uri) + 1;
 486       AsciiUri = AllocateZeroPool (UriLen);
 487       if (AsciiUri == NULL) {
 488         FreePool (Uri);
 489         return EFI_OUT_OF_RESOURCES;
 490       }
 491
 492       UnicodeStrToAsciiStrS (Uri, AsciiUri, UriLen);
 493
 494       Status = HttpBootCheckUriScheme (AsciiUri);
 495
 496       if (Status == EFI_INVALID_PARAMETER) {
 497
 498         DEBUG ((EFI_D_ERROR, "HttpBootFormCallback: %r.\n", Status));
 499
 500         CreatePopUp (
 501           EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
 502           &Key,
 503           L"ERROR: Unsupported URI!",
 504           L"Only supports HTTP and HTTPS",
 505           NULL
 506           );
 507       } else if (Status == EFI_ACCESS_DENIED) {
 508
 509         DEBUG ((EFI_D_ERROR, "HttpBootFormCallback: %r.\n", Status));
 510
 511         CreatePopUp (
 512           EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
 513           &Key,
 514           L"ERROR: Unsupported URI!",
 515           L"HTTP is disabled",
 516           NULL
 517           );
 518       }
 519     }
 520
 521     if (Uri != NULL) {
 522       FreePool (Uri);
 523     }
 524
 525     if (AsciiUri != NULL) {
 526       FreePool (AsciiUri);
 527     }
 528
 529     break;
 530
 531   default:
 532     break;
 533   }
 534
 535   return Status;
 536 }
 537
 538 /**
 539   Initialize the configuration form.
 540
 541   @param[in]  Private             Pointer to the driver private data.
 542
 543   @retval EFI_SUCCESS             The configuration form is initialized.
 544   @retval EFI_OUT_OF_RESOURCES    Failed to allocate memory.
 545
 546 **/
 547 EFI_STATUS
 548 HttpBootConfigFormInit (
 549   IN HTTP_BOOT_PRIVATE_DATA     *Private
 550   )
 551 {
 552   EFI_STATUS                        Status;
 553   HTTP_BOOT_FORM_CALLBACK_INFO      *CallbackInfo;
 554   VENDOR_DEVICE_PATH                VendorDeviceNode;
 555   CHAR16                            *MacString;
 556   CHAR16                            *OldMenuString;
 557   CHAR16                            MenuString[128];
 558
 559   CallbackInfo = &Private->CallbackInfo;
 560
 561   if (CallbackInfo->Initilized) {
 562     return EFI_SUCCESS;
 563   }
 564
 565   CallbackInfo->Signature = HTTP_BOOT_FORM_CALLBACK_INFO_SIGNATURE;
 566
 567   //
 568   // Construct device path node for EFI HII Config Access protocol,
 569   // which consists of controller physical device path and one hardware
 570   // vendor guid node.
 571   //
 572   ZeroMem (&VendorDeviceNode, sizeof (VENDOR_DEVICE_PATH));
 573   VendorDeviceNode.Header.Type    = HARDWARE_DEVICE_PATH;
 574   VendorDeviceNode.Header.SubType = HW_VENDOR_DP;
 575   CopyGuid (&VendorDeviceNode.Guid, &gEfiCallerIdGuid);
 576   SetDevicePathNodeLength (&VendorDeviceNode.Header, sizeof (VENDOR_DEVICE_PATH));
 577   CallbackInfo->HiiVendorDevicePath = AppendDevicePathNode (
 578                                         Private->ParentDevicePath,
 579                                         (EFI_DEVICE_PATH_PROTOCOL *) &VendorDeviceNode
 580                                         );
 581   if (CallbackInfo->HiiVendorDevicePath == NULL) {
 582     Status = EFI_OUT_OF_RESOURCES;
 583     goto Error;
 584   }
 585
 586   CallbackInfo->ConfigAccess.ExtractConfig = HttpBootFormExtractConfig;
 587   CallbackInfo->ConfigAccess.RouteConfig   = HttpBootFormRouteConfig;
 588   CallbackInfo->ConfigAccess.Callback      = HttpBootFormCallback;
 589
 590   //
 591   // Install Device Path Protocol and Config Access protocol to driver handle.
 592   //
 593   Status = gBS->InstallMultipleProtocolInterfaces (
 594                   &CallbackInfo->ChildHandle,
 595                   &gEfiDevicePathProtocolGuid,
 596                   CallbackInfo->HiiVendorDevicePath,
 597                   &gEfiHiiConfigAccessProtocolGuid,
 598                   &CallbackInfo->ConfigAccess,
 599                   NULL
 600                   );
 601   if (EFI_ERROR (Status)) {
 602     goto Error;
 603   }
 604
 605   //
 606   // Publish our HII data.
 607   //
 608   CallbackInfo->RegisteredHandle = HiiAddPackages (
 609                                      &gHttpBootConfigGuid,
 610                                      CallbackInfo->ChildHandle,
 611                                      HttpBootDxeStrings,
 612                                      HttpBootConfigVfrBin,
 613                                      NULL
 614                                      );
 615   if (CallbackInfo->RegisteredHandle == NULL) {
 616     Status = EFI_OUT_OF_RESOURCES;
 617     goto Error;
 618   }
 619
 620   //
 621   // Append MAC string in the menu help string
 622   //
 623   Status = NetLibGetMacString (Private->Controller, NULL, &MacString);
 624   if (!EFI_ERROR (Status)) {
 625     OldMenuString = HiiGetString (
 626                       CallbackInfo->RegisteredHandle,
 627                       STRING_TOKEN (STR_HTTP_BOOT_CONFIG_FORM_HELP),
 628                       NULL
 629                       );
 630     UnicodeSPrint (MenuString, 128, L"%s (MAC:%s)", OldMenuString, MacString);
 631     HiiSetString (
 632       CallbackInfo->RegisteredHandle,
 633       STRING_TOKEN (STR_HTTP_BOOT_CONFIG_FORM_HELP),
 634       MenuString,
 635       NULL
 636       );
 637
 638     FreePool (MacString);
 639     FreePool (OldMenuString);
 640
 641     CallbackInfo->Initilized = TRUE;
 642     return EFI_SUCCESS;
 643   }
 644
 645 Error:
 646
 647   HttpBootConfigFormUnload (Private);
 648   return Status;
 649 }
 650
 651 /**
 652   Unload the configuration form, this includes: delete all the configuration
 653   entries, uninstall the form callback protocol, and free the resources used.
 654   The form will only be unload completely when both IP4 and IP6 stack are stopped.
 655
 656   @param[in]  Private             Pointer to the driver private data.
 657
 658   @retval EFI_SUCCESS             The configuration form is unloaded.
 659   @retval Others                  Failed to unload the form.
 660
 661 **/
 662 EFI_STATUS
 663 HttpBootConfigFormUnload (
 664   IN HTTP_BOOT_PRIVATE_DATA     *Private
 665   )
 666 {
 667   HTTP_BOOT_FORM_CALLBACK_INFO      *CallbackInfo;
 668
 669   if (Private->Ip4Nic != NULL || Private->Ip6Nic != NULL) {
 670     //
 671     // Only unload the configuration form when both IP4 and IP6 stack are stopped.
 672     //
 673     return EFI_SUCCESS;
 674   }
 675
 676   CallbackInfo = &Private->CallbackInfo;
 677   if (CallbackInfo->ChildHandle != NULL) {
 678     //
 679     // Uninstall EFI_HII_CONFIG_ACCESS_PROTOCOL
 680     //
 681     gBS->UninstallMultipleProtocolInterfaces (
 682            CallbackInfo->ChildHandle,
 683            &gEfiDevicePathProtocolGuid,
 684            CallbackInfo->HiiVendorDevicePath,
 685            &gEfiHiiConfigAccessProtocolGuid,
 686            &CallbackInfo->ConfigAccess,
 687            NULL
 688            );
 689     CallbackInfo->ChildHandle = NULL;
 690   }
 691
 692   if (CallbackInfo->HiiVendorDevicePath != NULL) {
 693     FreePool (CallbackInfo->HiiVendorDevicePath);
 694     CallbackInfo->HiiVendorDevicePath = NULL;
 695   }
 696
 697   if (CallbackInfo->RegisteredHandle != NULL) {
 698     //
 699     // Remove HII package list
 700     //
 701     HiiRemovePackages (CallbackInfo->RegisteredHandle);
 702     CallbackInfo->RegisteredHandle = NULL;
 703   }
 704
 705   return EFI_SUCCESS;
 706 }