/** @file
  Implementation of HII utility library.

  Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
  (C) Copyright 2021 Hewlett Packard Enterprise Development LP<BR>
  Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.

  SPDX-License-Identifier: BSD-2-Clause-Patent

**/

#include "HiiInternal.h"

/**
  Initialize the internal data structure of a FormSet.

  @param  Handle                 PackageList Handle
  @param  FormSetGuid            On input, GUID or class GUID of a formset. If not
                                 specified (NULL or zero GUID), take the first
                                 FormSet with class GUID EFI_HII_PLATFORM_SETUP_FORMSET_GUID
                                 found in package list.
                                 On output, GUID of the formset found(if not NULL).
  @param  FormSet                FormSet data structure.

  @retval EFI_SUCCESS            The function completed successfully.
  @retval EFI_NOT_FOUND          The specified FormSet could not be found.

**/
EFI_STATUS
CreateFormSetFromHiiHandle (
  IN     EFI_HII_HANDLE  Handle,
  IN OUT EFI_GUID        *FormSetGuid,
  OUT HII_FORMSET        *FormSet
  )
{
  EFI_STATUS                 Status;
  EFI_HANDLE                 DriverHandle;
  EFI_HII_DATABASE_PROTOCOL  *HiiDatabase;

  if ((FormSetGuid == NULL) || (FormSet == NULL)) {
    return EFI_INVALID_PARAMETER;
  }

  //
  // Locate required Hii Database protocol
  //
  Status = gBS->LocateProtocol (
                  &gEfiHiiDatabaseProtocolGuid,
                  NULL,
                  (VOID **)&HiiDatabase
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }

  Status = GetIfrBinaryData (Handle, FormSetGuid, &FormSet->IfrBinaryLength, &FormSet->IfrBinaryData);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  FormSet->Signature = HII_FORMSET_SIGNATURE;
  FormSet->HiiHandle = Handle;
  CopyMem (&FormSet->Guid, FormSetGuid, sizeof (EFI_GUID));
  //
  // Retrieve ConfigAccess Protocol associated with this HiiPackageList
  //
  Status = HiiDatabase->GetPackageListHandle (HiiDatabase, Handle, &DriverHandle);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  FormSet->DriverHandle = DriverHandle;
  Status                = gBS->HandleProtocol (
                                 DriverHandle,
                                 &gEfiHiiConfigAccessProtocolGuid,
                                 (VOID **)&FormSet->ConfigAccess
                                 );
  if (EFI_ERROR (Status)) {
    //
    // Configuration Driver don't attach ConfigAccess protocol to its HII package
    // list, then there will be no configuration action required
    //
    FormSet->ConfigAccess = NULL;
  }

  Status = gBS->HandleProtocol (
                  DriverHandle,
                  &gEfiDevicePathProtocolGuid,
                  (VOID **)&FormSet->DevicePath
                  );
  if (EFI_ERROR (Status)) {
    //
    // Configuration Driver don't attach ConfigAccess protocol to its HII package
    // list, then there will be no configuration action required
    //
    FormSet->DevicePath = NULL;
  }

  //
  // Parse the IFR binary OpCodes
  //
  Status = ParseOpCodes (FormSet);

  return Status;
}

/**
  Initialize a Formset and get current setting for Questions.

  @param  FormSet                FormSet data structure.

**/
VOID
InitializeFormSet (
  IN OUT HII_FORMSET  *FormSet
  )
{
  LIST_ENTRY           *Link;
  HII_FORMSET_STORAGE  *Storage;
  LIST_ENTRY           *FormLink;
  HII_STATEMENT        *Question;
  HII_FORM             *Form;

  if (FormSet == NULL) {
    return;
  }

  //
  // Load Storage for all questions with storage
  //
  Link = GetFirstNode (&FormSet->StorageListHead);
  while (!IsNull (&FormSet->StorageListHead, Link)) {
    Storage = HII_STORAGE_FROM_LINK (Link);
    LoadFormSetStorage (FormSet, Storage);
    Link = GetNextNode (&FormSet->StorageListHead, Link);
  }

  //
  // Get Current Value for all no storage questions
  //
  FormLink = GetFirstNode (&FormSet->FormListHead);
  while (!IsNull (&FormSet->FormListHead, FormLink)) {
    Form = HII_FORM_FROM_LINK (FormLink);
    Link = GetFirstNode (&Form->StatementListHead);
    while (!IsNull (&Form->StatementListHead, Link)) {
      Question = HII_STATEMENT_FROM_LINK (Link);
      if (Question->Storage == NULL) {
        RetrieveQuestion (FormSet, Form, Question);
      }

      Link = GetNextNode (&Form->StatementListHead, Link);
    }

    FormLink = GetNextNode (&FormSet->FormListHead, FormLink);
  }
}

