EmulatorPkg/RedfishPlatformHostInterfaceLib library

BZ:
https://bugzilla.tianocore.org/show_bug.cgi?id=3102

Platform specific implementation of providing
Redfish host interface information.

Signed-off-by: Jiaxin Wu <jiaxin.wu@intel.com>
Signed-off-by: Ting Ye <ting.ye@intel.com>
Signed-off-by: Siyuan Fu <siyuan.fu@intel.com>
Signed-off-by: Fan Wang <fan.wang@intel.com>
Signed-off-by: Abner Chang <abner.chang@hpe.com>

Cc: Jordan Justen <jordan.l.justen@intel.com>
Cc: Andrew Fish <afish@apple.com>
Cc: Ray Ni <ray.ni@intel.com>
Cc: Nickle Wang <nickle.wang@hpe.com>
Cc: Peter O'Hanley <peter.ohanley@hpe.com>
Acked-by: Ray Ni <ray.ni@intel.com>

3 files changed, 576 insertions, 0 deletions

diff --git a/EmulatorPkg/EmulatorPkg.dec b/EmulatorPkg/EmulatorPkg.dec
index 064f963c72..5d7fe6473e 100644
--- a/EmulatorPkg/EmulatorPkg.dec
+++ b/EmulatorPkg/EmulatorPkg.dec
@@ -46,6 +46,7 @@
   gEmuSystemConfigGuid       = { 0xF8626165, 0x6CEB, 0x924A, { 0xBA, 0xFC, 0xF1, 0x3A, 0xB9, 0xD6, 0x57, 0x28 } }

   gEmuVirtualDisksGuid       = { 0xf2ba331a, 0x8985, 0x11db, { 0xa4, 0x06, 0x00, 0x40, 0xd0, 0x2b, 0x18, 0x35 } }

   gEmuPhysicalDisksGuid      = { 0xf2bdcc96, 0x8985, 0x11db, { 0x87, 0x19, 0x00, 0x40, 0xd0, 0x2b, 0x18, 0x35 } }

+  gEmuRedfishServiceGuid     = { 0x3fb208ac, 0x2185, 0x498c, { 0xbf, 0x46, 0xdc, 0x23, 0xda, 0x58, 0x7b, 0x55 } }

 

 [PcdsFeatureFlag]

   ## If TRUE, if symbols only load on breakpoints and gdb entry

diff --git a/EmulatorPkg/Library/RedfishPlatformHostInterfaceLib/RedfishPlatformHostInterfaceLib.c b/EmulatorPkg/Library/RedfishPlatformHostInterfaceLib/RedfishPlatformHostInterfaceLib.c
new file mode 100644
index 0000000000..4e7bb65c06
--- /dev/null
+++ b/EmulatorPkg/Library/RedfishPlatformHostInterfaceLib/RedfishPlatformHostInterfaceLib.c
@@ -0,0 +1,528 @@
+/** @file

+  PCI/PCIe network interface instace of RedfishPlatformHostInterfaceLib

+

+  Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>

+  (C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>

+

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

+

+**/

+

+#include <Uefi.h>

+#include <Library/BaseLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/DebugLib.h>

+#include <Library/DevicePathLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/PrintLib.h>

+#include <Library/RedfishHostInterfaceLib.h>

+#include <Library/UefiLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/UefiRuntimeServicesTableLib.h>

+

+#include <Pcd/RestExServiceDevicePath.h>

+#include <Guid/GlobalVariable.h>

+

+#define VERBOSE_COLUME_SIZE  (16)

+

+REDFISH_OVER_IP_PROTOCOL_DATA  *mRedfishOverIpProtocolData;

+UINT8 mRedfishProtocolDataSize;

+

+/**

+  Get the MAC address of NIC.

+

+  @param[out] MacAddress      Pointer to retrieve MAC address

+

+  @retval   EFI_SUCCESS      MAC address is returned in MacAddress

+

+**/

+EFI_STATUS

+GetMacAddressInformation (

+  OUT EFI_MAC_ADDRESS *MacAddress

+  )

