[mirror_edk2.git] / MdeModulePkg / Universal / HiiDatabaseDxe / ConfigRouting.c

/** @file\r
\r
Copyright (c) 2007 - 2008, Intel Corporation\r
All rights reserved. This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
Module Name:\r
\r
    ConfigRouting.c\r
\r
Abstract:\r
\r
    Implementation for EFI_HII_CONFIG_ROUTING_PROTOCOL.\r
\r
Revision History\r
\r
\r
**/\r
\r
\r
#include "HiiDatabase.h"\r
\r
#ifndef _DISABLE_UNUSED_HII_PROTOCOLS_\r
\r
/**\r
  Calculate the number of Unicode characters of the incoming Configuration string,\r
  not including NULL terminator.\r
\r
  This is a internal function.\r
\r
  @param  String                 String in <MultiConfigRequest> or\r
                                 <MultiConfigResp> format.\r
\r
  @return The number of Unicode characters.\r
\r
**/\r
UINTN\r
CalculateConfigStringLen (\r
  IN EFI_STRING                    String\r
  )\r
{\r
  UINTN Length;\r
\r
  //\r
  // "GUID=" should be the first element of incoming string.\r
  //\r
  ASSERT (String != NULL);\r
  ASSERT (StrnCmp (String, L"GUID=", StrLen (L"GUID=")) == 0);\r
\r
  Length  = StrLen (L"GUID=");\r
  String += Length;\r
\r
  //\r
  // The beginning of next <ConfigRequest>/<ConfigResp> should be "&GUID=".\r
  // Will meet '\0' if there is only one <ConfigRequest>/<ConfigResp>.\r
  //\r
  while (*String != 0 && StrnCmp (String, L"&GUID=", StrLen (L"&GUID=")) != 0) {\r
    Length++;\r
    String++;\r
  }\r
\r
  return Length;\r
}\r
\r
\r
/**\r
  Convert the hex UNICODE %02x encoding of a UEFI device path to binary\r
  from <PathHdr> of <ConfigHdr>.\r
\r
  This is a internal function.\r
\r
  @param  String                 UEFI configuration string\r
  @param  DevicePath             binary of a UEFI device path.\r
\r
  @retval EFI_INVALID_PARAMETER  Any incoming parameter is invalid.\r
  @retval EFI_OUT_OF_RESOURCES   Lake of resources to store neccesary structures.\r
  @retval EFI_SUCCESS            The device path is retrieved and translated to\r
                                 binary format.\r
\r
**/\r
EFI_STATUS\r
GetDevicePath (\r
  IN  EFI_STRING                   String,\r
  OUT UINT8                        **DevicePath\r
  )\r
{\r
  UINTN      Length;\r
  EFI_STRING PathHdr;\r
  EFI_STRING DevicePathString;\r
\r
  if (String == NULL || DevicePath == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Find the 'PATH=' of <PathHdr> and skip it.\r
  //\r
  for (; (*String != 0 && StrnCmp (String, L"PATH=", StrLen (L"PATH=")) != 0); String++);\r
  if (*String == 0) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  String += StrLen (L"PATH=");\r
  PathHdr = String;\r
\r
  //\r
  // The content between 'PATH=' of <ConfigHdr> and '&' of next element\r
  // or '\0' (end of configuration string) is the UNICODE %02x bytes encoding\r
  // of UEFI device path.\r
  //\r
  for (Length = 0; *String != 0 && *String != L'&'; String++, Length++);\r
  DevicePathString = (EFI_STRING) AllocateZeroPool ((Length + 1) * sizeof (CHAR16));\r
  if (DevicePathString == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
  StrnCpy (DevicePathString, PathHdr, Length);\r
  *(DevicePathString + Length) = 0;\r
\r
  //\r
  // The data in <PathHdr> is encoded as hex UNICODE %02x bytes in the same order\r
  // as the device path resides in RAM memory.\r
  // Translate the data into binary.\r
  //\r
  Length /= 2;\r
  *DevicePath = (UINT8 *) AllocateZeroPool (Length);\r
  if (*DevicePath == NULL) {\r
    SafeFreePool (DevicePathString);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  HexStringToBuffer (*DevicePath, &Length, DevicePathString);\r
\r
  SafeFreePool (DevicePathString);\r
\r
  return EFI_SUCCESS;\r
\r
}\r
\r
\r
/**\r
  Extract Storage from all Form Packages in current hii database.\r
\r
  This is a internal function.\r
\r
  @param  HiiDatabase            EFI_HII_DATABASE_PROTOCOL instance.\r
  @param  StorageListHead        Storage link List head.\r
\r
  @retval EFI_NOT_FOUND          There is no form package in current hii database.\r
  @retval EFI_INVALID_PARAMETER  Any parameter is invalid.\r
  @retval EFI_SUCCESS            All existing storage is exported.\r
\r
**/\r
EFI_STATUS\r
ExportAllStorage (\r
  IN EFI_HII_DATABASE_PROTOCOL     *HiiDatabase,\r
  IN OUT LIST_ENTRY                *StorageListHead\r
)\r
{\r
  EFI_STATUS                   Status;\r
  UINTN                        BufferSize;\r
  UINTN                        HandleCount;\r
  EFI_HII_HANDLE               *HandleBuffer;\r
  UINTN                        Index;\r
  UINTN                        Index2;\r
  EFI_HII_PACKAGE_LIST_HEADER  *HiiPackageList;\r
  EFI_HII_PACKAGE_HEADER       *Package;\r
  UINT8                        *OpCodeData;\r
  UINT8                        Operand;\r
  UINT32                       Offset;\r
  HII_FORMSET_STORAGE          *Storage;\r
  EFI_HII_HANDLE               HiiHandle;\r
  EFI_HANDLE                   DriverHandle;\r
  CHAR8                        *AsciiString;\r
  UINT32                       PackageListLength;\r
  EFI_HII_PACKAGE_HEADER       PackageHeader;\r
\r
  //\r
  // Find the package list which contains Form package.\r
  //\r
  BufferSize   = 0;\r
  HandleBuffer = NULL;\r
  Status = HiiListPackageLists (\r
             HiiDatabase,\r
             EFI_HII_PACKAGE_FORM,\r
             NULL,\r
             &BufferSize,\r
             HandleBuffer\r
             );\r
  if (Status == EFI_BUFFER_TOO_SMALL) {\r
    HandleBuffer = AllocateZeroPool (BufferSize);\r
    ASSERT (HandleBuffer != NULL);\r
\r
    Status = HiiListPackageLists (\r
               HiiDatabase,\r
               EFI_HII_PACKAGE_FORM,\r
               NULL,\r
               &BufferSize,\r
               HandleBuffer\r
               );\r
  }\r
  if (EFI_ERROR (Status)) {\r
    SafeFreePool (HandleBuffer);\r
    return Status;\r
  }\r
\r
  HandleCount = BufferSize / sizeof (EFI_HII_HANDLE);\r
  for (Index = 0; Index < HandleCount; Index++) {\r
    HiiHandle = HandleBuffer[Index];\r
\r
    BufferSize     = 0;\r
    HiiPackageList = NULL;\r
    Status = HiiExportPackageLists (HiiDatabase, HiiHandle, &BufferSize, HiiPackageList);\r
    if (Status == EFI_BUFFER_TOO_SMALL) {\r
      HiiPackageList = AllocateZeroPool (BufferSize);\r
      ASSERT (HiiPackageList != NULL);\r
      Status = HiiExportPackageLists (HiiDatabase, HiiHandle, &BufferSize, HiiPackageList);\r
    }\r
    if (EFI_ERROR (Status)) {\r
      SafeFreePool (HandleBuffer);\r
      SafeFreePool (HiiPackageList);\r
      return Status;\r
    }\r
\r
    //\r
    // Get Form package from this HII package List\r
    //\r
    Offset  = sizeof (EFI_HII_PACKAGE_LIST_HEADER);\r
    CopyMem (&PackageListLength, &HiiPackageList->PackageLength, sizeof (UINT32));\r
    Package = NULL;\r
    ZeroMem (&PackageHeader, sizeof (EFI_HII_PACKAGE_HEADER));\r
\r
    while (Offset < PackageListLength) {\r
      Package = (EFI_HII_PACKAGE_HEADER *) (((UINT8 *) HiiPackageList) + Offset);\r
      CopyMem (&PackageHeader, Package, sizeof (EFI_HII_PACKAGE_HEADER));\r
      if (PackageHeader.Type == EFI_HII_PACKAGE_FORM) {\r
        break;\r
      }\r
      Offset += PackageHeader.Length;\r
    }\r
    if (Offset >= PackageListLength) {\r
      //\r
      // Error here: No Form package found in this Package List\r
      //\r
      ASSERT (FALSE);\r
    }\r
\r
    //\r
    // Search Storage definition in this Form package\r
    //\r
    Offset = sizeof (EFI_HII_PACKAGE_HEADER);\r
    while (Offset < PackageHeader.Length) {\r
      OpCodeData = ((UINT8 *) Package) + Offset;\r
      Offset += ((EFI_IFR_OP_HEADER *) OpCodeData)->Length;\r
\r
      Operand = ((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode;\r
\r
      if ((Operand == EFI_IFR_VARSTORE_OP) ||\r
          (Operand == EFI_IFR_VARSTORE_NAME_VALUE_OP) ||\r
          (Operand == EFI_IFR_VARSTORE_EFI_OP)) {\r
\r
        Storage = AllocateZeroPool (sizeof (HII_FORMSET_STORAGE));\r
        ASSERT (Storage != NULL);\r
        InsertTailList (StorageListHead, &Storage->Entry);\r
\r
        Storage->Signature = HII_FORMSET_STORAGE_SIGNATURE;\r
        Storage->HiiHandle = HiiHandle;\r
\r
        Status = HiiGetPackageListHandle (HiiDatabase, HiiHandle, &DriverHandle);\r
        if (EFI_ERROR (Status)) {\r
          SafeFreePool (HandleBuffer);\r
          SafeFreePool (HiiPackageList);\r
          SafeFreePool (Storage);\r
          return Status;\r
        }\r
        Storage->DriverHandle = DriverHandle;\r
\r
        if (Operand == EFI_IFR_VARSTORE_OP) {\r
          Storage->Type = EFI_HII_VARSTORE_BUFFER;\r
\r
          CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE *) OpCodeData)->Guid, sizeof (EFI_GUID));\r
          CopyMem (&Storage->Size, &((EFI_IFR_VARSTORE *) OpCodeData)->Size, sizeof (UINT16));\r
\r
          AsciiString = (CHAR8 *) ((EFI_IFR_VARSTORE *) OpCodeData)->Name;\r
          Storage->Name = AllocateZeroPool (AsciiStrSize (AsciiString) * 2);\r
          ASSERT (Storage->Name != NULL);\r
          for (Index2 = 0; AsciiString[Index2] != 0; Index2++) {\r
            Storage->Name[Index2] = (CHAR16) AsciiString[Index2];\r
          }\r
          //\r
          // Append '\0' to the end of the unicode string.\r
          //\r
          Storage->Name[Index2] = 0;\r
        } else if (Operand == EFI_IFR_VARSTORE_NAME_VALUE_OP) {\r
          Storage->Type = EFI_HII_VARSTORE_NAME_VALUE;\r
\r
          CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE_NAME_VALUE *) OpCodeData)->Guid, sizeof (EFI_GUID));\r
        } else if (Operand == EFI_IFR_VARSTORE_EFI_OP) {\r
          Storage->Type = EFI_HII_VARSTORE_EFI_VARIABLE;\r
\r
          CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->Guid, sizeof (EFI_GUID));\r
        }\r
      }\r
    }\r
