NetworkPkg/Ip6Dxe/Ip6ConfigNv.c

   1 /** @file
   2   Helper functions for configuring or obtaining the parameters relating to IP6.
   3
   4   Copyright (c) 2010 - 2014, 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 "Ip6Impl.h"
  17
  18 CHAR16    mIp6ConfigStorageName[]     = L"IP6_CONFIG_IFR_NVDATA";
  19
  20 /**
  21   The notify function of create event when performing a manual configuration.
  22
  23   @param[in]    Event        The pointer of Event.
  24   @param[in]    Context      The pointer of Context.
  25
  26 **/
  27 VOID
  28 EFIAPI
  29 Ip6ConfigManualAddressNotify (
  30   IN EFI_EVENT    Event,
  31   IN VOID         *Context
  32   )
  33 {
  34   *((BOOLEAN *) Context) = TRUE;
  35 }
  36
  37 /**
  38   Get the configuration data for the EFI IPv6 network stack running on the
  39   communication. It is a help function to the call EfiIp6ConfigGetData().
  40
  41   @param[in]      Ip6Config      The pointer to the EFI_IP6_CONFIG_PROTOCOL instance.
  42   @param[in]      DataType       The type of data to get.
  43   @param[out]     DataSize       The size of buffer required in bytes.
  44   @param[out]     Data           The data buffer in which the configuration data is returned. The
  45                                  type of the data buffer associated with the DataType.
  46                                  It is the caller's responsibility to free the resource.
  47
  48   @retval EFI_SUCCESS           The specified configuration data was obtained successfully.
  49   @retval EFI_INVALID_PARAMETER One or more of the followings are TRUE:
  50                                 - Ip6Config is NULL or invalid.
  51                                 - DataSize is NULL.
  52                                 - Data is NULL.
  53   @retval EFI_OUT_OF_RESOURCES  Fail to perform the operation due to lack of resources.
  54   @retval EFI_NOT_READY         The specified configuration data is not ready due to an
  55                                 asynchronous configuration process already in progress.
  56   @retval EFI_NOT_FOUND         The specified configuration data was not found.
  57
  58 **/
  59 EFI_STATUS
  60 Ip6ConfigNvGetData (
  61   IN  EFI_IP6_CONFIG_PROTOCOL                *Ip6Config,
  62   IN  EFI_IP6_CONFIG_DATA_TYPE               DataType,
  63   OUT UINTN                                  *DataSize,
  64   OUT VOID                                   **Data
  65   )
  66 {
  67   UINTN                   BufferSize;
  68   VOID                    *Buffer;
  69   EFI_STATUS              Status;
  70
  71   if ((Ip6Config == NULL) || (Data == NULL) || (DataSize == NULL)) {
  72     return EFI_INVALID_PARAMETER;
  73   }
  74
  75   BufferSize = 0;
  76   Status = Ip6Config->GetData (
  77                         Ip6Config,
  78                         DataType,
  79                         &BufferSize,
  80                         NULL
  81                         );
  82   if (Status != EFI_BUFFER_TOO_SMALL) {
  83     return Status;
  84   }
  85
  86   Buffer = AllocateZeroPool (BufferSize);
  87   if (Buffer == NULL) {
  88     return EFI_OUT_OF_RESOURCES;
  89   }
  90
  91   Status = Ip6Config->GetData (
  92                         Ip6Config,
  93                         DataType,
  94                         &BufferSize,
  95                         Buffer
  96                         );
  97   if (EFI_ERROR (Status)) {
  98     FreePool (Buffer);
  99     return Status;
 100   }
 101
 102   *DataSize = BufferSize;
 103   *Data     = Buffer;
 104
 105   return EFI_SUCCESS;
 106 }
 107
 108 /**
 109   Free all nodes in IP6_ADDRESS_INFO_ENTRY in the list array specified
 110   with ListHead.
 111
 112   @param[in]      ListHead  The head of the list array in IP6_ADDRESS_INFO_ENTRY.
 113
 114 **/
 115 VOID
 116 Ip6FreeAddressInfoList (
 117   IN LIST_ENTRY                  *ListHead
 118   )
 119 {
 120   IP6_ADDRESS_INFO_ENTRY         *Node;
 121   LIST_ENTRY                     *Entry;
 122   LIST_ENTRY                     *NextEntry;
 123
 124   NET_LIST_FOR_EACH_SAFE (Entry, NextEntry, ListHead) {
 125     Node = NET_LIST_USER_STRUCT (Entry, IP6_ADDRESS_INFO_ENTRY, Link);
 126     RemoveEntryList (&Node->Link);
 127     FreePool (Node);
 128   }
 129 }
 130
 131 /**
 132   Convert the IPv6 address into a formatted string.
 133
 134   @param[in]  Ip6       The IPv6 address.
 135   @param[out] Str       The formatted IP string.
 136
 137 **/
 138 VOID
 139 Ip6ToStr (
 140   IN  EFI_IPv6_ADDRESS  *Ip6,
 141   OUT CHAR16            *Str
 142   )
 143 {
 144   UINTN                 Index;
 145   BOOLEAN               Short;
 146   UINTN                 Number;
 147   CHAR16                FormatString[8];
 148
 149   Short = FALSE;
 150
 151   for (Index = 0; Index < 15; Index = Index + 2) {
 152     if (!Short &&
 153         Index % 2 == 0 &&
 154         Ip6->Addr[Index] == 0 &&
 155         Ip6->Addr[Index + 1] == 0
 156         ) {
 157       //
 158       // Deal with the case of ::.
 159       //
 160       if (Index == 0) {
 161         *Str       = L':';
 162         *(Str + 1) = L':';
 163         Str        = Str + 2;
 164       } else {
 165         *Str       = L':';
 166         Str        = Str + 1;
 167       }
 168
 169       while ((Index < 15) && (Ip6->Addr[Index] == 0) && (Ip6->Addr[Index + 1] == 0)) {
 170         Index = Index + 2;
 171       }
 172
 173       Short = TRUE;
 174
 175       if (Index == 16) {
 176         //
 177         // :: is at the end of the address.
 178         //
 179         *Str = L'\0';
 180         break;
 181       }
 182     }
 183
 184     ASSERT (Index < 15);
 185
 186     if (Ip6->Addr[Index] == 0) {
 187       Number = UnicodeSPrint (Str, 2 * IP6_STR_MAX_SIZE, L"%x:", (UINTN) Ip6->Addr[Index + 1]);
 188     } else {
 189       if (Ip6->Addr[Index + 1] < 0x10) {
 190         CopyMem (FormatString, L"%x0%x:", StrSize (L"%x0%x:"));
 191       } else {
 192         CopyMem (FormatString, L"%x%x:", StrSize (L"%x%x:"));
 193       }
 194
 195       Number = UnicodeSPrint (
 196                  Str,
 197                  2 * IP6_STR_MAX_SIZE,
 198                  (CONST CHAR16 *) FormatString,
 199                  (UINTN) Ip6->Addr[Index],
 200                  (UINTN) Ip6->Addr[Index + 1]
 201                  );
 202     }
 203
 204     Str = Str + Number;
 205
 206     if (Index + 2 == 16) {
 207       *Str = L'\0';
 208       if (*(Str - 1) == L':') {
 209         *(Str - 1) = L'\0';
 210       }
 211     }
 212   }
 213 }
 214
 215 /**
 216   Convert EFI_IP6_CONFIG_INTERFACE_ID to string format.
 217
 218   @param[out]      String  The buffer to store the converted string.
 219   @param[in]       IfId    The pointer of EFI_IP6_CONFIG_INTERFACE_ID.
 220
 221   @retval EFI_SUCCESS              The string converted successfully.
 222   @retval EFI_INVALID_PARAMETER    Any input parameter is invalid.
 223
 224 **/
 225 EFI_STATUS
 226 Ip6ConvertInterfaceIdToString (
 227   OUT CHAR16                         *String,
 228   IN  EFI_IP6_CONFIG_INTERFACE_ID    *IfId
 229   )
 230 {
 231   UINT8                          Index;
 232   UINTN                          Number;
 233
 234   if ((String == NULL) || (IfId == NULL)) {
 235     return EFI_INVALID_PARAMETER;
 236   }
 237
 238   for (Index = 0; Index < 8; Index++) {
 239     Number = UnicodeSPrint (
 240                String,
 241                2 * INTERFACE_ID_STR_STORAGE,
 242                L"%x:",
 243                (UINTN) IfId->Id[Index]
 244                );
 245     String = String + Number;
 246   }
 247
 248   *(String - 1) = '\0';
 249
 250   return EFI_SUCCESS;
 251 }
 252
 253 /**
 254   Parse InterfaceId in string format and convert it to EFI_IP6_CONFIG_INTERFACE_ID.
 255
 256   @param[in]        String  The buffer of the string to be parsed.
 257   @param[out]       IfId    The pointer of EFI_IP6_CONFIG_INTERFACE_ID.
 258
 259   @retval EFI_SUCCESS              The operation finished successfully.
 260   @retval EFI_INVALID_PARAMETER    Any input parameter is invalid.
 261
 262 **/
 263 EFI_STATUS
 264 Ip6ParseInterfaceIdFromString (
 265   IN CONST CHAR16                    *String,
 266   OUT EFI_IP6_CONFIG_INTERFACE_ID    *IfId
 267   )
 268 {
 269   UINT8                          Index;
 270   CHAR16                         *IfIdStr;
 271   CHAR16                         *TempStr;
 272   UINTN                          NodeVal;
 273
 274   if ((String == NULL) || (IfId == NULL)) {
 275     return EFI_INVALID_PARAMETER;
 276   }
 277
 278   IfIdStr = (CHAR16 *) String;
 279
 280   ZeroMem (IfId, sizeof (EFI_IP6_CONFIG_INTERFACE_ID));
 281
 282   for (Index = 0; Index < 8; Index++) {
 283     TempStr = IfIdStr;
 284
 285     while ((*IfIdStr != L'\0') && (*IfIdStr != L':')) {
 286       IfIdStr++;
 287     }
 288
 289     //
 290     // The InterfaceId format is X:X:X:X, the number of X should not exceed 8.
 291     // If the number of X is less than 8, zero is appended to the InterfaceId.
 292     //
 293     if ((*IfIdStr == ':') && (Index == 7)) {
 294       return EFI_INVALID_PARAMETER;
 295     }
 296
 297     //
 298     // Convert the string to interface id. AsciiStrHexToUintn stops at the
 299     // first character that is not a valid hex character, ':' or '\0' here.
 300     //
 301     NodeVal = StrHexToUintn (TempStr);
 302     if (NodeVal > 0xFF) {
 303       return EFI_INVALID_PARAMETER;
 304     }
 305
 306     IfId->Id[Index] = (UINT8) NodeVal;
 307
 308     IfIdStr++;
 309   }
 310
 311   return EFI_SUCCESS;
 312 }
 313
 314 /**
 315   Create Hii Extend Label OpCode as the start opcode and end opcode. It is
 316   a help function.
 317
 318   @param[in]  StartLabelNumber   The number of start label.
 319   @param[out] StartOpCodeHandle  Points to the start opcode handle.
 320   @param[out] StartLabel         Points to the created start opcode.
 321   @param[out] EndOpCodeHandle    Points to the end opcode handle.
 322   @param[out] EndLabel           Points to the created end opcode.
 323
 324   @retval EFI_OUT_OF_RESOURCES   Does not have sufficient resources to finish this
 325                                  operation.
 326   @retval EFI_INVALID_PARAMETER  Any input parameter is invalid.
 327   @retval EFI_SUCCESS            The operation completed successfully.
 328
 329 **/
 330 EFI_STATUS
 331 Ip6CreateOpCode (
 332   IN  UINT16                        StartLabelNumber,
 333   OUT VOID                          **StartOpCodeHandle,
 334   OUT EFI_IFR_GUID_LABEL            **StartLabel,
 335   OUT VOID                          **EndOpCodeHandle,
 336   OUT EFI_IFR_GUID_LABEL            **EndLabel
 337   )
 338 {
 339   EFI_STATUS                        Status;
 340   EFI_IFR_GUID_LABEL                *InternalStartLabel;
 341   EFI_IFR_GUID_LABEL                *InternalEndLabel;
 342
 343   if (StartOpCodeHandle == NULL || StartLabel == NULL || EndOpCodeHandle == NULL || EndLabel == NULL) {
 344     return EFI_INVALID_PARAMETER;
 345   }
 346
 347   *StartOpCodeHandle = NULL;
 348   *EndOpCodeHandle   = NULL;
 349   Status             = EFI_OUT_OF_RESOURCES;
 350
 351   //
 352   // Initialize the container for dynamic opcodes.
 353   //
 354   *StartOpCodeHandle = HiiAllocateOpCodeHandle ();
 355   if (*StartOpCodeHandle == NULL) {
 356     return Status;
 357   }
 358
 359   *EndOpCodeHandle = HiiAllocateOpCodeHandle ();
 360   if (*EndOpCodeHandle == NULL) {
 361     goto Exit;
 362   }
 363
 364   //
 365   // Create Hii Extend Label OpCode as the start opcode.
 366   //
 367   InternalStartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
 368                                                 *StartOpCodeHandle,
 369                                                 &gEfiIfrTianoGuid,
 370                                                 NULL,
 371                                                 sizeof (EFI_IFR_GUID_LABEL)
 372                                                 );
 373   if (InternalStartLabel == NULL) {
 374     goto Exit;
 375   }
 376
 377   InternalStartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
 378   InternalStartLabel->Number       = StartLabelNumber;
 379
 380   //
 381   // Create Hii Extend Label OpCode as the end opcode.
 382   //
 383   InternalEndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
 384                                               *EndOpCodeHandle,
 385                                               &gEfiIfrTianoGuid,
 386                                               NULL,
 387                                               sizeof (EFI_IFR_GUID_LABEL)
 388                                               );
 389   if (InternalEndLabel == NULL) {
 390     goto Exit;
 391   }
 392
 393   InternalEndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
 394   InternalEndLabel->Number       = LABEL_END;
 395
 396   *StartLabel = InternalStartLabel;
 397   *EndLabel   = InternalEndLabel;
 398
 399   return EFI_SUCCESS;
 400
 401 Exit:
 402
 403   if (*StartOpCodeHandle != NULL) {
 404     HiiFreeOpCodeHandle (*StartOpCodeHandle);
 405   }
 406
 407   if (*EndOpCodeHandle != NULL) {
 408     HiiFreeOpCodeHandle (*EndOpCodeHandle);
 409   }
 410
 411   return Status;
 412 }
 413
 414 /**
 415   This function converts the different format of address list to string format and
 416   then generates the corresponding text opcode to illustarate the address info in
 417   IP6 configuration page. Currently, the following formats are supported:
 418   EFI_IP6_ADDRESS_INFO AddressType: Ip6ConfigNvHostAddress;
 419   EFI_IPv6_ADDRESS     AddressType: Ip6ConfigNvGatewayAddress and Ip6ConfigNvDnsAddress;
 420   EFI_IP6_ROUTE_TABLE  AddressType: Ip6ConfigNvRouteTable.
 421
 422   @param[in, out] String           The pointer to the buffer to store the converted
 423                                    string.
 424   @param[in]      HiiHandle        A handle that was previously registered in the
 425                                    HII Database.
 426   @param[in]      AddressType      The address type.
 427   @param[in]      AddressInfo      Pointer to the address list.
 428   @param[in]      AddressCount     The address count of the address list.
 429
 430   @retval EFI_SUCCESS              The operation finished successfully.
 431   @retval EFI_INVALID_PARAMETER    Any input parameter is invalid.
 432   @retval EFI_UNSUPPORTED          The AddressType is not supported.
 433
 434
 435 **/
 436 EFI_STATUS
 437 Ip6ConvertAddressListToString (
 438   IN OUT CHAR16                         *String,
 439   IN     EFI_HII_HANDLE                 HiiHandle,
 440   IN     IP6_CONFIG_NV_ADDRESS_TYPE     AddressType,
 441   IN     VOID                           *AddressInfo,
 442   IN     UINTN                          AddressCount
 443   )
 444 {
 445   UINTN                          Index;
 446   UINTN                          Number;
 447   CHAR16                         *TempStr;
 448   EFI_STATUS                     Status;
 449   VOID                           *StartOpCodeHandle;
 450   EFI_IFR_GUID_LABEL             *StartLabel;
 451   VOID                           *EndOpCodeHandle;
 452   EFI_IFR_GUID_LABEL             *EndLabel;
 453   UINT16                         StartLabelNumber;
 454   EFI_STRING_ID                  TextTwo;
 455   UINT8                          *AddressHead;
 456   UINT8                          PrefixLength;
 457   EFI_IPv6_ADDRESS               *Address;
 458
 459   if ((String == NULL) || (HiiHandle == NULL) || (AddressInfo == NULL)) {
 460     return EFI_INVALID_PARAMETER;
 461   }
 462
 463   if (AddressType == Ip6ConfigNvHostAddress) {
 464     StartLabelNumber = HOST_ADDRESS_LABEL;
 465   } else if (AddressType == Ip6ConfigNvGatewayAddress) {
 466     StartLabelNumber = GATEWAY_ADDRESS_LABEL;
 467   } else if (AddressType == Ip6ConfigNvDnsAddress) {
 468     StartLabelNumber = DNS_ADDRESS_LABEL;
 469   } else if (AddressType == Ip6ConfigNvRouteTable) {
 470     StartLabelNumber = ROUTE_TABLE_LABEL;
 471   } else {
 472     ASSERT (FALSE);
 473     return EFI_UNSUPPORTED;
 474   }
 475
 476   Status = Ip6CreateOpCode (
 477              StartLabelNumber,
 478              &StartOpCodeHandle,
 479              &StartLabel,
 480              &EndOpCodeHandle,
 481              &EndLabel
 482              );
 483   if (EFI_ERROR (Status)) {
 484     return Status;
 485   }
 486
 487   AddressHead = (UINT8 *) AddressInfo;
 488
 489   for (Index = 0; Index < AddressCount; Index++) {
 490     if (AddressType == Ip6ConfigNvHostAddress) {
 491       AddressInfo = AddressHead + sizeof (EFI_IP6_ADDRESS_INFO) * Index;
 492       Address     = &((EFI_IP6_ADDRESS_INFO *) AddressInfo)->Address;
 493     } else if (AddressType == Ip6ConfigNvRouteTable) {
 494       AddressInfo = AddressHead + sizeof (EFI_IP6_ROUTE_TABLE) * Index;
 495       Address     = &((EFI_IP6_ROUTE_TABLE *) AddressInfo)->Destination;
 496     } else {
 497       AddressInfo = AddressHead + sizeof (EFI_IPv6_ADDRESS) * Index;
 498       Address     = AddressInfo;
 499     }
 500
 501     //
 502     // Convert the IP address info to string.
 503     //
 504     Ip6ToStr (Address, String);
 505     TempStr = String + StrLen (String);
 506
 507     if ((AddressType == Ip6ConfigNvHostAddress) || (AddressType == Ip6ConfigNvRouteTable)) {
 508       if (AddressType == Ip6ConfigNvHostAddress) {
 509         PrefixLength = ((EFI_IP6_ADDRESS_INFO *) AddressInfo)->PrefixLength;
 510       } else {
 511         PrefixLength = ((EFI_IP6_ROUTE_TABLE *) AddressInfo)->PrefixLength;
 512       }
 513
 514       //
 515       // Append the prefix length to the string.
 516       //
 517       *TempStr = L'/';
 518       TempStr++;
 519       Number  = UnicodeSPrint (TempStr, 6, L"%d", PrefixLength);
 520       TempStr = TempStr + Number;
 521     }
 522
 523     if (AddressType == Ip6ConfigNvRouteTable) {
 524       //
 525       // Append " >> " to the string.
 526       //
 527       Number   = UnicodeSPrint (TempStr, 8, L" >>  ");
 528       TempStr  = TempStr + Number;
 529
 530       //
 531       // Append the gateway address to the string.
 532       //
 533       Ip6ToStr (&((EFI_IP6_ROUTE_TABLE *) AddressInfo)->Gateway, TempStr);
 534       TempStr = TempStr + StrLen (TempStr);
 535     }
 536
 537     //
 538     // Generate a text opcode and update the UI.
 539     //
 540     TextTwo = HiiSetString (HiiHandle, 0, String, NULL);
 541     if (TextTwo == 0) {
 542       Status = EFI_INVALID_PARAMETER;
 543       goto Exit;
 544     }
 545
 546     HiiCreateTextOpCode (StartOpCodeHandle, STR_NULL, STR_NULL, TextTwo);
 547
 548     String = TempStr;
 549     *String = IP6_ADDRESS_DELIMITER;
 550     String++;
 551   }
 552
 553   *(String - 1) = '\0';
 554
 555   Status = HiiUpdateForm (
 556              HiiHandle,                       // HII handle
 557              &gIp6ConfigNvDataGuid,           // Formset GUID
 558              FORMID_MAIN_FORM,                // Form ID
 559              StartOpCodeHandle,               // Label for where to insert opcodes
 560              EndOpCodeHandle                  // Replace data
 561              );
 562
 563 Exit:
 564   HiiFreeOpCodeHandle (StartOpCodeHandle);
 565   HiiFreeOpCodeHandle (EndOpCodeHandle);
 566
 567   return Status;
 568 }
 569
 570 /**
 571   Parse address list in string format and convert it to a list array of node in
 572   IP6_ADDRESS_INFO_ENTRY.
 573
 574   @param[in]        String         The buffer to string to be parsed.
 575   @param[out]       ListHead       The list head of array.
 576   @param[out]       AddressCount   The number of list nodes in the array.
 577
 578   @retval EFI_SUCCESS              The operation finished successfully.
 579   @retval EFI_INVALID_PARAMETER    Any input parameter is invalid.
 580   @retval EFI_OUT_OF_RESOURCES     Failed to perform the operation due to lack of resource.
 581
 582 **/
 583 EFI_STATUS
 584 Ip6ParseAddressListFromString (
 585   IN CONST CHAR16                    *String,
 586   OUT LIST_ENTRY                     *ListHead,
 587   OUT UINT32                         *AddressCount
 588   )
 589 {
 590   EFI_STATUS                     Status;
 591   CHAR16                         *LocalString;
 592   CHAR16                         *Temp;
 593   CHAR16                         *TempStr;
 594   EFI_IP6_ADDRESS_INFO           AddressInfo;
 595   IP6_ADDRESS_INFO_ENTRY         *Node;
 596   BOOLEAN                        Last;
 597   UINT32                         Count;
 598
 599   if ((String == NULL) || (ListHead == NULL) || (AddressCount == NULL)) {
 600     return EFI_INVALID_PARAMETER;
 601   }
 602
 603   ZeroMem (&AddressInfo, sizeof (EFI_IP6_ADDRESS_INFO));
 604   LocalString = (CHAR16 *) AllocateCopyPool (StrSize (String), String);
 605   if (LocalString == NULL) {
 606     return EFI_OUT_OF_RESOURCES;
 607   }
 608
 609   //
 610   // Clean the original address list.
 611   //
 612   Ip6FreeAddressInfoList (ListHead);
 613
 614   Temp  = LocalString;
 615   Last  = FALSE;
 616   Count = 0;
 617
 618   while (*LocalString != L'\0') {
 619     TempStr = LocalString;
 620     while ((*LocalString != L'\0') && (*LocalString != IP6_ADDRESS_DELIMITER)) {
 621       LocalString++;
 622     }
 623
 624     if (*LocalString == L'\0') {
 625       Last = TRUE;
 626     }
 627
 628     *LocalString = L'\0';
 629
 630     Status = NetLibStrToIp6andPrefix (TempStr, &AddressInfo.Address, &AddressInfo.PrefixLength);
 631     if (EFI_ERROR (Status)) {
 632       goto Error;
 633     }
 634
 635     if (AddressInfo.PrefixLength == 0xFF) {
 636       AddressInfo.PrefixLength = 0;
 637     }
 638
 639     if (!NetIp6IsValidUnicast (&AddressInfo.Address)) {
 640       Status = EFI_INVALID_PARAMETER;
 641       goto Error;
 642     }
 643
 644     Node = AllocatePool (sizeof (IP6_ADDRESS_INFO_ENTRY));
 645     if (Node == NULL) {
 646       Status = EFI_OUT_OF_RESOURCES;
 647       goto Error;
 648     }
 649
 650     CopyMem (&Node->AddrInfo, &AddressInfo, sizeof (EFI_IP6_ADDRESS_INFO));
 651     InsertTailList (ListHead, &Node->Link);
 652     Count++;
 653
 654     if (Last) {
 655       break;
 656     }
 657
 658     LocalString++;
 659   }
 660
 661   FreePool (Temp);
 662   *AddressCount = Count;
 663   return EFI_SUCCESS;
 664
 665 Error:
 666   Ip6FreeAddressInfoList (ListHead);
 667   FreePool (Temp);
 668   return Status;
 669 }
 670
 671 /**
 672   This function converts the interface info to string and draws it to the IP6 UI.
 673   The interface information includes interface name, interface type, hardware
 674   address and route table information.
 675
 676   @param[in]       IfInfo          The pointer of EFI_IP6_CONFIG_INTERFACE_INFO.
 677   @param[in]       HiiHandle       The handle that was previously registered in the
 678                                    HII Database.
 679   @param[in, out]  IfrNvData       Points to IP6_CONFIG_IFR_NVDATA.
 680
 681   @retval EFI_SUCCESS              The operation finished successfully.
 682   @retval EFI_INVALID_PARAMETER    Any input parameter is invalid.
 683   @retval EFI_OUT_OF_RESOURCES     The operation failed due to lack of resources.
 684
 685 **/
 686 EFI_STATUS
 687 Ip6ConvertInterfaceInfoToString (
 688   IN     EFI_IP6_CONFIG_INTERFACE_INFO  *IfInfo,
 689   IN     EFI_HII_HANDLE                 HiiHandle,
 690   IN OUT IP6_CONFIG_IFR_NVDATA          *IfrNvData
 691   )
 692 {
 693   UINT32                         Index;
 694   UINTN                          Number;
 695   CHAR16                         *String;
 696   CHAR16                         PortString[ADDRESS_STR_MAX_SIZE];
 697   CHAR16                         FormatString[8];
 698   EFI_STRING_ID                  StringId;
 699
 700   if ((IfInfo == NULL) || (HiiHandle == NULL) || (IfrNvData == NULL)) {
 701     return EFI_INVALID_PARAMETER;
 702   }
 703
 704   //
 705   // Print the interface name.
 706   //
 707   StringId = HiiSetString (
 708                HiiHandle,
 709                STRING_TOKEN (STR_IP6_INTERFACE_NAME_CONTENT),
 710                IfInfo->Name,
 711                NULL
 712                );
 713   if (StringId == 0) {
 714     return EFI_OUT_OF_RESOURCES;
 715   }
 716
 717   //
 718   // Print the interface type.
 719   //
 720   if (IfInfo->IfType == Ip6InterfaceTypeEthernet) {
 721     StrnCpy (PortString, IP6_ETHERNET, sizeof (PortString) / sizeof (CHAR16) - 1);
 722   } else if (IfInfo->IfType == Ip6InterfaceTypeExperimentalEthernet) {
 723     StrnCpy (PortString, IP6_EXPERIMENTAL_ETHERNET, sizeof (PortString) / sizeof (CHAR16) - 1);
 724   } else {
 725     //
 726     // Refer to RFC1700, chapter Number Hardware Type.
 727     //
 728     UnicodeSPrint (PortString, 6, L"%d", IfInfo->IfType);
 729   }
 730
 731   StringId = HiiSetString (
 732                HiiHandle,
 733                STRING_TOKEN (STR_IP6_INTERFACE_TYPE_CONTENT),
 734                PortString,
 735                NULL
 736                );
 737   if (StringId == 0) {
 738     return EFI_OUT_OF_RESOURCES;
 739   }
 740
 741   //
 742   // Convert the hardware address.
 743   //
 744   String = PortString;
 745   ASSERT (IfInfo->HwAddressSize <= 32);
 746
 747   for (Index = 0; Index < IfInfo->HwAddressSize; Index++) {
 748
 749     if (IfInfo->HwAddress.Addr[Index] < 0x10) {
 750       StrnCpy (FormatString, L"0%x-", sizeof (FormatString) / sizeof (CHAR16) - 1);
 751     } else {
 752       StrnCpy (FormatString, L"%x-", sizeof (FormatString) / sizeof (CHAR16) - 1);
 753     }
 754
 755     Number = UnicodeSPrint (
 756                String,
 757                8,
 758                (CONST CHAR16 *) FormatString,
 759                (UINTN) IfInfo->HwAddress.Addr[Index]
 760                );
 761     String = String + Number;
 762   }
 763
 764   if (Index != 0) {
 765     ASSERT (String > PortString);
 766     String--;
 767     *String = '\0';
 768   }
 769
 770   //
 771   // Print the hardware address.
 772   //
 773   StringId = HiiSetString (
 774                HiiHandle,
 775                STRING_TOKEN (STR_IP6_MAC_ADDRESS_CONTENT),
 776                PortString,
 777                NULL
 778                );
 779   if (StringId == 0) {
 780     return EFI_OUT_OF_RESOURCES;
 781   }
 782
 783   return EFI_SUCCESS;
 784 }
 785
 786 /**
 787   Build the address info list from list array of node in IP6_ADDRESS_INFO_ENTRY.
 788
 789   @param[in]      Instance         Points to IP6 config instance data.
 790   @param[in]      AddressType      The address type.
 791   @param[out]     AddressInfo      The pointer to the buffer to store the address list.
 792   @param[out]     AddressSize      The address size of the address list.
 793
 794   @retval EFI_SUCCESS              The operation finished successfully.
 795   @retval EFI_INVALID_PARAMETER    Any input parameter is invalid.
 796   @retval EFI_UNSUPPORTED          The AddressType is not supported.
 797
 798 **/
 799 EFI_STATUS
 800 Ip6BuildNvAddressInfo (
 801   IN  IP6_CONFIG_INSTANCE            *Instance,
 802   IN  IP6_CONFIG_NV_ADDRESS_TYPE     AddressType,
 803   OUT VOID                           **AddressInfo,
 804   OUT UINTN                          *AddressSize
 805   )
 806 {
 807   IP6_CONFIG_NVDATA                  *Ip6NvData;
 808   LIST_ENTRY                         *Entry;
 809   LIST_ENTRY                         *ListHead;
 810   IP6_ADDRESS_INFO_ENTRY             *Node;
 811   VOID                               *AddressList;
 812   VOID                               *TmpStr;
 813   UINTN                              DataSize;
 814   EFI_IPv6_ADDRESS                   *Ip6Address;
 815   EFI_IP6_CONFIG_MANUAL_ADDRESS      *ManualAddress;
 816
 817   if ((Instance == NULL) || (AddressInfo == NULL) || (AddressSize == NULL)) {
 818     return EFI_INVALID_PARAMETER;
 819   }
 820
 821   NET_CHECK_SIGNATURE (Instance, IP6_CONFIG_INSTANCE_SIGNATURE);
 822
 823   Ip6NvData = &Instance->Ip6NvData;
 824
 825   if (AddressType == Ip6ConfigNvHostAddress) {
 826     ListHead = &Ip6NvData->ManualAddress;
 827     DataSize = sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS) * Ip6NvData->ManualAddressCount;
 828   } else if (AddressType == Ip6ConfigNvGatewayAddress) {
 829     ListHead = &Ip6NvData->GatewayAddress;
 830     DataSize = sizeof (EFI_IPv6_ADDRESS) * Ip6NvData->GatewayAddressCount;
 831   } else if (AddressType == Ip6ConfigNvDnsAddress) {
 832     ListHead = &Ip6NvData->DnsAddress;
 833     DataSize = sizeof (EFI_IPv6_ADDRESS) * Ip6NvData->DnsAddressCount;
 834   } else {
 835     return EFI_UNSUPPORTED;
 836   }
 837
 838   AddressList = AllocateZeroPool (DataSize);
 839   if (AddressList  == NULL) {
 840     return EFI_OUT_OF_RESOURCES;
 841   }
 842
 843   TmpStr = AddressList;
 844
 845   NET_LIST_FOR_EACH (Entry, ListHead) {
 846     Node = NET_LIST_USER_STRUCT (Entry, IP6_ADDRESS_INFO_ENTRY, Link);
 847     if (AddressType == Ip6ConfigNvHostAddress) {
 848       ManualAddress = (EFI_IP6_CONFIG_MANUAL_ADDRESS *) AddressList;
 849       IP6_COPY_ADDRESS (&ManualAddress->Address, &Node->AddrInfo.Address);
 850       ManualAddress->PrefixLength = Node->AddrInfo.PrefixLength;
 851       AddressList = (UINT8 *) AddressList + sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS);
 852     } else {
 853       Ip6Address = (EFI_IPv6_ADDRESS *) AddressList;
 854       IP6_COPY_ADDRESS (Ip6Address, &Node->AddrInfo.Address);
 855       AddressList = (UINT8 *) AddressList + sizeof (EFI_IPv6_ADDRESS);
 856     }
 857   }
 858
 859   *AddressInfo = TmpStr;
 860   *AddressSize = DataSize;
 861   return EFI_SUCCESS;
 862 }
 863
 864 /**
 865   Convert the IP6 configuration data into the IFR data.
 866
 867   @param[in, out]  IfrNvData       The IFR NV data.
 868   @param[in]       Instance        The IP6 config instance data.
 869
 870   @retval EFI_SUCCESS              The operation finished successfully.
 871   @retval EFI_INVALID_PARAMETER    Any input parameter is invalid.
 872   @retval EFI_UNSUPPORTED          The policy is not supported in the current implementation.
 873   @retval Others                   Other errors as indicated.
 874
 875 **/
 876 EFI_STATUS
 877 Ip6ConvertConfigNvDataToIfrNvData (
 878   IN OUT IP6_CONFIG_IFR_NVDATA       *IfrNvData,
 879   IN     IP6_CONFIG_INSTANCE         *Instance
 880   )
 881 {
 882   IP6_CONFIG_NVDATA                          *Ip6NvData;
 883   EFI_IP6_CONFIG_PROTOCOL                    *Ip6Config;
 884   UINTN                                      DataSize;
 885   VOID                                       *Data;
 886   EFI_STATUS                                 Status;
 887   EFI_IP6_CONFIG_POLICY                      Policy;
 888   EFI_IP6_CONFIG_DUP_ADDR_DETECT_TRANSMITS   DadXmits;
 889   EFI_HII_HANDLE                             HiiHandle;
 890
 891   if ((IfrNvData == NULL) || (Instance == NULL)) {
 892     return EFI_INVALID_PARAMETER;
 893   }
 894
 895   NET_CHECK_SIGNATURE (Instance, IP6_CONFIG_INSTANCE_SIGNATURE);
 896
 897   Ip6Config = &Instance->Ip6Config;
 898   Ip6NvData = &Instance->Ip6NvData;
 899   Data      = NULL;
 900   DataSize  = 0;
 901   HiiHandle = Instance->CallbackInfo.RegisteredHandle;
 902
 903   //
 904   // Get the current interface info.
 905   //
 906   Status = Ip6ConfigNvGetData (
 907              Ip6Config,
 908              Ip6ConfigDataTypeInterfaceInfo,
 909              &DataSize,
 910              (VOID **) &Data
 911              );
 912   if (EFI_ERROR (Status)) {
 913     goto Exit;
 914   }
 915
 916   //
 917   // Convert the interface info to string and print.
 918   //
 919   Status = Ip6ConvertInterfaceInfoToString (
 920              (EFI_IP6_CONFIG_INTERFACE_INFO *) Data,
 921              HiiHandle,
 922              IfrNvData
 923              );
 924   if (EFI_ERROR (Status)) {
 925     goto Exit;
 926   }
 927
 928   //
 929   // Get the interface id.
 930   //
 931   DataSize = sizeof (EFI_IP6_CONFIG_INTERFACE_ID);
 932   ZeroMem (&Ip6NvData->InterfaceId, DataSize);
 933   Status = Ip6Config->GetData (
 934                         Ip6Config,
 935                         Ip6ConfigDataTypeAltInterfaceId,
 936                         &DataSize,
 937                         &Ip6NvData->InterfaceId
 938                         );
 939   if (EFI_ERROR (Status)) {
 940     goto Exit;
 941   }
 942
 943   Ip6ConvertInterfaceIdToString (IfrNvData->InterfaceId, &Ip6NvData->InterfaceId);
 944
 945   //
 946   // Get current policy.
 947   //
 948   DataSize = sizeof (EFI_IP6_CONFIG_POLICY);
 949   Status   = Ip6Config->GetData (
 950                           Ip6Config,
 951                           Ip6ConfigDataTypePolicy,
 952                           &DataSize,
 953                           &Policy
 954                           );
 955
 956   if (EFI_ERROR (Status)) {
 957     goto Exit;
 958   }
 959
 960   if (Policy == Ip6ConfigPolicyManual) {
 961     IfrNvData->Policy = IP6_POLICY_MANUAL;
 962   } else if (Policy == Ip6ConfigPolicyAutomatic) {
 963     IfrNvData->Policy = IP6_POLICY_AUTO;
 964   } else {
 965     ASSERT (FALSE);
 966     Status = EFI_UNSUPPORTED;
 967     goto Exit;
 968   }
 969
 970   //
 971   // Get Duplicate Address Detection Transmits count.
 972   //
 973   DataSize = sizeof (EFI_IP6_CONFIG_DUP_ADDR_DETECT_TRANSMITS);
 974   Status   = Ip6Config->GetData (
 975                           Ip6Config,
 976                           Ip6ConfigDataTypeDupAddrDetectTransmits,
 977                           &DataSize,
 978                           &DadXmits
 979                           );
 980
 981   if (EFI_ERROR (Status)) {
 982     goto Exit;
 983   }
 984
 985   IfrNvData->DadTransmitCount = DadXmits.DupAddrDetectTransmits;
 986
 987 Exit:
 988   if (Data != NULL) {
 989      FreePool (Data);
 990   }
 991
 992   return Status;
 993 }
 994
 995 /**
 996   Convert IFR data into IP6 configuration data. The policy, alternative interface
 997   ID, and DAD transmit counts, and will be saved.
 998
 999   @param[in]       IfrNvData       The IFR NV data.
1000   @param[in, out]  Instance        The IP6 config instance data.
1001
1002   @retval EFI_SUCCESS              The operation finished successfully.
1003   @retval EFI_INVALID_PARAMETER    Any input parameter is invalid.
1004   @retval Others                   Other errors as indicated.
1005
1006 **/
1007 EFI_STATUS
1008 Ip6ConvertIfrNvDataToConfigNvDataGeneral (
1009   IN     IP6_CONFIG_IFR_NVDATA       *IfrNvData,
1010   IN OUT IP6_CONFIG_INSTANCE         *Instance
1011   )
1012 {
1013   IP6_CONFIG_NVDATA                  *Ip6NvData;
1014   EFI_IP6_CONFIG_PROTOCOL            *Ip6Config;
1015   EFI_STATUS                         Status;
1016
1017   if ((IfrNvData == NULL) || (Instance == NULL)) {
1018     return EFI_INVALID_PARAMETER;
1019   }
1020
1021   NET_CHECK_SIGNATURE (Instance, IP6_CONFIG_INSTANCE_SIGNATURE);
1022   Ip6NvData = &Instance->Ip6NvData;
1023   Ip6Config = &Instance->Ip6Config;
1024
1025   //
1026   // Update those fields which don't have INTERACTIVE attribute.
1027   //
1028   if (IfrNvData->Policy == IP6_POLICY_AUTO) {
1029     Ip6NvData->Policy = Ip6ConfigPolicyAutomatic;
1030   } else if (IfrNvData->Policy == IP6_POLICY_MANUAL) {
1031     Ip6NvData->Policy = Ip6ConfigPolicyManual;
1032   }
1033
1034   Ip6NvData->DadTransmitCount.DupAddrDetectTransmits = IfrNvData->DadTransmitCount;
1035
1036   //
1037   // Set the configured policy.
1038   //
1039   Status = Ip6Config->SetData (
1040                         Ip6Config,
1041                         Ip6ConfigDataTypePolicy,
1042                         sizeof (EFI_IP6_CONFIG_POLICY),
1043                         &Ip6NvData->Policy
1044                         );
1045   if (EFI_ERROR (Status)) {
1046     return Status;
1047   }
1048
1049   //
1050   // Set the duplicate address detection transmits count.
1051   //
1052   Status = Ip6Config->SetData (
1053                         Ip6Config,
1054                         Ip6ConfigDataTypeDupAddrDetectTransmits,
1055                         sizeof (EFI_IP6_CONFIG_DUP_ADDR_DETECT_TRANSMITS),
1056                         &Ip6NvData->DadTransmitCount
1057                         );
1058   if (EFI_ERROR (Status)) {
1059     return Status;
1060   }
1061
1062   //
1063   // Set the alternative interface ID
1064   //
1065   Status = Ip6Config->SetData (
1066                         Ip6Config,
1067                         Ip6ConfigDataTypeAltInterfaceId,
1068                         sizeof (EFI_IP6_CONFIG_INTERFACE_ID),
1069                         &Ip6NvData->InterfaceId
1070                         );
1071   if (EFI_ERROR (Status)) {
1072     return Status;
1073   }
1074
1075   return EFI_SUCCESS;
1076 }
1077
1078 /**
1079   Convert IFR data into IP6 configuration data. The policy, configured
1080   manual address, gateway address, and DNS server address will be saved.
1081
1082   @param[in]       IfrNvData       The IFR NV data.
1083   @param[in, out]  Instance        The IP6 config instance data.
1084
1085   @retval EFI_SUCCESS              The operation finished successfully.
1086   @retval EFI_INVALID_PARAMETER    Any input parameter is invalid.
1087   @retval Others                   Other errors as indicated.
1088
1089 **/
1090 EFI_STATUS
1091 Ip6ConvertIfrNvDataToConfigNvDataAdvanced (
1092   IN     IP6_CONFIG_IFR_NVDATA       *IfrNvData,
1093   IN OUT IP6_CONFIG_INSTANCE         *Instance
1094   )
1095 {
1096   IP6_CONFIG_NVDATA                  *Ip6NvData;
1097   EFI_IP6_CONFIG_PROTOCOL            *Ip6Config;
1098   EFI_STATUS                         Status;
1099   EFI_IP6_CONFIG_MANUAL_ADDRESS      *ManualAddress;
1100   EFI_IPv6_ADDRESS                   *Address;
1101   BOOLEAN                            IsAddressOk;
1102   EFI_EVENT                          SetAddressEvent;
1103   EFI_EVENT                          TimeoutEvent;
1104   UINTN                              DataSize;
1105
1106   if ((IfrNvData == NULL) || (Instance == NULL)) {
1107     return EFI_INVALID_PARAMETER;
1108   }
1109
1110   if (IfrNvData->Policy == IP6_POLICY_AUTO) {
1111     return EFI_SUCCESS;
1112   }
1113
1114   NET_CHECK_SIGNATURE (Instance, IP6_CONFIG_INSTANCE_SIGNATURE);
1115   Ip6NvData = &Instance->Ip6NvData;
1116   Ip6Config = &Instance->Ip6Config;
1117
1118   //
1119   // Update those fields which don't have INTERACTIVE attribute.
1120   //
1121   Ip6NvData->Policy = Ip6ConfigPolicyManual;
1122
1123   //
1124   // Set the configured policy.
1125   //
1126   Status = Ip6Config->SetData (
1127                         Ip6Config,
1128                         Ip6ConfigDataTypePolicy,
1129                         sizeof (EFI_IP6_CONFIG_POLICY),
1130                         &Ip6NvData->Policy
1131                         );
1132   if (EFI_ERROR (Status)) {
1133     return Status;
1134   }
1135
1136   //
1137   // Create events & timers for asynchronous settings.
1138   //
1139   SetAddressEvent = NULL;
1140   TimeoutEvent    = NULL;
1141   ManualAddress   = NULL;
1142   Address         = NULL;
1143
1144   Status = gBS->CreateEvent (
1145                   EVT_NOTIFY_SIGNAL,
1146                   TPL_NOTIFY,
1147                   Ip6ConfigManualAddressNotify,
1148                   &IsAddressOk,
1149                   &SetAddressEvent
1150                   );
1151   if (EFI_ERROR (Status)) {
1152     goto Exit;
1153   }
1154
1155   Status = gBS->CreateEvent (
1156                   EVT_TIMER,
1157                   TPL_CALLBACK,
1158                   NULL,
1159                   NULL,
1160                   &TimeoutEvent
1161                   );
1162   if (EFI_ERROR (Status)) {
1163     goto Exit;
1164   }
1165
1166   //
1167   // Set the manual address list. This is an asynchronous process.
1168   //
1169   if (!IsListEmpty (&Ip6NvData->ManualAddress) && (Ip6NvData->ManualAddressCount != 0)) {
1170     Status = Ip6BuildNvAddressInfo (
1171                Instance,
1172                Ip6ConfigNvHostAddress,
1173                (VOID **) &ManualAddress,
1174                &DataSize
1175                );
1176     if (EFI_ERROR (Status)) {
1177       goto Exit;
1178     }
1179
1180     IsAddressOk = FALSE;
1181
1182     Status = Ip6Config->RegisterDataNotify (
1183                           Ip6Config,
1184                           Ip6ConfigDataTypeManualAddress,
1185                           SetAddressEvent
1186                           );
1187     if (EFI_ERROR (Status)) {
1188       goto Exit;
1189     }
1190
1191     Status = Ip6Config->SetData (
1192                           Ip6Config,
1193                           Ip6ConfigDataTypeManualAddress,
1194                           DataSize,
1195                           (VOID *) ManualAddress
1196                           );
1197     if (Status == EFI_NOT_READY) {
1198       gBS->SetTimer (TimeoutEvent, TimerRelative, 50000000);
1199       while (EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {
1200         if (IsAddressOk) {
1201           Status = EFI_SUCCESS;
1202         }
1203         break;
1204       }
1205     }
1206
1207     Status = Ip6Config->UnregisterDataNotify (
1208                           Ip6Config,
1209                           Ip6ConfigDataTypeManualAddress,
1210                           SetAddressEvent
1211                           );
1212     if (EFI_ERROR (Status)) {
1213       goto Exit;
1214     }
1215   }
1216
1217   //
1218   // Set gateway address list.
1219   //
1220   if (!IsListEmpty (&Ip6NvData->GatewayAddress) && (Ip6NvData->GatewayAddressCount != 0)) {
1221     Status = Ip6BuildNvAddressInfo (
1222                Instance,
1223                Ip6ConfigNvGatewayAddress,
1224                (VOID **) &Address,
1225                &DataSize
1226                );
1227     if (EFI_ERROR (Status)) {
1228       goto Exit;
1229     }
1230
1231     Status = Ip6Config->SetData (
1232                           Ip6Config,
1233                           Ip6ConfigDataTypeGateway,
1234                           DataSize,
1235                           (VOID *) Address
1236                           );
1237     if (EFI_ERROR (Status)) {
1238       goto Exit;
1239     }
1240
1241     FreePool (Address);
1242     Address = NULL;
1243   }
1244
1245   //
1246   // Set DNS server address list.
1247   //
1248   if (!IsListEmpty (&Ip6NvData->DnsAddress) && (Ip6NvData->DnsAddressCount != 0)) {
1249     Status = Ip6BuildNvAddressInfo (
1250                Instance,
1251                Ip6ConfigNvDnsAddress,
1252                (VOID **) &Address,
1253                &DataSize
1254                );
1255     if (EFI_ERROR (Status)) {
1256       goto Exit;
1257     }
1258
1259     Status = Ip6Config->SetData (
1260                           Ip6Config,
1261                           Ip6ConfigDataTypeDnsServer,
1262                           DataSize,
1263                           (VOID *) Address
1264                           );
1265     if (EFI_ERROR (Status)) {
1266       goto Exit;
1267     }
1268   }
1269
1270   Status = EFI_SUCCESS;
1271
1272 Exit:
1273   if (SetAddressEvent != NULL) {
1274     gBS->CloseEvent (SetAddressEvent);
1275   }
1276
1277   if (TimeoutEvent != NULL) {
1278     gBS->CloseEvent (TimeoutEvent);
1279   }
1280
1281   if (ManualAddress != NULL) {
1282     FreePool (ManualAddress);
1283   }
1284
1285   if (Address != NULL) {
1286     FreePool (Address);
1287   }
1288
1289   return Status;
1290 }
1291
1292
1293 /**
1294   This function allows the caller to request the current
1295   configuration for one or more named elements. The resulting
1296   string is in <ConfigAltResp> format. Any and all alternative
1297   configuration strings shall also be appended to the end of the
1298   current configuration string. If they are, they must appear
1299   after the current configuration. They must contain the same
1300   routing (GUID, NAME, PATH) as the current configuration string.
1301   They must have an additional description indicating the type of
1302   alternative configuration the string represents,
1303   "ALTCFG=<StringToken>". That <StringToken> (when
1304   converted from Hex UNICODE to binary) is a reference to a
1305   string in the associated string pack.
1306
1307   @param[in] This       Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1308   @param[in] Request    A null-terminated Unicode string in
1309                         <ConfigRequest> format. Note that this
1310                         includes the routing information as well as
1311                         the configurable name / value pairs. It is
1312                         invalid for this string to be in
1313                         <MultiConfigRequest> format.
1314   @param[out] Progress  On return, points to a character in the
1315                         Request string. Points to the string's null
1316                         terminator if request was successful. Points
1317                         to the most recent "&" before the first
1318                         failing name / value pair (or the beginning
1319                         of the string if the failure is in the first
1320                         name / value pair) if the request was not
1321                         successful.
1322   @param[out] Results   A null-terminated Unicode string in
1323                         <ConfigAltResp> format which has all values
1324                         filled in for the names in the Request string.
1325                         String to be allocated by the called function.
1326
1327   @retval EFI_SUCCESS             The Results string is filled with the
1328                                   values corresponding to all requested
1329                                   names.
1330   @retval EFI_OUT_OF_RESOURCES    Not enough memory to store the
1331                                   parts of the results that must be
1332                                   stored awaiting possible future
1333                                   protocols.
1334   @retval EFI_INVALID_PARAMETER   For example, passing in a NULL
1335                                   for the Request parameter
1336                                   would result in this type of
1337                                   error. In this case, the
1338                                   Progress parameter would be
1339                                   set to NULL.
1340   @retval EFI_NOT_FOUND           Routing data doesn't match any
1341                                   known driver. Progress set to the
1342                                   first character in the routing header.
1343                                   Note: There is no requirement that the
1344                                   driver validate the routing data. It
1345                                   must skip the <ConfigHdr> in order to
1346                                   process the names.
1347   @retval EFI_INVALID_PARAMETER   Illegal syntax. Progress set
1348                                   to most recent & before the
1349                                   error or the beginning of the
1350                                   string.
1351   @retval EFI_INVALID_PARAMETER   Unknown name. Progress points
1352                                   to the & before the name in
1353                                   question. Currently not implemented.
1354 **/
1355 EFI_STATUS
1356 EFIAPI
1357 Ip6FormExtractConfig (
1358   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
1359   IN  CONST EFI_STRING                       Request,
1360   OUT EFI_STRING                             *Progress,
1361   OUT EFI_STRING                             *Results
1362   )
1363 {
1364
1365   EFI_STATUS                                 Status;
1366   IP6_FORM_CALLBACK_INFO                     *Private;
1367   IP6_CONFIG_INSTANCE                        *Ip6ConfigInstance;
1368   IP6_CONFIG_IFR_NVDATA                      *IfrNvData;
1369   EFI_STRING                                 ConfigRequestHdr;
1370   EFI_STRING                                 ConfigRequest;
1371   BOOLEAN                                    AllocatedRequest;
1372   UINTN                                      Size;
1373   UINTN                                      BufferSize;
1374
1375   if (This == NULL || Progress == NULL || Results == NULL) {
1376     return EFI_INVALID_PARAMETER;
1377   }
1378
1379   *Progress = Request;
1380   if ((Request != NULL) &&
1381       !HiiIsConfigHdrMatch (Request, &gIp6ConfigNvDataGuid, mIp6ConfigStorageName)) {
1382     return EFI_NOT_FOUND;
1383   }
1384
1385   ConfigRequestHdr = NULL;
1386   ConfigRequest    = NULL;
1387   AllocatedRequest = FALSE;
1388   Size             = 0;
1389
1390   Private = IP6_FORM_CALLBACK_INFO_FROM_CONFIG_ACCESS (This);
1391   Ip6ConfigInstance = IP6_CONFIG_INSTANCE_FROM_FORM_CALLBACK (Private);
1392   BufferSize = sizeof (IP6_CONFIG_IFR_NVDATA);
1393
1394   IfrNvData = (IP6_CONFIG_IFR_NVDATA *) AllocateZeroPool (BufferSize);
1395   if (IfrNvData == NULL) {
1396     return EFI_OUT_OF_RESOURCES;
1397   }
1398
1399   Status = Ip6ConvertConfigNvDataToIfrNvData (IfrNvData, Ip6ConfigInstance);
1400   if (EFI_ERROR (Status)) {
1401     goto Exit;
1402   }
1403
1404   ConfigRequest = Request;
1405   if ((Request == NULL) || (StrStr (Request, L"OFFSET") == NULL)) {
1406     //
1407     // Request has no request element, construct full request string.
1408     // Allocate and fill a buffer large enough to hold the <ConfigHdr> template
1409     // followed by "&OFFSET=0&WIDTH=WWWWWWWWWWWWWWWW" followed by a Null-terminator.
1410     //
1411     ConfigRequestHdr = HiiConstructConfigHdr (
1412                          &gIp6ConfigNvDataGuid,
1413                          mIp6ConfigStorageName,
1414                          Private->ChildHandle
1415                          );
1416     Size = (StrLen (ConfigRequestHdr) + 32 + 1) * sizeof (CHAR16);
1417     ConfigRequest = AllocateZeroPool (Size);
1418     ASSERT (ConfigRequest != NULL);
1419     AllocatedRequest = TRUE;
1420     UnicodeSPrint (
1421       ConfigRequest,
1422       Size,
1423       L"%s&OFFSET=0&WIDTH=%016LX",
1424       ConfigRequestHdr,
1425       (UINT64) BufferSize
1426       );
1427     FreePool (ConfigRequestHdr);
1428   }
1429
1430   //
1431   // Convert buffer data to <ConfigResp> by helper function BlockToConfig()
1432   //
1433   Status = gHiiConfigRouting->BlockToConfig (
1434                                 gHiiConfigRouting,
1435                                 ConfigRequest,
1436                                 (UINT8 *) IfrNvData,
1437                                 BufferSize,
1438                                 Results,
1439                                 Progress
1440                                 );
1441
1442 Exit:
1443   FreePool (IfrNvData);
1444   //
1445   // Free the allocated config request string.
1446   //
1447   if (AllocatedRequest) {
1448     FreePool (ConfigRequest);
1449     ConfigRequest = NULL;
1450   }
1451   //
1452   // Set Progress string to the original request string.
1453   //
1454   if (Request == NULL) {
1455     *Progress = NULL;
1456   } else if (StrStr (Request, L"OFFSET") == NULL) {
1457     *Progress = Request + StrLen (Request);
1458   }
1459
1460   return Status;
1461 }
1462
1463 /**
1464   This function applies changes in a driver's configuration.
1465   Input is a Configuration, which has the routing data for this
1466   driver followed by name / value configuration pairs. The driver
1467   must apply those pairs to its configurable storage. If the
1468   driver's configuration is stored in a linear block of data
1469   and the driver's name / value pairs are in <BlockConfig>
1470   format, it may use the ConfigToBlock helper function (above) to
1471   simplify the job. Currently not implemented.
1472
1473   @param[in]  This           Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1474   @param[in]  Configuration  A null-terminated Unicode string in
1475                              <ConfigString> format.
1476   @param[out] Progress       A pointer to a string filled in with the
1477                              offset of the most recent '&' before the
1478                              first failing name / value pair (or the
1479                              beginn ing of the string if the failure
1480                              is in the first name / value pair) or
1481                              the terminating NULL if all was
1482                              successful.
1483
1484   @retval EFI_SUCCESS             The results have been distributed or are
1485                                   awaiting distribution.
1486   @retval EFI_OUT_OF_MEMORY       Not enough memory to store the
1487                                   parts of the results that must be
1488                                   stored awaiting possible future
1489                                   protocols.
1490   @retval EFI_INVALID_PARAMETERS  Passing in a NULL for the
1491                                   Results parameter would result
1492                                   in this type of error.
1493   @retval EFI_NOT_FOUND           Target for the specified routing data
1494                                   was not found.
1495 **/
1496 EFI_STATUS
1497 EFIAPI
1498 Ip6FormRouteConfig (
1499   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
1500   IN  CONST EFI_STRING                       Configuration,
1501   OUT EFI_STRING                             *Progress
1502   )
1503 {
1504   if (This == NULL || Configuration == NULL || Progress == NULL) {
1505     return EFI_INVALID_PARAMETER;
1506   }
1507
1508   //
1509   // Check routing data in <ConfigHdr>.
1510   // Note: if only one Storage is used, then this checking could be skipped.
1511   //
1512   if (!HiiIsConfigHdrMatch (Configuration, &gIp6ConfigNvDataGuid, mIp6ConfigStorageName)) {
1513     *Progress = Configuration;
1514     return EFI_NOT_FOUND;
1515   }
1516
1517   *Progress = Configuration + StrLen (Configuration);
1518
1519   return EFI_SUCCESS;
1520 }
1521
1522 /**
1523   Display host addresses, route table, DNS addresses and gateway addresses in
1524   "IPv6 Current Setting" page.
1525
1526   @param[in]       Instance        The IP6 config instance data.
1527
1528   @retval EFI_SUCCESS              The operation finished successfully.
1529   @retval Others                   Other errors as indicated.
1530
1531 **/
1532 EFI_STATUS
1533 Ip6GetCurrentSetting (
1534   IN IP6_CONFIG_INSTANCE        *Instance
1535   )
1536 {
1537   EFI_IP6_CONFIG_PROTOCOL       *Ip6Config;
1538   EFI_HII_HANDLE                HiiHandle;
1539   EFI_IP6_CONFIG_INTERFACE_INFO *Data;
1540   UINTN                         DataSize;
1541   EFI_STATUS                    Status;
1542   CHAR16                        PortString[ADDRESS_STR_MAX_SIZE];
1543   EFI_IP6_CONFIG_INTERFACE_INFO *IfInfo;
1544
1545
1546   Ip6Config = &Instance->Ip6Config;
1547   HiiHandle = Instance->CallbackInfo.RegisteredHandle;
1548   Data      = NULL;
1549
1550   //
1551   // Get current interface info.
1552   //
1553   Status = Ip6ConfigNvGetData (
1554              Ip6Config,
1555              Ip6ConfigDataTypeInterfaceInfo,
1556              &DataSize,
1557              (VOID **) &Data
1558              );
1559   if (EFI_ERROR (Status)) {
1560     return Status;
1561   }
1562
1563   //
1564   // Generate dynamic text opcode for host address and draw it.
1565   //
1566   IfInfo = (EFI_IP6_CONFIG_INTERFACE_INFO *) Data;
1567   Status = Ip6ConvertAddressListToString (
1568              PortString,
1569              HiiHandle,
1570              Ip6ConfigNvHostAddress,
1571              IfInfo->AddressInfo,
1572              IfInfo->AddressInfoCount
1573              );
1574   if (EFI_ERROR (Status)) {
1575     FreePool (Data);
1576     return Status;
1577   }
1578
1579   //
1580   // Generate the dynamic text opcode for route table and draw it.
1581   //
1582   Status = Ip6ConvertAddressListToString (
1583              PortString,
1584              HiiHandle,
1585              Ip6ConfigNvRouteTable,
1586              IfInfo->RouteTable,
1587              IfInfo->RouteCount
1588              );
1589   if (EFI_ERROR (Status)) {
1590     FreePool (Data);
1591     return Status;
1592   }
1593
1594   //
1595   // Get DNS server list.
1596   //
1597   FreePool (Data);
1598   DataSize = 0;
1599   Data = NULL;
1600   Status = Ip6ConfigNvGetData (
1601              Ip6Config,
1602              Ip6ConfigDataTypeDnsServer,
1603              &DataSize,
1604              (VOID **) &Data
1605              );
1606   if (EFI_ERROR (Status) && (Status != EFI_NOT_FOUND)) {
1607     if (Data != NULL) {
1608       FreePool (Data);
1609     }
1610     return Status;
1611   }
1612
1613   if (DataSize > 0) {
1614     //
1615     // Generate the dynamic text opcode for DNS server and draw it.
1616     //
1617     Status = Ip6ConvertAddressListToString (
1618                PortString,
1619                HiiHandle,
1620                Ip6ConfigNvDnsAddress,
1621                Data,
1622                DataSize / sizeof (EFI_IPv6_ADDRESS)
1623                );
1624     if (EFI_ERROR (Status)) {
1625       FreePool (Data);
1626       return Status;
1627     }
1628   }
1629
1630   //
1631   // Get gateway adderss list.
1632   //
1633   if (Data != NULL) {
1634     FreePool (Data);
1635   }
1636
1637   DataSize = 0;
1638   Data = NULL;
1639   Status = Ip6ConfigNvGetData (
1640              Ip6Config,
1641              Ip6ConfigDataTypeGateway,
1642              &DataSize,
1643              (VOID **) &Data
1644              );
1645   if (EFI_ERROR (Status) && (Status != EFI_NOT_FOUND)) {
1646     if (Data != NULL) {
1647       FreePool (Data);
1648     }
1649     return Status;
1650   }
1651
1652   if (DataSize > 0) {
1653     //
1654     // Generate the dynamic text opcode for gateway and draw it.
1655     //
1656     Status = Ip6ConvertAddressListToString (
1657                PortString,
1658                HiiHandle,
1659                Ip6ConfigNvGatewayAddress,
1660                Data,
1661                DataSize / sizeof (EFI_IPv6_ADDRESS)
1662                );
1663     if (EFI_ERROR (Status)) {
1664       FreePool (Data);
1665       return Status;
1666     }
1667   }
1668
1669   if (Data != NULL) {
1670     FreePool (Data);
1671   }
1672
1673   return EFI_SUCCESS;
1674 }
1675
1676 /**
1677   This function is called to provide results data to the driver.
1678   This data consists of a unique key that is used to identify
1679   which data is either being passed back or being asked for.
1680
1681   @param[in]  This               Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1682   @param[in]  Action             Specifies the type of action taken by the browser.
1683   @param[in]  QuestionId         A unique value which is sent to the original
1684                                  exporting driver so that it can identify the type
1685                                  of data to expect. The format of the data tends to
1686                                  vary based on the opcode that generated the callback.
1687   @param[in]  Type               The type of value for the question.
1688   @param[in]  Value              A pointer to the data being sent to the original
1689                                  exporting driver.
1690   @param[out]  ActionRequest     On return, points to the action requested by the
1691                                  callback function.
1692
1693   @retval EFI_SUCCESS            The callback successfully handled the action.
1694   @retval EFI_OUT_OF_RESOURCES   Not enough storage is available to hold the
1695                                  variable and its data.
1696   @retval EFI_DEVICE_ERROR       The variable could not be saved.
1697   @retval EFI_UNSUPPORTED        The specified Action is not supported by the
1698                                  callback. Currently not implemented.
1699   @retval EFI_INVALID_PARAMETER  Passed in the wrong parameter.
1700   @retval Others                 Other errors as indicated.
1701
1702 **/
1703 EFI_STATUS
1704 EFIAPI
1705 Ip6FormCallback (
1706   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
1707   IN  EFI_BROWSER_ACTION                     Action,
1708   IN  EFI_QUESTION_ID                        QuestionId,
1709   IN  UINT8                                  Type,
1710   IN  EFI_IFR_TYPE_VALUE                     *Value,
1711   OUT EFI_BROWSER_ACTION_REQUEST             *ActionRequest
1712   )
1713 {
1714   IP6_FORM_CALLBACK_INFO        *Private;
1715   UINTN                         BufferSize;
1716   IP6_CONFIG_IFR_NVDATA         *IfrNvData;
1717   EFI_STATUS                    Status;
1718   EFI_INPUT_KEY                 Key;
1719   IP6_CONFIG_INSTANCE           *Instance;
1720   IP6_CONFIG_NVDATA             *Ip6NvData;
1721
1722   if (This == NULL) {
1723     return EFI_INVALID_PARAMETER;
1724   }
1725
1726   Private   = IP6_FORM_CALLBACK_INFO_FROM_CONFIG_ACCESS (This);
1727   Instance  = IP6_CONFIG_INSTANCE_FROM_FORM_CALLBACK (Private);
1728   Ip6NvData = &Instance->Ip6NvData;
1729
1730   if ((Action == EFI_BROWSER_ACTION_FORM_OPEN) || (Action == EFI_BROWSER_ACTION_FORM_CLOSE)){
1731     return EFI_SUCCESS;
1732   }
1733
1734   if (Action != EFI_BROWSER_ACTION_CHANGING && Action != EFI_BROWSER_ACTION_CHANGED) {
1735     return EFI_UNSUPPORTED;
1736   }
1737
1738   if ((Value == NULL) || (ActionRequest == NULL)) {
1739     return EFI_INVALID_PARAMETER;
1740   }
1741
1742   //
1743   // Retrieve uncommitted data from Browser
1744   //
1745
1746   BufferSize = sizeof (IP6_CONFIG_IFR_NVDATA);
1747   IfrNvData = AllocateZeroPool (BufferSize);
1748   if (IfrNvData == NULL) {
1749     return EFI_OUT_OF_RESOURCES;
1750   }
1751
1752   Status = EFI_SUCCESS;
1753
1754   HiiGetBrowserData (NULL, NULL, BufferSize, (UINT8 *) IfrNvData);
1755
1756   if (Action == EFI_BROWSER_ACTION_CHANGING) {
1757     switch (QuestionId) {
1758     case KEY_GET_CURRENT_SETTING:
1759       Status = Ip6GetCurrentSetting (Instance);
1760       break;
1761
1762     default:
1763       break;
1764     }
1765   } else if (Action == EFI_BROWSER_ACTION_CHANGED) {
1766     switch (QuestionId) {
1767     case KEY_SAVE_CONFIG_CHANGES:
1768       Status = Ip6ConvertIfrNvDataToConfigNvDataAdvanced (IfrNvData, Instance);
1769       if (EFI_ERROR (Status)) {
1770         break;
1771       }
1772
1773       Status = Ip6GetCurrentSetting (Instance);
1774
1775       *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT;
1776       break;
1777
1778     case KEY_IGNORE_CONFIG_CHANGES:
1779       Ip6FreeAddressInfoList (&Ip6NvData->ManualAddress);
1780       Ip6FreeAddressInfoList (&Ip6NvData->GatewayAddress);
1781       Ip6FreeAddressInfoList (&Ip6NvData->DnsAddress);
1782
1783       Ip6NvData->ManualAddressCount  = 0;
1784       Ip6NvData->GatewayAddressCount = 0;
1785       Ip6NvData->DnsAddressCount     = 0;
1786
1787       *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT;
1788       break;
1789
1790     case KEY_SAVE_CHANGES:
1791       Status = Ip6ConvertIfrNvDataToConfigNvDataGeneral (IfrNvData, Instance);
1792       if (EFI_ERROR (Status)) {
1793         break;
1794       }
1795       *ActionRequest = EFI_BROWSER_ACTION_REQUEST_SUBMIT;
1796       break;
1797
1798     case KEY_INTERFACE_ID:
1799       Status = Ip6ParseInterfaceIdFromString (IfrNvData->InterfaceId, &Ip6NvData->InterfaceId);
1800       if (EFI_ERROR (Status)) {
1801         CreatePopUp (
1802           EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
1803           &Key,
1804           L"Invalid Interface ID!",
1805           NULL
1806           );
1807       }
1808
1809       break;
1810
1811     case KEY_MANUAL_ADDRESS:
1812       Status = Ip6ParseAddressListFromString (
1813                  IfrNvData->ManualAddress,
1814                  &Ip6NvData->ManualAddress,
1815                  &Ip6NvData->ManualAddressCount
1816                  );
1817       if (EFI_ERROR (Status)) {
1818         CreatePopUp (
1819           EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
1820           &Key,
1821           L"Invalid Host Addresses!",
1822           NULL
1823           );
1824       }
1825
1826       break;
1827
1828     case KEY_GATEWAY_ADDRESS:
1829       Status = Ip6ParseAddressListFromString (
1830                  IfrNvData->GatewayAddress,
1831                  &Ip6NvData->GatewayAddress,
1832                  &Ip6NvData->GatewayAddressCount
1833                  );
1834       if (EFI_ERROR (Status)) {
1835         CreatePopUp (
1836           EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
1837           &Key,
1838           L"Invalid Gateway Addresses!",
1839           NULL
1840           );
1841       }
1842
1843       break;
1844
1845     case KEY_DNS_ADDRESS:
1846       Status = Ip6ParseAddressListFromString (
1847                  IfrNvData->DnsAddress,
1848                  &Ip6NvData->DnsAddress,
1849                  &Ip6NvData->DnsAddressCount
1850                  );
1851       if (EFI_ERROR (Status)) {
1852         CreatePopUp (
1853           EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
1854           &Key,
1855           L"Invalid DNS Addresses!",
1856           NULL
1857           );
1858       }
1859
1860       break;
1861
1862     default:
1863       break;
1864     }
1865   }
1866
1867   if (!EFI_ERROR (Status)) {
1868     //
1869     // Pass changed uncommitted data back to Form Browser.
1870     //
1871     BufferSize = sizeof (IP6_CONFIG_IFR_NVDATA);
1872     HiiSetBrowserData (NULL, NULL, BufferSize, (UINT8 *) IfrNvData, NULL);
1873   }
1874
1875   FreePool (IfrNvData);
1876   return Status;
1877 }
1878
1879 /**
1880   Install HII Config Access protocol for network device and allocate resources.
1881
1882   @param[in, out]  Instance      The IP6_CONFIG_INSTANCE to create a form.
1883
1884   @retval EFI_SUCCESS            The HII Config Access protocol is installed.
1885   @retval EFI_OUT_OF_RESOURCES   Failed to allocate memory.
1886   @retval Others                 Other errors as indicated.
1887
1888 **/
1889 EFI_STATUS
1890 Ip6ConfigFormInit (
1891   IN OUT IP6_CONFIG_INSTANCE     *Instance
1892   )
1893 {
1894   EFI_STATUS                     Status;
1895   IP6_SERVICE                    *IpSb;
1896   IP6_FORM_CALLBACK_INFO         *CallbackInfo;
1897   EFI_HII_CONFIG_ACCESS_PROTOCOL *ConfigAccess;
1898   VENDOR_DEVICE_PATH             VendorDeviceNode;
1899   EFI_SERVICE_BINDING_PROTOCOL   *MnpSb;
1900   CHAR16                         *MacString;
1901   CHAR16                         MenuString[128];
1902   CHAR16                         PortString[128];
1903   CHAR16                         *OldMenuString;
1904   EFI_DEVICE_PATH_PROTOCOL       *ParentDevicePath;
1905
1906   IpSb = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);
1907   ASSERT (IpSb != NULL);
1908
1909   Status = gBS->HandleProtocol (
1910                   IpSb->Controller,
1911                   &gEfiDevicePathProtocolGuid,
1912                   (VOID **) &ParentDevicePath
1913                   );
1914   if (EFI_ERROR (Status)) {
1915     return Status;
1916   }
1917
1918   CallbackInfo = &Instance->CallbackInfo;
1919   CallbackInfo->Signature = IP6_FORM_CALLBACK_INFO_SIGNATURE;
1920
1921   //
1922   // Construct device path node for EFI HII Config Access protocol,
1923   // which consists of controller physical device path and one hardware
1924   // vendor guid node.
1925   //
1926   ZeroMem (&VendorDeviceNode, sizeof (VENDOR_DEVICE_PATH));
1927   VendorDeviceNode.Header.Type    = HARDWARE_DEVICE_PATH;
1928   VendorDeviceNode.Header.SubType = HW_VENDOR_DP;
1929
1930   CopyGuid (&VendorDeviceNode.Guid, &gEfiCallerIdGuid);
1931
1932   SetDevicePathNodeLength (&VendorDeviceNode.Header, sizeof (VENDOR_DEVICE_PATH));
1933   CallbackInfo->HiiVendorDevicePath = AppendDevicePathNode (
1934                                         ParentDevicePath,
1935                                         (EFI_DEVICE_PATH_PROTOCOL *) &VendorDeviceNode
1936                                         );
1937   if (CallbackInfo->HiiVendorDevicePath == NULL) {
1938     Status = EFI_OUT_OF_RESOURCES;
1939     goto Error;
1940   }
1941
1942   ConfigAccess                = &CallbackInfo->HiiConfigAccess;
1943   ConfigAccess->ExtractConfig = Ip6FormExtractConfig;
1944   ConfigAccess->RouteConfig   = Ip6FormRouteConfig;
1945   ConfigAccess->Callback      = Ip6FormCallback;
1946
1947   //
1948   // Install Device Path Protocol and Config Access protocol on new handle
1949   //
1950   Status = gBS->InstallMultipleProtocolInterfaces (
1951                   &CallbackInfo->ChildHandle,
1952                   &gEfiDevicePathProtocolGuid,
1953                   CallbackInfo->HiiVendorDevicePath,
1954                   &gEfiHiiConfigAccessProtocolGuid,
1955                   ConfigAccess,
1956                   NULL
1957                   );
1958   if (!EFI_ERROR (Status)) {
1959     //
1960     // Open the Parent Handle for the child
1961     //
1962     Status = gBS->OpenProtocol (
1963                     IpSb->Controller,
1964                     &gEfiManagedNetworkServiceBindingProtocolGuid,
1965                     (VOID **) &MnpSb,
1966                     IpSb->Image,
1967                     CallbackInfo->ChildHandle,
1968                     EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
1969                     );
1970   }
1971
1972   if (EFI_ERROR (Status)) {
1973     goto Error;
1974   }
1975
1976   //
1977   // Publish our HII data
1978   //
1979   CallbackInfo->RegisteredHandle = HiiAddPackages (
1980                                      &gIp6ConfigNvDataGuid,
1981                                      CallbackInfo->ChildHandle,
1982                                      Ip6DxeStrings,
1983                                      Ip6ConfigBin,
1984                                      NULL
1985                                      );
1986   if (CallbackInfo->RegisteredHandle == NULL) {
1987     Status = EFI_OUT_OF_RESOURCES;
1988     goto Error;
1989   }
1990
1991   //
1992   // Append MAC string in the menu help string and tile help string
1993   //
1994   Status = NetLibGetMacString (IpSb->Controller, IpSb->Image, &MacString);
1995   if (!EFI_ERROR (Status)) {
1996     OldMenuString = HiiGetString (
1997                       CallbackInfo->RegisteredHandle,
1998                       STRING_TOKEN (STR_IP6_CONFIG_FORM_HELP),
1999                       NULL)
2000                       ;
2001     UnicodeSPrint (MenuString, 128, L"%s (MAC:%s)", OldMenuString, MacString);
2002     HiiSetString (
2003       CallbackInfo->RegisteredHandle,
2004       STRING_TOKEN (STR_IP6_CONFIG_FORM_HELP),
2005       MenuString,
2006       NULL
2007       );
2008     UnicodeSPrint (PortString, 128, L"MAC:%s", MacString);
2009     HiiSetString (
2010       CallbackInfo->RegisteredHandle,
2011       STRING_TOKEN (STR_IP6_DEVICE_FORM_HELP),
2012       PortString,
2013       NULL
2014       );
2015
2016     FreePool (MacString);
2017     FreePool (OldMenuString);
2018
2019     InitializeListHead (&Instance->Ip6NvData.ManualAddress);
2020     InitializeListHead (&Instance->Ip6NvData.GatewayAddress);
2021     InitializeListHead (&Instance->Ip6NvData.DnsAddress);
2022
2023     return EFI_SUCCESS;
2024   }
2025
2026 Error:
2027   Ip6ConfigFormUnload (Instance);
2028   return Status;
2029 }
2030
2031 /**
2032   Uninstall the HII Config Access protocol for network devices and free up the resources.
2033
2034   @param[in, out]  Instance      The IP6_CONFIG_INSTANCE to unload a form.
2035
2036 **/
2037 VOID
2038 Ip6ConfigFormUnload (
2039   IN OUT IP6_CONFIG_INSTANCE     *Instance
2040   )
2041 {
2042   IP6_SERVICE                    *IpSb;
2043   IP6_FORM_CALLBACK_INFO         *CallbackInfo;
2044   IP6_CONFIG_NVDATA              *Ip6NvData;
2045
2046   IpSb = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);
2047   ASSERT (IpSb != NULL);
2048
2049   CallbackInfo = &Instance->CallbackInfo;
2050
2051   if (CallbackInfo->ChildHandle != NULL) {
2052
2053     //
2054     // Close the child handle
2055     //
2056     gBS->CloseProtocol (
2057            IpSb->Controller,
2058            &gEfiManagedNetworkServiceBindingProtocolGuid,
2059            IpSb->Image,
2060            CallbackInfo->ChildHandle
2061            );
2062     //
2063     // Uninstall EFI_HII_CONFIG_ACCESS_PROTOCOL
2064     //
2065     gBS->UninstallMultipleProtocolInterfaces (
2066            CallbackInfo->ChildHandle,
2067            &gEfiDevicePathProtocolGuid,
2068            CallbackInfo->HiiVendorDevicePath,
2069            &gEfiHiiConfigAccessProtocolGuid,
2070            &CallbackInfo->HiiConfigAccess,
2071            NULL
2072            );
2073   }
2074
2075   if (CallbackInfo->HiiVendorDevicePath != NULL) {
2076     FreePool (CallbackInfo->HiiVendorDevicePath);
2077   }
2078
2079   if (CallbackInfo->RegisteredHandle != NULL) {
2080     //
2081     // Remove HII package list
2082     //
2083     HiiRemovePackages (CallbackInfo->RegisteredHandle);
2084   }
2085
2086   Ip6NvData = &Instance->Ip6NvData;
2087
2088   Ip6FreeAddressInfoList (&Ip6NvData->ManualAddress);
2089   Ip6FreeAddressInfoList (&Ip6NvData->GatewayAddress);
2090   Ip6FreeAddressInfoList (&Ip6NvData->DnsAddress);
2091
2092   Ip6NvData->ManualAddressCount  = 0;
2093   Ip6NvData->GatewayAddressCount = 0;
2094   Ip6NvData->DnsAddressCount     = 0;
2095 }