+{

+  MAC_ADDR_DEVICE_PATH                     *Mac;

+  REST_EX_SERVICE_DEVICE_PATH_DATA         *RestExServiceDevicePathData;

+  EFI_DEVICE_PATH_PROTOCOL                 *RestExServiceDevicePath;

+  MAC_ADDR_DEVICE_PATH                     *MacAddressDevicePath;

+

+  Mac = NULL;

+  RestExServiceDevicePathData  = NULL;

+  RestExServiceDevicePath      = NULL;

+

+  RestExServiceDevicePathData = (REST_EX_SERVICE_DEVICE_PATH_DATA *)PcdGetPtr(PcdRedfishRestExServiceDevicePath);

+  if (RestExServiceDevicePathData == NULL ||

+      RestExServiceDevicePathData->DevicePathNum == 0 ||

+      !IsDevicePathValid (RestExServiceDevicePathData->DevicePath, 0)) {

+    return EFI_NOT_FOUND;

+  }

+

+  RestExServiceDevicePath = RestExServiceDevicePathData->DevicePath;

+  if (RestExServiceDevicePathData->DevicePathMatchMode != DEVICE_PATH_MATCH_MAC_NODE) {

+    return EFI_NOT_FOUND;

+  }

+

+  //

+  // Find Mac DevicePath Node.

+  //

+  while (!IsDevicePathEnd (RestExServiceDevicePath) &&

+         ((DevicePathType (RestExServiceDevicePath) != MESSAGING_DEVICE_PATH) ||

+          (DevicePathSubType (RestExServiceDevicePath) != MSG_MAC_ADDR_DP))) {

+    RestExServiceDevicePath = NextDevicePathNode (RestExServiceDevicePath);

+  }

+

+  if (!IsDevicePathEnd (RestExServiceDevicePath)) {

+    MacAddressDevicePath = (MAC_ADDR_DEVICE_PATH *)RestExServiceDevicePath;

+    CopyMem ((VOID *)MacAddress, (VOID *)&MacAddressDevicePath->MacAddress, sizeof (EFI_MAC_ADDRESS));

+    return EFI_SUCCESS;

+  }

+  return EFI_NOT_FOUND;

+}

+

+/**

+  Get platform Redfish host interface device descriptor.

+

+  @param[out] DeviceType        Pointer to retrieve device type.

+  @param[out] DeviceDescriptor  Pointer to retrieve REDFISH_INTERFACE_DATA, caller has to free

+                                this memory using FreePool().

+  @retval EFI_SUCCESS     Device descriptor is returned successfully in DeviceDescriptor.

+  @retval EFI_NOT_FOUND   No Redfish host interface descriptor provided on this platform.

+  @retval Others          Fail to get device descriptor.

+**/

+EFI_STATUS

+RedfishPlatformHostInterfaceDeviceDescriptor (

+  OUT UINT8 *DeviceType,

+  OUT REDFISH_INTERFACE_DATA  **DeviceDescriptor

+)

+{

+  EFI_STATUS Status;

+  EFI_MAC_ADDRESS MacAddress;

+  REDFISH_INTERFACE_DATA *RedfishInterfaceData;

+  PCI_OR_PCIE_INTERFACE_DEVICE_DESCRIPTOR_V2 *ThisDeviceDescriptor;

+

+  RedfishInterfaceData = AllocateZeroPool (sizeof (PCI_OR_PCIE_INTERFACE_DEVICE_DESCRIPTOR_V2) + 1);

+  if (RedfishInterfaceData == NULL) {

+    return EFI_OUT_OF_RESOURCES;

+  }

+  RedfishInterfaceData->DeviceType = REDFISH_HOST_INTERFACE_DEVICE_TYPE_PCI_PCIE_V2;

+  //

+  // Fill up device type information.

+  //

+  ThisDeviceDescriptor = (PCI_OR_PCIE_INTERFACE_DEVICE_DESCRIPTOR_V2 *)((UINT8 *)RedfishInterfaceData + 1);

+  ThisDeviceDescriptor->Length = sizeof (PCI_OR_PCIE_INTERFACE_DEVICE_DESCRIPTOR_V2) + 1;

+  Status = GetMacAddressInformation (&MacAddress);

+  if (EFI_ERROR (Status)) {

+    FreePool (RedfishInterfaceData);

+    return EFI_NOT_FOUND;

+  }

+  CopyMem ((VOID *)&ThisDeviceDescriptor->MacAddress, (VOID *)&MacAddress, sizeof (ThisDeviceDescriptor->MacAddress));

+  *DeviceType = REDFISH_HOST_INTERFACE_DEVICE_TYPE_PCI_PCIE_V2;

+  *DeviceDescriptor = RedfishInterfaceData;

+  return EFI_SUCCESS;

+}

