RedfishRestExProtocol.c

Go to the documentation of this file.

 
#include <Uefi.h>
#include "RedfishRestExInternal.h"
 
EFI_REST_EX_PROTOCOL  mRedfishRestExProtocol = {
  RedfishRestExSendReceive,
  RedfishRestExGetServiceTime,
  RedfishRestExGetService,
  RedfishRestExGetModeData,
  RedfishRestExConfigure,
  RedfishRestExAyncSendReceive,
  RedfishRestExEventService
};
 
EFI_STATUS
EFIAPI
RedfishRestExSendReceive (
  IN      EFI_REST_EX_PROTOCOL  *This,
  IN      EFI_HTTP_MESSAGE      *RequestMessage,
  OUT     EFI_HTTP_MESSAGE      *ResponseMessage
  )
{
  EFI_STATUS                      Status;
  RESTEX_INSTANCE                 *Instance;
  HTTP_IO_RESPONSE_DATA           *ResponseData;
  UINTN                           TotalReceivedSize;
  UINTN                           Index;
  LIST_ENTRY                      *ChunkListLink;
  HTTP_IO_CHUNKS                  *ThisChunk;
  BOOLEAN                         CopyChunkData;
  BOOLEAN                         MediaPresent;
  EFI_HTTP_HEADER                 *PreservedRequestHeaders;
  BOOLEAN                         ItsWrite;
  BOOLEAN                         IsGetChunkedTransfer;
  HTTP_IO_SEND_CHUNK_PROCESS      SendChunkProcess;
  HTTP_IO_SEND_NON_CHUNK_PROCESS  SendNonChunkProcess;
  EFI_HTTP_MESSAGE                ChunkTransferRequestMessage;
 
  Status                  = EFI_SUCCESS;
  ResponseData            = NULL;
  IsGetChunkedTransfer    = FALSE;
  SendChunkProcess        = HttpIoSendChunkNone;
  SendNonChunkProcess     = HttpIoSendNonChunkNone;
  ItsWrite                = FALSE;
  PreservedRequestHeaders = NULL;
 
  //
  // Validate the parameters
  //
  if ((This == NULL) || (RequestMessage == NULL) || (ResponseMessage == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance = RESTEX_INSTANCE_FROM_THIS (This);
 
  //
  // Check Media Status.
  //
  MediaPresent = TRUE;
  NetLibDetectMedia (Instance->Service->ControllerHandle, &MediaPresent);
  if (!MediaPresent) {
    DEBUG ((DEBUG_REDFISH_NETWORK, "RedfishRestExSendReceive(): No MediaPresent.\n"));
    return EFI_NO_MEDIA;
  }
 
  DEBUG ((DEBUG_REDFISH_NETWORK, "\nRedfishRestExSendReceive():\n"));
  DEBUG ((DEBUG_REDFISH_NETWORK, "*** Perform HTTP Request Method - %d, URL: %s\n", RequestMessage->Data.Request->Method, RequestMessage->Data.Request->Url));
 
  if (FixedPcdGetBool (PcdRedfishRestExChunkRequestMode)) {
    //
    // Add header "Expect" to server, only for URL write.
    //
    Status = RedfishHttpAddExpectation (This, RequestMessage, &PreservedRequestHeaders, &ItsWrite);
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    if (ItsWrite == TRUE) {
      if (RequestMessage->BodyLength > HTTP_IO_MAX_SEND_PAYLOAD) {
        //
        // Send chunked transfer.
        //
        SendChunkProcess++;
        CopyMem ((VOID *)&ChunkTransferRequestMessage, (VOID *)RequestMessage, sizeof (EFI_HTTP_MESSAGE));
      } else {
        SendNonChunkProcess++;
      }
    }
  }
 
ReSendRequest:;
 
  if (FixedPcdGetBool (PcdRedfishRestExChunkRequestMode)) {
    //
    // Send the chunked request to REST service.
    //
    if (ItsWrite == TRUE) {
      //
      // This is write to URI
      //
      if (SendChunkProcess > HttpIoSendChunkNone) {
        //
        // This is chunk transfer for writing large payload.
        // Send request header first and then handle the
        // following request message body using chunk transfer.
        //
        do {
          Status = HttpIoSendChunkedTransfer (
                     &(Instance->HttpIo),
                     &SendChunkProcess,
                     &ChunkTransferRequestMessage
                     );
          if (EFI_ERROR (Status)) {
            goto ON_EXIT;
          }
        } while (SendChunkProcess == HttpIoSendChunkContent || SendChunkProcess == HttpIoSendChunkEndChunk);
      } else {
        //
        // This is the non-chunk transfer, send request header first and then
        // handle the following request message body using chunk transfer.
        //
        Status = HttpIoSendRequest (
                   &(Instance->HttpIo),
                   (SendNonChunkProcess == HttpIoSendNonChunkContent) ? NULL : RequestMessage->Data.Request,
                   (SendNonChunkProcess == HttpIoSendNonChunkContent) ? 0 : RequestMessage->HeaderCount,
                   (SendNonChunkProcess == HttpIoSendNonChunkContent) ? NULL : RequestMessage->Headers,
                   (SendNonChunkProcess == HttpIoSendNonChunkHeaderZeroContent) ? 0 : RequestMessage->BodyLength,
                   (SendNonChunkProcess == HttpIoSendNonChunkHeaderZeroContent) ? NULL : RequestMessage->Body
                   );
      }
    } else {
      //
      // This is read from URI.
      //
      Status = HttpIoSendRequest (
                 &(Instance->HttpIo),
                 RequestMessage->Data.Request,
                 RequestMessage->HeaderCount,
                 RequestMessage->Headers,
                 RequestMessage->BodyLength,
                 RequestMessage->Body
                 );
    }
  } else {
    //
    // This is normal request to URI.
    //
    Status = HttpIoSendRequest (
               &(Instance->HttpIo),
               RequestMessage->Data.Request,
               RequestMessage->HeaderCount,
               RequestMessage->Headers,
               RequestMessage->BodyLength,
               RequestMessage->Body
               );
  }
 
  if (EFI_ERROR (Status)) {
    //
    // Communication failure happens. Reset the session.
    //
    ResetHttpTslSession (Instance);
    goto ON_EXIT;
  }
 
  //
  // ResponseMessage->Data.Response is to indicate whether to receive the HTTP header or not.
  // ResponseMessage->BodyLength/ResponseMessage->Body are to indicate whether to receive the response body or not.
  // Clean the previous buffers and all of them will be allocated later according to the actual situation.
  //
  if (ResponseMessage->Data.Response != NULL) {
    FreePool (ResponseMessage->Data.Response);
    ResponseMessage->Data.Response = NULL;
  }
 
  ResponseMessage->BodyLength = 0;
  if (ResponseMessage->Body != NULL) {
    FreePool (ResponseMessage->Body);
    ResponseMessage->Body = NULL;
  }
 
  //
  // Use zero BodyLength to only receive the response headers.
  //
  ResponseData = AllocateZeroPool (sizeof (HTTP_IO_RESPONSE_DATA));
  if (ResponseData == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto ON_EXIT;
  }
 
  DEBUG ((DEBUG_REDFISH_NETWORK, "Receiving HTTP response and headers...\n"));
  Status = RedfishCheckHttpReceiveStatus (
             Instance,
             HttpIoRecvResponse (
               &(Instance->HttpIo),
               TRUE,
               ResponseData
               )
             );
  if (Status == EFI_NOT_READY) {
    goto ReSendRequest;
  } else if (Status == EFI_DEVICE_ERROR) {
    goto ON_EXIT;
  }
 
  //
  // Restore the headers if it ever changed in RedfishHttpAddExpectation().
  //
  if (FixedPcdGetBool (PcdRedfishRestExAddingExpect) && (RequestMessage->Headers != PreservedRequestHeaders)) {
    FreePool (RequestMessage->Headers);
    RequestMessage->Headers = PreservedRequestHeaders; // Restore headers before we adding "Expect".
    RequestMessage->HeaderCount--;                     // Minus one header count for "Expect".
  }
 
  DEBUG ((DEBUG_REDFISH_NETWORK, "HTTP Response StatusCode - %d:", ResponseData->Response.StatusCode));
  if (ResponseData->Response.StatusCode == HTTP_STATUS_200_OK) {
    DEBUG ((DEBUG_REDFISH_NETWORK, "HTTP_STATUS_200_OK\n"));
 
    if (FixedPcdGetBool (PcdRedfishRestExChunkRequestMode) && (SendChunkProcess == HttpIoSendChunkHeaderZeroContent)) {
      DEBUG ((DEBUG_REDFISH_NETWORK, "This is chunk transfer, start to send all chunks - %d.", ResponseData->Response.StatusCode));
      SendChunkProcess++;
      goto ReSendRequest;
    }
  } else if (ResponseData->Response.StatusCode == HTTP_STATUS_204_NO_CONTENT) {
    DEBUG ((DEBUG_MANAGEABILITY, "HTTP_STATUS_204_NO_CONTENT\n"));
 
    if (FixedPcdGetBool (PcdRedfishRestExChunkRequestMode) && (SendChunkProcess == HttpIoSendChunkHeaderZeroContent)) {
      DEBUG ((DEBUG_MANAGEABILITY, "This is chunk transfer, start to send all chunks - %d.", ResponseData->Response.StatusCode));
      SendChunkProcess++;
      goto ReSendRequest;
    }
  } else if (ResponseData->Response.StatusCode == HTTP_STATUS_201_CREATED) {
    DEBUG ((DEBUG_MANAGEABILITY, "HTTP_STATUS_201_CREATED\n"));
  } else if (ResponseData->Response.StatusCode == HTTP_STATUS_202_ACCEPTED) {
    DEBUG ((DEBUG_MANAGEABILITY, "HTTP_STATUS_202_ACCEPTED\n"));
  } else if (ResponseData->Response.StatusCode == HTTP_STATUS_413_REQUEST_ENTITY_TOO_LARGE) {
    DEBUG ((DEBUG_REDFISH_NETWORK, "HTTP_STATUS_413_REQUEST_ENTITY_TOO_LARGE\n"));
 
    Status = EFI_BAD_BUFFER_SIZE;
    goto ON_EXIT;
  } else if (ResponseData->Response.StatusCode == HTTP_STATUS_405_METHOD_NOT_ALLOWED) {
    DEBUG ((DEBUG_ERROR, "HTTP_STATUS_405_METHOD_NOT_ALLOWED\n"));
 
    Status = EFI_ACCESS_DENIED;
    goto ON_EXIT;
  } else if (ResponseData->Response.StatusCode == HTTP_STATUS_400_BAD_REQUEST) {
    DEBUG ((DEBUG_REDFISH_NETWORK, "HTTP_STATUS_400_BAD_REQUEST\n"));
    if (FixedPcdGetBool (PcdRedfishRestExChunkRequestMode) && (SendChunkProcess == HttpIoSendChunkHeaderZeroContent)) {
      DEBUG ((DEBUG_REDFISH_NETWORK, "Bad request may caused by zero length chunk. Try to send all chunks...\n"));
      SendChunkProcess++;
      goto ReSendRequest;
    }
  } else if (ResponseData->Response.StatusCode == HTTP_STATUS_100_CONTINUE) {
    DEBUG ((DEBUG_REDFISH_NETWORK, "HTTP_STATUS_100_CONTINUE\n"));
    if (FixedPcdGetBool (PcdRedfishRestExChunkRequestMode) && (SendChunkProcess == HttpIoSendChunkHeaderZeroContent)) {
      //
      // We get HTTP_STATUS_100_CONTINUE to send the body using chunk transfer.
      //
      DEBUG ((DEBUG_REDFISH_NETWORK, "HTTP_STATUS_100_CONTINUE for chunk transfer...\n"));
      SendChunkProcess++;
      goto ReSendRequest;
    }
 
    if (FixedPcdGetBool (PcdRedfishRestExChunkRequestMode) && (SendNonChunkProcess == HttpIoSendNonChunkHeaderZeroContent)) {
      DEBUG ((DEBUG_REDFISH_NETWORK, "HTTP_STATUS_100_CONTINUE for non chunk transfer...\n"));
      SendNonChunkProcess++;
      goto ReSendRequest;
    }
 
    //
    // It's the REST protocol's responsibility to handle the interim HTTP response (e.g. 100 Continue Informational),
    // and return the final response content to the caller.
    //
    if ((ResponseData->Headers != NULL) && (ResponseData->HeaderCount != 0)) {
      FreePool (ResponseData->Headers);
    }
 
    ZeroMem (ResponseData, sizeof (HTTP_IO_RESPONSE_DATA));
    Status = HttpIoRecvResponse (
               &(Instance->HttpIo),
               TRUE,
               ResponseData
               );
    if (EFI_ERROR (Status)) {
      goto ON_EXIT;
    }
  } else {
    DEBUG ((DEBUG_ERROR, "This HTTP Status is not handled!\n"));
    DumpHttpStatusCode (DEBUG_REDFISH_NETWORK, ResponseData->Response.StatusCode);
    Status = EFI_UNSUPPORTED;
 
    //
    // Deliver status code back to caller so caller can handle it.
    //
    ResponseMessage->Data.Response = AllocateZeroPool (sizeof (EFI_HTTP_RESPONSE_DATA));
    if (ResponseMessage->Data.Response == NULL) {
      Status = EFI_OUT_OF_RESOURCES;
      goto ON_EXIT;
    }
 
    ResponseMessage->Data.Response->StatusCode = ResponseData->Response.StatusCode;
 
    goto ON_EXIT;
  }
 
  //
  // Ready to return the StatusCode, Header info and BodyLength.
  //
  ResponseMessage->Data.Response = AllocateZeroPool (sizeof (EFI_HTTP_RESPONSE_DATA));
  if (ResponseMessage->Data.Response == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto ON_EXIT;
  }
 
  ResponseMessage->Data.Response->StatusCode = ResponseData->Response.StatusCode;
  ResponseMessage->HeaderCount               = ResponseData->HeaderCount;
  ResponseMessage->Headers                   = ResponseData->Headers;
 
  //
  // Get response message body.
  //
  if (ResponseMessage->HeaderCount > 0) {
    Status = HttpIoGetContentLength (ResponseMessage->HeaderCount, ResponseMessage->Headers, &ResponseMessage->BodyLength);
    if (EFI_ERROR (Status) && (Status != EFI_NOT_FOUND)) {
      goto ON_EXIT;
    }
 
    if (Status == EFI_NOT_FOUND) {
      ASSERT (ResponseMessage->BodyLength == 0);
    }
 
    if (ResponseMessage->BodyLength == 0) {
      //
      // Check if Chunked Transfer Coding.
      //
      Status = HttpIoGetChunkedTransferContent (
                 &(Instance->HttpIo),
                 ResponseMessage->HeaderCount,
                 ResponseMessage->Headers,
                 &ChunkListLink,
                 &ResponseMessage->BodyLength
                 );
      if (EFI_ERROR (Status) && (Status != EFI_NOT_FOUND)) {
        goto ON_EXIT;
      }
 
      if ((Status == EFI_SUCCESS) &&
          (ChunkListLink != NULL) &&
          !IsListEmpty (ChunkListLink) &&
          (ResponseMessage->BodyLength != 0))
      {
        IsGetChunkedTransfer = TRUE;
        //
        // Copy data to Message body.
        //
        CopyChunkData         = TRUE;
        ResponseMessage->Body = AllocateZeroPool (ResponseMessage->BodyLength);
        if (ResponseMessage->Body == NULL) {
          Status        = EFI_OUT_OF_RESOURCES;
          CopyChunkData = FALSE;
        }
 
        Index = 0;
        while (!IsListEmpty (ChunkListLink)) {
          ThisChunk = (HTTP_IO_CHUNKS *)GetFirstNode (ChunkListLink);
          if (CopyChunkData) {
            CopyMem (((UINT8 *)ResponseMessage->Body + Index), (UINT8 *)ThisChunk->Data, ThisChunk->Length);
            Index += ThisChunk->Length;
          }
 
          RemoveEntryList (&ThisChunk->NextChunk);
          FreePool ((VOID *)ThisChunk->Data);
          FreePool ((VOID *)ThisChunk);
        }
 
        FreePool ((VOID *)ChunkListLink);
      }
    }
 
    Status = EFI_SUCCESS;
  }
 
  //
  // Ready to return the Body from REST service if have any.
  //
  if ((ResponseMessage->BodyLength > 0) && !IsGetChunkedTransfer) {
    ResponseData->HeaderCount = 0;
    ResponseData->Headers     = NULL;
 
    ResponseMessage->Body = AllocateZeroPool (ResponseMessage->BodyLength);
    if (ResponseMessage->Body == NULL) {
      Status = EFI_OUT_OF_RESOURCES;
      goto ON_EXIT;
    }
 
    //
    // Only receive the Body.
    //
    TotalReceivedSize = 0;
    while (TotalReceivedSize < ResponseMessage->BodyLength) {
      ResponseData->BodyLength = ResponseMessage->BodyLength - TotalReceivedSize;
      ResponseData->Body       = (CHAR8 *)ResponseMessage->Body + TotalReceivedSize;
      Status                   = HttpIoRecvResponse (
                                   &(Instance->HttpIo),
                                   FALSE,
                                   ResponseData
                                   );
      if (EFI_ERROR (Status)) {
        goto ON_EXIT;
      }
 
      TotalReceivedSize += ResponseData->BodyLength;
    }
 
    DEBUG ((DEBUG_REDFISH_NETWORK, "Total of length of Response :%d\n", TotalReceivedSize));
  }
 
  DEBUG ((DEBUG_REDFISH_NETWORK, "RedfishRestExSendReceive()- EFI_STATUS: %r\n", Status));
 
ON_EXIT:
 
  if (ResponseData != NULL) {
    FreePool (ResponseData);
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
RedfishRestExGetServiceTime (
  IN      EFI_REST_EX_PROTOCOL  *This,
  OUT     EFI_TIME              *Time
  )
{
  return EFI_UNSUPPORTED;
}
 
EFI_STATUS
EFIAPI
RedfishRestExGetService (
  IN   EFI_REST_EX_PROTOCOL      *This,
  OUT  EFI_REST_EX_SERVICE_INFO  **RestExServiceInfo
  )
{
  EFI_TPL                   OldTpl;
  RESTEX_INSTANCE           *Instance;
  EFI_REST_EX_SERVICE_INFO  *ServiceInfo;
 
  ServiceInfo = NULL;
 
  if ((This == NULL) || (RestExServiceInfo == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  Instance = RESTEX_INSTANCE_FROM_THIS (This);
 
  ServiceInfo = AllocateZeroPool (sizeof (EFI_REST_EX_SERVICE_INFO));
  if (ServiceInfo == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  CopyMem (ServiceInfo, &(Instance->Service->RestExServiceInfo), sizeof (EFI_REST_EX_SERVICE_INFO));
 
  *RestExServiceInfo = ServiceInfo;
 
  gBS->RestoreTPL (OldTpl);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
RedfishRestExGetModeData (
  IN  EFI_REST_EX_PROTOCOL     *This,
  OUT EFI_REST_EX_CONFIG_DATA  *RestExConfigData
  )
{
  return EFI_UNSUPPORTED;
}
 
EFI_STATUS
EFIAPI
RedfishRestExConfigure (
  IN  EFI_REST_EX_PROTOCOL     *This,
  IN  EFI_REST_EX_CONFIG_DATA  RestExConfigData
  )
{
  EFI_STATUS       Status;
  EFI_TPL          OldTpl;
  RESTEX_INSTANCE  *Instance;
 
  EFI_HTTP_CONFIG_DATA  *HttpConfigData;
 
  Status         = EFI_SUCCESS;
  HttpConfigData = NULL;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  Instance = RESTEX_INSTANCE_FROM_THIS (This);
 
  if (RestExConfigData == NULL) {
    //
    // Set RestExConfigData to NULL means to put EFI REST EX child instance into the unconfigured state.
    //
    HttpIoDestroyIo (&(Instance->HttpIo));
 
    if (Instance->ConfigData != NULL) {
      if (((EFI_REST_EX_HTTP_CONFIG_DATA *)Instance->ConfigData)->HttpConfigData.AccessPoint.IPv4Node != NULL) {
        FreePool (((EFI_REST_EX_HTTP_CONFIG_DATA *)Instance->ConfigData)->HttpConfigData.AccessPoint.IPv4Node);
      }
 
      FreePool (Instance->ConfigData);
      Instance->ConfigData = NULL;
    }
 
    Instance->State = RESTEX_STATE_UNCONFIGED;
  } else {
    HttpConfigData = &((EFI_REST_EX_HTTP_CONFIG_DATA *)RestExConfigData)->HttpConfigData;
    Status         = Instance->HttpIo.Http->Configure (Instance->HttpIo.Http, HttpConfigData);
    if (EFI_ERROR (Status)) {
      goto ON_EXIT;
    }
 
    Instance->HttpIo.Timeout = ((EFI_REST_EX_HTTP_CONFIG_DATA *)RestExConfigData)->SendReceiveTimeout;
 
    Instance->ConfigData = AllocateZeroPool (sizeof (EFI_REST_EX_HTTP_CONFIG_DATA));
    if (Instance->ConfigData == NULL) {
      Status = EFI_OUT_OF_RESOURCES;
      goto ON_EXIT;
    }
 
    CopyMem (Instance->ConfigData, RestExConfigData, sizeof (EFI_REST_EX_HTTP_CONFIG_DATA));
    if (HttpConfigData->LocalAddressIsIPv6 == TRUE) {
      ((EFI_REST_EX_HTTP_CONFIG_DATA *)Instance->ConfigData)->HttpConfigData.AccessPoint.IPv6Node = AllocateZeroPool (sizeof (EFI_HTTPv6_ACCESS_POINT));
      if (((EFI_REST_EX_HTTP_CONFIG_DATA *)Instance->ConfigData)->HttpConfigData.AccessPoint.IPv6Node == NULL) {
        Status = EFI_OUT_OF_RESOURCES;
        goto ON_EXIT;
      }
 
      CopyMem (
        ((EFI_REST_EX_HTTP_CONFIG_DATA *)Instance->ConfigData)->HttpConfigData.AccessPoint.IPv6Node,
        HttpConfigData->AccessPoint.IPv6Node,
        sizeof (EFI_HTTPv6_ACCESS_POINT)
        );
    } else {
      ((EFI_REST_EX_HTTP_CONFIG_DATA *)Instance->ConfigData)->HttpConfigData.AccessPoint.IPv4Node = AllocateZeroPool (sizeof (EFI_HTTPv4_ACCESS_POINT));
      if (((EFI_REST_EX_HTTP_CONFIG_DATA *)Instance->ConfigData)->HttpConfigData.AccessPoint.IPv4Node == NULL) {
        Status = EFI_OUT_OF_RESOURCES;
        goto ON_EXIT;
      }
 
      CopyMem (
        ((EFI_REST_EX_HTTP_CONFIG_DATA *)Instance->ConfigData)->HttpConfigData.AccessPoint.IPv4Node,
        HttpConfigData->AccessPoint.IPv4Node,
        sizeof (EFI_HTTPv4_ACCESS_POINT)
        );
    }
 
    Instance->State = RESTEX_STATE_CONFIGED;
  }
 
ON_EXIT:
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
EFIAPI
RedfishRestExAyncSendReceive (
  IN      EFI_REST_EX_PROTOCOL  *This,
  IN      EFI_HTTP_MESSAGE      *RequestMessage OPTIONAL,
  IN      EFI_REST_EX_TOKEN     *RestExToken,
  IN      UINTN                 *TimeOutInMilliSeconds OPTIONAL
  )
{
  return EFI_UNSUPPORTED;
}
 
EFI_STATUS
EFIAPI
RedfishRestExEventService (
  IN      EFI_REST_EX_PROTOCOL  *This,
  IN      EFI_HTTP_MESSAGE      *RequestMessage OPTIONAL,
  IN      EFI_REST_EX_TOKEN     *RestExToken
  )
{
  return EFI_UNSUPPORTED;
}