[mirror_edk2.git] / RedfishPkg / PrivateLibrary / RedfishLib / edk2libredfish / src / service.c

/** @file\r
  This file is cloned from DMTF libredfish library tag v1.0.0 and maintained\r
  by EDKII.\r
\r
//----------------------------------------------------------------------------\r
// Copyright Notice:\r
// Copyright 2017 Distributed Management Task Force, Inc. All rights reserved.\r
// License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libredfish/LICENSE.md\r
//----------------------------------------------------------------------------\r
\r
  Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>\r
  (C) Copyright 2021 Hewlett Packard Enterprise Development LP<BR>\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include <redfishService.h>\r
#include <redfishPayload.h>\r
#include <redpath.h>\r
\r
static int\r
initRest (\r
  redfishService  *service,\r
  void            *restProtocol\r
  );\r
\r
static redfishService *\r
createServiceEnumeratorNoAuth (\r
  const char    *host,\r
  const char    *rootUri,\r
  bool          enumerate,\r
  unsigned int  flags,\r
  void          *restProtocol\r
  );\r
\r
static redfishService *\r
createServiceEnumeratorBasicAuth (\r
  const char    *host,\r
  const char    *rootUri,\r
  const char    *username,\r
  const char    *password,\r
  unsigned int  flags,\r
  void          *restProtocol\r
  );\r
\r
static redfishService *\r
createServiceEnumeratorSessionAuth (\r
  const char    *host,\r
  const char    *rootUri,\r
  const char    *username,\r
  const char    *password,\r
  unsigned int  flags,\r
  void          *restProtocol\r
  );\r
\r
static char *\r
makeUrlForService (\r
  redfishService  *service,\r
  const char      *uri\r
  );\r
\r
static json_t *\r
getVersions (\r
  redfishService  *service,\r
  const char      *rootUri\r
  );\r
\r
static void\r
addStringToJsonObject (\r
  json_t      *object,\r
  const char  *key,\r
  const char  *value\r
  );\r
\r
CHAR16 *\r
C8ToC16 (\r
  CHAR8  *AsciiStr\r
  )\r
{\r
  CHAR16  *Str;\r
  UINTN   BufLen;\r
\r
  BufLen = (AsciiStrLen (AsciiStr) + 1) * 2;\r
  Str    = AllocatePool (BufLen);\r
  ASSERT (Str != NULL);\r
\r
  AsciiStrToUnicodeStrS (AsciiStr, Str, AsciiStrLen (AsciiStr) + 1);\r
\r
  return Str;\r
}\r
\r
VOID\r
RestConfigFreeHttpRequestData (\r
  IN EFI_HTTP_REQUEST_DATA  *RequestData\r
  )\r
{\r
  if (RequestData == NULL) {\r
    return;\r
  }\r
\r
  if (RequestData->Url != NULL) {\r
    FreePool (RequestData->Url);\r
  }\r
\r
  FreePool (RequestData);\r
}\r
\r
VOID\r
RestConfigFreeHttpMessage (\r
  IN EFI_HTTP_MESSAGE  *Message,\r
  IN BOOLEAN           IsRequest\r
  )\r
{\r
  if (Message == NULL) {\r
    return;\r
  }\r
\r
  if (IsRequest) {\r
    RestConfigFreeHttpRequestData (Message->Data.Request);\r
    Message->Data.Request = NULL;\r
  } else {\r
    if (Message->Data.Response != NULL) {\r
      FreePool (Message->Data.Response);\r
      Message->Data.Response = NULL;\r
    }\r
  }\r
\r
  if (Message->Headers != NULL) {\r
    FreePool (Message->Headers);\r
    Message->Headers = NULL;\r
  }\r
\r
  if (Message->Body != NULL) {\r
    FreePool (Message->Body);\r
    Message->Body = NULL;\r
  }\r
}\r
\r
/**\r
  Converts the Unicode string to ASCII string to a new allocated buffer.\r
\r
  @param[in]       String       Unicode string to be converted.\r
\r
  @return     Buffer points to ASCII string, or NULL if error happens.\r
\r
**/\r
CHAR8 *\r
UnicodeStrDupToAsciiStr (\r
  CONST CHAR16  *String\r
  )\r
{\r
  CHAR8       *AsciiStr;\r
  UINTN       BufLen;\r
  EFI_STATUS  Status;\r
\r
  BufLen   = StrLen (String) + 1;\r
  AsciiStr = AllocatePool (BufLen);\r
  if (AsciiStr == NULL) {\r
    return NULL;\r
  }\r
\r
  Status = UnicodeStrToAsciiStrS (String, AsciiStr, BufLen);\r
  if (EFI_ERROR (Status)) {\r
    return NULL;\r
  }\r
\r
  return AsciiStr;\r
}\r
\r
/**\r
  This function encodes the content.\r
\r
  @param[in]   ContentEncodedValue   HTTP conent encoded value.\r
  @param[in]   OriginalContent       Original content.\r
  @param[out]  EncodedContent        Pointer to receive encoded content.\r
  @param[out]  EncodedContentLength  Length of encoded content.\r
\r
  @retval EFI_SUCCESS              Content encoded successfully.\r
  @retval EFI_UNSUPPORTED          No source encoding funciton,\r
  @retval EFI_INVALID_PARAMETER    One of the given parameter is invalid.\r
\r
**/\r
EFI_STATUS\r
EncodeRequestContent (\r
  IN CHAR8   *ContentEncodedValue,\r
  IN CHAR8   *OriginalContent,\r
  OUT VOID   **EncodedContent,\r
  OUT UINTN  *EncodedContentLength\r
  )\r
{\r
  EFI_STATUS  Status;\r
  VOID        *EncodedPointer;\r
  UINTN       EncodedLength;\r
\r
  if ((OriginalContent == NULL) || (EncodedContent == NULL) || (EncodedContentLength == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Status = RedfishContentEncode (\r
             ContentEncodedValue,\r
             OriginalContent,\r
             AsciiStrLen (OriginalContent),\r
             &EncodedPointer,\r
             &EncodedLength\r
             );\r
  if (Status == EFI_SUCCESS) {\r
    *EncodedContent       = EncodedPointer;\r
    *EncodedContentLength = EncodedLength;\r
    return EFI_SUCCESS;\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  This function decodes the content. The Memory block pointed by\r
  ContentPointer would be freed and replaced with the cooked Redfish\r
  payload.\r
\r
  @param[in]        ContentEncodedValue HTTP conent encoded value.\r
  @param[in, out]   ContentPointer      Pointer to encoded content.\r
                                        Pointer of decoded content when out.\r
  @param[in, out]   ContentLength       Pointer to the length of encoded content.\r
                                        Length of decoded content when out.\r
\r
  @retval EFI_SUCCESS              Functinos found.\r
  @retval EFI_UNSUPPORTED          No functions found.\r
  @retval EFI_INVALID_PARAMETER    One of the given parameter is invalid.\r
\r
**/\r
EFI_STATUS\r
DecodeResponseContent (\r
  IN CHAR8      *ContentEncodedValue,\r
  IN OUT VOID   **ContentPointer,\r
  IN OUT UINTN  *ContentLength\r
  )\r
{\r
  EFI_STATUS  Status;\r
  VOID        *DecodedPointer;\r
  UINTN       DecodedLength;\r
\r
  if (ContentEncodedValue == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Status = RedfishContentDecode (\r
             ContentEncodedValue,\r
             *ContentPointer,\r
             *ContentLength,\r
             &DecodedPointer,\r
             &DecodedLength\r
             );\r
  if (Status == EFI_SUCCESS) {\r
    FreePool (*ContentPointer);\r
    *ContentPointer = DecodedPointer;\r
    *ContentLength  = DecodedLength;\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Create a HTTP URL string for specific Redfish resource.\r
\r
  This function build a URL string from the Redfish Host interface record and caller specified\r
  relative path of the resource.\r
\r
  Callers are responsible for freeing the returned string storage pointed by HttpUrl.\r
\r
  @param[in]   RedfishData         Redfish network host interface record.\r
  @param[in]   RelativePath        Relative path of a resource.\r
  @param[out]  HttpUrl             The pointer to store the returned URL string.\r
\r
  @retval EFI_SUCCESS              Build the URL string successfully.\r
  @retval EFI_INVALID_PARAMETER    RedfishData or HttpUrl is NULL.\r
  @retval EFI_OUT_OF_RESOURCES     There are not enough memory resources.\r
\r
**/\r
EFI_STATUS\r
RedfishBuildUrl (\r
  IN  REDFISH_CONFIG_SERVICE_INFORMATION  *RedfishConfigServiceInfo,\r
  IN  CHAR16                              *RelativePath    OPTIONAL,\r
  OUT CHAR16                              **HttpUrl\r
  )\r
{\r
  CHAR16  *Url;\r
  CHAR16  *UrlHead;\r
  UINTN   UrlLength;\r
  UINTN   PathLen;\r
\r
  if ((RedfishConfigServiceInfo == NULL) || (HttpUrl == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // RFC2616: http_URL = "http(s):" "//" host [ ":" port ] [ abs_path [ "?" query ]]\r
  //\r
  if (RelativePath == NULL) {\r
    PathLen = 0;\r
  } else {\r
    PathLen = StrLen (RelativePath);\r
  }\r
\r
  UrlLength = StrLen (HTTPS_FLAG) + StrLen (REDFISH_FIRST_URL) + 1 + StrLen (RedfishConfigServiceInfo->RedfishServiceLocation) + PathLen;\r
  Url       = AllocateZeroPool (UrlLength * sizeof (CHAR16));\r
  if (Url == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  UrlHead = Url;\r
  //\r
  // Copy "http://" or "https://" according RedfishServiceIpPort.\r
  //\r
  if (!RedfishConfigServiceInfo->RedfishServiceUseHttps) {\r
    StrCpyS (Url, StrLen (HTTPS_FLAG) + 1, HTTP_FLAG);\r
    Url = Url + StrLen (HTTP_FLAG);\r
  } else {\r
    StrCpyS (Url, StrLen (HTTPS_FLAG) + 1, HTTPS_FLAG);\r
    Url = Url + StrLen (HTTPS_FLAG);\r
  }\r
\r
  StrCpyS (Url, StrLen (RedfishConfigServiceInfo->RedfishServiceLocation) + 1, RedfishConfigServiceInfo->RedfishServiceLocation);\r
  Url = Url + StrLen (RedfishConfigServiceInfo->RedfishServiceLocation);\r
\r
  //\r
  // Copy abs_path\r
  //\r
  if ((RelativePath != NULL) && (PathLen != 0)) {\r
    StrnCpyS (Url, UrlLength, RelativePath, PathLen);\r
  }\r
\r
  *HttpUrl = UrlHead;\r
  return EFI_SUCCESS;\r
}\r
\r
redfishService *\r
createServiceEnumerator (\r
  REDFISH_CONFIG_SERVICE_INFORMATION  *RedfishConfigServiceInfo,\r
  const char                          *rootUri,\r
  enumeratorAuthentication            *auth,\r
  unsigned int                        flags\r
  )\r
{\r
  EFI_STATUS            Status;\r
  CHAR16                *HttpUrl;\r
  CHAR8                 *AsciiHost;\r
  EFI_REST_EX_PROTOCOL  *RestEx;\r
  redfishService        *ret;\r
\r
  HttpUrl   = NULL;\r
  AsciiHost = NULL;\r
  RestEx    = NULL;\r
  ret       = NULL;\r
\r
  if (RedfishConfigServiceInfo->RedfishServiceRestExHandle == NULL) {\r
    goto ON_EXIT;\r
  }\r
\r
  Status = RedfishBuildUrl (RedfishConfigServiceInfo, NULL, &HttpUrl);\r
  if (EFI_ERROR (Status)) {\r
    goto ON_EXIT;\r
  }\r
\r
  ASSERT (HttpUrl != NULL);\r
\r
  AsciiHost = UnicodeStrDupToAsciiStr (HttpUrl);\r
  if (AsciiHost == NULL) {\r
    goto ON_EXIT;\r
  }\r
\r
  Status = gBS->HandleProtocol (\r
                  RedfishConfigServiceInfo->RedfishServiceRestExHandle,\r
                  &gEfiRestExProtocolGuid,\r
                  (VOID **)&RestEx\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    goto ON_EXIT;\r
  }\r
\r
  if (auth == NULL) {\r
    ret = createServiceEnumeratorNoAuth (AsciiHost, rootUri, true, flags, RestEx);\r
  } else if (auth->authType == REDFISH_AUTH_BASIC) {\r
    ret = createServiceEnumeratorBasicAuth (AsciiHost, rootUri, auth->authCodes.userPass.username, auth->authCodes.userPass.password, flags, RestEx);\r
  } else if (auth->authType == REDFISH_AUTH_SESSION) {\r
    ret = createServiceEnumeratorSessionAuth (AsciiHost, rootUri, auth->authCodes.userPass.username, auth->authCodes.userPass.password, flags, RestEx);\r
  } else {\r
    goto ON_EXIT;\r
  }\r
\r
  ret->RestEx = RestEx;\r
ON_EXIT:\r
  if (HttpUrl != NULL) {\r
    FreePool (HttpUrl);\r
  }\r
\r
  if (AsciiHost != NULL) {\r
    FreePool (AsciiHost);\r
  }\r
\r
  return ret;\r
}\r
\r
json_t *\r
getUriFromService (\r
  redfishService        *service,\r
  const char            *uri,\r
  EFI_HTTP_STATUS_CODE  **StatusCode\r
  )\r
{\r
  char                   *url;\r
  json_t                 *ret;\r
  HTTP_IO_HEADER         *HttpIoHeader = NULL;\r
  EFI_STATUS             Status;\r
  EFI_HTTP_REQUEST_DATA  *RequestData = NULL;\r
  EFI_HTTP_MESSAGE       *RequestMsg  = NULL;\r
  EFI_HTTP_MESSAGE       ResponseMsg;\r
  EFI_HTTP_HEADER        *ContentEncodedHeader;\r
\r
  if ((service == NULL) || (uri == NULL) || (StatusCode == NULL)) {\r
    return NULL;\r
  }\r
\r
  *StatusCode = NULL;\r
\r
  url = makeUrlForService (service, uri);\r
  if (!url) {\r
    return NULL;\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "libredfish: getUriFromService(): %a\n", url));\r
\r
  //\r
  // Step 1: Create HTTP request message with 4 headers:\r
  //\r
  HttpIoHeader = HttpIoCreateHeader ((service->sessionToken || service->basicAuthStr) ? 6 : 5);\r
  if (HttpIoHeader == NULL) {\r
    ret = NULL;\r
    goto ON_EXIT;\r
  }\r
\r
  if (service->sessionToken) {\r
    Status = HttpIoSetHeader (HttpIoHeader, "X-Auth-Token", service->sessionToken);\r
    ASSERT_EFI_ERROR (Status);\r
  } else if (service->basicAuthStr) {\r
    Status = HttpIoSetHeader (HttpIoHeader, "Authorization", service->basicAuthStr);\r
    ASSERT_EFI_ERROR (Status);\r
  }\r
\r
  Status = HttpIoSetHeader (HttpIoHeader, "Host", service->HostHeaderValue);\r
  ASSERT_EFI_ERROR (Status);\r
  Status = HttpIoSetHeader (HttpIoHeader, "OData-Version", "4.0");\r
  ASSERT_EFI_ERROR (Status);\r
  Status = HttpIoSetHeader (HttpIoHeader, "Accept", "application/json");\r
  ASSERT_EFI_ERROR (Status);\r
  Status = HttpIoSetHeader (HttpIoHeader, "User-Agent", "libredfish");\r
  ASSERT_EFI_ERROR (Status);\r
  Status = HttpIoSetHeader (HttpIoHeader, "Connection", "Keep-Alive");\r
  ASSERT_EFI_ERROR (Status);\r
\r
  //\r
  // Step 2: build the rest of HTTP request info.\r
  //\r
  RequestData = AllocateZeroPool (sizeof (EFI_HTTP_REQUEST_DATA));\r
  if (RequestData == NULL) {\r
    ret = NULL;\r
    goto ON_EXIT;\r
  }\r
\r
  RequestData->Method = HttpMethodGet;\r
  RequestData->Url    = C8ToC16 (url);\r
\r
  //\r
  // Step 3: fill in EFI_HTTP_MESSAGE\r
  //\r
  RequestMsg = AllocateZeroPool (sizeof (EFI_HTTP_MESSAGE));\r
  if (RequestMsg == NULL) {\r
    ret = NULL;\r
    goto ON_EXIT;\r
  }\r
\r
  RequestMsg->Data.Request = RequestData;\r
  RequestMsg->HeaderCount  = HttpIoHeader->HeaderCount;\r
  RequestMsg->Headers      = HttpIoHeader->Headers;\r
\r
  ZeroMem (&ResponseMsg, sizeof (ResponseMsg));\r
\r
  //\r
  // Step 4: call RESTEx to get response from REST service.\r
  //\r
  Status = service->RestEx->SendReceive (service->RestEx, RequestMsg, &ResponseMsg);\r
  if (EFI_ERROR (Status)) {\r
    ret = NULL;\r
    goto ON_EXIT;\r
  }\r
\r
  //\r
  // Step 5: Return the HTTP StatusCode and Body message.\r
  //\r
  if (ResponseMsg.Data.Response != NULL) {\r
    *StatusCode = AllocateZeroPool (sizeof (EFI_HTTP_STATUS_CODE));\r
    if (*StatusCode == NULL) {\r
      ret = NULL;\r
      goto ON_EXIT;\r
    }\r
\r
    //\r
    // The caller shall take the responsibility to free the buffer.\r
    //\r
    **StatusCode = ResponseMsg.Data.Response->StatusCode;\r
  }\r
\r
  if ((ResponseMsg.BodyLength != 0) && (ResponseMsg.Body != NULL)) {\r
    //\r
    // Check if data is encoded.\r
    //\r
    ContentEncodedHeader = HttpFindHeader (ResponseMsg.HeaderCount, ResponseMsg.Headers, HTTP_HEADER_CONTENT_ENCODING);\r
    if (ContentEncodedHeader != NULL) {\r
      //\r
      // The content is encoded.\r
      //\r
      Status = DecodeResponseContent (ContentEncodedHeader->FieldValue, &ResponseMsg.Body, &ResponseMsg.BodyLength);\r
      if (EFI_ERROR (Status)) {\r
        DEBUG ((DEBUG_ERROR, "%a: Failed to decompress the response content %r\n.", __FUNCTION__, Status));\r
        ret = NULL;\r
        goto ON_EXIT;\r
      }\r
    }\r
\r
    ret = json_loadb (ResponseMsg.Body, ResponseMsg.BodyLength, 0, NULL);\r
  } else {\r
    //\r
    // There is no message body returned from server.\r
    //\r
    ret = NULL;\r
  }\r
\r
ON_EXIT:\r
  if (url != NULL) {\r
    free (url);\r
  }\r
\r
  if (HttpIoHeader != NULL) {\r
    HttpIoFreeHeader (HttpIoHeader);\r
  }\r
\r
  if (RequestData != NULL) {\r
    RestConfigFreeHttpRequestData (RequestData);\r
  }\r
\r
  if (RequestMsg != NULL) {\r
    FreePool (RequestMsg);\r
  }\r
\r
  RestConfigFreeHttpMessage (&ResponseMsg, FALSE);\r
\r
  return ret;\r
}\r
\r
json_t *\r
patchUriFromService (\r
  redfishService        *service,\r
  const char            *uri,\r
  const char            *content,\r
  EFI_HTTP_STATUS_CODE  **StatusCode\r
  )\r
{\r
  char                   *url;\r
  json_t                 *ret;\r
  HTTP_IO_HEADER         *HttpIoHeader = NULL;\r
  EFI_STATUS             Status;\r
  EFI_HTTP_REQUEST_DATA  *RequestData = NULL;\r
  EFI_HTTP_MESSAGE       *RequestMsg  = NULL;\r
  EFI_HTTP_MESSAGE       ResponseMsg;\r
  CHAR8                  ContentLengthStr[80];\r
  CHAR8                  *EncodedContent;\r
  UINTN                  EncodedContentLen;\r
\r
  if ((service == NULL) || (uri == NULL) || (content == NULL) || (StatusCode == NULL)) {\r
    return NULL;\r
  }\r
\r
  *StatusCode = NULL;\r
\r
  url = makeUrlForService (service, uri);\r
  if (!url) {\r
    return NULL;\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "libredfish: patchUriFromService(): %a\n", url));\r
\r
  //\r
  // Step 1: Create HTTP request message with 4 headers:\r
  //\r
  HttpIoHeader = HttpIoCreateHeader ((service->sessionToken || service->basicAuthStr) ? 9 : 8);\r
  if (HttpIoHeader == NULL) {\r
    ret = NULL;\r
    goto ON_EXIT;\r
  }\r
\r
  if (service->sessionToken) {\r
    Status = HttpIoSetHeader (HttpIoHeader, "X-Auth-Token", service->sessionToken);\r
    ASSERT_EFI_ERROR (Status);\r
  } else if (service->basicAuthStr) {\r
    Status = HttpIoSetHeader (HttpIoHeader, "Authorization", service->basicAuthStr);\r
    ASSERT_EFI_ERROR (Status);\r
  }\r
\r
  Status = HttpIoSetHeader (HttpIoHeader, "Host", service->HostHeaderValue);\r
  ASSERT_EFI_ERROR (Status);\r
  Status = HttpIoSetHeader (HttpIoHeader, "Content-Type", "application/json");\r
  ASSERT_EFI_ERROR (Status);\r
  Status = HttpIoSetHeader (HttpIoHeader, "Accept", "application/json");\r
  ASSERT_EFI_ERROR (Status);\r
  Status = HttpIoSetHeader (HttpIoHeader, "User-Agent", "libredfish");\r
  ASSERT_EFI_ERROR (Status);\r
  Status = HttpIoSetHeader (HttpIoHeader, "Connection", "Keep-Alive");\r
  ASSERT_EFI_ERROR (Status);\r
\r
  AsciiSPrint (\r
    ContentLengthStr,\r
    sizeof (ContentLengthStr),\r
    "%lu",\r
    (UINT64)strlen (content)\r
    );\r
  Status = HttpIoSetHeader (HttpIoHeader, "Content-Length", ContentLengthStr);\r
  ASSERT_EFI_ERROR (Status);\r
  Status = HttpIoSetHeader (HttpIoHeader, "OData-Version", "4.0");\r
  ASSERT_EFI_ERROR (Status);\r
\r
  //\r
  // Step 2: build the rest of HTTP request info.\r
  //\r
  RequestData = AllocateZeroPool (sizeof (EFI_HTTP_REQUEST_DATA));\r
  if (RequestData == NULL) {\r
    ret = NULL;\r
    goto ON_EXIT;\r
  }\r
\r
  RequestData->Method = HttpMethodPatch;\r
  RequestData->Url    = C8ToC16 (url);\r
\r
  //\r
  // Step 3: fill in EFI_HTTP_MESSAGE\r
  //\r
  RequestMsg = AllocateZeroPool (sizeof (EFI_HTTP_MESSAGE));\r
  if (RequestMsg == NULL) {\r
    ret = NULL;\r
    goto ON_EXIT;\r
  }\r
\r
  EncodedContent    = (CHAR8 *)content;\r
  EncodedContentLen = strlen (content);\r
  //\r
  // We currently only support gzip Content-Encoding.\r
  //\r
  Status = EncodeRequestContent ((CHAR8 *)HTTP_CONTENT_ENCODING_GZIP, (CHAR8 *)content, (VOID **)&EncodedContent, &EncodedContentLen);\r
  if (Status == EFI_INVALID_PARAMETER) {\r
    DEBUG ((DEBUG_ERROR, "%a: Error to encode content.\n", __FUNCTION__));\r
    ret = NULL;\r
    goto ON_EXIT;\r
  } else if (Status == EFI_UNSUPPORTED) {\r
    DEBUG ((DEBUG_INFO, "No content coding for %a! Use raw data instead.\n", HTTP_CONTENT_ENCODING_GZIP));\r
    Status = HttpIoSetHeader (HttpIoHeader, "Content-Encoding", HTTP_CONTENT_ENCODING_IDENTITY);\r
    ASSERT_EFI_ERROR (Status);\r
  } else {\r
    Status = HttpIoSetHeader (HttpIoHeader, "Content-Encoding", HTTP_CONTENT_ENCODING_GZIP);\r
    ASSERT_EFI_ERROR (Status);\r
  }\r
\r
  RequestMsg->Data.Request = RequestData;\r
  RequestMsg->HeaderCount  = HttpIoHeader->HeaderCount;\r
  RequestMsg->Headers      = HttpIoHeader->Headers;\r
  RequestMsg->BodyLength   = EncodedContentLen;\r
  RequestMsg->Body         = (VOID *)EncodedContent;\r
\r
  ZeroMem (&ResponseMsg, sizeof (ResponseMsg));\r
\r
  //\r
  // Step 4: call RESTEx to get response from REST service.\r
  //\r
  Status = service->RestEx->SendReceive (service->RestEx, RequestMsg, &ResponseMsg);\r
  if (EFI_ERROR (Status)) {\r
    ret = NULL;\r
    goto ON_EXIT;\r
  }\r
\r
  //\r
  // Step 5: Return the HTTP StatusCode and Body message.\r
  //\r
  if (ResponseMsg.Data.Response != NULL) {\r
    *StatusCode = AllocateZeroPool (sizeof (EFI_HTTP_STATUS_CODE));\r
    if (*StatusCode == NULL) {\r
      ret = NULL;\r
      goto ON_EXIT;\r
    }\r
\r
    //\r
    // The caller shall take the responsibility to free the buffer.\r
    //\r
    **StatusCode = ResponseMsg.Data.Response->StatusCode;\r
  }\r
\r
  if (EncodedContent != content) {\r
    FreePool (EncodedContent);\r
  }\r
\r
  if ((ResponseMsg.BodyLength != 0) && (ResponseMsg.Body != NULL)) {\r
    ret = json_loadb (ResponseMsg.Body, ResponseMsg.BodyLength, 0, NULL);\r
  } else {\r
    //\r
    // There is no message body returned from server.\r
    //\r
    ret = NULL;\r
  }\r
\r
ON_EXIT:\r
  if (url != NULL) {\r
    free (url);\r
  }\r
\r
  if (HttpIoHeader != NULL) {\r
    HttpIoFreeHeader (HttpIoHeader);\r
  }\r
\r
  if (RequestData != NULL) {\r
    RestConfigFreeHttpRequestData (RequestData);\r
  }\r
\r
  if (RequestMsg != NULL) {\r
    FreePool (RequestMsg);\r
  }\r
\r
  RestConfigFreeHttpMessage (&ResponseMsg, FALSE);\r
\r
  return ret;\r
}\r
\r
json_t *\r
postUriFromService (\r
  redfishService        *service,\r
  const char            *uri,\r
  const char            *content,\r
  size_t                contentLength,\r
  const char            *contentType,\r
  EFI_HTTP_STATUS_CODE  **StatusCode\r
  )\r
{\r
  char                   *url = NULL;\r
  json_t                 *ret;\r
  HTTP_IO_HEADER         *HttpIoHeader = NULL;\r
  EFI_STATUS             Status;\r
  EFI_HTTP_REQUEST_DATA  *RequestData = NULL;\r
  EFI_HTTP_MESSAGE       *RequestMsg  = NULL;\r
  EFI_HTTP_MESSAGE       ResponseMsg;\r
  CHAR8                  ContentLengthStr[80];\r
  EFI_HTTP_HEADER        *HttpHeader = NULL;\r
\r
  ret = NULL;\r
\r
  if ((service == NULL) || (uri == NULL) || (content == NULL) || (StatusCode == NULL)) {\r
    return NULL;\r
  }\r
\r
  *StatusCode = NULL;\r
\r
  url = makeUrlForService (service, uri);\r
  if (!url) {\r
    return NULL;\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "libredfish: postUriFromService(): %a\n", url));\r
\r
  if (contentLength == 0) {\r
    contentLength = strlen (content);\r
  }\r
\r
  //\r
  // Step 1: Create HTTP request message with 4 headers:\r
  //\r
  HttpIoHeader = HttpIoCreateHeader ((service->sessionToken || service->basicAuthStr) ? 8 : 7);\r
  if (HttpIoHeader == NULL) {\r
    goto ON_EXIT;\r
  }\r
\r
  if (service->sessionToken) {\r
    Status = HttpIoSetHeader (HttpIoHeader, "X-Auth-Token", service->sessionToken);\r
    ASSERT_EFI_ERROR (Status);\r
  } else if (service->basicAuthStr) {\r
    Status = HttpIoSetHeader (HttpIoHeader, "Authorization", service->basicAuthStr);\r
    ASSERT_EFI_ERROR (Status);\r
  }\r
\r
  if (contentType == NULL) {\r
    Status = HttpIoSetHeader (HttpIoHeader, "Content-Type", "application/json");\r
    ASSERT_EFI_ERROR (Status);\r
  } else {\r
    Status = HttpIoSetHeader (HttpIoHeader, "Content-Type", (CHAR8 *)contentType);\r
    ASSERT_EFI_ERROR (Status);\r
  }\r
\r
  Status = HttpIoSetHeader (HttpIoHeader, "Host", service->HostHeaderValue);\r
  ASSERT_EFI_ERROR (Status);\r
  Status = HttpIoSetHeader (HttpIoHeader, "Accept", "application/json");\r
  ASSERT_EFI_ERROR (Status);\r
  Status = HttpIoSetHeader (HttpIoHeader, "User-Agent", "libredfish");\r
  ASSERT_EFI_ERROR (Status);\r
  Status = HttpIoSetHeader (HttpIoHeader, "Connection", "Keep-Alive");\r
  ASSERT_EFI_ERROR (Status);\r
  AsciiSPrint (\r
    ContentLengthStr,\r
    sizeof (ContentLengthStr),\r
    "%lu",\r
    (UINT64)contentLength\r
    );\r
  Status = HttpIoSetHeader (HttpIoHeader, "Content-Length", ContentLengthStr);\r
  ASSERT_EFI_ERROR (Status);\r
  Status = HttpIoSetHeader (HttpIoHeader, "OData-Version", "4.0");\r
  ASSERT_EFI_ERROR (Status);\r
\r
  //\r
  // Step 2: build the rest of HTTP request info.\r
  //\r
  RequestData = AllocateZeroPool (sizeof (EFI_HTTP_REQUEST_DATA));\r
  if (RequestData == NULL) {\r
    goto ON_EXIT;\r
  }\r
\r
  RequestData->Method = HttpMethodPost;\r
  RequestData->Url    = C8ToC16 (url);\r
\r
  //\r
  // Step 3: fill in EFI_HTTP_MESSAGE\r
  //\r
  RequestMsg = AllocateZeroPool (sizeof (EFI_HTTP_MESSAGE));\r
  if (RequestMsg == NULL) {\r
    goto ON_EXIT;\r
  }\r
\r
  RequestMsg->Data.Request = RequestData;\r
  RequestMsg->HeaderCount  = HttpIoHeader->HeaderCount;\r
  RequestMsg->Headers      = HttpIoHeader->Headers;\r
  RequestMsg->BodyLength   = contentLength;\r
  RequestMsg->Body         = (VOID *)content;\r
\r
  ZeroMem (&ResponseMsg, sizeof (ResponseMsg));\r
\r
  //\r
  // Step 4: call RESTEx to get response from REST service.\r
  //\r
  Status = service->RestEx->SendReceive (service->RestEx, RequestMsg, &ResponseMsg);\r
  if (EFI_ERROR (Status)) {\r
    goto ON_EXIT;\r
  }\r
\r
  //\r
  // Step 5: Return the HTTP StatusCode and Body message.\r
  //\r
  if (ResponseMsg.Data.Response != NULL) {\r
    *StatusCode = AllocateZeroPool (sizeof (EFI_HTTP_STATUS_CODE));\r
    if (*StatusCode == NULL) {\r
      goto ON_EXIT;\r
    }\r
\r
    //\r
    // The caller shall take the responsibility to free the buffer.\r
    //\r
    **StatusCode = ResponseMsg.Data.Response->StatusCode;\r
  }\r
\r
  if ((ResponseMsg.BodyLength != 0) && (ResponseMsg.Body != NULL)) {\r
    ret = json_loadb (ResponseMsg.Body, ResponseMsg.BodyLength, 0, NULL);\r
  }\r
\r
  //\r
  // Step 6: Parsing the HttpHeader to retrive the X-Auth-Token if the HTTP StatusCode is correct.\r
  //\r
  if ((ResponseMsg.Data.Response->StatusCode == HTTP_STATUS_200_OK) ||\r
      (ResponseMsg.Data.Response->StatusCode == HTTP_STATUS_204_NO_CONTENT))\r
  {\r
    HttpHeader = HttpFindHeader (ResponseMsg.HeaderCount, ResponseMsg.Headers, "X-Auth-Token");\r
    if (HttpHeader != NULL) {\r
      if (service->sessionToken) {\r
        free (service->sessionToken);\r
      }\r
\r
      service->sessionToken = AllocateCopyPool (AsciiStrSize (HttpHeader->FieldValue), HttpHeader->FieldValue);\r
    }\r
\r
    /*\r
    //\r
    // Below opeation seems to be unnecessary.\r
    // Besides, the FieldValue for the Location is the full HTTP URI (Http://0.0.0.0:5000/XXX), so we can't use it as the\r
    // parameter of getUriFromService () directly.\r
    //\r
    HttpHeader = HttpFindHeader (ResponseMsg.HeaderCount, ResponseMsg.Headers, "Location");\r
    if (HttpHeader != NULL) {\r
      ret = getUriFromService(service, HttpHeader->FieldValue);\r
      goto ON_EXIT;\r
    }\r
    */\r
  }\r
\r
ON_EXIT:\r
  if (url != NULL) {\r
    free (url);\r
  }\r
\r
  if (HttpIoHeader != NULL) {\r
    HttpIoFreeHeader (HttpIoHeader);\r
  }\r
\r
  if (RequestData != NULL) {\r
    RestConfigFreeHttpRequestData (RequestData);\r
  }\r
\r
  if (RequestMsg != NULL) {\r
    FreePool (RequestMsg);\r
  }\r
\r
  RestConfigFreeHttpMessage (&ResponseMsg, FALSE);\r
\r
  return ret;\r
}\r
\r
json_t *\r
deleteUriFromServiceEx (\r
  redfishService        *service,\r
  const char            *uri,\r
  const char            *content,\r
  EFI_HTTP_STATUS_CODE  **StatusCode\r
  )\r
{\r
  char                   *url;\r
  json_t                 *ret;\r
  HTTP_IO_HEADER         *HttpIoHeader = NULL;\r
  EFI_STATUS             Status;\r
  EFI_HTTP_REQUEST_DATA  *RequestData = NULL;\r
  EFI_HTTP_MESSAGE       *RequestMsg  = NULL;\r
  EFI_HTTP_MESSAGE       ResponseMsg;\r
  CHAR8                  ContentLengthStr[80];\r
  size_t                 contentLength;\r
\r
  ret = NULL;\r
\r
  if ((service == NULL) || (uri == NULL) || (StatusCode == NULL)) {\r
    return NULL;\r
  }\r
\r
  *StatusCode = NULL;\r
\r
  url = makeUrlForService (service, uri);\r
  if (!url) {\r
    return NULL;\r
  }\r
\r
  DEBUG ((DEBUG_INFO, "libredfish: deleteUriFromService(): %a\n", url));\r
\r
  //\r
  // Step 1: Create HTTP request message with 4 headers:\r
  //\r
  HttpIoHeader = HttpIoCreateHeader ((service->sessionToken || service->basicAuthStr) ? 8 : 7);\r
  if (HttpIoHeader == NULL) {\r
    ret = NULL;\r
    goto ON_EXIT;\r
  }\r
\r
  if (service->sessionToken) {\r
    Status = HttpIoSetHeader (HttpIoHeader, "X-Auth-Token", service->sessionToken);\r
    ASSERT_EFI_ERROR (Status);\r
  } else if (service->basicAuthStr) {\r
    Status = HttpIoSetHeader (HttpIoHeader, "Authorization", service->basicAuthStr);\r
    ASSERT_EFI_ERROR (Status);\r
  }\r
\r
  Status = HttpIoSetHeader (HttpIoHeader, "Host", service->HostHeaderValue);\r
  ASSERT_EFI_ERROR (Status);\r
  Status = HttpIoSetHeader (HttpIoHeader, "User-Agent", "libredfish");\r
  ASSERT_EFI_ERROR (Status);\r
  Status = HttpIoSetHeader (HttpIoHeader, "OData-Version", "4.0");\r
  ASSERT_EFI_ERROR (Status);\r
  Status = HttpIoSetHeader (HttpIoHeader, "Connection", "Keep-Alive");\r
  ASSERT_EFI_ERROR (Status);\r
\r
  Status = HttpIoSetHeader (HttpIoHeader, "Content-Type", "application/json");\r
  ASSERT_EFI_ERROR (Status);\r
\r
  if (content != NULL) {\r
    contentLength = strlen (content);\r
    AsciiSPrint (\r
      ContentLengthStr,\r
      sizeof (ContentLengthStr),\r
      "%lu",\r
      (UINT64)contentLength\r
      );\r
    Status = HttpIoSetHeader (HttpIoHeader, "Content-Length", ContentLengthStr);\r
    ASSERT_EFI_ERROR (Status);\r
    Status = HttpIoSetHeader (HttpIoHeader, "OData-Version", "4.0");\r
    ASSERT_EFI_ERROR (Status);\r
  }\r
\r
  //\r
  // Step 2: build the rest of HTTP request info.\r
  //\r
  RequestData = AllocateZeroPool (sizeof (EFI_HTTP_REQUEST_DATA));\r
  if (RequestData == NULL) {\r
    ret = NULL;\r
    goto ON_EXIT;\r
  }\r
\r
  RequestData->Method = HttpMethodDelete;\r
  RequestData->Url    = C8ToC16 (url);\r
\r
  //\r
  // Step 3: fill in EFI_HTTP_MESSAGE\r
  //\r
  RequestMsg = AllocateZeroPool (sizeof (EFI_HTTP_MESSAGE));\r
  if (RequestMsg == NULL) {\r
    ret = NULL;\r
    goto ON_EXIT;\r
  }\r
\r
  RequestMsg->Data.Request = RequestData;\r
  RequestMsg->HeaderCount  = HttpIoHeader->HeaderCount;\r
  RequestMsg->Headers      = HttpIoHeader->Headers;\r
\r
  if (content != NULL) {\r
    RequestMsg->BodyLength = contentLength;\r
    RequestMsg->Body       = (VOID *)content;\r
  }\r
\r
  ZeroMem (&ResponseMsg, sizeof (ResponseMsg));\r
\r
  //\r
  // Step 4: call RESTEx to get response from REST service.\r
  //\r
  Status = service->RestEx->SendReceive (service->RestEx, RequestMsg, &ResponseMsg);\r
  if (EFI_ERROR (Status)) {\r
    ret = NULL;\r
    goto ON_EXIT;\r
  }\r
\r
  //\r
  // Step 5: Return the HTTP StatusCode and Body message.\r
  //\r
  if (ResponseMsg.Data.Response != NULL) {\r
    *StatusCode = AllocateZeroPool (sizeof (EFI_HTTP_STATUS_CODE));\r
    if (*StatusCode == NULL) {\r
      ret = NULL;\r
      goto ON_EXIT;\r
    }\r
\r
    //\r
    // The caller shall take the responsibility to free the buffer.\r
    //\r
    **StatusCode = ResponseMsg.Data.Response->StatusCode;\r
  }\r
\r
  if ((ResponseMsg.BodyLength != 0) && (ResponseMsg.Body != NULL)) {\r
    ret = json_loadb (ResponseMsg.Body, ResponseMsg.BodyLength, 0, NULL);\r
  }\r
\r
ON_EXIT:\r
  if (url != NULL) {\r
    free (url);\r
  }\r
\r
  if (HttpIoHeader != NULL) {\r
    HttpIoFreeHeader (HttpIoHeader);\r
  }\r
\r
  if (RequestData != NULL) {\r
    RestConfigFreeHttpRequestData (RequestData);\r
  }\r
\r
  if (RequestMsg != NULL) {\r
    FreePool (RequestMsg);\r
  }\r
\r
  RestConfigFreeHttpMessage (&ResponseMsg, FALSE);\r
\r
  return ret;\r
}\r
\r
json_t *\r
deleteUriFromService (\r
  redfishService        *service,\r
  const char            *uri,\r
  EFI_HTTP_STATUS_CODE  **StatusCode\r
  )\r
{\r
  return deleteUriFromServiceEx (service, uri, NULL, StatusCode);\r
}\r
\r
redfishPayload *\r
getRedfishServiceRoot (\r
  redfishService        *service,\r
  const char            *version,\r
  EFI_HTTP_STATUS_CODE  **StatusCode\r
  )\r
{\r
  json_t      *value;\r
  json_t      *versionNode;\r
  const char  *verUrl;\r
\r
  if (version == NULL) {\r
    versionNode = json_object_get (service->versions, "v1");\r
  } else {\r
    versionNode = json_object_get (service->versions, version);\r
  }\r
\r
  if (versionNode == NULL) {\r
    return NULL;\r
  }\r
\r
  verUrl = json_string_value (versionNode);\r
  if (verUrl == NULL) {\r
    return NULL;\r
  }\r
\r
  value = getUriFromService (service, verUrl, StatusCode);\r
  if (value == NULL) {\r
    if ((service->flags & REDFISH_FLAG_SERVICE_NO_VERSION_DOC) == 0) {\r
      json_decref (versionNode);\r
    }\r
\r
    return NULL;\r
  }\r
\r
  return createRedfishPayload (value, service);\r
}\r
\r
redfishPayload *\r
getPayloadByPath (\r
  redfishService        *service,\r
  const char            *path,\r
  EFI_HTTP_STATUS_CODE  **StatusCode\r
  )\r
{\r
  redPathNode     *redpath;\r
  redfishPayload  *root;\r
  redfishPayload  *ret;\r
\r
  if (!service || !path || (StatusCode == NULL)) {\r
    return NULL;\r
  }\r
\r
  *StatusCode = NULL;\r
\r
  redpath = parseRedPath (path);\r
  if (!redpath) {\r
    return NULL;\r
  }\r
\r
  if (!redpath->isRoot) {\r
    cleanupRedPath (redpath);\r
    return NULL;\r
  }\r
\r
  root = getRedfishServiceRoot (service, redpath->version, StatusCode);\r
  if ((*StatusCode == NULL) || (**StatusCode < HTTP_STATUS_200_OK) || (**StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT)) {\r
    cleanupRedPath (redpath);\r
    return root;\r
  }\r
\r
  if (redpath->next == NULL) {\r
    cleanupRedPath (redpath);\r
    return root;\r
  }\r
\r
  FreePool (*StatusCode);\r
  *StatusCode = NULL;\r
\r
  ret = getPayloadForPath (root, redpath->next, StatusCode);\r
  if ((*StatusCode == NULL) && (ret != NULL)) {\r
    //\r
    // In such a case, the Redfish resource is parsed from the input payload (root) directly.\r
    // So, we still return HTTP_STATUS_200_OK.\r
    //\r
    *StatusCode = AllocateZeroPool (sizeof (EFI_HTTP_STATUS_CODE));\r
    if (*StatusCode == NULL) {\r
      ret = NULL;\r
    } else {\r
      **StatusCode = HTTP_STATUS_200_OK;\r
    }\r
  }\r
\r
  cleanupPayload (root);\r
  cleanupRedPath (redpath);\r
  return ret;\r
}\r
\r
void\r
cleanupServiceEnumerator (\r
  redfishService  *service\r
  )\r
{\r
  if (!service) {\r
    return;\r
  }\r
\r
  free (service->host);\r
  json_decref (service->versions);\r
  if (service->sessionToken != NULL) {\r
    ZeroMem (service->sessionToken, (UINTN)strlen (service->sessionToken));\r
    FreePool (service->sessionToken);\r
  }\r
\r
  if (service->basicAuthStr != NULL) {\r
    ZeroMem (service->basicAuthStr, (UINTN)strlen (service->basicAuthStr));\r
    FreePool (service->basicAuthStr);\r
  }\r
\r
  free (service);\r
}\r
\r
static int\r
initRest (\r
  redfishService  *service,\r
  void            *restProtocol\r
  )\r
{\r
  service->RestEx = restProtocol;\r
  return 0;\r
}\r
\r
static redfishService *\r
createServiceEnumeratorNoAuth (\r
  const char    *host,\r
  const char    *rootUri,\r
  bool          enumerate,\r
  unsigned int  flags,\r
  void          *restProtocol\r
  )\r
{\r
  redfishService  *ret;\r
  char            *HostStart;\r
\r
  ret = (redfishService *)calloc (1, sizeof (redfishService));\r
  ZeroMem (ret, sizeof (redfishService));\r
  if (initRest (ret, restProtocol) != 0) {\r
    free (ret);\r
    return NULL;\r
  }\r
\r
  ret->host  = AllocateCopyPool (AsciiStrSize (host), host);\r
  ret->flags = flags;\r
  if (enumerate) {\r
    ret->versions = getVersions (ret, rootUri);\r
  }\r
\r
  HostStart = strstr (ret->host, "//");\r
  if ((HostStart != NULL) && (*(HostStart + 2) != '\0')) {\r
    ret->HostHeaderValue = HostStart + 2;\r
  }\r
\r
  return ret;\r
}\r
\r
EFI_STATUS\r
createBasicAuthStr (\r
  IN  redfishService  *service,\r
  IN  CONST CHAR8     *UserId,\r
  IN  CONST CHAR8     *Password\r
  )\r
{\r
  EFI_STATUS  Status;\r
  CHAR8       *RawAuthValue;\r
  UINTN       RawAuthBufSize;\r
  CHAR8       *EnAuthValue;\r
  UINTN       EnAuthValueSize;\r
  CHAR8       *BasicWithEnAuthValue;\r
  UINTN       BasicBufSize;\r
\r
  EnAuthValue     = NULL;\r
  EnAuthValueSize = 0;\r
\r
  RawAuthBufSize = AsciiStrLen (UserId) + AsciiStrLen (Password) + 2;\r
  RawAuthValue   = AllocatePool (RawAuthBufSize);\r
  if (RawAuthValue == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Build raw AuthValue (UserId:Password).\r
  //\r
  AsciiSPrint (\r
    RawAuthValue,\r
    RawAuthBufSize,\r
    "%a:%a",\r
    UserId,\r
    Password\r
    );\r
\r
  //\r
  // Encoding RawAuthValue into Base64 format.\r
  //\r
  Status = Base64Encode (\r
             (CONST UINT8 *)RawAuthValue,\r
             AsciiStrLen (RawAuthValue),\r
             EnAuthValue,\r
             &EnAuthValueSize\r
             );\r
  if (Status == EFI_BUFFER_TOO_SMALL) {\r
    EnAuthValue = (CHAR8 *)AllocateZeroPool (EnAuthValueSize);\r
    if (EnAuthValue == NULL) {\r
      Status = EFI_OUT_OF_RESOURCES;\r
      return Status;\r
    }\r
\r
    Status = Base64Encode (\r
               (CONST UINT8 *)RawAuthValue,\r
               AsciiStrLen (RawAuthValue),\r
               EnAuthValue,\r
               &EnAuthValueSize\r
               );\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    goto Exit;\r
  }\r
\r
  BasicBufSize         = AsciiStrLen ("Basic ") + AsciiStrLen (EnAuthValue) + 2;\r
  BasicWithEnAuthValue = AllocatePool (BasicBufSize);\r
  if (BasicWithEnAuthValue == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto Exit;\r
  }\r
\r
  //\r
  // Build encoded EnAuthValue with Basic (Basic EnAuthValue).\r
  //\r
  AsciiSPrint (\r
    BasicWithEnAuthValue,\r
    BasicBufSize,\r
    "%a %a",\r
    "Basic",\r
    EnAuthValue\r
    );\r
\r
  service->basicAuthStr = BasicWithEnAuthValue;\r
\r
Exit:\r
  if (RawAuthValue != NULL) {\r
    ZeroMem (RawAuthValue, RawAuthBufSize);\r
    FreePool (RawAuthValue);\r
  }\r
\r
  if (EnAuthValue != NULL) {\r
    ZeroMem (EnAuthValue, EnAuthValueSize);\r
    FreePool (EnAuthValue);\r
  }\r
\r
  return Status;\r
}\r
\r
static redfishService *\r
createServiceEnumeratorBasicAuth (\r
  const char    *host,\r
  const char    *rootUri,\r
  const char    *username,\r
  const char    *password,\r
  unsigned int  flags,\r
  void          *restProtocol\r
  )\r
{\r
  redfishService  *ret;\r
  EFI_STATUS      Status;\r
\r
  ret = createServiceEnumeratorNoAuth (host, rootUri, false, flags, restProtocol);\r
\r
  // add basic auth str\r
  Status = createBasicAuthStr (ret, username, password);\r
  if (EFI_ERROR (Status)) {\r
    cleanupServiceEnumerator (ret);\r
    return NULL;\r
  }\r
\r
  ret->versions = getVersions (ret, rootUri);\r
  return ret;\r
}\r
\r
static redfishService *\r
createServiceEnumeratorSessionAuth (\r
  const char    *host,\r
  const char    *rootUri,\r
  const char    *username,\r
  const char    *password,\r
  unsigned int  flags,\r
  void          *restProtocol\r
  )\r
{\r
  redfishService        *ret;\r
  redfishPayload        *payload;\r
  redfishPayload        *links;\r
  json_t                *sessionPayload;\r
  json_t                *session;\r
  json_t                *odataId;\r
  const char            *uri;\r
  json_t                *post;\r
  char                  *content;\r
  EFI_HTTP_STATUS_CODE  *StatusCode;\r
\r
  content    = NULL;\r
  StatusCode = NULL;\r
\r
  ret = createServiceEnumeratorNoAuth (host, rootUri, true, flags, restProtocol);\r
  if (ret == NULL) {\r
    return NULL;\r
  }\r
\r
  payload = getRedfishServiceRoot (ret, NULL, &StatusCode);\r
  if ((StatusCode == NULL) || (*StatusCode < HTTP_STATUS_200_OK) || (*StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT)) {\r
    if (StatusCode != NULL) {\r
      FreePool (StatusCode);\r
    }\r
\r
    if (payload != NULL) {\r
      cleanupPayload (payload);\r
    }\r
\r
    cleanupServiceEnumerator (ret);\r
    return NULL;\r
  }\r
\r
  if (StatusCode != NULL) {\r
    FreePool (StatusCode);\r
    StatusCode = NULL;\r
  }\r
\r
  links = getPayloadByNodeName (payload, "Links", &StatusCode);\r
  cleanupPayload (payload);\r
  if (links == NULL) {\r
    cleanupServiceEnumerator (ret);\r
    return NULL;\r
  }\r
\r
  session = json_object_get (links->json, "Sessions");\r
  if (session == NULL) {\r
    cleanupPayload (links);\r
    cleanupServiceEnumerator (ret);\r
    return NULL;\r
  }\r
\r
  odataId = json_object_get (session, "@odata.id");\r
  if (odataId == NULL) {\r
    cleanupPayload (links);\r
    cleanupServiceEnumerator (ret);\r
    return NULL;\r
  }\r
\r
  uri  = json_string_value (odataId);\r
  post = json_object ();\r
  addStringToJsonObject (post, "UserName", username);\r
  addStringToJsonObject (post, "Password", password);\r
  content = json_dumps (post, 0);\r
  json_decref (post);\r
  sessionPayload = postUriFromService (ret, uri, content, 0, NULL, &StatusCode);\r
\r
  if (content != NULL) {\r
    ZeroMem (content, (UINTN)strlen (content));\r
    free (content);\r
  }\r
\r
  if ((sessionPayload == NULL) || (StatusCode == NULL) || (*StatusCode < HTTP_STATUS_200_OK) || (*StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT)) {\r
    // Failed to create session!\r
\r
    cleanupPayload (links);\r
    cleanupServiceEnumerator (ret);\r
\r
    if (StatusCode != NULL) {\r
      FreePool (StatusCode);\r
    }\r
\r
    if (sessionPayload != NULL) {\r
      json_decref (sessionPayload);\r
    }\r
\r
    return NULL;\r
  }\r
\r
  json_decref (sessionPayload);\r
  cleanupPayload (links);\r
  FreePool (StatusCode);\r
  return ret;\r
}\r
\r
static char *\r
makeUrlForService (\r
  redfishService  *service,\r
  const char      *uri\r
  )\r
{\r
  char  *url;\r
\r
  if (service->host == NULL) {\r
    return NULL;\r
  }\r
\r
  url = (char *)malloc (strlen (service->host)+strlen (uri)+1);\r
  strcpy (url, service->host);\r
  strcat (url, uri);\r
  return url;\r
}\r
\r
static json_t *\r
getVersions (\r
  redfishService  *service,\r
  const char      *rootUri\r
  )\r
{\r
  json_t                *ret        = NULL;\r
  EFI_HTTP_STATUS_CODE  *StatusCode = NULL;\r
\r
  if (service->flags & REDFISH_FLAG_SERVICE_NO_VERSION_DOC) {\r
    service->versions = json_object ();\r
    if (service->versions == NULL) {\r
      return NULL;\r
    }\r
\r
    addStringToJsonObject (service->versions, "v1", "/redfish/v1");\r
    return service->versions;\r
  }\r
\r
  if (rootUri != NULL) {\r
    ret = getUriFromService (service, rootUri, &StatusCode);\r
  } else {\r
    ret = getUriFromService (service, "/redfish", &StatusCode);\r
  }\r
\r
  if ((ret == NULL) || (StatusCode == NULL) || (*StatusCode < HTTP_STATUS_200_OK) || (*StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT)) {\r
    if (ret != NULL) {\r
      json_decref (ret);\r
    }\r
\r
    ret = NULL;\r
  }\r
\r
  if (StatusCode != NULL) {\r
    FreePool (StatusCode);\r
  }\r
\r
  return ret;\r
}\r
\r
static void\r
addStringToJsonObject (\r
  json_t      *object,\r
  const char  *key,\r
  const char  *value\r
  )\r
{\r
  json_t  *jValue = json_string (value);\r
\r
  json_object_set (object, key, jValue);\r
\r
  json_decref (jValue);\r
}\r