+/**

+  Get platform Redfish host interface protocol data.

+  Caller should pass NULL in ProtocolRecord to retrive the first protocol record.

+  Then continuously pass previous ProtocolRecord for retrieving the next ProtocolRecord.

+

+  @param[out] ProtocolRecord     Pointer to retrieve the protocol record.

+                                 caller has to free the new protocol record returned from

+                                 this function using FreePool().

+  @param[in] IndexOfProtocolData The index of protocol data.

+

+  @retval EFI_SUCCESS     Protocol records are all returned.

+  @retval EFI_NOT_FOUND   No more protocol records.

+  @retval Others          Fail to get protocol records.

+**/

+EFI_STATUS

+RedfishPlatformHostInterfaceProtocolData (

+  OUT MC_HOST_INTERFACE_PROTOCOL_RECORD **ProtocolRecord,

+  IN UINT8  IndexOfProtocolData

+)

+{

+  MC_HOST_INTERFACE_PROTOCOL_RECORD *ThisProtocolRecord;

+

+  if (mRedfishOverIpProtocolData == 0) {

+    return EFI_NOT_FOUND;

+  }

+  if (IndexOfProtocolData == 0) {

+    //

+    // Return the first Redfish protocol data to caller. We only have

+    // one protocol data in this case.

+    //

+    ThisProtocolRecord = (MC_HOST_INTERFACE_PROTOCOL_RECORD *) AllocatePool (mRedfishProtocolDataSize + sizeof (MC_HOST_INTERFACE_PROTOCOL_RECORD) - 1);

+    ThisProtocolRecord->ProtocolType = MCHostInterfaceProtocolTypeRedfishOverIP;

+    ThisProtocolRecord->ProtocolTypeDataLen = mRedfishProtocolDataSize;

+    CopyMem ((VOID *)&ThisProtocolRecord->ProtocolTypeData, (VOID *)mRedfishOverIpProtocolData, mRedfishProtocolDataSize);

+    *ProtocolRecord = ThisProtocolRecord;

+    return EFI_SUCCESS;

+  }

+  return EFI_NOT_FOUND;

+}

+/**

+  Dump IPv4 address.

+

+  @param[in] Ip IPv4 address

+**/

+VOID

+InternalDumpIp4Addr (

+  IN EFI_IPv4_ADDRESS   *Ip

+  )

+{

+  UINTN                 Index;

+

+  for (Index = 0; Index < 4; Index++) {

+    DEBUG ((DEBUG_VERBOSE, "%d", Ip->Addr[Index]));

+    if (Index < 3) {

+      DEBUG ((DEBUG_VERBOSE, "."));

+    }

+  }

+

+  DEBUG ((DEBUG_VERBOSE, "\n"));

+}

+/**

+  Dump IPv6 address.

+

+  @param[in] Ip IPv6 address

+**/

+VOID

+InternalDumpIp6Addr (

+  IN EFI_IPv6_ADDRESS   *Ip

+  )

+{

+  UINTN Index;

+

+  for (Index = 0; Index < 16; Index++) {

+    if (Ip->Addr[Index] != 0) {

+      DEBUG ((DEBUG_VERBOSE, "%x", Ip->Addr[Index]));

+    }

+    Index++;

+

+    if (Index > 15) {

+      return;

+    }

+

+    if (((Ip->Addr[Index] & 0xf0) == 0) && (Ip->Addr[Index - 1] != 0)) {

+      DEBUG ((DEBUG_VERBOSE, "0"));

+    }

+    DEBUG ((DEBUG_VERBOSE, "%x", Ip->Addr[Index]));

+

+    if (Index < 15) {

+      DEBUG ((DEBUG_VERBOSE, ":"));

+    }

+  }

+  DEBUG ((DEBUG_VERBOSE, "\n"));

+}

