RedfishLib.c

Go to the documentation of this file.

 
#include "RedfishMisc.h"
 
REDFISH_SERVICE
EFIAPI
RedfishCreateService (
  IN  REDFISH_CONFIG_SERVICE_INFORMATION  *RedfishConfigServiceInfo
  )
{
  REDFISH_SERVICE            RedfishService;
  EDKII_REDFISH_AUTH_METHOD  AuthMethod;
  CHAR8                      *UserId;
  CHAR8                      *Password;
  EFI_STATUS                 Status;
 
  RedfishService = NULL;
  UserId         = NULL;
  Password       = NULL;
 
  //
  // Check Input Parameters.
  //
  if (RedfishConfigServiceInfo == NULL) {
    return NULL;
  }
 
  //
  // Get Authentication Configuration.
  //
  Status = RedfishGetAuthInfo (&AuthMethod, &UserId, &Password);
  if (EFI_ERROR (Status)) {
    goto ON_EXIT;
  }
 
  //
  // Create a redfish service node based on Redfish network host interface.
  //
  RedfishService = RedfishCreateLibredfishService (
                     RedfishConfigServiceInfo,
                     AuthMethod,
                     UserId,
                     Password
                     );
 
ON_EXIT:
  if (UserId != NULL) {
    FreePool (UserId);
  }
 
  if (Password != NULL) {
    FreePool (Password);
  }
 
  return RedfishService;
}
 
VOID
EFIAPI
RedfishCleanupService (
  IN REDFISH_SERVICE  RedfishService
  )
{
  if (RedfishService == NULL) {
    return;
  }
 
  cleanupServiceEnumerator (RedfishService);
}
 
REDFISH_PAYLOAD
EFIAPI
RedfishCreatePayload (
  IN EDKII_JSON_VALUE  Value,
  IN REDFISH_SERVICE   RedfishService
  )
{
  EDKII_JSON_VALUE  CopyValue;
 
  CopyValue = JsonValueClone (Value);
  return createRedfishPayload (CopyValue, RedfishService);
}
 
VOID
EFIAPI
RedfishCleanupPayload (
  IN REDFISH_PAYLOAD  Payload
  )
{
  if (Payload == NULL) {
    return;
  }
 
  cleanupPayload ((redfishPayload *)Payload);
}
 
EDKII_JSON_VALUE
EFIAPI
RedfishJsonInPayload (
  IN REDFISH_PAYLOAD  Payload
  )
{
  if (Payload == NULL) {
    return NULL;
  }
 
  return ((redfishPayload *)Payload)->json;
}
 
REDFISH_SERVICE
EFIAPI
RedfishServiceInPayload (
  IN REDFISH_PAYLOAD  Payload
  )
{
  if (Payload == NULL) {
    return NULL;
  }
 
  return ((redfishPayload *)Payload)->service;
}
 
CHAR8 *
EFIAPI
RedfishBuildPathWithSystemUuid (
  IN CONST CHAR8  *RedPath,
  IN BOOLEAN      FromSmbios,
  IN CHAR8        *IdString OPTIONAL
  )
{
  UINTN       BufSize;
  CHAR8       *RetRedPath;
  EFI_GUID    SystemUuid;
  EFI_STATUS  Status;
 
  if (RedPath == NULL) {
    return NULL;
  }
 
  //
  // Find system UUID from SMBIOS table.
  //
  if (FromSmbios) {
    Status = NetLibGetSystemGuid (&SystemUuid);
    if (EFI_ERROR (Status)) {
      return NULL;
    }
 
    // AsciiStrLen ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx") = 36
    BufSize = AsciiStrSize (RedPath) + AsciiStrLen ("XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX");
  } else {
    BufSize = AsciiStrSize (RedPath) + AsciiStrLen (IdString);
  }
 
  RetRedPath = AllocateZeroPool (BufSize);
  if (RetRedPath == NULL) {
    return NULL;
  }
 
  if (FromSmbios) {
    AsciiSPrint (RetRedPath, BufSize, RedPath, &SystemUuid);
  } else {
    AsciiSPrint (RetRedPath, BufSize, RedPath, IdString);
  }
 
  return RetRedPath;
}
 
