NetworkPkg/HttpBootDxe/HttpBootConfig.c

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