+/**

+  Dump data

+

+  @param[in] Data Pointer to data.

+  @param[in] Size size of data to dump.

+**/

+VOID

+InternalDumpData (

+  IN UINT8  *Data,

+  IN UINTN  Size

+  )

+{

+  UINTN  Index;

+  for (Index = 0; Index < Size; Index++) {

+    DEBUG ((DEBUG_VERBOSE, "%02x ", (UINTN)Data[Index]));

+  }

+}

+/**

+  Dump hex data

+

+  @param[in] Data Pointer to hex data.

+  @param[in] Size size of hex data to dump.

+**/

+VOID

+InternalDumpHex (

+  IN UINT8  *Data,

+  IN UINTN  Size

+  )

+{

+  UINTN   Index;

+  UINTN   Count;

+  UINTN   Left;

+

+  Count = Size / VERBOSE_COLUME_SIZE;

+  Left  = Size % VERBOSE_COLUME_SIZE;

+  for (Index = 0; Index < Count; Index++) {

+    InternalDumpData (Data + Index * VERBOSE_COLUME_SIZE, VERBOSE_COLUME_SIZE);

+    DEBUG ((DEBUG_VERBOSE, "\n"));

+  }

+

+  if (Left != 0) {

+    InternalDumpData (Data + Index * VERBOSE_COLUME_SIZE, Left);

+    DEBUG ((DEBUG_VERBOSE, "\n"));

+  }

+

+  DEBUG ((DEBUG_VERBOSE, "\n"));

+}

+/**

+  Dump Redfish over IP protocol data

+

+  @param[in] RedfishProtocolData     Pointer to REDFISH_OVER_IP_PROTOCOL_DATA

+  @param[in] RedfishProtocolDataSize size of data to dump.

+**/

+VOID

+DumpRedfishIpProtocolData (

+  IN REDFISH_OVER_IP_PROTOCOL_DATA   *RedfishProtocolData,

+  IN UINT8                           RedfishProtocolDataSize

+  )

+{

+  CHAR16 Hostname[16];

+

+  DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData: \n"));

+  InternalDumpHex ((UINT8 *) RedfishProtocolData, RedfishProtocolDataSize);

+

+  DEBUG ((DEBUG_VERBOSE, "Parsing as below: \n"));

+

+  DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->ServiceUuid - %g\n", &(RedfishProtocolData->ServiceUuid)));

+

+  DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->HostIpAssignmentType - %d\n", RedfishProtocolData->HostIpAssignmentType));

+

+  DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->HostIpAddressFormat - %d\n", RedfishProtocolData->HostIpAddressFormat));

+

+  DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->HostIpAddress: \n"));

+  if (RedfishProtocolData->HostIpAddressFormat == 0x01) {

+    InternalDumpIp4Addr ((EFI_IPv4_ADDRESS *) (RedfishProtocolData->HostIpAddress));

+  } else {

+    InternalDumpIp6Addr ((EFI_IPv6_ADDRESS *) (RedfishProtocolData->HostIpAddress));

+  }

+

+  DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->HostIpMask: \n"));

+  if (RedfishProtocolData->HostIpAddressFormat == 0x01) {

+    InternalDumpIp4Addr ((EFI_IPv4_ADDRESS *) (RedfishProtocolData->HostIpMask));

+  } else {

+    InternalDumpIp6Addr ((EFI_IPv6_ADDRESS *) (RedfishProtocolData->HostIpMask));

+  }

+

+  DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceIpDiscoveryType - %d\n", RedfishProtocolData->RedfishServiceIpDiscoveryType));

+

+  DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceIpAddressFormat - %d\n", RedfishProtocolData->RedfishServiceIpAddressFormat));

+

+  DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceIpAddress: \n"));

+  if (RedfishProtocolData->RedfishServiceIpAddressFormat == 0x01) {

+    InternalDumpIp4Addr ((EFI_IPv4_ADDRESS *) (RedfishProtocolData->RedfishServiceIpAddress));

+  } else {

+    InternalDumpIp6Addr ((EFI_IPv6_ADDRESS *) (RedfishProtocolData->RedfishServiceIpAddress));

+  }

+

+  DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceIpMask: \n"));

+  if (RedfishProtocolData->RedfishServiceIpAddressFormat == 0x01) {

+    InternalDumpIp4Addr ((EFI_IPv4_ADDRESS *) (RedfishProtocolData->RedfishServiceIpMask));

+  } else {

+    InternalDumpIp6Addr ((EFI_IPv6_ADDRESS *) (RedfishProtocolData->RedfishServiceIpMask));

+  }

+

+  DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceIpPort - %d\n", RedfishProtocolData->RedfishServiceIpPort));

+

+  DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceVlanId - %d\n", RedfishProtocolData->RedfishServiceVlanId));

+

+  DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceHostnameLength - %d\n", RedfishProtocolData->RedfishServiceHostnameLength));

+

+  AsciiStrToUnicodeStrS((CHAR8 *) RedfishProtocolData->RedfishServiceHostname, Hostname, sizeof (Hostname) / sizeof (Hostname[0]));

+  DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceHostname - %s\n", Hostname));

+}