\r
    SafeFreePool (HiiPackageList);\r
  }\r
\r
  SafeFreePool (HandleBuffer);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Generate a sub string then output it.\r
\r
  This is a internal function.\r
\r
  @param  String                 A constant string which is the prefix of the to be\r
                                 generated string, e.g. GUID=\r
  @param  BufferLen              The length of the Buffer in bytes.\r
  @param  Buffer                 Points to a buffer which will be converted to be the \r
                                          content of the generated string.\r
  @param  Flag           If 1, the buffer contains data for the value of GUID or PATH stored in \r
                                UINT8 *; if 2, the buffer contains unicode string for the value of NAME;\r
                                if 3, the buffer contains other data.\r
  @param  SubStr                 Points to the output string. It's caller's\r
                                 responsibility to free this buffer.\r
\r
\r
**/\r
VOID\r
GenerateSubStr (\r
  IN CONST EFI_STRING              String,\r
  IN  UINTN                        BufferLen,\r
  IN  VOID                         *Buffer,\r
  IN  UINT8                        Flag,\r
  OUT EFI_STRING                   *SubStr\r
  )\r
{\r
  UINTN       Length;\r
  EFI_STRING  Str;\r
  EFI_STATUS  Status;\r
  EFI_STRING  StringHeader;\r
\r
  ASSERT (String != NULL && SubStr != NULL);\r
\r
  if (Buffer == NULL) {\r
    *SubStr = AllocateCopyPool (StrSize (String), String);\r
    ASSERT (*SubStr != NULL);\r
    return ;\r
  }\r
\r
  Length = StrLen (String) + BufferLen * 2 + 1 + 1;\r
  Str = AllocateZeroPool (Length * sizeof (CHAR16));\r
  ASSERT (Str != NULL);\r
\r
  StrCpy (Str, String);\r
  Length = (BufferLen * 2 + 1) * sizeof (CHAR16);\r
\r
  Status       = EFI_SUCCESS;\r
  StringHeader = Str + StrLen (String);\r
\r
  switch (Flag) {\r
  case 1:\r
    Status = BufferToHexString (StringHeader, (UINT8 *) Buffer, BufferLen);\r
    break;\r
  case 2:\r
    Status = UnicodeToConfigString (StringHeader, &Length, (CHAR16 *) Buffer);\r
    break;\r
  case 3:\r
    Status = BufToHexString (StringHeader, &Length, (UINT8 *) Buffer, BufferLen);\r
    //\r
    // Convert the uppercase to lowercase since <HexAf> is defined in lowercase format.\r
    //\r
    ToLower (StringHeader);\r
    break;\r
  default:\r
    break;\r
  }\r
\r
  ASSERT_EFI_ERROR (Status);\r
  StrCat (Str, L"&");\r
\r
  *SubStr = Str;\r
}\r
\r
\r
/**\r
  Retrieve the <ConfigBody> from String then output it.\r
\r
  This is a internal function.\r
\r
  @param  String                 A sub string of a configuration string in\r
                                 <MultiConfigAltResp> format.\r
  @param  ConfigBody             Points to the output string. It's caller's\r
                                 responsibility to free this buffer.\r
\r
  @retval EFI_INVALID_PARAMETER  There is no form package in current hii database.\r
  @retval EFI_OUT_OF_RESOURCES   Not enough memory to finish this operation.\r
  @retval EFI_SUCCESS            All existing storage is exported.\r
\r
**/\r
EFI_STATUS\r
OutputConfigBody (\r
  IN  EFI_STRING                   String,\r
  OUT EFI_STRING                   *ConfigBody\r
  )\r
{\r
  EFI_STRING  TmpPtr;\r
  EFI_STRING  Result;\r
  UINTN       Length;\r
\r
  if (String == NULL || ConfigBody == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  TmpPtr = StrStr (String, L"GUID=");\r
  if (TmpPtr == NULL) {\r
    //\r
    // It is the last <ConfigResp> of the incoming configuration string.\r
    //\r
    Result = AllocateCopyPool (StrSize (String), String);\r
    if (Result == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    } else {\r
      *ConfigBody = Result;\r
      return EFI_SUCCESS;\r
    }\r
  }\r
\r
  Length = TmpPtr - String;\r
  Result = AllocateCopyPool (Length * sizeof (CHAR16), String);\r
  if (Result == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  *(Result + Length - 1) = 0;\r
  *ConfigBody = Result;\r
  return EFI_SUCCESS;\r
\r
}\r
\r
\r
#endif\r
\r
/**\r
  Adjusts the size of a previously allocated buffer.\r
\r
\r
  @param OldPool         A pointer to the buffer whose size is being adjusted.\r
  @param OldSize         The size of the current buffer.\r
  @param NewSize         The size of the new buffer.\r
\r
  @return The new buffer allocated.\r
\r
**/\r
VOID *\r
ReallocatePool (\r
  IN VOID                          *OldPool,\r
  IN UINTN                         OldSize,\r
  IN UINTN                         NewSize\r
  )\r
{\r
  VOID  *NewPool;\r
\r
  NewPool = NULL;\r
  if (NewSize != 0) {\r
    NewPool = AllocateZeroPool (NewSize);\r
  }\r
\r
  if (OldPool != NULL) {\r
    if (NewPool != NULL) {\r
      CopyMem (NewPool, OldPool, OldSize < NewSize ? OldSize : NewSize);\r
    }\r
\r
    gBS->FreePool (OldPool);\r
  }\r
\r
  return NewPool;\r
}\r
\r
\r
/**\r
  Append a string to a multi-string format.\r
\r
  This is a internal function.\r
\r
  @param  MultiString            String in <MultiConfigRequest>,\r
                                 <MultiConfigAltResp>, or <MultiConfigResp>. On\r
                                 input, the buffer length of  this string is\r
                                 MAX_STRING_LENGTH. On output, the  buffer length\r
                                 might be updated.\r
  @param  AppendString           NULL-terminated Unicode string.\r
\r
  @retval EFI_INVALID_PARAMETER  Any incoming parameter is invalid.\r
  @retval EFI_SUCCESS            AppendString is append to the end of MultiString\r
\r
**/\r
EFI_STATUS\r
AppendToMultiString (\r
  IN OUT EFI_STRING                *MultiString,\r
  IN EFI_STRING                    AppendString\r
  )\r
{\r
  UINTN AppendStringSize;\r
  UINTN MultiStringSize;\r
\r
  if (MultiString == NULL || *MultiString == NULL || AppendString == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  AppendStringSize = StrSize (AppendString);\r
  MultiStringSize  = StrSize (*MultiString);\r
\r
  //\r
  // Enlarge the buffer each time when length exceeds MAX_STRING_LENGTH.\r
  //\r
  if (MultiStringSize + AppendStringSize > MAX_STRING_LENGTH ||\r
      MultiStringSize > MAX_STRING_LENGTH) {\r
    *MultiString = (EFI_STRING) ReallocatePool (\r
                                  (VOID *) (*MultiString),\r
                                  MultiStringSize,\r
                                  MultiStringSize + AppendStringSize\r
                                  );\r
  }\r
\r
  //\r
  // Append the incoming string\r
  //\r
  StrCat (*MultiString, AppendString);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Get the value of <Number> in <BlockConfig> format, i.e. the value of OFFSET\r
  or WIDTH or VALUE.\r
  <BlockConfig> ::= 'OFFSET='<Number>&'WIDTH='<Number>&'VALUE'=<Number>\r
\r
  This is a internal function.\r
\r
  @param  StringPtr              String in <BlockConfig> format and points to the\r
                                 first character of <Number>.\r
  @param  Number                 The output value. Caller takes the responsibility\r
                                 to free memory.\r
  @param  Len                    Length of the <Number>, in characters.\r
\r
  @retval EFI_OUT_OF_RESOURCES   Insufficient resources to store neccessary\r
                                 structures.\r
  @retval EFI_SUCCESS            Value of <Number> is outputted in Number\r
                                 successfully.\r
\r
**/\r
EFI_STATUS\r
GetValueOfNumber (\r
  IN EFI_STRING                    StringPtr,\r
  OUT UINT8                        **Number,\r
  OUT UINTN                        *Len\r
  )\r
{\r
  EFI_STRING               TmpPtr;\r
  UINTN                    Length;\r
  EFI_STRING               Str;\r
  UINT8                    *Buf;\r
  EFI_STATUS               Status;\r
\r
  ASSERT (StringPtr != NULL && Number != NULL && Len != NULL);\r
  ASSERT (*StringPtr != 0);\r
\r
  Buf = NULL;\r
\r
  TmpPtr = StringPtr;\r
  while (*StringPtr != 0 && *StringPtr != L'&') {\r
    StringPtr++;\r
  }\r
  *Len   = StringPtr - TmpPtr;\r
  Length = *Len + 1;\r
\r
  Str = (EFI_STRING) AllocateZeroPool (Length * sizeof (EFI_STRING));\r
  if (Str == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto Exit;\r
  }\r
  CopyMem (Str, TmpPtr, *Len * sizeof (CHAR16));\r
  *(Str + *Len) = 0;\r
\r
  Length = (Length + 1) / 2;\r
  Buf = (UINT8 *) AllocateZeroPool (Length);\r
  if (Buf == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto Exit;\r
  }\r
\r
  Status = HexStringToBuf (Buf, &Length, Str, NULL);\r
  if (EFI_ERROR (Status)) {\r
    goto Exit;\r
  }\r
\r
  *Number = Buf;\r
  Status  = EFI_SUCCESS;\r
\r
Exit:\r
  SafeFreePool (Str);\r
  return Status;\r
}\r
\r
\r
/**\r
  This function allows a caller to extract the current configuration\r
  for one or more named elements from one or more drivers.\r
\r
  @param  This                   A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL\r
                                 instance.\r
  @param  Request                A null-terminated Unicode string in\r
                                 <MultiConfigRequest> format.\r
  @param  Progress               On return, points to a character in the Request\r
                                 string. Points to the string's null terminator if\r
                                 request was successful. Points to the most recent\r
                                 & before the first failing name / value pair (or\r
                                 the beginning of the string if the failure is in\r
                                 the first name / value pair) if the request was\r
                                 not successful.\r
  @param  Results                Null-terminated Unicode string in\r
                                 <MultiConfigAltResp> format which has all values\r
                                 filled in for the names in the Request string.\r
                                 String to be allocated by the called function.\r
\r
  @retval EFI_SUCCESS            The Results string is filled with the values\r
                                 corresponding to all requested names.\r
  @retval EFI_OUT_OF_RESOURCES   Not enough memory to store the parts of the\r
                                 results that must be stored awaiting possible\r
                                 future        protocols.\r
  @retval EFI_NOT_FOUND          Routing data doesn't match any known driver.\r
                                   Progress set to the "G" in "GUID" of the routing\r
                                  header that doesn't match. Note: There is no\r
                                    requirement that all routing data be validated\r
                                 before any configuration extraction.\r
  @retval EFI_INVALID_PARAMETER  For example, passing in a NULL for the Request\r
                                 parameter would result in this type of error. The\r
                                 Progress parameter is set to NULL.\r
  @retval EFI_INVALID_PARAMETER  Illegal syntax. Progress set to most recent &\r
                                 before the error or the beginning of the string.\r
  @retval EFI_INVALID_PARAMETER  Unknown name. Progress points to the & before the\r
                                 name in question.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
HiiConfigRoutingExtractConfig (\r
  IN  CONST EFI_HII_CONFIG_ROUTING_PROTOCOL  *This,\r
  IN  CONST EFI_STRING                       Request,\r
  OUT EFI_STRING                             *Progress,\r
  OUT EFI_STRING                             *Results\r
  )\r
{\r
#ifndef _DISABLE_UNUSED_HII_PROTOCOLS_\r
\r
  HII_DATABASE_PRIVATE_DATA           *Private;\r
  EFI_STRING                          StringPtr;\r
  EFI_STRING                          ConfigRequest;\r
  UINTN                               Length;\r
  EFI_DEVICE_PATH_PROTOCOL            *DevicePath;\r
  EFI_STATUS                          Status;\r
  LIST_ENTRY                          *Link;\r
  HII_DATABASE_RECORD                 *Database;\r
  UINT8                               *CurrentDevicePath;\r
  EFI_HANDLE                          DriverHandle;\r
  EFI_HII_CONFIG_ACCESS_PROTOCOL      *ConfigAccess;\r
  EFI_STRING                          AccessProgress;\r
  EFI_STRING                          AccessResults;\r
  UINTN                               RemainSize;\r
  EFI_STRING                          TmpPtr;\r
\r
  if (This == NULL || Progress == NULL || Results == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (Request == NULL) {\r
    *Progress = NULL;\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Private   = CONFIG_ROUTING_DATABASE_PRIVATE_DATA_FROM_THIS (This);\r
  StringPtr = Request;\r
  *Progress = StringPtr;\r
\r
  //\r
  // The first element of <MultiConfigRequest> should be\r
  // <GuidHdr>, which is in 'GUID='<Guid> syntax.\r
  //\r
  if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Allocate a fix length of memory to store Results. Reallocate memory for\r
  // Results if this fix length is insufficient.\r
  //\r
  *Results = (EFI_STRING) AllocateZeroPool (MAX_STRING_LENGTH);\r
  if (*Results == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  while (*StringPtr != 0 && StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) == 0) {\r
    //\r
    // If parsing error, set Progress to the beginning of the <MultiConfigRequest>\r
    // or most recent & before the error.\r
    //\r
    if (StringPtr == Request) {\r
      *Progress = StringPtr;\r
    } else {\r
      *Progress = StringPtr - 1;\r
    }\r
\r
    //\r
    // Process each <ConfigRequest> of <MultiConfigRequest>\r
    //\r
    Length = CalculateConfigStringLen (StringPtr);\r
    ConfigRequest = AllocateCopyPool ((Length + 1) * sizeof (CHAR16), StringPtr);\r
    if (ConfigRequest == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    *(ConfigRequest + Length) = 0;\r
\r
    //\r
    // Get the UEFI device path\r
    //\r
    Status = GetDevicePath (ConfigRequest, (UINT8 **) &DevicePath);\r
    if (EFI_ERROR (Status)) {\r
      SafeFreePool (ConfigRequest);\r
      return Status;\r
    }\r
\r
    //\r
    // Find driver which matches the routing data.\r
    //\r
    DriverHandle = NULL;\r
    for (Link = Private->DatabaseList.ForwardLink;\r
         Link != &Private->DatabaseList;\r
         Link = Link->ForwardLink\r
        ) {\r
      Database = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);\r
      CurrentDevicePath = Database->PackageList->DevicePathPkg + sizeof (EFI_HII_PACKAGE_HEADER);\r
      if (CurrentDevicePath != NULL) {\r
        if (CompareMem (\r
              DevicePath,\r
              CurrentDevicePath,\r
              GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL *) CurrentDevicePath)\r
              ) == 0) {\r
          DriverHandle = Database->DriverHandle;\r
          break;\r
        }\r
      }\r
    }\r
\r
    SafeFreePool (DevicePath);\r
\r
    if (DriverHandle == NULL) {\r
      //\r
      // Routing data does not match any known driver.\r
      // Set Progress to the 'G' in "GUID" of the routing header.\r
      //\r
      *Progress = StringPtr;\r
      SafeFreePool (ConfigRequest);\r
      return EFI_NOT_FOUND;\r
    }\r
\r
    //\r
    // Call corresponding ConfigAccess protocol to extract settings\r
    //\r
    Status = gBS->HandleProtocol (\r
                    DriverHandle,\r
                    &gEfiHiiConfigAccessProtocolGuid,\r
                    (VOID **) &ConfigAccess\r
                    );\r
    ASSERT_EFI_ERROR (Status);\r
\r
    Status = ConfigAccess->ExtractConfig (\r
                             ConfigAccess,\r
                             ConfigRequest,\r
                             &AccessProgress,\r
                             &AccessResults\r
                             );\r
    if (EFI_ERROR (Status)) {\r
      //\r
      // AccessProgress indicates the parsing progress on <ConfigRequest>.\r
      // Map it to the progress on <MultiConfigRequest> then return it.\r
      //\r
      RemainSize = StrSize (AccessProgress);\r
      for (TmpPtr = StringPtr; CompareMem (TmpPtr, AccessProgress, RemainSize) != 0; TmpPtr++);\r
      *Progress = TmpPtr;\r
\r
      SafeFreePool (ConfigRequest);\r
      return Status;\r
    }\r
\r
    //\r
    // Attach this <ConfigAltResp> to a <MultiConfigAltResp>\r
    //\r
    ASSERT (*AccessProgress == 0);\r
    Status = AppendToMultiString (Results, AccessResults);\r
    ASSERT_EFI_ERROR (Status);\r
    SafeFreePool (AccessResults);\r
    AccessResults = NULL;\r
    SafeFreePool (ConfigRequest);\r
    ConfigRequest = NULL;\r
\r
    //\r
    // Go to next <ConfigRequest> (skip '&').\r
    //\r
    StringPtr += Length;\r
    if (*StringPtr == 0) {\r
      *Progress = StringPtr;\r
      break;\r
    }\r
\r
    StringPtr++;\r
\r
  }\r
\r
  return EFI_SUCCESS;\r
#else\r
  return EFI_UNSUPPORTED;\r
#endif\r
\r
}\r
\r
\r
/**\r
  This function allows the caller to request the current configuration for the\r
  entirety of the current HII database and returns the data in a\r
  null-terminated Unicode string.\r
\r
  @param  This                   A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL\r
                                 instance.\r
  @param  Results                Null-terminated Unicode string in\r
                                 <MultiConfigAltResp> format which has all values\r
                                 filled in for the names in the Request string.\r
                                 String to be allocated by the  called function.\r
                                 De-allocation is up to the caller.\r
\r
  @retval EFI_SUCCESS            The Results string is filled with the values\r
                                 corresponding to all requested names.\r
  @retval EFI_OUT_OF_RESOURCES   Not enough memory to store the parts of the\r
                                 results that must be stored awaiting possible\r
                                 future        protocols.\r
  @retval EFI_INVALID_PARAMETER  For example, passing in a NULL for the Results\r
                                 parameter would result in this type of error.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
HiiConfigRoutingExportConfig (\r
  IN  CONST EFI_HII_CONFIG_ROUTING_PROTOCOL  *This,\r
  OUT EFI_STRING                             *Results\r
  )\r
{\r
#ifndef _DISABLE_UNUSED_HII_PROTOCOLS_\r
\r
  EFI_STATUS                          Status;\r
  HII_DATABASE_PRIVATE_DATA           *Private;\r
  LIST_ENTRY                          StorageListHdr;\r
  HII_FORMSET_STORAGE                 *Storage;\r
  LIST_ENTRY                          *Link;\r
  EFI_DEVICE_PATH_PROTOCOL            *DevicePath;\r
  UINTN                               Length;\r
  EFI_STRING                          PathHdr;\r
  UINTN                               PathHdrSize;\r
  EFI_STRING                          ConfigRequest;\r
  UINTN                               RequestSize;\r
  EFI_STRING                          StringPtr;\r
  EFI_HII_CONFIG_ACCESS_PROTOCOL      *ConfigAccess;\r
  EFI_STRING                          AccessProgress;\r
  EFI_STRING                          AccessResults;\r
  UINTN                               TmpSize;\r
\r
  if (This == NULL || Results == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Private = CONFIG_ROUTING_DATABASE_PRIVATE_DATA_FROM_THIS (This);\r
\r
  InitializeListHead (&StorageListHdr);\r
\r
  Status = ExportAllStorage (&Private->HiiDatabase, &StorageListHdr);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Allocate a fix length of memory to store Results. Reallocate memory for\r
  // Results if this fix length is insufficient.\r
  //\r
  *Results = (EFI_STRING) AllocateZeroPool (MAX_STRING_LENGTH);\r
  if (*Results == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Parsing all formset storages.\r
  //\r
  for (Link = StorageListHdr.ForwardLink; Link != &StorageListHdr; Link = Link->ForwardLink) {\r
    Storage = CR (Link, HII_FORMSET_STORAGE, Entry, HII_FORMSET_STORAGE_SIGNATURE);\r
    //\r
    // Find the corresponding device path instance\r
    //\r
    Status = gBS->HandleProtocol (\r
                    Storage->DriverHandle,\r
                    &gEfiDevicePathProtocolGuid,\r
                    (VOID **) &DevicePath\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
    //\r
    // Convert the device path binary to hex UNICODE %02x bytes in the same order\r
    // as the device path resides in RAM memory.\r
    //\r
    Length      = GetDevicePathSize (DevicePath);\r
    PathHdrSize = (Length * 2 + 1) * sizeof (CHAR16);\r
    PathHdr     = (EFI_STRING) AllocateZeroPool (PathHdrSize);\r
    if (PathHdr == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    Status = BufferToHexString (PathHdr, (UINT8 *) DevicePath, Length);\r
    ASSERT_EFI_ERROR (Status);\r
\r
    //\r
    // Generate a <ConfigRequest> with one <ConfigHdr> and zero <RequestElement>.\r
    // It means extract all possible configurations from this specific driver.\r
    //\r
    TmpSize = StrLen (L"GUID=&NAME=&PATH=");\r
    RequestSize   = (TmpSize + 32 +  StrLen (Storage->Name) * 4)\r
                     * sizeof (CHAR16) + PathHdrSize;\r
    ConfigRequest = (EFI_STRING) AllocateZeroPool (RequestSize);\r
    if (ConfigRequest == NULL) {\r
      SafeFreePool (PathHdr);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    //\r
    // Add <GuidHdr>\r
    // <GuidHdr> ::= 'GUID='<Guid>\r
    // Convert <Guid> in the same order as it resides in RAM memory.\r
    //\r
    StringPtr = ConfigRequest;\r
    StrnCpy (StringPtr, L"GUID=", StrLen (L"GUID="));\r
    StringPtr += StrLen (L"GUID=");\r
\r
    Status = BufferToHexString (StringPtr, (UINT8 *) (&Storage->Guid), sizeof (EFI_GUID));\r
    ASSERT_EFI_ERROR (Status);\r
    \r
    StringPtr += 32;\r
    ASSERT (*StringPtr == 0);\r
    *StringPtr = L'&';\r
    StringPtr++;\r
\r
    //\r
    // Add <NameHdr>\r
    // <NameHdr> ::= 'NAME='<String>\r
    //\r
    StrnCpy (StringPtr, L"NAME=", StrLen (L"NAME="));\r
    StringPtr += StrLen (L"NAME=");\r
\r
    Length = (StrLen (Storage->Name) * 4 + 1) * sizeof (CHAR16);\r
    Status = UnicodeToConfigString (StringPtr, &Length, Storage->Name);\r
    ASSERT_EFI_ERROR (Status);\r
    StringPtr += StrLen (Storage->Name) * 4;\r
    \r
    *StringPtr = L'&';\r
    StringPtr++;\r
\r
    //\r
    // Add <PathHdr>\r
    // <PathHdr> ::= '<PATH=>'<UEFI binary represented as hex UNICODE %02x>\r
    //\r
    StrnCpy (StringPtr, L"PATH=", StrLen (L"PATH="));\r
    StringPtr += StrLen (L"PATH=");\r
    StrCpy (StringPtr, PathHdr);\r
\r
    SafeFreePool (PathHdr);\r
    PathHdr = NULL;\r
\r
    //\r
    // BUGBUG: The "Implementation note" of ExportConfig() in UEFI spec makes the\r
    // code somewhat complex. Let's TBD here whether a <ConfigRequest> or a <ConfigHdr>\r
    // is required to call ConfigAccess.ExtractConfig().\r
    //\r
    // Here we use <ConfigHdr> to call ConfigAccess instance. It requires ConfigAccess\r
    // to handle such kind of "ConfigRequest". It is not supported till now.\r
    //\r
    // Either the ExportConfig will be updated or the ConfigAccess.ExtractConfig()\r
    // will be updated as soon as the decision is made.\r
\r
    //\r
    // Route the request to corresponding ConfigAccess protocol to extract settings.\r
    //\r
    Status = gBS->HandleProtocol (\r
                    Storage->DriverHandle,\r
                    &gEfiHiiConfigAccessProtocolGuid,\r
                    (VOID **)  &ConfigAccess\r
                    );\r
    ASSERT_EFI_ERROR (Status);\r
\r
    Status = ConfigAccess->ExtractConfig (\r
                             ConfigAccess,\r
                             ConfigRequest,\r
                             &AccessProgress,\r
                             &AccessResults\r
                             );\r
    if (EFI_ERROR (Status)) {\r
      SafeFreePool (ConfigRequest);\r
      SafeFreePool (AccessResults);\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    //\r
    // Attach this <ConfigAltResp> to a <MultiConfigAltResp>\r
    //\r
    ASSERT (*AccessProgress == 0);\r
    Status = AppendToMultiString (Results, AccessResults);\r
    ASSERT_EFI_ERROR (Status);\r
    SafeFreePool (AccessResults);\r
    AccessResults = NULL;\r
    SafeFreePool (ConfigRequest);\r
    ConfigRequest = NULL;\r
\r
  }\r
\r
  //\r
  // Free the exported storage resource\r
  //\r
  while (!IsListEmpty (&StorageListHdr)) {\r
    Storage = CR (\r
                StorageListHdr.ForwardLink,\r
                HII_FORMSET_STORAGE,\r
                Entry,\r
                HII_FORMSET_STORAGE_SIGNATURE\r
                );\r
    RemoveEntryList (&Storage->Entry);\r
    SafeFreePool (Storage->Name);\r
    SafeFreePool (Storage);\r
  }\r
\r
  return EFI_SUCCESS;\r
#else\r
  return EFI_UNSUPPORTED;\r
#endif\r
}\r
\r
\r
/**\r
  This function processes the results of processing forms and routes it to the\r
  appropriate handlers or storage.\r
\r
  @param  This                   A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL\r
                                 instance.\r
  @param  Configuration          A null-terminated Unicode string in\r
                                 <MulltiConfigResp> format.\r
  @param  Progress               A pointer to a string filled in with the offset of\r
                                 the most recent & before the first failing name /\r
                                 value pair (or the beginning of the string if the\r
                                 failure is in the first name / value pair) or the\r
                                 terminating NULL if all was successful.\r
\r
  @retval EFI_SUCCESS            The results have been distributed or are awaiting\r
                                 distribution.\r
  @retval EFI_OUT_OF_RESOURCES   Not enough memory to store the parts of the\r
                                 results that must be stored awaiting possible\r
                                 future        protocols.\r
  @retval EFI_INVALID_PARAMETER  Passing in a NULL for the Configuration parameter\r
                                 would result in this type of error.\r
  @retval EFI_NOT_FOUND          Target for the specified routing data was not\r
                                 found.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
HiiConfigRoutingRouteConfig (\r
  IN  CONST EFI_HII_CONFIG_ROUTING_PROTOCOL  *This,\r
  IN  CONST EFI_STRING                       Configuration,\r
  OUT EFI_STRING                             *Progress\r
  )\r
{\r
#ifndef _DISABLE_UNUSED_HII_PROTOCOLS_\r
\r
  HII_DATABASE_PRIVATE_DATA           *Private;\r
  EFI_STRING                          StringPtr;\r
  EFI_STRING                          ConfigResp;\r
  UINTN                               Length;\r
  EFI_STATUS                          Status;\r
  EFI_DEVICE_PATH_PROTOCOL            *DevicePath;\r
  LIST_ENTRY                          *Link;\r
  HII_DATABASE_RECORD                 *Database;\r
  UINT8                               *CurrentDevicePath;\r
  EFI_HANDLE                          DriverHandle;\r
  EFI_HII_CONFIG_ACCESS_PROTOCOL      *ConfigAccess;\r
  EFI_STRING                          AccessProgress;\r
  UINTN                               RemainSize;\r
  EFI_STRING                          TmpPtr;\r
\r
  if (This == NULL || Progress == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (Configuration == NULL) {\r
    *Progress = NULL;\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Private   = CONFIG_ROUTING_DATABASE_PRIVATE_DATA_FROM_THIS (This);\r
  StringPtr = Configuration;\r
  *Progress = StringPtr;\r
\r
  //\r
  // The first element of <MultiConfigResp> should be\r
  // <GuidHdr>, which is in 'GUID='<Guid> syntax.\r
  //\r
  if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  while (*StringPtr != 0 && StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) == 0) {\r
    //\r
    // If parsing error, set Progress to the beginning of the <MultiConfigResp>\r
    // or most recent & before the error.\r
    //\r
    if (StringPtr == Configuration) {\r
      *Progress = StringPtr;\r
    } else {\r
      *Progress = StringPtr - 1;\r
    }\r
\r
    //\r
    // Process each <ConfigResp> of <MultiConfigResp>\r
    //\r
    Length = CalculateConfigStringLen (StringPtr);\r
    ConfigResp = AllocateCopyPool ((Length + 1) * sizeof (CHAR16), StringPtr);\r
    if (ConfigResp == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    //\r
    // Append '\0' to the end of ConfigRequest\r
    //\r
    *(ConfigResp + Length) = 0;\r
\r
    //\r
    // Get the UEFI device path\r
    //\r
    Status = GetDevicePath (ConfigResp, (UINT8 **) &DevicePath);\r
    if (EFI_ERROR (Status)) {\r
      SafeFreePool (ConfigResp);\r
      return Status;\r
    }\r
\r
    //\r
    // Find driver which matches the routing data.\r
    //\r
    DriverHandle = NULL;\r
    for (Link = Private->DatabaseList.ForwardLink;\r
         Link != &Private->DatabaseList;\r
         Link = Link->ForwardLink\r
        ) {\r
      Database = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);\r
      CurrentDevicePath = Database->PackageList->DevicePathPkg + sizeof (EFI_HII_PACKAGE_HEADER);\r
      if (CurrentDevicePath != NULL) {\r
        if (CompareMem (\r
              DevicePath,\r
              CurrentDevicePath,\r
              GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL *) CurrentDevicePath)\r
              ) == 0) {\r
          DriverHandle = Database->DriverHandle;\r
          break;\r
        }\r
      }\r
    }\r
\r
    SafeFreePool (DevicePath);\r
\r
    if (DriverHandle == NULL) {\r
      //\r
      // Routing data does not match any known driver.\r
      // Set Progress to the 'G' in "GUID" of the routing header.\r
      //\r
      *Progress = StringPtr;\r
      SafeFreePool (ConfigResp);\r
      return EFI_NOT_FOUND;\r
    }\r
\r
    //\r
    // Call corresponding ConfigAccess protocol to route settings\r
    //\r
    Status = gBS->HandleProtocol (\r
                    DriverHandle,\r
                    &gEfiHiiConfigAccessProtocolGuid,\r
                    (VOID **)  &ConfigAccess\r
                    );\r
    ASSERT_EFI_ERROR (Status);\r
\r
    Status = ConfigAccess->RouteConfig (\r
                             ConfigAccess,\r
                             ConfigResp,\r
                             &AccessProgress\r
                             );\r
\r
    if (EFI_ERROR (Status)) {\r
      //\r
      // AccessProgress indicates the parsing progress on <ConfigResp>.\r
      // Map it to the progress on <MultiConfigResp> then return it.\r
      //\r
      RemainSize = StrSize (AccessProgress);\r
      for (TmpPtr = StringPtr; CompareMem (TmpPtr, AccessProgress, RemainSize) != 0; TmpPtr++);\r
      *Progress = TmpPtr;\r
\r
      SafeFreePool (ConfigResp);\r
      return Status;\r
    }\r
\r
    SafeFreePool (ConfigResp);\r
    ConfigResp = NULL;\r
\r
    //\r
    // Go to next <ConfigResp> (skip '&').\r
    //\r
    StringPtr += Length;\r
    if (*StringPtr == 0) {\r
      *Progress = StringPtr;\r
      break;\r
    }\r
\r
    StringPtr++;\r
\r
  }\r
\r
  return EFI_SUCCESS;\r
#else\r
  return EFI_UNSUPPORTED;\r
#endif\r
}\r
\r
\r
/**\r
  This helper function is to be called by drivers to map configuration data\r
  stored in byte array ("block") formats such as UEFI Variables into current\r
  configuration strings.\r
\r
  @param  This                   A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL\r
                                 instance.\r
  @param  ConfigRequest          A null-terminated Unicode string in\r
                                 <ConfigRequest> format.\r
  @param  Block                  Array of bytes defining the block's configuration.\r
  @param  BlockSize              Length in bytes of Block.\r
  @param  Config                 Filled-in configuration string. String allocated\r
                                 by  the function. Returned only if call is\r
                                 successful.\r
  @param  Progress               A pointer to a string filled in with the offset of\r
                                  the most recent & before the first failing\r
                                 name/value pair (or the beginning of the string if\r
                                 the failure is in the first name / value pair) or\r
                                 the terminating NULL if all was successful.\r
\r
  @retval EFI_SUCCESS            The request succeeded. Progress points to the null\r
                                 terminator at the end of the ConfigRequest\r
                                 string.\r
  @retval EFI_OUT_OF_RESOURCES   Not enough memory to allocate Config.     Progress\r
                                 points to the first character of ConfigRequest.\r
  @retval EFI_INVALID_PARAMETER  Passing in a NULL for the ConfigRequest or\r
                                 Block parameter would result in this type of\r
                                 error. Progress points to the first character of\r
                                 ConfigRequest.\r
  @retval EFI_DEVICE_ERROR       Block not large enough. Progress undefined.\r
  @retval EFI_INVALID_PARAMETER  Encountered non <BlockName> formatted string.\r
                                     Block is left updated and Progress points at\r
                                 the "&" preceding the first non-<BlockName>.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
HiiBlockToConfig (\r
  IN  CONST EFI_HII_CONFIG_ROUTING_PROTOCOL  *This,\r
  IN  CONST EFI_STRING                       ConfigRequest,\r
  IN  CONST UINT8                            *Block,\r
  IN  CONST UINTN                            BlockSize,\r
  OUT EFI_STRING                             *Config,\r
  OUT EFI_STRING                             *Progress\r
  )\r
{\r
  HII_DATABASE_PRIVATE_DATA           *Private;\r
  EFI_STRING                          StringPtr;\r
  UINTN                               Length;\r
  EFI_STATUS                          Status;\r
  EFI_STRING                          TmpPtr;\r
  UINT8                               *TmpBuffer;\r
  UINTN                               Offset;\r
  UINTN                               Width;\r
  UINT8                               *Value;\r
  EFI_STRING                          ValueStr;\r
  EFI_STRING                          ConfigElement;\r
\r
  if (This == NULL || Progress == NULL || Config == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (Block == NULL || ConfigRequest == NULL) {\r
    *Progress = ConfigRequest;\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
\r
  Private = CONFIG_ROUTING_DATABASE_PRIVATE_DATA_FROM_THIS (This);\r
  ASSERT (Private != NULL);\r
\r
  StringPtr     = ConfigRequest;\r
  ValueStr      = NULL;\r
  Value         = NULL;\r
  ConfigElement = NULL;\r
\r
  //\r
  // Allocate a fix length of memory to store Results. Reallocate memory for\r
  // Results if this fix length is insufficient.\r
  //\r
  *Config = (EFI_STRING) AllocateZeroPool (MAX_STRING_LENGTH);\r
  if (*Config == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Jump <ConfigHdr>\r
  //\r
  if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) {\r
    *Progress = StringPtr;\r
    Status = EFI_INVALID_PARAMETER;\r
    goto Exit;\r
  }\r
  while (*StringPtr != 0 && StrnCmp (StringPtr, L"PATH=", StrLen (L"PATH=")) != 0) {\r
    StringPtr++;\r
  }\r
  if (*StringPtr == 0) {\r
    *Progress = StringPtr;\r
    Status = EFI_INVALID_PARAMETER;\r
    goto Exit;\r
  }\r
  while (*StringPtr++ != L'&');\r
\r
  //\r
  // Copy <ConfigHdr> and an additional '&' to <ConfigResp>\r
  //\r
  Length = StringPtr - ConfigRequest;\r
  CopyMem (*Config, ConfigRequest, Length * sizeof (CHAR16));\r
\r
  //\r
  // Parse each <RequestElement> if exists\r
  // Only <BlockName> format is supported by this help function.\r
  // <BlockName> ::= 'OFFSET='<Number>&'WIDTH='<Number>\r
  //\r
  while (*StringPtr != 0 && StrnCmp (StringPtr, L"OFFSET=", StrLen (L"OFFSET=")) == 0) {\r
    //\r
    // Back up the header of one <BlockName>\r
    //\r
    TmpPtr = StringPtr;\r
\r
    StringPtr += StrLen (L"OFFSET=");\r
    //\r
    // Get Offset\r
    //\r
    Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length);\r
    if (Status == EFI_OUT_OF_RESOURCES) {\r
      *Progress = ConfigRequest;\r
      goto Exit;\r
    }\r
    Offset = 0;\r
    CopyMem (\r
      &Offset,\r
      TmpBuffer,\r
      (((Length + 1) / 2) < sizeof (UINTN)) ? ((Length + 1) / 2) : sizeof (UINTN)\r
      );\r
    SafeFreePool (TmpBuffer);\r
\r
    StringPtr += Length;\r
    if (StrnCmp (StringPtr, L"&WIDTH=", StrLen (L"&WIDTH=")) != 0) {\r
      *Progress = StringPtr - Length - StrLen (L"OFFSET=") - 1;\r
      Status = EFI_INVALID_PARAMETER;\r
      goto Exit;\r
    }\r
    StringPtr += StrLen (L"&WIDTH=");\r
\r
    //\r
    // Get Width\r
    //\r
    Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length);\r
    if (Status == EFI_OUT_OF_RESOURCES) {\r
      *Progress = ConfigRequest;\r
      goto Exit;\r
    }\r
    Width = 0;\r
    CopyMem (\r
      &Width,\r
      TmpBuffer,\r
      (((Length + 1) / 2) < sizeof (UINTN)) ? ((Length + 1) / 2) : sizeof (UINTN)\r
      );\r
    SafeFreePool (TmpBuffer);\r
\r
    StringPtr += Length;\r
    if (*StringPtr != 0 && *StringPtr != L'&') {\r
      *Progress = StringPtr - Length - StrLen (L"&WIDTH=");\r
      Status = EFI_INVALID_PARAMETER;\r
      goto Exit;\r
    }\r
\r
    //\r
    // Calculate Value and convert it to hex string.\r
    //\r
    if (Offset + Width > BlockSize) {\r
      *Progress = StringPtr;\r
      Status = EFI_DEVICE_ERROR;\r
      goto Exit;\r
    }\r
\r
    Value = (UINT8 *) AllocateZeroPool (Width);\r
    if (Value == NULL) {\r
      *Progress = ConfigRequest;\r
      Status = EFI_OUT_OF_RESOURCES;\r
      goto Exit;\r
    }\r
\r
    CopyMem (Value, (UINT8 *) Block + Offset, Width);\r
\r
    Length = Width * 2 + 1;\r
    ValueStr = (EFI_STRING) AllocateZeroPool (Length  * sizeof (CHAR16));\r
    if (ValueStr == NULL) {\r
      *Progress = ConfigRequest;\r
      Status = EFI_OUT_OF_RESOURCES;\r
      goto Exit;\r
    }\r
\r
    Status = BufToHexString (ValueStr, &Length, Value, Width);\r
    ASSERT_EFI_ERROR (Status);\r
    ToLower (ValueStr);\r
\r
    SafeFreePool (Value);\r
    Value = NULL;\r
\r
    //\r
    // Build a ConfigElement\r
    //\r
    Length += StringPtr - TmpPtr + 1 + StrLen (L"VALUE=");\r
    ConfigElement = (EFI_STRING) AllocateZeroPool (Length * sizeof (CHAR16));\r
    if (ConfigElement == NULL) {\r
      Status = EFI_OUT_OF_RESOURCES;\r
      goto Exit;\r
    }\r
    CopyMem (ConfigElement, TmpPtr, (StringPtr - TmpPtr + 1) * sizeof (CHAR16));\r
    if (*StringPtr == 0) {\r
      *(ConfigElement + (StringPtr - TmpPtr)) = L'&';\r
    }\r
    *(ConfigElement + (StringPtr - TmpPtr) + 1) = 0;\r
    StrCat (ConfigElement, L"VALUE=");\r
    StrCat (ConfigElement, ValueStr);\r
\r
    AppendToMultiString (Config, ConfigElement);\r
\r
    SafeFreePool (ConfigElement);\r
    SafeFreePool (ValueStr);\r
    ConfigElement = NULL;\r
    ValueStr = NULL;\r
\r
    //\r
    // If '\0', parsing is finished. Otherwise skip '&' to continue\r
    //\r
    if (*StringPtr == 0) {\r
      break;\r
    }\r
    AppendToMultiString (Config, L"&");\r
    StringPtr++;\r
\r
  }\r
\r
  if (*StringPtr != 0) {\r
    *Progress = StringPtr - 1;\r
    Status = EFI_INVALID_PARAMETER;\r
    goto Exit;\r
  }\r
\r
  *Progress = StringPtr;\r
  return EFI_SUCCESS;\r
\r
Exit:\r
\r
  SafeFreePool (*Config);\r
  SafeFreePool (ValueStr);\r
  SafeFreePool (Value);\r
  SafeFreePool (ConfigElement);\r
\r
  return Status;\r
\r
}\r
\r
\r
/**\r
  This helper function is to be called by drivers to map configuration strings\r
  to configurations stored in byte array ("block") formats such as UEFI Variables.\r
\r
  @param  This                   A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL\r
                                 instance.\r
  @param  ConfigResp             A null-terminated Unicode string in <ConfigResp>\r
                                 format.\r
  @param  Block                  A possibly null array of bytes representing the\r
                                 current  block. Only bytes referenced in the\r
                                 ConfigResp string  in the block are modified. If\r
                                 this parameter is null or if the *BlockSize\r
                                 parameter is (on input) shorter than required by\r
                                 the Configuration string, only the BlockSize\r
                                 parameter is updated and an appropriate status\r
                                 (see below)  is returned.\r
  @param  BlockSize              The length of the Block in units of UINT8.  On\r
                                 input, this is the size of the Block. On output,\r
                                 if successful, contains the index of the  last\r
                                 modified byte in the Block.\r
  @param  Progress               On return, points to an element of the ConfigResp\r
                                 string filled in with the offset of the most\r
                                 recent '&' before the first failing name / value\r
                                 pair (or  the beginning of the string if the\r
                                 failure is in the  first name / value pair) or the\r
                                 terminating NULL if all was successful.\r
\r
  @retval EFI_SUCCESS            The request succeeded. Progress points to the null\r
                                 terminator at the end of the ConfigResp string.\r
  @retval EFI_OUT_OF_RESOURCES   Not enough memory to allocate Config.     Progress\r
                                 points to the first character of ConfigResp.\r
  @retval EFI_INVALID_PARAMETER  Passing in a NULL for the ConfigResp or\r
                                 Block parameter would result in this type of\r
                                 error. Progress points to the first character of\r
                                         ConfigResp.\r
  @retval EFI_INVALID_PARAMETER  Encountered non <BlockName> formatted name /\r
                                 value pair. Block is left updated and\r
                                 Progress points at the '&' preceding the first\r
                                 non-<BlockName>.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
HiiConfigToBlock (\r
  IN     CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *This,\r
  IN     CONST EFI_STRING                      ConfigResp,\r
  IN OUT UINT8                                 *Block,\r
  IN OUT UINTN                                 *BlockSize,\r
  OUT    EFI_STRING                            *Progress\r
  )\r
{\r
  HII_DATABASE_PRIVATE_DATA           *Private;\r
  EFI_STRING                          StringPtr;\r
  UINTN                               Length;\r
  EFI_STATUS                          Status;\r
  UINT8                               *TmpBuffer;\r
  UINTN                               Offset;\r
  UINTN                               Width;\r
  UINT8                               *Value;\r
  UINTN                               BufferSize;\r
\r
  if (This == NULL || BlockSize == NULL || Progress == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (ConfigResp == NULL || Block == NULL) {\r
    *Progress = ConfigResp;\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Private = CONFIG_ROUTING_DATABASE_PRIVATE_DATA_FROM_THIS (This);\r
  ASSERT (Private != NULL);\r
\r
  StringPtr  = ConfigResp;\r
  BufferSize = *BlockSize;\r
  Value      = NULL;\r
\r
  //\r
  // Jump <ConfigHdr>\r
  //\r
  if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) {\r
    *Progress = StringPtr;\r
    Status = EFI_INVALID_PARAMETER;\r
    goto Exit;\r
  }\r
  while (*StringPtr != 0 && StrnCmp (StringPtr, L"PATH=", StrLen (L"PATH=")) != 0) {\r
    StringPtr++;\r
  }\r
  if (*StringPtr == 0) {\r
    *Progress = StringPtr;\r
    Status = EFI_INVALID_PARAMETER;\r
    goto Exit;\r
  }\r
  while (*StringPtr++ != L'&');\r
\r
  //\r
  // Parse each <ConfigElement> if exists\r
  // Only <BlockConfig> format is supported by this help function.\r
  // <BlockConfig> ::= 'OFFSET='<Number>&'WIDTH='<Number>&'VALUE='<Number>\r
  //\r
  while (*StringPtr != 0 && StrnCmp (StringPtr, L"OFFSET=", StrLen (L"OFFSET=")) == 0) {\r
    StringPtr += StrLen (L"OFFSET=");\r
    //\r
    // Get Offset\r
    //\r
    Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length);\r
    if (Status == EFI_OUT_OF_RESOURCES) {\r
      *Progress = ConfigResp;\r
      goto Exit;\r
    }\r
    Offset = 0;\r
    CopyMem (\r
      &Offset,\r
      TmpBuffer,\r
      (((Length + 1) / 2) < sizeof (UINTN)) ? ((Length + 1) / 2) : sizeof (UINTN)\r
      );\r
    SafeFreePool (TmpBuffer);\r
\r
    StringPtr += Length;\r
    if (StrnCmp (StringPtr, L"&WIDTH=", StrLen (L"&WIDTH=")) != 0) {\r
      *Progress = StringPtr - Length - StrLen (L"OFFSET=") - 1;\r
      Status = EFI_INVALID_PARAMETER;\r
      goto Exit;\r
    }\r
    StringPtr += StrLen (L"&WIDTH=");\r
\r
    //\r
    // Get Width\r
    //\r
    Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length);\r
    if (Status == EFI_OUT_OF_RESOURCES) {\r
      *Progress = ConfigResp;\r
      goto Exit;\r
    }\r
    Width = 0;\r
    CopyMem (\r
      &Width,\r
      TmpBuffer,\r
      (((Length + 1) / 2) < sizeof (UINTN)) ? ((Length + 1) / 2) : sizeof (UINTN)\r
      );\r
    SafeFreePool (TmpBuffer);\r
\r
    StringPtr += Length;\r
    if (StrnCmp (StringPtr, L"&VALUE=", StrLen (L"&VALUE=")) != 0) {\r
      *Progress = StringPtr - Length - StrLen (L"&WIDTH=");\r
      Status = EFI_INVALID_PARAMETER;\r
      goto Exit;\r
    }\r
    StringPtr += StrLen (L"&VALUE=");\r
\r
    //\r
    // Get Value\r
    //\r
    Status = GetValueOfNumber (StringPtr, &Value, &Length);\r
    if (Status == EFI_OUT_OF_RESOURCES) {\r
      *Progress = ConfigResp;\r
      goto Exit;\r
    }\r
\r
    StringPtr += Length;\r
    if (*StringPtr != 0 && *StringPtr != L'&') {\r
      *Progress = StringPtr - Length - 7;\r
      Status = EFI_INVALID_PARAMETER;\r
      goto Exit;\r
    }\r
\r
    //\r
    // Update the Block with configuration info\r
    //\r
\r
    if (Offset + Width > BufferSize) {\r
      return EFI_DEVICE_ERROR;\r
    }\r
\r
    CopyMem (Block + Offset, Value, Width);\r
    *BlockSize = Offset + Width - 1;\r
\r
    SafeFreePool (Value);\r
    Value = NULL;\r
\r
    //\r
    // If '\0', parsing is finished. Otherwise skip '&' to continue\r
    //\r
    if (*StringPtr == 0) {\r
      break;\r
    }\r
\r
    StringPtr++;\r
  }\r
\r
  if (*StringPtr != 0) {\r
    *Progress = StringPtr - 1;\r
    Status = EFI_INVALID_PARAMETER;\r
    goto Exit;\r
  }\r
\r
  *Progress = StringPtr;\r
  return EFI_SUCCESS;\r
\r
Exit:\r
\r
  SafeFreePool (Value);\r
  return Status;\r
}\r
\r
\r
/**\r
  This helper function is to be called by drivers to extract portions of\r
  a larger configuration string.\r
\r
  @param  This                   A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL\r
                                 instance.\r
  @param  Configuration          A null-terminated Unicode string in\r
                                 <MultiConfigAltResp> format.\r
  @param  Guid                   A pointer to the GUID value to search for in the\r
                                 routing portion of the ConfigResp string when\r
                                 retrieving  the requested data. If Guid is NULL,\r
                                 then all GUID  values will be searched for.\r
  @param  Name                   A pointer to the NAME value to search for in the\r
                                 routing portion of the ConfigResp string when\r
                                 retrieving  the requested data. If Name is NULL,\r
                                 then all Name  values will be searched for.\r
  @param  DevicePath             A pointer to the PATH value to search for in the\r
                                 routing portion of the ConfigResp string when\r
                                 retrieving  the requested data. If DevicePath is\r
                                 NULL, then all  DevicePath values will be searched\r
                                 for.\r
  @param  AltCfgId               A pointer to the ALTCFG value to search for in the\r
                                  routing portion of the ConfigResp string when\r
                                 retrieving  the requested data.  If this parameter\r
                                 is NULL,  then the current setting will be\r
                                 retrieved.\r
  @param  AltCfgResp             A pointer to a buffer which will be allocated by\r
                                 the  function which contains the retrieved string\r
                                 as requested.   This buffer is only allocated if\r
                                 the call was successful.\r
\r
  @retval EFI_SUCCESS            The request succeeded. The requested data was\r
                                 extracted  and placed in the newly allocated\r
                                 AltCfgResp buffer.\r
  @retval EFI_OUT_OF_RESOURCES   Not enough memory to allocate AltCfgResp.\r
  @retval EFI_INVALID_PARAMETER  Any parameter is invalid.\r
  @retval EFI_NOT_FOUND          Target for the specified routing data was not\r
                                 found.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
HiiGetAltCfg (\r
  IN  CONST EFI_HII_CONFIG_ROUTING_PROTOCOL    *This,\r
  IN  CONST EFI_STRING                         Configuration,\r
  IN  CONST EFI_GUID                           *Guid,\r
  IN  CONST EFI_STRING                         Name,\r
  IN  CONST EFI_DEVICE_PATH_PROTOCOL           *DevicePath,\r
  IN  CONST UINT16                             *AltCfgId,\r
  OUT EFI_STRING                               *AltCfgResp\r
  )\r
{\r
#ifndef _DISABLE_UNUSED_HII_PROTOCOLS_\r
\r
  EFI_STATUS                          Status;\r
  EFI_STRING                          StringPtr;\r
  EFI_STRING                          HdrStart;\r
  EFI_STRING                          HdrEnd;\r
  EFI_STRING                          TmpPtr;\r
  UINTN                               Length;\r
  EFI_STRING                          GuidStr;\r
  EFI_STRING                          NameStr;\r
  EFI_STRING                          PathStr;\r
  EFI_STRING                          AltIdStr;\r
  EFI_STRING                          Result;\r
  BOOLEAN                             GuidFlag;\r
  BOOLEAN                             NameFlag;\r
  BOOLEAN                             PathFlag;\r
\r
  HdrStart = NULL;\r
  HdrEnd   = NULL;\r
  GuidStr  = NULL;\r
  NameStr  = NULL;\r
  PathStr  = NULL;\r
  AltIdStr = NULL;\r
  Result   = NULL;\r
  GuidFlag = FALSE;\r
  NameFlag = FALSE;\r
  PathFlag = FALSE;\r
\r
  if (This == NULL || Configuration == NULL || AltCfgResp == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  StringPtr = Configuration;\r
  if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Generate the sub string for later matching.\r
  //\r
  GenerateSubStr (L"GUID=", sizeof (EFI_GUID), (VOID *) Guid, 1, &GuidStr);\r
  GenerateSubStr (\r
    L"PATH=",\r
    GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL *) DevicePath),\r
    (VOID *) DevicePath,\r
    1,\r
    &PathStr\r
    );\r
  if (AltCfgId != NULL) {\r
    GenerateSubStr (L"ALTCFG=", sizeof (UINT16), (VOID *) AltCfgId, 3, &AltIdStr);  \r
  }\r
  if (Name != NULL) {\r
    GenerateSubStr (L"NAME=", StrLen (Name) * sizeof (CHAR16), (VOID *) Name, 2, &NameStr);    \r
  } else {\r
    GenerateSubStr (L"NAME=", 0, NULL, 2, &NameStr);\r
  }\r
\r
  while (*StringPtr != 0) {\r
    //\r
    // Try to match the GUID\r
    //\r
    if (!GuidFlag) {\r
      TmpPtr = StrStr (StringPtr, GuidStr);\r
      if (TmpPtr == NULL) {\r
        Status = EFI_NOT_FOUND;\r
        goto Exit;\r
      }\r
      HdrStart = TmpPtr;\r
\r
      //\r
      // Jump to <NameHdr>\r
      //\r
      if (Guid != NULL) {\r
        StringPtr = TmpPtr + StrLen (GuidStr);\r
      } else {\r
        StringPtr = StrStr (TmpPtr, L"NAME=");\r
        if (StringPtr == NULL) {\r
          Status = EFI_NOT_FOUND;\r
          goto Exit;\r
        }\r
      }\r
      GuidFlag = TRUE;\r
    }\r
\r
    //\r
    // Try to match the NAME\r
    //\r
    if (GuidFlag && !NameFlag) {\r
      if (StrnCmp (StringPtr, NameStr, StrLen (NameStr)) != 0) {\r
        GuidFlag = FALSE;\r
      } else {\r
        //\r
        // Jump to <PathHdr>\r
        //\r
        if (Name != NULL) {\r
          StringPtr += StrLen (NameStr);\r
        } else {\r
          StringPtr = StrStr (StringPtr, L"PATH=");\r
          if (StringPtr == NULL) {\r
            Status = EFI_NOT_FOUND;\r
            goto Exit;\r
          }\r
        }\r
        NameFlag = TRUE;\r
      }\r
    }\r
\r
    //\r
    // Try to match the DevicePath\r
    //\r
    if (GuidFlag && NameFlag && !PathFlag) {\r
      if (StrnCmp (StringPtr, PathStr, StrLen (PathStr)) != 0) {\r
        GuidFlag = FALSE;\r
        NameFlag = FALSE;\r
      } else {\r
        //\r
        // Jump to '&' before <DescHdr> or <ConfigBody>\r
        //\r
        if (DevicePath != NULL) {\r
          StringPtr += StrLen (PathStr);\r
        } else {\r
          StringPtr = StrStr (StringPtr, L"&");\r
          if (StringPtr == NULL) {\r
            Status = EFI_NOT_FOUND;\r
            goto Exit;\r
          }\r
        }\r
        PathFlag = TRUE;\r
        HdrEnd   = ++StringPtr;\r
      }\r
    }\r
\r
    //\r
    // Try to match the AltCfgId\r
    //\r
    if (GuidFlag && NameFlag && PathFlag) {\r
      if (AltCfgId == NULL) {\r
        //\r
        // Return Current Setting when AltCfgId is NULL.\r
        //\r
        Status = OutputConfigBody (StringPtr, &Result);\r
        goto Exit;\r
      }\r
      //\r
      // Search the <ConfigAltResp> to get the <AltResp> with AltCfgId.\r
      //\r
      if (StrnCmp (StringPtr, AltIdStr, StrLen (AltIdStr)) != 0) {\r
        GuidFlag = FALSE;\r
        NameFlag = FALSE;\r
        PathFlag = FALSE;\r
      } else {\r
        Status = OutputConfigBody (StringPtr, &Result);\r
        goto Exit;\r
      }\r
    }\r
  }\r
\r
  Status = EFI_NOT_FOUND;\r
\r
Exit:\r
\r
  if (!EFI_ERROR (Status)) {\r
    //\r
    // Copy the <ConfigHdr> and <ConfigBody>\r
    //\r
    Length = HdrEnd - HdrStart + StrLen (Result);\r
    *AltCfgResp = AllocateZeroPool (Length * sizeof (CHAR16));\r
    if (*AltCfgResp == NULL) {\r
      Status = EFI_OUT_OF_RESOURCES;\r
    } else {\r
      StrnCpy (*AltCfgResp, HdrStart, HdrEnd - HdrStart);\r
      StrCat (*AltCfgResp, Result);\r
      Status = EFI_SUCCESS;\r
    }\r
  }\r
\r
  SafeFreePool (GuidStr);\r
  SafeFreePool (NameStr);\r
  SafeFreePool (PathStr);\r
  SafeFreePool (AltIdStr);\r
  SafeFreePool (Result);\r
\r
  return Status;\r
\r
#else\r
  return EFI_UNSUPPORTED;\r
#endif\r
\r
}\r
\r
\r