/**
  Free resources allocated for a FormSet.

  @param[in,out]  FormSet                Pointer of the FormSet

**/
VOID
DestroyFormSet (
  IN OUT HII_FORMSET  *FormSet
  )
{
  LIST_ENTRY                *Link;
  HII_FORMSET_STORAGE       *Storage;
  HII_FORMSET_DEFAULTSTORE  *DefaultStore;
  HII_FORM                  *Form;

  if (FormSet->IfrBinaryData == NULL) {
    //
    // Uninitialized FormSet
    //
    FreePool (FormSet);
    return;
  }

  //
  // Free IFR binary buffer
  //
  FreePool (FormSet->IfrBinaryData);

  //
  // Free FormSet Storage
  //
  if (FormSet->StorageListHead.ForwardLink != NULL) {
    while (!IsListEmpty (&FormSet->StorageListHead)) {
      Link    = GetFirstNode (&FormSet->StorageListHead);
      Storage = HII_STORAGE_FROM_LINK (Link);
      RemoveEntryList (&Storage->Link);

      if (Storage != NULL) {
        FreePool (Storage);
      }
    }
  }

  //
  // Free FormSet Default Store
  //
  if (FormSet->DefaultStoreListHead.ForwardLink != NULL) {
    while (!IsListEmpty (&FormSet->DefaultStoreListHead)) {
      Link         = GetFirstNode (&FormSet->DefaultStoreListHead);
      DefaultStore = HII_FORMSET_DEFAULTSTORE_FROM_LINK (Link);
      RemoveEntryList (&DefaultStore->Link);

      FreePool (DefaultStore);
    }
  }

  //
  // Free Forms
  //
  if (FormSet->FormListHead.ForwardLink != NULL) {
    while (!IsListEmpty (&FormSet->FormListHead)) {
      Link = GetFirstNode (&FormSet->FormListHead);
      Form = HII_FORM_FROM_LINK (Link);
      RemoveEntryList (&Form->Link);

      DestroyForm (FormSet, Form);
    }
  }

  FreePool (FormSet);
}

/**
  Submit data for a form.

  @param[in]  FormSet                FormSet which contains the Form.
  @param[in]  Form                   Form to submit.

  @retval EFI_SUCCESS            The function completed successfully.
  @retval Others                 Other errors occur.

**/
EFI_STATUS
SubmitForm (
  IN HII_FORMSET  *FormSet,
  IN HII_FORM     *Form
  )
{
  EFI_STATUS                       Status;
  EFI_HII_CONFIG_ROUTING_PROTOCOL  *HiiConfigRouting;
  LIST_ENTRY                       *Link;
  EFI_STRING                       ConfigResp;
  EFI_STRING                       Progress;
  HII_FORMSET_STORAGE              *Storage;
  HII_FORM_CONFIG_REQUEST          *ConfigInfo;

  if ((FormSet == NULL) || (Form == NULL)) {
    return EFI_INVALID_PARAMETER;
  }

  Status = NoSubmitCheck (FormSet, &Form, NULL);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  Link = GetFirstNode (&Form->ConfigRequestHead);
  while (!IsNull (&Form->ConfigRequestHead, Link)) {
    ConfigInfo = HII_FORM_CONFIG_REQUEST_FROM_LINK (Link);
    Link       = GetNextNode (&Form->ConfigRequestHead, Link);

    Storage = ConfigInfo->Storage;
    if (Storage->Type == EFI_HII_VARSTORE_EFI_VARIABLE) {
      continue;
    }

    //
    // Skip if there is no RequestElement
    //
    if (ConfigInfo->ElementCount == 0) {
      continue;
    }

    Status = StorageToConfigResp (ConfigInfo->Storage, &ConfigResp, ConfigInfo->ConfigRequest);
    if (EFI_ERROR (Status)) {
      return Status;
    }

    Status = gBS->LocateProtocol (
                    &gEfiHiiConfigRoutingProtocolGuid,
                    NULL,
                    (VOID **)&HiiConfigRouting
                    );
    if (EFI_ERROR (Status)) {
      return Status;
    }

    Status = HiiConfigRouting->RouteConfig (
                                 HiiConfigRouting,
                                 ConfigResp,
                                 &Progress
                                 );

    if (EFI_ERROR (Status)) {
      FreePool (ConfigResp);
      continue;
    }

    FreePool (ConfigResp);
  }

  return Status;
}