+

+/**

+  Get Redfish host interface protocol data from variale.

+

+  @param[out] RedfishProtocolData  Pointer to retrieve REDFISH_OVER_IP_PROTOCOL_DATA.

+  @param[out] RedfishProtocolDataSize  Size of REDFISH_OVER_IP_PROTOCOL_DATA.

+

+  @retval EFI_SUCESS   REDFISH_OVER_IP_PROTOCOL_DATA is returned successfully.

+**/

+EFI_STATUS

+GetRedfishRecordFromVariable (

+  OUT REDFISH_OVER_IP_PROTOCOL_DATA   **RedfishProtocolData,

+  OUT UINT8 *RedfishProtocolDataSize

+  )

+{

+  EFI_STATUS                      Status;

+  UINT8                           HostIpAssignmentType;

+  UINTN                           HostIpAssignmentTypeSize;

+  EFI_IPv4_ADDRESS                HostIpAddress;

+  UINTN                           IPv4DataSize;

+  EFI_IPv4_ADDRESS                HostIpMask;

+  EFI_IPv4_ADDRESS                RedfishServiceIpAddress;

+  EFI_IPv4_ADDRESS                RedfishServiceIpMask;

+  UINT16                          RedfishServiceIpPort;

+  UINTN                           IpPortDataSize;

+  UINT8                           HostNameSize;

+  CHAR8                           RedfishHostName[20];

+

+  if (RedfishProtocolData == NULL || RedfishProtocolDataSize == NULL) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  //

+  // 1. Retrieve Address Information from variable.

+  //

+  Status = gRT->GetVariable (

+                  L"HostIpAssignmentType",

+                  &gEmuRedfishServiceGuid,

+                  NULL,

+                  &HostIpAssignmentTypeSize,

+                  &HostIpAssignmentType

+                  );

+  if (EFI_ERROR (Status)) {

+    DEBUG ((DEBUG_ERROR, "RedfishPlatformDxe: GetVariable HostIpAssignmentType - %r\n", Status));

+    return Status;

+  }

+

+  IPv4DataSize = sizeof (EFI_IPv4_ADDRESS);

+  if (HostIpAssignmentType == 1 ) {

+    Status = gRT->GetVariable (

+                    L"HostIpAddress",

+                    &gEmuRedfishServiceGuid,

+                    NULL,

+                    &IPv4DataSize,

+                    &HostIpAddress

+                    );

+    if (EFI_ERROR (Status)) {

+      DEBUG ((DEBUG_ERROR, "RedfishPlatformDxe: GetVariable HostIpAddress - %r\n", Status));

+      return Status;

+    }

+

+    Status = gRT->GetVariable (

+                    L"HostIpMask",

+                    &gEmuRedfishServiceGuid,

+                    NULL,

+                    &IPv4DataSize,

+                    &HostIpMask

+                    );

+    if (EFI_ERROR (Status)) {

+      DEBUG ((DEBUG_ERROR, "RedfishPlatformDxe: GetVariable HostIpMask - %r\n", Status));

+      return Status;

+    }

+  }

+

+  Status = gRT->GetVariable (

+                  L"RedfishServiceIpAddress",

+                  &gEmuRedfishServiceGuid,

+                  NULL,

+                  &IPv4DataSize,

+                  &RedfishServiceIpAddress

+                  );

+  if (EFI_ERROR (Status)) {

+    DEBUG ((DEBUG_ERROR, "RedfishPlatformDxe: GetVariable RedfishServiceIpAddress - %r\n", Status));

+    return Status;

+  }

+

+  Status = gRT->GetVariable (

+                  L"RedfishServiceIpMask",

+                  &gEmuRedfishServiceGuid,

+                  NULL,

+                  &IPv4DataSize,

+                  &RedfishServiceIpMask

+                  );

+  if (EFI_ERROR (Status)) {

+    DEBUG ((DEBUG_ERROR, "RedfishPlatformDxe: GetVariable RedfishServiceIpMask - %r\n", Status));

+    return Status;

+  }

+

+  Status = gRT->GetVariable (

+                  L"RedfishServiceIpPort",

+                  &gEmuRedfishServiceGuid,

+                  NULL,

+                  &IpPortDataSize,

+                  &RedfishServiceIpPort

+                  );

+  if (EFI_ERROR (Status)) {

+    DEBUG ((DEBUG_ERROR, "RedfishPlatformDxe: GetVariable RedfishServiceIpPort - %r\n", Status));

+    return Status;

+  }

+

+  AsciiSPrint (

+    RedfishHostName,

+    sizeof (RedfishHostName),

+    "%d.%d.%d.%d",

+    RedfishServiceIpAddress.Addr[0],

+    RedfishServiceIpAddress.Addr[1],

+    RedfishServiceIpAddress.Addr[2],

+    RedfishServiceIpAddress.Addr[3]

+    );

+

+  HostNameSize = (UINT8) AsciiStrLen (RedfishHostName) + 1;

+

+  //

+  // 2. Protocol Data Size.

+  //

+  *RedfishProtocolDataSize = sizeof (REDFISH_OVER_IP_PROTOCOL_DATA) - 1 + HostNameSize;

+

+  //

+  // 3. Protocol Data.

+  //

+  *RedfishProtocolData = (REDFISH_OVER_IP_PROTOCOL_DATA *) AllocateZeroPool (*RedfishProtocolDataSize);

+  if (*RedfishProtocolData == NULL) {

+    return EFI_OUT_OF_RESOURCES;

+  }

+

+  CopyGuid (&(*RedfishProtocolData)->ServiceUuid, &gEmuRedfishServiceGuid);

+

+  (*RedfishProtocolData)->HostIpAssignmentType = HostIpAssignmentType;

+  (*RedfishProtocolData)->HostIpAddressFormat = 1;   // Only support IPv4

+

+  if (HostIpAssignmentType == 1 ) {

+    (*RedfishProtocolData)->HostIpAddress[0] = HostIpAddress.Addr[0];

+    (*RedfishProtocolData)->HostIpAddress[1] = HostIpAddress.Addr[1];

+    (*RedfishProtocolData)->HostIpAddress[2] = HostIpAddress.Addr[2];

+    (*RedfishProtocolData)->HostIpAddress[3] = HostIpAddress.Addr[3];

+

+    (*RedfishProtocolData)->HostIpMask[0] = HostIpMask.Addr[0];

+    (*RedfishProtocolData)->HostIpMask[1] = HostIpMask.Addr[1];

+    (*RedfishProtocolData)->HostIpMask[2] = HostIpMask.Addr[2];

+    (*RedfishProtocolData)->HostIpMask[3] = HostIpMask.Addr[3];

+  }

+

+  (*RedfishProtocolData)->RedfishServiceIpDiscoveryType = 1;  // Use static IP address

+  (*RedfishProtocolData)->RedfishServiceIpAddressFormat = 1;  // Only support IPv4

+

+  (*RedfishProtocolData)->RedfishServiceIpAddress[0] = RedfishServiceIpAddress.Addr[0];

+  (*RedfishProtocolData)->RedfishServiceIpAddress[1] = RedfishServiceIpAddress.Addr[1];

+  (*RedfishProtocolData)->RedfishServiceIpAddress[2] = RedfishServiceIpAddress.Addr[2];

+  (*RedfishProtocolData)->RedfishServiceIpAddress[3] = RedfishServiceIpAddress.Addr[3];

+

+  (*RedfishProtocolData)->RedfishServiceIpMask[0] = RedfishServiceIpMask.Addr[0];

+  (*RedfishProtocolData)->RedfishServiceIpMask[1] = RedfishServiceIpMask.Addr[1];

+  (*RedfishProtocolData)->RedfishServiceIpMask[2] = RedfishServiceIpMask.Addr[2];

+  (*RedfishProtocolData)->RedfishServiceIpMask[3] = RedfishServiceIpMask.Addr[3];

+

+  (*RedfishProtocolData)->RedfishServiceIpPort = RedfishServiceIpPort;

+  (*RedfishProtocolData)->RedfishServiceVlanId = 0xffffffff;

+

+  (*RedfishProtocolData)->RedfishServiceHostnameLength = HostNameSize;

+  AsciiStrCpyS ((CHAR8 *) ((*RedfishProtocolData)->RedfishServiceHostname), HostNameSize, RedfishHostName);

+

+  return Status;

+}