EFI_STATUS
EFIAPI
RedfishGetByService (
  IN     REDFISH_SERVICE   RedfishService,
  IN     CONST CHAR8       *RedPath,
  OUT    REDFISH_RESPONSE  *RedResponse
  )
{
  if ((RedfishService == NULL) || (RedPath == NULL) || (RedResponse == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  ZeroMem (RedResponse, sizeof (REDFISH_RESPONSE));
 
  RedResponse->Payload = (REDFISH_PAYLOAD)getPayloadByPath (RedfishService, RedPath, &(RedResponse->StatusCode));
 
  //
  // 1. If the returned Payload is NULL, indicates any error happen.
  // 2. If the returned StatusCode is NULL, indicates any error happen.
  //
  if ((RedResponse->Payload == NULL) || (RedResponse->StatusCode == NULL)) {
    return EFI_DEVICE_ERROR;
  }
 
  //
  // 3. If the returned StatusCode is not 2XX, indicates any error happen.
  //    NOTE: If there is any error message returned from server, it will be returned in
  //          Payload within RedResponse.
  //
  if ((*(RedResponse->StatusCode) < HTTP_STATUS_200_OK) || \
      (*(RedResponse->StatusCode) > HTTP_STATUS_206_PARTIAL_CONTENT))
  {
    return EFI_DEVICE_ERROR;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
RedfishGetByUri (
  IN     REDFISH_SERVICE   RedfishService,
  IN     CONST CHAR8       *Uri,
  OUT    REDFISH_RESPONSE  *RedResponse
  )
{
  EDKII_JSON_VALUE  JsonValue;
 
  if ((RedfishService == NULL) || (Uri == NULL) || (RedResponse == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  ZeroMem (RedResponse, sizeof (REDFISH_RESPONSE));
 
  JsonValue            = getUriFromServiceEx (RedfishService, Uri, &RedResponse->Headers, &RedResponse->HeaderCount, &RedResponse->StatusCode);
  RedResponse->Payload = createRedfishPayload (JsonValue, RedfishService);
 
  //
  // 1. If the returned Payload is NULL, indicates any error happen.
  // 2. If the returned StatusCode is NULL, indicates any error happen.
  //
  if ((RedResponse->Payload == NULL) || (RedResponse->StatusCode == NULL)) {
    return EFI_DEVICE_ERROR;
  }
 
  //
  // 3. If the returned StatusCode is not 2XX, indicates any error happen.
  //    NOTE: If there is any error message returned from server, it will be returned in
  //          Payload within RedResponse.
  //
  if ((*(RedResponse->StatusCode) < HTTP_STATUS_200_OK) || \
      (*(RedResponse->StatusCode) > HTTP_STATUS_206_PARTIAL_CONTENT))
  {
    return EFI_DEVICE_ERROR;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
RedfishGetByPayload (
  IN     REDFISH_PAYLOAD   Payload,
  IN     CONST CHAR8       *RedPath,
  OUT    REDFISH_RESPONSE  *RedResponse
  )
{
  if ((Payload == NULL) || (RedPath == NULL) || (RedResponse == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  ZeroMem (RedResponse, sizeof (REDFISH_RESPONSE));
 
  RedResponse->Payload = (REDFISH_PAYLOAD)getPayloadForPathString (Payload, RedPath, &(RedResponse->StatusCode));
 
  //
  // 1. If the returned Payload is NULL, indicates any error happen.
  //
  if (RedResponse->Payload == NULL) {
    return EFI_DEVICE_ERROR;
  }
 
  //
  // 2. If StatusCode is not NULL and the returned value of StatusCode is not 2XX, indicates any
  //    error happen.
  //    NOTE: If there is any error message returned from server, it will be returned in
  //          Payload within RedResponse.
  //
  if ((RedResponse->StatusCode != NULL) && \
      ((*(RedResponse->StatusCode) < HTTP_STATUS_200_OK) || \
       (*(RedResponse->StatusCode) > HTTP_STATUS_206_PARTIAL_CONTENT)
      ))
  {
    return EFI_DEVICE_ERROR;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
RedfishPatchToUri (
  IN     REDFISH_SERVICE   RedfishService,
  IN     CONST CHAR8       *Uri,
  IN     CONST CHAR8       *Content,
  OUT    REDFISH_RESPONSE  *RedResponse
  )
{
  EFI_STATUS        Status;
  EDKII_JSON_VALUE  JsonValue;
 
  Status    = EFI_SUCCESS;
  JsonValue = NULL;
 
  if ((RedfishService == NULL) || (Uri == NULL) || (Content == NULL) || (RedResponse == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  ZeroMem (RedResponse, sizeof (REDFISH_RESPONSE));
 
  JsonValue = (EDKII_JSON_VALUE)patchUriFromServiceEx (
                                  RedfishService,
                                  Uri,
                                  Content,
                                  &(RedResponse->Headers),
                                  &(RedResponse->HeaderCount),
                                  &(RedResponse->StatusCode)
                                  );
 
  //
  // 1. If the returned StatusCode is NULL, indicates any error happen.
  //
  if (RedResponse->StatusCode == NULL) {
    Status = EFI_DEVICE_ERROR;
    goto ON_EXIT;
  }
 
  //
  // 2. If the returned StatusCode is not NULL and the value is not 2XX, indicates any error happen.
  //    NOTE: If there is any error message returned from server, it will be returned in
  //          Payload within RedResponse.
  //
  if ((*(RedResponse->StatusCode) < HTTP_STATUS_200_OK) || \
      (*(RedResponse->StatusCode) > HTTP_STATUS_206_PARTIAL_CONTENT))
  {
    Status = EFI_DEVICE_ERROR;
  }
 
ON_EXIT:
  if (JsonValue != NULL) {
    RedResponse->Payload = createRedfishPayload (JsonValue, RedfishService);
    if (RedResponse->Payload == NULL) {
      //
      // Ignore the error when create RedfishPayload, just free the JsonValue since it's not what
      // we care about if the returned StatusCode is 2XX.
      //
      JsonValueFree (JsonValue);
    }
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
RedfishPatchToPayload (
  IN     REDFISH_PAYLOAD   Target,
  IN     REDFISH_PAYLOAD   Payload,
  OUT    REDFISH_RESPONSE  *RedResponse
  )
{
  if ((Target == NULL) || (Payload == NULL) || (RedResponse == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  ZeroMem (RedResponse, sizeof (REDFISH_RESPONSE));
 
  RedResponse->Payload = (REDFISH_PAYLOAD)patchPayload (
                                            Target,
                                            Payload,
                                            &(RedResponse->StatusCode)
                                            );
 
  //
  // 1. If the returned StatusCode is NULL, indicates any error happen.
  //
  if (RedResponse->StatusCode == NULL) {
    return EFI_DEVICE_ERROR;
  }
 
  //
  // 2. If the returned StatusCode is not NULL and the value is not 2XX, indicates any error happen.
  //    NOTE: If there is any error message returned from server, it will be returned in
  //          Payload within RedResponse.
  //
  if ((*(RedResponse->StatusCode) < HTTP_STATUS_200_OK) || \
      (*(RedResponse->StatusCode) > HTTP_STATUS_206_PARTIAL_CONTENT))
  {
    return EFI_DEVICE_ERROR;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
RedfishPostToUri (
  IN     REDFISH_SERVICE   RedfishService,
  IN     CONST CHAR8       *Uri,
  IN     CONST CHAR8       *Content,
  IN     UINTN             ContentSize OPTIONAL,
  IN     CONST CHAR8       *ContentType OPTIONAL,
  OUT    REDFISH_RESPONSE  *RedResponse
  )
{
  EFI_STATUS        Status;
  EDKII_JSON_VALUE  JsonValue;
 
  Status    = EFI_SUCCESS;
  JsonValue = NULL;
 
  if ((RedfishService == NULL) || (Uri == NULL) || (Content == NULL) || (RedResponse == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  ZeroMem (RedResponse, sizeof (REDFISH_RESPONSE));
 
  JsonValue = (EDKII_JSON_VALUE)postUriFromServiceEx (
                                  RedfishService,
                                  Uri,
                                  Content,
                                  ContentSize,
                                  ContentType,
                                  &(RedResponse->Headers),
                                  &(RedResponse->HeaderCount),
                                  &(RedResponse->StatusCode)
                                  );
 
  //
  // 1. If the returned StatusCode is NULL, indicates any error happen.
  //
  if (RedResponse->StatusCode == NULL) {
    Status = EFI_DEVICE_ERROR;
    goto ON_EXIT;
  }
 
  //
  // 2. If the returned StatusCode is not NULL and the value is not 2XX, indicates any error happen.
  //    NOTE: If there is any error message returned from server, it will be returned in
  //          Payload within RedResponse.
  //
  if ((*(RedResponse->StatusCode) < HTTP_STATUS_200_OK) || \
      (*(RedResponse->StatusCode) > HTTP_STATUS_206_PARTIAL_CONTENT))
  {
    Status = EFI_DEVICE_ERROR;
  }
 
ON_EXIT:
  if (JsonValue != NULL) {
    RedResponse->Payload = createRedfishPayload (JsonValue, RedfishService);
    if (RedResponse->Payload == NULL) {
      //
      // Ignore the error when create RedfishPayload, just free the JsonValue since it's not what
      // we care about if the returned StatusCode is 2XX.
      //
      JsonValueFree (JsonValue);
    }
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
RedfishPostToPayload (
  IN     REDFISH_PAYLOAD   Target,
  IN     REDFISH_PAYLOAD   Payload,
  OUT    REDFISH_RESPONSE  *RedResponse
  )
{
  if ((Target == NULL) || (Payload == NULL) || (RedResponse == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  ZeroMem (RedResponse, sizeof (REDFISH_RESPONSE));
 
  RedResponse->Payload = (REDFISH_PAYLOAD)postPayload (
                                            Target,
                                            Payload,
                                            &(RedResponse->StatusCode)
                                            );
 
  //
  // 1. If the returned StatusCode is NULL, indicates any error happen.
  //
  if (RedResponse->StatusCode == NULL) {
    return EFI_DEVICE_ERROR;
  }
 
  //
  // 2. If the returned StatusCode is not NULL and the value is not 2XX, indicates any error happen.
  //    NOTE: If there is any error message returned from server, it will be returned in
  //          Payload within RedResponse.
  //
  if ((*(RedResponse->StatusCode) < HTTP_STATUS_200_OK) || \
      (*(RedResponse->StatusCode) > HTTP_STATUS_206_PARTIAL_CONTENT))
  {
    return EFI_DEVICE_ERROR;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
RedfishDeleteByUri (
  IN     REDFISH_SERVICE   RedfishService,
  IN     CONST CHAR8       *Uri,
  OUT    REDFISH_RESPONSE  *RedResponse
  )
{
  EFI_STATUS        Status;
  EDKII_JSON_VALUE  JsonValue;
 
  Status    = EFI_SUCCESS;
  JsonValue = NULL;
 
  if ((RedfishService == NULL) || (Uri == NULL) || (RedResponse == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  ZeroMem (RedResponse, sizeof (REDFISH_RESPONSE));
 
  JsonValue = (EDKII_JSON_VALUE)deleteUriFromService (
                                  RedfishService,
                                  Uri,
                                  &(RedResponse->StatusCode)
                                  );
 
  //
  // 1. If the returned StatusCode is NULL, indicates any error happen.
  //
  if (RedResponse->StatusCode == NULL) {
    Status = EFI_DEVICE_ERROR;
    goto ON_EXIT;
  }
 
  //
  // 2. If the returned StatusCode is not NULL and the value is not 2XX, indicates any error happen.
  //    NOTE: If there is any error message returned from server, it will be returned in
  //          Payload within RedResponse.
  //
  if ((*(RedResponse->StatusCode) < HTTP_STATUS_200_OK) || \
      (*(RedResponse->StatusCode) > HTTP_STATUS_206_PARTIAL_CONTENT))
  {
    Status = EFI_DEVICE_ERROR;
  }
 
ON_EXIT:
  if (JsonValue != NULL) {
    RedResponse->Payload = createRedfishPayload (JsonValue, RedfishService);
    if (RedResponse->Payload == NULL) {
      //
      // Ignore the error when create RedfishPayload, just free the JsonValue since it's not what
      // we care about if the returned StatusCode is 2XX.
      //
      JsonValueFree (JsonValue);
    }
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
RedfishDeleteByUriEx (
  IN     REDFISH_SERVICE   RedfishService,
  IN     CONST CHAR8       *Uri,
  IN     CONST CHAR8       *Content,
  OUT    REDFISH_RESPONSE  *RedResponse
  )
{
  EFI_STATUS        Status;
  EDKII_JSON_VALUE  JsonValue;
 
  Status    = EFI_SUCCESS;
  JsonValue = NULL;
 
  if ((RedfishService == NULL) || (Content == NULL) || (Uri == NULL) || (RedResponse == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  ZeroMem (RedResponse, sizeof (REDFISH_RESPONSE));
 
  JsonValue = (EDKII_JSON_VALUE)deleteUriFromServiceEx (
                                  RedfishService,
                                  Uri,
                                  Content,
                                  &(RedResponse->StatusCode)
                                  );
 
  //
  // 1. If the returned StatusCode is NULL, indicates any error happen.
  //
  if (RedResponse->StatusCode == NULL) {
    Status = EFI_DEVICE_ERROR;
    goto ON_EXIT;
  }
 
  //
  // 2. If the returned StatusCode is not NULL and the value is not 2XX, indicates any error happen.
  //    NOTE: If there is any error message returned from server, it will be returned in
  //          Payload within RedResponse.
  //
  if ((*(RedResponse->StatusCode) < HTTP_STATUS_200_OK) || \
      (*(RedResponse->StatusCode) > HTTP_STATUS_206_PARTIAL_CONTENT))
  {
    Status = EFI_DEVICE_ERROR;
  }
 
ON_EXIT:
  if (JsonValue != NULL) {
    RedResponse->Payload = createRedfishPayload (JsonValue, RedfishService);
    if (RedResponse->Payload == NULL) {
      //
      // Ignore the error when create RedfishPayload, just free the JsonValue since it's not what
      // we care about if the returned StatusCode is 2XX.
      //
      JsonValueFree (JsonValue);
    }
  }
 
  return Status;
}
 
VOID
RedfishDumpJsonStringFractions (
  IN CHAR8  *String
  )
{
  CHAR8  *NextFraction;
  UINTN  StringFractionSize;
  UINTN  StrLen;
  UINTN  Count;
  CHAR8  BackupChar;
 
  StringFractionSize = 200;
  if (String == NULL) {
    return;
  }
 
  DEBUG ((DEBUG_MANAGEABILITY, "JSON text:\n"));
  NextFraction = String;
  StrLen       = AsciiStrLen (String);
  if (StrLen == 0) {
    return;
  }
 
  for (Count = 0; Count < (StrLen / StringFractionSize); Count++) {
    BackupChar                           = *(NextFraction + StringFractionSize);
    *(NextFraction + StringFractionSize) = 0;
    DEBUG ((DEBUG_MANAGEABILITY, "%a", NextFraction));
    *(NextFraction + StringFractionSize) = BackupChar;
    NextFraction                        += StringFractionSize;
  }
 
  if ((StrLen % StringFractionSize) != 0) {
    DEBUG ((DEBUG_MANAGEABILITY, "%a\n\n", NextFraction));
  }
}
 
VOID
RedfishDumpJson (
  IN EDKII_JSON_VALUE  JsonValue
  )
{
  CHAR8  *String;
 
  String = JsonDumpString (JsonValue, 0);
  if (String == NULL) {
    return;
  }
 
  RedfishDumpJsonStringFractions (String);
  FreePool (String);
}
 
VOID
RedfishDumpPayload (
  IN REDFISH_PAYLOAD  Payload
  )
{
  EDKII_JSON_VALUE  JsonValue;
  CHAR8             *String;
 
  JsonValue = NULL;
  String    = NULL;
 
  if (Payload == NULL) {
    return;
  }
 
  JsonValue = RedfishJsonInPayload (Payload);
  if (JsonValue == NULL) {
    return;
  }
 
  String = JsonDumpString (JsonValue, 0);
  if (String == NULL) {
    return;
  }
 
  RedfishDumpJsonStringFractions (String);
  FreePool (String);
}
 
VOID
RedfishFreeResponse (
  IN EFI_HTTP_STATUS_CODE  *StatusCode,
  IN UINTN                 HeaderCount,
  IN EFI_HTTP_HEADER       *Headers,
  IN REDFISH_PAYLOAD       Payload
  )
{
  if (StatusCode != NULL) {
    FreePool (StatusCode);
    StatusCode = NULL;
  }
 
  if ((HeaderCount != 0) && (Headers != NULL)) {
    HttpFreeHeaderFields (Headers, HeaderCount);
    Headers = NULL;
  }
 
  if (Payload != NULL) {
    RedfishCleanupPayload (Payload);
    Payload = NULL;
  }
}
 
BOOLEAN
RedfishIsValidOdataType (
  IN REDFISH_PAYLOAD             Payload,
  IN CONST CHAR8                 *OdataTypeName,
  IN REDFISH_ODATA_TYPE_MAPPING  *OdataTypeMappingList,
  IN UINTN                       OdataTypeMappingListSize
  )
{
  UINTN             Index;
  EDKII_JSON_VALUE  OdataType;
  EDKII_JSON_VALUE  JsonValue;
 
  if ((Payload == NULL) || (OdataTypeName == NULL)) {
    return FALSE;
  }
 
  JsonValue = RedfishJsonInPayload (Payload);
  if (!JsonValueIsObject (JsonValue)) {
    return FALSE;
  }
 
  OdataType = JsonObjectGetValue (JsonValueGetObject (JsonValue), "@odata.type");
  if (!JsonValueIsString (OdataType) || (JsonValueGetAsciiString (OdataType) == NULL)) {
    return FALSE;
  }
 
  for (Index = 0; Index < OdataTypeMappingListSize; Index++) {
    if ((AsciiStrCmp (OdataTypeMappingList[Index].OdataTypeName, OdataTypeName) == 0) &&
        (AsciiStrCmp (OdataTypeMappingList[Index].OdataType, JsonValueGetAsciiString (OdataType)) == 0))
    {
      return TRUE;
    }
  }
 
  DEBUG ((DEBUG_MANAGEABILITY, "%a: This Odata type is not in the list.\n", __func__));
  return FALSE;
}
 
BOOLEAN
RedfishIsPayloadCollection (
  IN REDFISH_PAYLOAD  Payload
  )
{
  return isPayloadCollection (Payload);
}
 
EFI_STATUS
RedfishGetCollectionSize (
  IN REDFISH_PAYLOAD  Payload,
  IN UINTN            *CollectionSize
  )
{
  if ((Payload == NULL) || (CollectionSize == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (!RedfishIsPayloadCollection (Payload)) {
    return EFI_INVALID_PARAMETER;
  }
 
  *CollectionSize = (UINTN)getCollectionSize (Payload);
  return EFI_SUCCESS;
}
 
REDFISH_PAYLOAD
RedfishGetPayloadByIndex (
  IN REDFISH_PAYLOAD  Payload,
  IN UINTN            Index
  )
{
  REDFISH_RESPONSE  RedfishResponse;
  REDFISH_PAYLOAD   PayloadReturn;
 
  PayloadReturn = (VOID *)getPayloadByIndex (Payload, Index, &RedfishResponse.StatusCode);
  if ((PayloadReturn == NULL) ||
      ((*(RedfishResponse.StatusCode) < HTTP_STATUS_200_OK) && (*(RedfishResponse.StatusCode) > HTTP_STATUS_206_PARTIAL_CONTENT)))
  {
    return NULL;
  }
 
  return PayloadReturn;
}
 
EFI_STATUS
RedfishCheckIfRedpathExist (
  IN REDFISH_SERVICE   RedfishService,
  IN CHAR8             *Redpath,
  IN REDFISH_RESPONSE  *Response OPTIONAL
  )
{
  EFI_STATUS        Status;
  REDFISH_RESPONSE  TempResponse;
 
  if (Redpath == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Status = RedfishGetByService (RedfishService, Redpath, &TempResponse);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  if (Response == NULL) {
    RedfishFreeResponse (
      TempResponse.StatusCode,
      TempResponse.HeaderCount,
      TempResponse.Headers,
      TempResponse.Payload
      );
  } else {
    CopyMem ((VOID *)Response, (VOID *)&TempResponse, sizeof (REDFISH_RESPONSE));
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
RedfishPutToUri (
  IN     REDFISH_SERVICE   RedfishService,
  IN     CONST CHAR8       *Uri,
  IN     CONST CHAR8       *Content,
  IN     UINTN             ContentSize OPTIONAL,
  IN     CONST CHAR8       *ContentType OPTIONAL,
  OUT    REDFISH_RESPONSE  *RedResponse
  )
{
  EFI_STATUS        Status;
  EDKII_JSON_VALUE  JsonValue;
 
  Status    = EFI_SUCCESS;
  JsonValue = NULL;
 
  if ((RedfishService == NULL) || (Uri == NULL) || (Content == NULL) || (RedResponse == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  ZeroMem (RedResponse, sizeof (REDFISH_RESPONSE));
 
  JsonValue = (EDKII_JSON_VALUE)putUriFromServiceEx (
                                  RedfishService,
                                  Uri,
                                  Content,
                                  ContentSize,
                                  ContentType,
                                  &(RedResponse->Headers),
                                  &(RedResponse->HeaderCount),
                                  &(RedResponse->StatusCode)
                                  );
 
  //
  // 1. If the returned StatusCode is NULL, indicates any error happen.
  //
  if (RedResponse->StatusCode == NULL) {
    Status = EFI_DEVICE_ERROR;
    goto ON_EXIT;
  }
 
  //
  // 2. If the returned StatusCode is not NULL and the value is not 2XX, indicates any error happen.
  //    NOTE: If there is any error message returned from server, it will be returned in
  //          Payload within RedResponse.
  //
  if ((*(RedResponse->StatusCode) < HTTP_STATUS_200_OK) || \
      (*(RedResponse->StatusCode) > HTTP_STATUS_206_PARTIAL_CONTENT))
  {
    Status = EFI_DEVICE_ERROR;
  }
 
ON_EXIT:
  if (JsonValue != NULL) {
    RedResponse->Payload = createRedfishPayload (JsonValue, RedfishService);
    if (RedResponse->Payload == NULL) {
      //
      // Ignore the error when create RedfishPayload, just free the JsonValue since it's not what
      // we care about if the returned StatusCode is 2XX.
      //
      JsonValueFree (JsonValue);
    }
  }
 
  return Status;
}