/**
  Save Question Value to the memory, but not to storage.

  @param[in]     FormSet                FormSet data structure.
  @param[in]     Form                   Form data structure.
  @param[in,out] Question               Pointer to the Question.
  @param[in]     QuestionValue          New Question Value to be set.

  @retval EFI_SUCCESS            The question value has been set successfully.
  @retval EFI_INVALID_PARAMETER  One or more parameters are invalid.

**/
EFI_STATUS
SetQuestionValue (
  IN     HII_FORMSET          *FormSet,
  IN     HII_FORM             *Form,
  IN OUT HII_STATEMENT        *Question,
  IN     HII_STATEMENT_VALUE  *QuestionValue
  )
{
  UINT8                *Src;
  UINTN                BufferLen;
  UINTN                StorageWidth;
  HII_FORMSET_STORAGE  *Storage;
  CHAR16               *ValueStr;
  BOOLEAN              IsBufferStorage;
  UINT8                *TemBuffer;
  CHAR16               *TemName;
  CHAR16               *TemString;
  UINTN                Index;
  HII_NAME_VALUE_NODE  *Node;
  EFI_STATUS           Status;

  if ((FormSet == NULL) || (Form == NULL) || (Question == NULL) || (QuestionValue == NULL)) {
    return EFI_INVALID_PARAMETER;
  }

  Status = EFI_SUCCESS;
  Node   = NULL;

  //
  // If Question value is provided by an Expression, then it is read only
  //
  if ((Question->ValueExpression != NULL) || (Question->Value.Type != QuestionValue->Type)) {
    return EFI_INVALID_PARAMETER;
  }

  //
  // Before set question value, evaluate its write expression.
  //
  if ((Question->WriteExpression != NULL) && (Form->FormType == STANDARD_MAP_FORM_TYPE)) {
    Status = EvaluateHiiExpression (FormSet, Form, Question->WriteExpression);
    if (EFI_ERROR (Status)) {
      return Status;
    }
  }

  Storage = Question->Storage;
  if (Storage != NULL) {
    StorageWidth = Question->StorageWidth;
    if (Question->Value.Type == EFI_IFR_TYPE_BUFFER) {
      Question->Value.BufferLen = QuestionValue->BufferLen;
      Question->Value.Buffer    = AllocateCopyPool (QuestionValue->BufferLen, QuestionValue->Buffer);
      if (Question->Value.Buffer == NULL) {
        return EFI_OUT_OF_RESOURCES;
      }

      Question->Value.BufferValueType = QuestionValue->BufferValueType;
      Src                             = Question->Value.Buffer;
    } else if (Question->Value.Type == EFI_IFR_TYPE_STRING) {
      Question->Value.Value.string = QuestionValue->Value.string;
      TemString                    = HiiGetString (FormSet->HiiHandle, QuestionValue->Value.string, NULL);
      if (TemString == NULL) {
        return EFI_ABORTED;
      }

      Question->Value.BufferLen = Question->StorageWidth;
      Question->Value.Buffer    = AllocateZeroPool (Question->StorageWidth);
      if (Question->Value.Buffer == NULL) {
        return EFI_OUT_OF_RESOURCES;
      }

      CopyMem (Question->Value.Buffer, TemString, StrSize (TemString));
      Src = Question->Value.Buffer;
    } else {
      CopyMem (&Question->Value.Value, &QuestionValue->Value, sizeof (EFI_IFR_TYPE_VALUE));
      Src = (UINT8 *)&Question->Value.Value;
    }

    if ((Storage->Type == EFI_HII_VARSTORE_BUFFER) || (Storage->Type == EFI_HII_VARSTORE_EFI_VARIABLE_BUFFER)) {
      IsBufferStorage = TRUE;
    } else {
      IsBufferStorage = FALSE;
    }

    if (IsBufferStorage) {
      //
      // If the Question refer to bit filed, copy the value in related bit filed to storage edit buffer.
      //
      if (Question->QuestionReferToBitField) {
        SetBitsQuestionValue (Question, Storage->Buffer + Question->VarStoreInfo.VarOffset, (UINT32)(*Src));
      } else {
        CopyMem (Storage->Buffer + Question->VarStoreInfo.VarOffset, Src, StorageWidth);
      }
    } else {
      if (Question->Value.Type == EFI_IFR_TYPE_STRING) {
        //
        // Allocate enough string buffer.
        //
        ValueStr  = NULL;
        BufferLen = ((StrLen ((CHAR16 *)Src) * 4) + 1) * sizeof (CHAR16);
        ValueStr  = AllocatePool (BufferLen);
        if (ValueStr == NULL) {
          if (Question->Value.Buffer != NULL) {
            FreePool (Question->Value.Buffer);
          }

          return EFI_OUT_OF_RESOURCES;
        }

        //
        // Convert Unicode String to Config String, e.g. "ABCD" => "0041004200430044"
        //
        TemName   = (CHAR16 *)Src;
        TemString = ValueStr;
        for ( ; *TemName != L'\0'; TemName++) {
          UnicodeValueToStringS (
            TemString,
            BufferLen - ((UINTN)TemString - (UINTN)ValueStr),
            PREFIX_ZERO | RADIX_HEX,
            *TemName,
            4
            );
          TemString += StrnLenS (TemString, (BufferLen - ((UINTN)TemString - (UINTN)ValueStr)) / sizeof (CHAR16));
        }
      } else {
        BufferLen = StorageWidth * 2 + 1;
        ValueStr  = AllocateZeroPool (BufferLen * sizeof (CHAR16));
        if (ValueStr == NULL) {
          if (Question->Value.Buffer != NULL) {
            FreePool (Question->Value.Buffer);
          }

          return EFI_OUT_OF_RESOURCES;
        }

        //
        // Convert Buffer to Hex String
        //
        TemBuffer = Src + StorageWidth - 1;
        TemString = ValueStr;
        for (Index = 0; Index < StorageWidth; Index++, TemBuffer--) {
          UnicodeValueToStringS (
            TemString,
            BufferLen * sizeof (CHAR16) - ((UINTN)TemString - (UINTN)ValueStr),
            PREFIX_ZERO | RADIX_HEX,
            *TemBuffer,
            2
            );
          TemString += StrnLenS (TemString, BufferLen - ((UINTN)TemString - (UINTN)ValueStr) / sizeof (CHAR16));
        }
      }

      Status = SetValueByName (Storage, Question->VariableName, ValueStr, &Node);
      FreePool (ValueStr);
      if (EFI_ERROR (Status)) {
        if (Question->Value.Buffer != NULL) {
          FreePool (Question->Value.Buffer);
        }

        return Status;
      }
    }
  } else {
    if (Question->Value.Type == EFI_IFR_TYPE_BUFFER) {
      Question->Value.BufferLen = QuestionValue->BufferLen;
      Question->Value.Buffer    = AllocateCopyPool (QuestionValue->BufferLen, QuestionValue->Buffer);
      if (Question->Value.Buffer == NULL) {
        return EFI_OUT_OF_RESOURCES;
      }

      Question->Value.BufferValueType = QuestionValue->BufferValueType;
    } else if (Question->Value.Type == EFI_IFR_TYPE_STRING) {
      Question->Value.Value.string = QuestionValue->Value.string;
      TemString                    = HiiGetString (FormSet->HiiHandle, QuestionValue->Value.string, NULL);
      if (TemString == NULL) {
        return EFI_ABORTED;
      }

      Question->Value.BufferLen = (UINT16)StrSize (TemString);
      Question->Value.Buffer    = AllocateZeroPool (QuestionValue->BufferLen);
      if (Question->Value.Buffer == NULL) {
        FreePool (TemString);
        return EFI_OUT_OF_RESOURCES;
      }

      CopyMem (Question->Value.Buffer, TemString, StrSize (TemString));
      FreePool (TemString);
    } else {
      CopyMem (&Question->Value.Value, &QuestionValue->Value, sizeof (EFI_IFR_TYPE_VALUE));
    }
  }

  return Status;
}