+

+/**

+  Construct Redfish host interface protocol data.

+

+  @param ImageHandle     The image handle.

+  @param SystemTable     The system table.

+

+  @retval  EFI_SUCEESS  Install Boot manager menu success.

+  @retval  Other        Return error status.

+

+**/

+EFI_STATUS

+EFIAPI

+RedfishPlatformHostInterfaceConstructor (

+  IN EFI_HANDLE                            ImageHandle,

+  IN EFI_SYSTEM_TABLE                      *SystemTable

+)

+{

+  EFI_STATUS Status;

+

+  Status = GetRedfishRecordFromVariable (&mRedfishOverIpProtocolData, &mRedfishProtocolDataSize);

+  DEBUG ((DEBUG_INFO, "%a: GetRedfishRecordFromVariable() - %r\n", __FUNCTION__, Status));

+  if (!EFI_ERROR (Status)) {

+    DumpRedfishIpProtocolData (mRedfishOverIpProtocolData, mRedfishProtocolDataSize);

+  }

+  return EFI_SUCCESS;

+}

diff --git a/EmulatorPkg/Library/RedfishPlatformHostInterfaceLib/RedfishPlatformHostInterfaceLib.inf b/EmulatorPkg/Library/RedfishPlatformHostInterfaceLib/RedfishPlatformHostInterfaceLib.inf
new file mode 100644
index 0000000000..668a81351e
--- /dev/null
+++ b/EmulatorPkg/Library/RedfishPlatformHostInterfaceLib/RedfishPlatformHostInterfaceLib.inf
@@ -0,0 +1,47 @@
+## @file

