RedfishHttpOperation.c

Go to the documentation of this file.

 
#include "RedfishHttpOperation.h"
#include "RedfishHttpData.h"
 
EFI_STATUS
CopyHttpHeaders (
  IN  EFI_HTTP_HEADER  *SrcHeaders,
  IN  UINTN            SrcHeaderCount,
  OUT EFI_HTTP_HEADER  **DstHeaders,
  OUT UINTN            *DstHeaderCount
  )
{
  UINTN  Index;
 
  if ((SrcHeaders == NULL) || (SrcHeaderCount == 0) || (DstHeaders == NULL) || (DstHeaderCount == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  *DstHeaderCount = 0;
  *DstHeaders     = AllocateZeroPool (sizeof (EFI_HTTP_HEADER) * SrcHeaderCount);
  if (*DstHeaders == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  *DstHeaderCount = SrcHeaderCount;
  for (Index = 0; Index < SrcHeaderCount; Index++) {
    (*DstHeaders)[Index].FieldName = ASCII_STR_DUPLICATE (SrcHeaders[Index].FieldName);
    if ((*DstHeaders)[Index].FieldName == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
 
    (*DstHeaders)[Index].FieldValue = ASCII_STR_DUPLICATE (SrcHeaders[Index].FieldValue);
    if ((*DstHeaders)[Index].FieldValue == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
ReleaseRedfishRequest (
  IN  REDFISH_REQUEST  *Request
  )
{
  if (Request == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((Request->Headers != NULL) && (Request->HeaderCount > 0)) {
    HttpFreeHeaderFields (Request->Headers, Request->HeaderCount);
    Request->Headers     = NULL;
    Request->HeaderCount = 0;
  }
 
  if (Request->Content != NULL) {
    FreePool (Request->Content);
    Request->Content = NULL;
  }
 
  if (Request->ContentType != NULL) {
    FreePool (Request->ContentType);
    Request->ContentType = NULL;
  }
 
  Request->ContentLength = 0;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
ReleaseRedfishResponse (
  IN  REDFISH_RESPONSE  *Response
  )
{
  if (Response == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((Response->Headers != NULL) && (Response->HeaderCount > 0)) {
    HttpFreeHeaderFields (Response->Headers, Response->HeaderCount);
    Response->Headers     = NULL;
    Response->HeaderCount = 0;
  }
 
  if (Response->Payload != NULL) {
    ReleaseRedfishPayload (Response->Payload);
    Response->Payload = NULL;
  }
 
  if (Response->StatusCode != NULL) {
    FreePool (Response->StatusCode);
    Response->StatusCode = NULL;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
ReleaseHttpMessage (
  IN  EFI_HTTP_MESSAGE  *HttpMessage,
  IN  BOOLEAN           IsRequest
  )
{
  if (HttpMessage == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (IsRequest) {
    if (HttpMessage->Data.Request != NULL) {
      if (HttpMessage->Data.Request->Url != NULL) {
        FreePool (HttpMessage->Data.Request->Url);
      }
 
      FreePool (HttpMessage->Data.Request);
      HttpMessage->Data.Request = NULL;
    }
  } else {
    if (HttpMessage->Data.Response != NULL) {
      FreePool (HttpMessage->Data.Response);
      HttpMessage->Data.Response = NULL;
    }
  }
 
  if (HttpMessage->Body != NULL) {
    FreePool (HttpMessage->Body);
    HttpMessage->Body = NULL;
  }
 
  if (HttpMessage->Headers != NULL) {
    HttpFreeHeaderFields (HttpMessage->Headers, HttpMessage->HeaderCount);
    HttpMessage->Headers     = NULL;
    HttpMessage->HeaderCount = 0;
  }
 
  return EFI_SUCCESS;
}
 
EFI_HTTP_MESSAGE *
BuildRequestMessage (
  IN REDFISH_SERVICE_PRIVATE  *ServicePrivate,
  IN EFI_STRING               Uri,
  IN EFI_HTTP_METHOD          Method,
  IN REDFISH_REQUEST          *Request OPTIONAL,
  IN CHAR8                    *ContentEncoding OPTIONAL
  )
{
  EFI_STATUS             Status;
  EFI_STRING             Url;
  UINTN                  UrlSize;
  UINTN                  Index;
  EFI_HTTP_MESSAGE       *RequestMsg;
  EFI_HTTP_REQUEST_DATA  *RequestData;
  UINTN                  HeaderCount;
  UINTN                  HeaderIndex;
  EFI_HTTP_HEADER        *Headers;
  CHAR8                  ContentLengthStr[REDFISH_CONTENT_LENGTH_SIZE];
  VOID                   *Content;
  UINTN                  ContentLength;
  BOOLEAN                HasContent;
  BOOLEAN                DoContentEncoding;
 
  RequestMsg        = NULL;
  RequestData       = NULL;
  Url               = NULL;
  UrlSize           = 0;
  Content           = NULL;
  ContentLength     = 0;
  HeaderCount       = REDFISH_COMMON_HEADER_SIZE;
  HeaderIndex       = 0;
  Headers           = NULL;
  HasContent        = FALSE;
  DoContentEncoding = FALSE;
 
  if ((ServicePrivate == NULL) || (IS_EMPTY_STRING (Uri))) {
    return NULL;
  }
 
  if (Method >= HttpMethodMax) {
    return NULL;
  }
 
  DEBUG ((REDFISH_HTTP_CACHE_DEBUG_REQUEST, "%a: %s\n", __func__, Uri));
 
  //
  // Build full URL for HTTP query.
  //
  UrlSize = (AsciiStrLen (ServicePrivate->Host) + StrLen (Uri) + 1) * sizeof (CHAR16);
  Url     = AllocateZeroPool (UrlSize);
  if (Url == NULL) {
    return NULL;
  }
 
  UnicodeSPrint (Url, UrlSize, L"%a%s", ServicePrivate->Host, Uri);
  DEBUG ((REDFISH_HTTP_CACHE_DEBUG_REQUEST, "%a: Url: %s\n", __func__, Url));
 
  //
  // Step 1: build the HTTP headers.
  //
  if (!IS_EMPTY_STRING (ServicePrivate->SessionToken) || !IS_EMPTY_STRING (ServicePrivate->BasicAuth)) {
    HeaderCount++;
  }
 
  if ((Request != NULL) && (Request->HeaderCount > 0)) {
    HeaderCount += Request->HeaderCount;
  }
 
  //
  // Check and see if we will do content encoding or not
  //
  if (!IS_EMPTY_STRING (ContentEncoding)) {
    if (AsciiStrCmp (ContentEncoding, REDFISH_HTTP_CONTENT_ENCODING_NONE) != 0) {
      DoContentEncoding = TRUE;
    }
  }
 
  if ((Request != NULL) && !IS_EMPTY_STRING (Request->Content)) {
    HeaderCount += 2;
    HasContent   = TRUE;
    if (DoContentEncoding) {
      HeaderCount += 1;
    }
  }
 
  Headers = AllocateZeroPool (HeaderCount * sizeof (EFI_HTTP_HEADER));
  if (Headers == NULL) {
    goto ON_ERROR;
  }
 
  if (!IS_EMPTY_STRING (ServicePrivate->SessionToken)) {
    Status = HttpSetFieldNameAndValue (&Headers[HeaderIndex++], HTTP_HEADER_X_AUTH_TOKEN, ServicePrivate->SessionToken);
    if (EFI_ERROR (Status)) {
      goto ON_ERROR;
    }
  } else if (!IS_EMPTY_STRING (ServicePrivate->BasicAuth)) {
    Status = HttpSetFieldNameAndValue (&Headers[HeaderIndex++], HTTP_HEADER_AUTHORIZATION, ServicePrivate->BasicAuth);
    if (EFI_ERROR (Status)) {
      goto ON_ERROR;
    }
  }
 
  if (Request != NULL) {
    for (Index = 0; Index < Request->HeaderCount; Index++) {
      Status = HttpSetFieldNameAndValue (&Headers[HeaderIndex++], Request->Headers[Index].FieldName, Request->Headers[Index].FieldValue);
      if (EFI_ERROR (Status)) {
        goto ON_ERROR;
      }
    }
  }
 
  Status = HttpSetFieldNameAndValue (&Headers[HeaderIndex++], HTTP_HEADER_HOST, ServicePrivate->HostName);
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  Status = HttpSetFieldNameAndValue (&Headers[HeaderIndex++], REDFISH_HTTP_HEADER_ODATA_VERSION_STR, REDFISH_HTTP_HEADER_ODATA_VERSION_VALUE);
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  Status = HttpSetFieldNameAndValue (&Headers[HeaderIndex++], HTTP_HEADER_ACCEPT, HTTP_CONTENT_TYPE_APP_JSON);
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  Status = HttpSetFieldNameAndValue (&Headers[HeaderIndex++], HTTP_HEADER_USER_AGENT, REDFISH_HTTP_HEADER_USER_AGENT_VALUE);
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  Status = HttpSetFieldNameAndValue (&Headers[HeaderIndex++], REDFISH_HTTP_HEADER_CONNECTION_STR, REDFISH_HTTP_HEADER_CONNECTION_VALUE);
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  //
  // Handle content header
  //
  if (HasContent) {
    if (Request->ContentType == NULL) {
      Status = HttpSetFieldNameAndValue (&Headers[HeaderIndex++], HTTP_HEADER_CONTENT_TYPE, HTTP_CONTENT_TYPE_APP_JSON);
      if (EFI_ERROR (Status)) {
        goto ON_ERROR;
      }
    } else {
      Status = HttpSetFieldNameAndValue (&Headers[HeaderIndex++], HTTP_HEADER_CONTENT_TYPE, Request->ContentType);
      if (EFI_ERROR (Status)) {
        goto ON_ERROR;
      }
    }
 
    if (Request->ContentLength == 0) {
      Request->ContentLength =  AsciiStrLen (Request->Content);
    }
 
    AsciiSPrint (
      ContentLengthStr,
      sizeof (ContentLengthStr),
      "%lu",
      (UINT64)Request->ContentLength
      );
    Status = HttpSetFieldNameAndValue (&Headers[HeaderIndex++], HTTP_HEADER_CONTENT_LENGTH, ContentLengthStr);
    if (EFI_ERROR (Status)) {
      goto ON_ERROR;
    }
 
    //
    // Encoding
    //
    if (DoContentEncoding) {
      //
      // We currently only support gzip Content-Encoding.
      //
      Status =  RedfishContentEncode (
                  ContentEncoding,
                  Request->Content,
                  Request->ContentLength,
                  &Content,
                  &ContentLength
                  );
      if (Status == EFI_INVALID_PARAMETER) {
        DEBUG ((DEBUG_ERROR, "%a: Error to encode content.\n", __func__));
        goto ON_ERROR;
      } else if (Status == EFI_UNSUPPORTED) {
        DoContentEncoding = FALSE;
        DEBUG ((REDFISH_HTTP_CACHE_DEBUG_REQUEST, "%a: No content coding for %a! Use raw data instead.\n", __func__, ContentEncoding));
        Status = HttpSetFieldNameAndValue (&Headers[HeaderIndex++], HTTP_HEADER_CONTENT_ENCODING, HTTP_CONTENT_ENCODING_IDENTITY);
        if (EFI_ERROR (Status)) {
          goto ON_ERROR;
        }
      } else {
        Status = HttpSetFieldNameAndValue (&Headers[HeaderIndex++], HTTP_HEADER_CONTENT_ENCODING, HTTP_CONTENT_ENCODING_GZIP);
        if (EFI_ERROR (Status)) {
          goto ON_ERROR;
        }
      }
    }
 
    //
    // When the content is from caller, we use our own copy so that we properly release it later.
    //
    if (!DoContentEncoding) {
      Content = AllocateCopyPool (Request->ContentLength, Request->Content);
      if (Content == NULL) {
        goto ON_ERROR;
      }
 
      ContentLength = Request->ContentLength;
    }
  }
 
  //
  // Step 2: build the rest of HTTP request info.
  //
  RequestData = AllocateZeroPool (sizeof (EFI_HTTP_REQUEST_DATA));
  if (RequestData == NULL) {
    goto ON_ERROR;
  }
 
  RequestData->Method = Method;
  RequestData->Url    = Url;
 
  //
  // Step 3: fill in EFI_HTTP_MESSAGE
  //
  RequestMsg = AllocateZeroPool (sizeof (EFI_HTTP_MESSAGE));
  if (RequestMsg == NULL) {
    goto ON_ERROR;
  }
 
  ASSERT (HeaderIndex == HeaderCount);
  RequestMsg->Data.Request = RequestData;
  RequestMsg->HeaderCount  = HeaderIndex;
  RequestMsg->Headers      = Headers;
 
  if (HasContent) {
    RequestMsg->BodyLength = ContentLength;
    RequestMsg->Body       = Content;
  }
 
  return RequestMsg;
 
ON_ERROR:
 
  if (Headers != NULL) {
    HttpFreeHeaderFields (Headers, HeaderIndex);
  }
 
  if (RequestData != NULL) {
    FreePool (RequestData);
  }
 
  if (RequestMsg != NULL) {
    FreePool (RequestMsg);
  }
 
  if (Url != NULL) {
    FreePool (Url);
  }
 
  return NULL;
}
 
EFI_STATUS
ParseResponseMessage (
  IN  REDFISH_SERVICE_PRIVATE  *ServicePrivate,
  IN  EFI_HTTP_MESSAGE         *ResponseMsg,
  OUT REDFISH_RESPONSE         *RedfishResponse
  )
{
  EFI_STATUS        Status;
  EDKII_JSON_VALUE  JsonData;
  EFI_HTTP_HEADER   *ContentEncodedHeader;
  EFI_HTTP_HEADER   *ContentTypeHeader;
  VOID              *DecodedBody;
  UINTN             DecodedLength;
 
  if ((ServicePrivate == NULL) || (ResponseMsg == NULL) || (RedfishResponse == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  DEBUG ((REDFISH_HTTP_CACHE_DEBUG_REQUEST, "%a\n", __func__));
 
  //
  // Initialization
  //
  JsonData                     = NULL;
  RedfishResponse->HeaderCount = 0;
  RedfishResponse->Headers     = NULL;
  RedfishResponse->Payload     = NULL;
  RedfishResponse->StatusCode  = NULL;
  DecodedBody                  = NULL;
  DecodedLength                = 0;
 
  //
  // Return the HTTP StatusCode.
  //
  if (ResponseMsg->Data.Response != NULL) {
    DEBUG ((REDFISH_HTTP_CACHE_DEBUG_REQUEST, "%a: status: %d\n", __func__, ResponseMsg->Data.Response->StatusCode));
    RedfishResponse->StatusCode = AllocateCopyPool (sizeof (EFI_HTTP_STATUS_CODE), &ResponseMsg->Data.Response->StatusCode);
    if (RedfishResponse->StatusCode == NULL) {
      DEBUG ((DEBUG_ERROR, "%a: Failed to create status code.\n", __func__));
    }
  }
 
  //
  // Return the HTTP headers.
  //
  if (ResponseMsg->Headers != NULL) {
    DEBUG ((REDFISH_HTTP_CACHE_DEBUG_REQUEST, "%a: header count: %d\n", __func__, ResponseMsg->HeaderCount));
    Status = CopyHttpHeaders (
               ResponseMsg->Headers,
               ResponseMsg->HeaderCount,
               &RedfishResponse->Headers,
               &RedfishResponse->HeaderCount
               );
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "%a: Failed to copy HTTP headers: %r\n", __func__, Status));
    }
  }
 
  //
  // Return the HTTP body.
  //
  if ((ResponseMsg->BodyLength != 0) && (ResponseMsg->Body != NULL)) {
    DEBUG ((REDFISH_HTTP_CACHE_DEBUG_REQUEST, "%a: body length: %d\n", __func__, ResponseMsg->BodyLength));
 
    //
    // We expect to see JSON body
    //
    ContentTypeHeader = HttpFindHeader (RedfishResponse->HeaderCount, RedfishResponse->Headers, HTTP_HEADER_CONTENT_TYPE);
    if (ContentTypeHeader != NULL) {
      if (AsciiStrCmp (ContentTypeHeader->FieldValue, HTTP_CONTENT_TYPE_APP_JSON) != 0) {
        DEBUG ((DEBUG_WARN, "%a: body is not in %a format\n", __func__, HTTP_CONTENT_TYPE_APP_JSON));
      }
    }
 
    //
    // Check if data is encoded.
    //
    ContentEncodedHeader = HttpFindHeader (RedfishResponse->HeaderCount, RedfishResponse->Headers, HTTP_HEADER_CONTENT_ENCODING);
    if (ContentEncodedHeader != NULL) {
      //
      // The content is encoded.
      //
      Status = RedfishContentDecode (
                 ContentEncodedHeader->FieldValue,
                 ResponseMsg->Body,
                 ResponseMsg->BodyLength,
                 &DecodedBody,
                 &DecodedLength
                 );
      if (EFI_ERROR (Status)) {
        DEBUG ((DEBUG_ERROR, "%a: Failed to decompress the response content: %r decoding method: %a\n.", __func__, Status, ContentEncodedHeader->FieldValue));
        goto ON_ERROR;
      }
 
      JsonData = JsonLoadBuffer (DecodedBody, DecodedLength, 0, NULL);
      FreePool (DecodedBody);
    } else {
      JsonData = JsonLoadBuffer (ResponseMsg->Body, ResponseMsg->BodyLength, 0, NULL);
    }
 
    if (!JsonValueIsNull (JsonData)) {
      RedfishResponse->Payload = CreateRedfishPayload (ServicePrivate, JsonData);
      if (RedfishResponse->Payload == NULL) {
        DEBUG ((DEBUG_ERROR, "%a: Failed to create payload\n.", __func__));
      }
 
      JsonValueFree (JsonData);
    } else {
      DEBUG ((DEBUG_ERROR, "%a: No payload available\n", __func__));
    }
  }
 
  return EFI_SUCCESS;
 
ON_ERROR:
 
  if (RedfishResponse != NULL) {
    ReleaseRedfishResponse (RedfishResponse);
  }
 
  return Status;
}
 
EFI_STATUS
HttpSendReceive (
  IN  REDFISH_SERVICE   Service,
  IN  EFI_STRING        Uri,
  IN  EFI_HTTP_METHOD   Method,
  IN  REDFISH_REQUEST   *Request  OPTIONAL,
  OUT REDFISH_RESPONSE  *Response
  )
{
  EFI_STATUS               Status;
  EFI_STATUS               RestExStatus;
  EFI_HTTP_MESSAGE         *RequestMsg;
  EFI_HTTP_MESSAGE         ResponseMsg;
  REDFISH_SERVICE_PRIVATE  *ServicePrivate;
  EFI_HTTP_HEADER          *XAuthTokenHeader;
  CHAR8                    *HttpContentEncoding;
 
  if ((Service == NULL) || IS_EMPTY_STRING (Uri) || (Response == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  DEBUG ((REDFISH_HTTP_CACHE_DEBUG_REQUEST, "%a: Method: 0x%x %s\n", __func__, Method, Uri));
 
  ServicePrivate = (REDFISH_SERVICE_PRIVATE *)Service;
  if (ServicePrivate->Signature != REDFISH_HTTP_SERVICE_SIGNATURE) {
    DEBUG ((DEBUG_ERROR, "%a: signature check failure\n", __func__));
    return EFI_INVALID_PARAMETER;
  }
 
  ZeroMem (&ResponseMsg, sizeof (ResponseMsg));
  HttpContentEncoding = (CHAR8 *)PcdGetPtr (PcdRedfishServiceContentEncoding);
 
  RequestMsg = BuildRequestMessage (Service, Uri, Method, Request, HttpContentEncoding);
  if (RequestMsg == NULL) {
    DEBUG ((DEBUG_ERROR, "%a: cannot build request message for %s\n", __func__, Uri));
    return EFI_PROTOCOL_ERROR;
  }
 
  //
  // call RESTEx to get response from REST service.
  //
  RestExStatus = ServicePrivate->RestEx->SendReceive (ServicePrivate->RestEx, RequestMsg, &ResponseMsg);
  if (EFI_ERROR (RestExStatus)) {
    DEBUG ((DEBUG_ERROR, "%a: %s SendReceive failure: %r\n", __func__, Uri, RestExStatus));
  }
 
  //
  // Return status code, headers and payload to caller as much as possible even when RestEx returns failure.
  //
  Status = ParseResponseMessage (ServicePrivate, &ResponseMsg, Response);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "%a: %s parse response failure: %r\n", __func__, Uri, Status));
  } else {
    //
    // Capture session token in header
    //
    if ((Method == HttpMethodPost) &&
        (Response->StatusCode != NULL) &&
        ((*Response->StatusCode == HTTP_STATUS_200_OK) || (*Response->StatusCode == HTTP_STATUS_204_NO_CONTENT)))
    {
      XAuthTokenHeader = HttpFindHeader (ResponseMsg.HeaderCount, ResponseMsg.Headers, HTTP_HEADER_X_AUTH_TOKEN);
      if (XAuthTokenHeader != NULL) {
        Status = UpdateSessionToken (ServicePrivate, XAuthTokenHeader->FieldValue);
        if (EFI_ERROR (Status)) {
          DEBUG ((DEBUG_ERROR, "%a: update session token failure: %r\n", __func__, Status));
        }
      }
    }
  }
 
  //
  // Release resources
  //
  if (RequestMsg != NULL) {
    ReleaseHttpMessage (RequestMsg, TRUE);
    FreePool (RequestMsg);
  }
 
  ReleaseHttpMessage (&ResponseMsg, FALSE);
 
  return RestExStatus;
}