/**
  Get Question's current Value from storage.

  @param[in]     FormSet                FormSet data structure.
  @param[in]     Form                   Form data structure.
  @param[in,out] Question               Question to be initialized.

  @return the current Question Value in storage if success.
  @return NULL if Question is not found or any error occurs.

**/
HII_STATEMENT_VALUE *
RetrieveQuestion (
  IN     HII_FORMSET    *FormSet,
  IN     HII_FORM       *Form,
  IN OUT HII_STATEMENT  *Question
  )
{
  EFI_STATUS                       Status;
  EFI_HII_CONFIG_ROUTING_PROTOCOL  *HiiConfigRouting;
  EFI_BROWSER_ACTION_REQUEST       ActionRequest;
  HII_FORMSET_STORAGE              *Storage;
  HII_STATEMENT_VALUE              *QuestionValue;
  EFI_IFR_TYPE_VALUE               *TypeValue;
  EFI_TIME                         EfiTime;
  BOOLEAN                          Enabled;
  BOOLEAN                          Pending;
  UINT8                            *Dst;
  UINTN                            StorageWidth;
  CHAR16                           *ConfigRequest;
  CHAR16                           *Progress;
  CHAR16                           *Result;
  CHAR16                           *ValueStr;
  UINTN                            Length;
  BOOLEAN                          IsBufferStorage;
  CHAR16                           *NewHiiString;

  if ((FormSet == NULL) || (Form == NULL) || (Question == NULL)) {
    return NULL;
  }

  Status   = EFI_SUCCESS;
  ValueStr = NULL;
  Result   = NULL;

  QuestionValue = AllocateZeroPool (sizeof (HII_STATEMENT_VALUE));
  if (QuestionValue == NULL) {
    return NULL;
  }

  QuestionValue->Type      = Question->Value.Type;
  QuestionValue->BufferLen = Question->Value.BufferLen;
  if (QuestionValue->BufferLen != 0) {
    QuestionValue->Buffer = AllocateZeroPool (QuestionValue->BufferLen);
    if (QuestionValue->Buffer == NULL) {
      FreePool (QuestionValue);
      return NULL;
    }
  }

  //
  // Question value is provided by RTC
  //
  Storage      = Question->Storage;
  StorageWidth = Question->StorageWidth;

  if (Storage == NULL) {
    //
    // It's a Question without storage, or RTC date/time
    //
    if ((Question->Operand == EFI_IFR_DATE_OP) || (Question->Operand == EFI_IFR_TIME_OP)) {
      //
      // Date and time define the same Flags bit
      //
      switch (Question->ExtraData.Flags & EFI_QF_DATE_STORAGE) {
        case QF_DATE_STORAGE_TIME:

          Status = gRT->GetTime (&EfiTime, NULL);
          break;

        case QF_DATE_STORAGE_WAKEUP:

          Status = gRT->GetWakeupTime (&Enabled, &Pending, &EfiTime);
          break;

        case QF_DATE_STORAGE_NORMAL:
        default:

          goto ON_ERROR;
      }

      if (EFI_ERROR (Status)) {
        if (Question->Operand == EFI_IFR_DATE_OP) {
          QuestionValue->Value.date.Year  = 0xff;
          QuestionValue->Value.date.Month = 0xff;
          QuestionValue->Value.date.Day   = 0xff;
        } else {
          QuestionValue->Value.time.Hour   = 0xff;
          QuestionValue->Value.time.Minute = 0xff;
          QuestionValue->Value.time.Second = 0xff;
        }

        return QuestionValue;
      }

      if (Question->Operand == EFI_IFR_DATE_OP) {
        QuestionValue->Value.date.Year  = EfiTime.Year;
        QuestionValue->Value.date.Month = EfiTime.Month;
        QuestionValue->Value.date.Day   = EfiTime.Day;
      } else {
        QuestionValue->Value.time.Hour   = EfiTime.Hour;
        QuestionValue->Value.time.Minute = EfiTime.Minute;
        QuestionValue->Value.time.Second = EfiTime.Second;
      }
    } else {
      if (((Question->QuestionFlags & EFI_IFR_FLAG_CALLBACK) != EFI_IFR_FLAG_CALLBACK) ||
          (FormSet->ConfigAccess == NULL))
      {
        goto ON_ERROR;
      }

      if (QuestionValue->Type == EFI_IFR_TYPE_BUFFER) {
        //
        // For OrderedList, passing in the value buffer to Callback()
        //
        TypeValue = (EFI_IFR_TYPE_VALUE *)QuestionValue->Buffer;
      } else {
        TypeValue = &QuestionValue->Value;
      }

      ActionRequest = EFI_BROWSER_ACTION_REQUEST_NONE;
      Status        = FormSet->ConfigAccess->Callback (
                                               FormSet->ConfigAccess,
                                               EFI_BROWSER_ACTION_RETRIEVE,
                                               Question->QuestionId,
                                               QuestionValue->Type,
                                               TypeValue,
                                               &ActionRequest
                                               );

      if (!EFI_ERROR (Status) && (QuestionValue->Type == EFI_IFR_TYPE_STRING)) {
        if (TypeValue->string == 0) {
          goto ON_ERROR;
        }

        NewHiiString = GetTokenString (TypeValue->string, FormSet->HiiHandle);
        if (NewHiiString == NULL) {
          goto ON_ERROR;
        }

        QuestionValue->Buffer = AllocatePool (StrSize (NewHiiString));
        if (QuestionValue->Buffer == NULL) {
          FreePool (NewHiiString);
          goto ON_ERROR;
        }

        CopyMem (QuestionValue->Buffer, NewHiiString, StrSize (NewHiiString));
        QuestionValue->BufferLen = (UINT16)StrSize (NewHiiString);

        FreePool (NewHiiString);
      }
    }

    return QuestionValue;
  }

  //
  // Question value is provided by EFI variable
  //
  if (Storage->Type == EFI_HII_VARSTORE_EFI_VARIABLE) {
    if ((QuestionValue->Type != EFI_IFR_TYPE_BUFFER) && (QuestionValue->Type != EFI_IFR_TYPE_STRING)) {
      Dst          = QuestionValue->Buffer;
      StorageWidth = QuestionValue->BufferLen;
    } else {
      Dst          = (UINT8 *)&QuestionValue->Value;
      StorageWidth = sizeof (EFI_IFR_TYPE_VALUE);
    }

    Status = gRT->GetVariable (
                    Question->VariableName,
                    &Storage->Guid,
                    NULL,
                    &StorageWidth,
                    Dst
                    );

    return QuestionValue;
  }

  Status = gBS->LocateProtocol (
                  &gEfiHiiConfigRoutingProtocolGuid,
                  NULL,
                  (VOID **)&HiiConfigRouting
                  );
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }

  if (QuestionValue->BufferLen != 0) {
    Dst = QuestionValue->Buffer;
  } else {
    Dst = (UINT8 *)&QuestionValue->Value;
  }

  if ((Storage->Type == EFI_HII_VARSTORE_BUFFER) || (Storage->Type == EFI_HII_VARSTORE_EFI_VARIABLE_BUFFER)) {
    IsBufferStorage = TRUE;
  } else {
    IsBufferStorage = FALSE;
  }

  Storage = GetFstStgFromVarId (FormSet, Question->VarStoreId);
  if (Storage == NULL) {
    goto ON_ERROR;
  }

  //
  // <ConfigRequest> ::= <ConfigHdr> + <BlockName> || <ConfigHdr> + "&" + <VariableName>
  //
  if (IsBufferStorage) {
    Length  = StrLen (Storage->ConfigHdr);
    Length += StrLen (Question->BlockName);
  } else {
    Length  = StrLen (Storage->ConfigHdr);
    Length += StrLen (Question->VariableName) + 1;
  }

  ConfigRequest = AllocatePool ((Length + 1) * sizeof (CHAR16));
  if (ConfigRequest == NULL) {
    goto ON_ERROR;
  }

  StrCpyS (ConfigRequest, Length + 1, Storage->ConfigHdr);
  if (IsBufferStorage) {
    StrCatS (ConfigRequest, Length + 1, Question->BlockName);
  } else {
    StrCatS (ConfigRequest, Length + 1, L"&");
    StrCatS (ConfigRequest, Length + 1, Question->VariableName);
  }

  //
  // Request current settings from Configuration Driver
  //
  Status = HiiConfigRouting->ExtractConfig (
                               HiiConfigRouting,
                               ConfigRequest,
                               &Progress,
                               &Result
                               );
  FreePool (ConfigRequest);
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }

  if (IsBufferStorage) {
    ValueStr = StrStr (Result, L"&VALUE");
    if (ValueStr == NULL) {
      FreePool (Result);
      goto ON_ERROR;
    }

    ValueStr = ValueStr + 6;
  } else {
    ValueStr = Result + Length;
  }

  if (*ValueStr != '=') {
    FreePool (Result);
    goto ON_ERROR;
  }

  ValueStr++;
  Status = BufferToQuestionValue (Question, ValueStr, QuestionValue);
  if (EFI_ERROR (Status)) {
    FreePool (Result);
    goto ON_ERROR;
  }

  if (Result != NULL) {
    FreePool (Result);
  }

  return QuestionValue;

ON_ERROR:

  if (QuestionValue->Buffer != NULL) {
    FreePool (QuestionValue->Buffer);
  }

  FreePool (QuestionValue);

  return NULL;
}