+#  NULL instance of RedfishPlatformHostInterfaceLib

+#

+#  (C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>

+#

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

+#

+##

+

+[Defines]

+  INF_VERSION                    = 0x0001000b

+  BASE_NAME                      = RedfishPlatformHostInterfaceLib

+  FILE_GUID                      = D5ECB7F2-4906-94E2-45B1-31BF4FD90122

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = RedfishPlatformHostInterfaceLib

+  CONSTRUCTOR                    = RedfishPlatformHostInterfaceConstructor

+#

+#  VALID_ARCHITECTURES           = IA32 X64

+#

+

+[Sources]

+  RedfishPlatformHostInterfaceLib.c

+

+[Packages]

+  EmulatorPkg/EmulatorPkg.dec

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+  RedfishPkg/RedfishPkg.dec

+

+[LibraryClasses]

+  BaseLib

+  BaseMemoryLib

+  DebugLib

+  MemoryAllocationLib

+  PcdLib

+  UefiLib

+

+[Pcd]

+  gEfiRedfishPkgTokenSpaceGuid.PcdRedfishRestExServiceDevicePath         ## CONSUMES

+

+[Guids]

+  gEmuRedfishServiceGuid

+

+[Depex]

+  gEfiVariableArchProtocolGuid AND

+  gEfiVariableWriteArchProtocolGuid