RedfishPkg: Apply uncrustify changes

REF: https://bugzilla.tianocore.org/show_bug.cgi?id=3737

Apply uncrustify changes to .c/.h files in the RedfishPkg package

Cc: Andrew Fish <afish@apple.com>
Cc: Leif Lindholm <leif@nuviainc.com>
Cc: Michael D Kinney <michael.d.kinney@intel.com>
Signed-off-by: Michael Kubacki <michael.kubacki@microsoft.com>
Reviewed-by: Abner Chang <abner.chang@hpe.com>

1 files changed, 580 insertions, 453 deletions

diff --git a/RedfishPkg/PrivateLibrary/RedfishLib/edk2libredfish/src/service.c b/RedfishPkg/PrivateLibrary/RedfishLib/edk2libredfish/src/service.c
index edfd4fc6f9..afa172b531 100644
--- a/RedfishPkg/PrivateLibrary/RedfishLib/edk2libredfish/src/service.c
+++ b/RedfishPkg/PrivateLibrary/RedfishLib/edk2libredfish/src/service.c
@@ -19,22 +19,70 @@
 #include <redfishPayload.h>

 #include <redpath.h>

 

-static int initRest(redfishService* service, void * restProtocol);

-static redfishService* createServiceEnumeratorNoAuth(const char* host, const char* rootUri, bool enumerate, unsigned int flags, void * restProtocol);

-static redfishService* createServiceEnumeratorBasicAuth(const char* host, const char* rootUri, const char* username, const char* password, unsigned int flags, void * restProtocol);

-static redfishService* createServiceEnumeratorSessionAuth(const char* host, const char* rootUri, const char* username, const char* password, unsigned int flags, void * restProtocol);

-static char* makeUrlForService(redfishService* service, const char* uri);

-static json_t* getVersions(redfishService* service, const char* rootUri);

-static void addStringToJsonObject(json_t* object, const char* key, const char* value);

-

-CHAR16*

-C8ToC16 (CHAR8 *AsciiStr)

+static int

+initRest (

+  redfishService  *service,

+  void            *restProtocol

+  );

+

+static redfishService *

+createServiceEnumeratorNoAuth (

+  const char    *host,

+  const char    *rootUri,

+  bool          enumerate,

+  unsigned int  flags,

+  void          *restProtocol

+  );

+

+static redfishService *

+createServiceEnumeratorBasicAuth (

+  const char    *host,

+  const char    *rootUri,

+  const char    *username,

+  const char    *password,

+  unsigned int  flags,

+  void          *restProtocol

+  );

+

+static redfishService *

+createServiceEnumeratorSessionAuth (

+  const char    *host,

+  const char    *rootUri,

+  const char    *username,

+  const char    *password,

+  unsigned int  flags,

+  void          *restProtocol

+  );

+

+static char *

+makeUrlForService (

+  redfishService  *service,

+  const char      *uri

+  );

+

+static json_t *

+getVersions (

+  redfishService  *service,

+  const char      *rootUri

+  );

+

+static void

+addStringToJsonObject (

+  json_t      *object,

+  const char  *key,

+  const char  *value

+  );

+

+CHAR16 *

+C8ToC16 (

+  CHAR8  *AsciiStr

+  )

 {

-  CHAR16   *Str;

+  CHAR16  *Str;

   UINTN   BufLen;

 

   BufLen = (AsciiStrLen (AsciiStr) + 1) * 2;

-  Str = AllocatePool (BufLen);

+  Str    = AllocatePool (BufLen);

   ASSERT (Str != NULL);

 

   AsciiStrToUnicodeStrS (AsciiStr, Str, AsciiStrLen (AsciiStr) + 1);

@@ -44,11 +92,11 @@ C8ToC16 (CHAR8 *AsciiStr)
 

 VOID

 RestConfigFreeHttpRequestData (

-  IN EFI_HTTP_REQUEST_DATA        *RequestData

+  IN EFI_HTTP_REQUEST_DATA  *RequestData

   )

 {

   if (RequestData == NULL) {

-    return ;

+    return;

   }

 

   if (RequestData->Url != NULL) {

@@ -60,12 +108,12 @@ RestConfigFreeHttpRequestData (
 

 VOID

 RestConfigFreeHttpMessage (

-  IN EFI_HTTP_MESSAGE             *Message,

-  IN BOOLEAN                      IsRequest

+  IN EFI_HTTP_MESSAGE  *Message,

+  IN BOOLEAN           IsRequest

   )

 {

   if (Message == NULL) {

-    return ;

+    return;

   }

 

   if (IsRequest) {

@@ -82,6 +130,7 @@ RestConfigFreeHttpMessage (
     FreePool (Message->Headers);

     Message->Headers = NULL;

   }

+

   if (Message->Body != NULL) {

     FreePool (Message->Body);

     Message->Body = NULL;

@@ -96,17 +145,16 @@ RestConfigFreeHttpMessage (
   @return     Buffer points to ASCII string, or NULL if error happens.

 

 **/

-

 CHAR8 *

 UnicodeStrDupToAsciiStr (

-  CONST CHAR16 *String

+  CONST CHAR16  *String

   )

 {

-  CHAR8      *AsciiStr;

-  UINTN      BufLen;

-  EFI_STATUS Status;

+  CHAR8       *AsciiStr;

+  UINTN       BufLen;

+  EFI_STATUS  Status;

 

-  BufLen = StrLen (String) + 1;

+  BufLen   = StrLen (String) + 1;

   AsciiStr = AllocatePool (BufLen);

   if (AsciiStr == NULL) {

     return NULL;

@@ -119,6 +167,7 @@ UnicodeStrDupToAsciiStr (
 

   return AsciiStr;

 }

+

 /**

   This function encodes the content.

 

@@ -134,31 +183,33 @@ UnicodeStrDupToAsciiStr (
 **/

 EFI_STATUS

 EncodeRequestContent (

-  IN CHAR8 *ContentEncodedValue,

-  IN CHAR8 *OriginalContent,

-  OUT VOID **EncodedContent,

-  OUT UINTN *EncodedContentLength

-)

+  IN CHAR8   *ContentEncodedValue,

+  IN CHAR8   *OriginalContent,

+  OUT VOID   **EncodedContent,

+  OUT UINTN  *EncodedContentLength

+  )

 {

-  EFI_STATUS Status;

-  VOID *EncodedPointer;

-  UINTN EncodedLength;

+  EFI_STATUS  Status;

+  VOID        *EncodedPointer;

+  UINTN       EncodedLength;

 

-  if (OriginalContent == NULL || EncodedContent == NULL || EncodedContentLength == NULL) {

+  if ((OriginalContent == NULL) || (EncodedContent == NULL) || (EncodedContentLength == NULL)) {

     return EFI_INVALID_PARAMETER;

   }

-  Status = RedfishContentEncode  (

+

+  Status = RedfishContentEncode (

              ContentEncodedValue,

              OriginalContent,

              AsciiStrLen (OriginalContent),

              &EncodedPointer,

              &EncodedLength

-           );

+             );

   if (Status == EFI_SUCCESS) {

-    *EncodedContent = EncodedPointer;

+    *EncodedContent       = EncodedPointer;

     *EncodedContentLength = EncodedLength;

     return EFI_SUCCESS;

   }

+

   return Status;

 }

 

@@ -180,30 +231,32 @@ EncodeRequestContent (
 **/

 EFI_STATUS

 DecodeResponseContent (

-  IN CHAR8 *ContentEncodedValue,

-  IN OUT VOID **ContentPointer,

-  IN OUT UINTN *ContentLength

-)

+  IN CHAR8      *ContentEncodedValue,

+  IN OUT VOID   **ContentPointer,

+  IN OUT UINTN  *ContentLength

+  )

 {

-  EFI_STATUS Status;

-  VOID *DecodedPointer;

-  UINTN DecodedLength;

+  EFI_STATUS  Status;

+  VOID        *DecodedPointer;

+  UINTN       DecodedLength;

 

   if (ContentEncodedValue == NULL) {

     return EFI_INVALID_PARAMETER;

   }

+

   Status = RedfishContentDecode (

-              ContentEncodedValue,

-              *ContentPointer,

-              *ContentLength,

-              &DecodedPointer,

-              &DecodedLength

-              );

+             ContentEncodedValue,

+             *ContentPointer,

+             *ContentLength,

+             &DecodedPointer,

+             &DecodedLength

+             );

   if (Status == EFI_SUCCESS) {

     FreePool (*ContentPointer);

     *ContentPointer = DecodedPointer;

-    *ContentLength = DecodedLength;

+    *ContentLength  = DecodedLength;

   }

+

   return Status;

 }

 

@@ -226,15 +279,15 @@ DecodeResponseContent (
 **/

 EFI_STATUS

 RedfishBuildUrl (

-  IN  REDFISH_CONFIG_SERVICE_INFORMATION *RedfishConfigServiceInfo,

-  IN  CHAR16                        *RelativePath    OPTIONAL,

-  OUT CHAR16                        **HttpUrl

+  IN  REDFISH_CONFIG_SERVICE_INFORMATION  *RedfishConfigServiceInfo,

+  IN  CHAR16                              *RelativePath    OPTIONAL,

+  OUT CHAR16                              **HttpUrl

   )

 {

-  CHAR16                            *Url;

-  CHAR16                            *UrlHead;

-  UINTN                             UrlLength;

-  UINTN                             PathLen;

+  CHAR16  *Url;

+  CHAR16  *UrlHead;

+  UINTN   UrlLength;

+  UINTN   PathLen;

 

   if ((RedfishConfigServiceInfo == NULL) || (HttpUrl == NULL)) {

     return EFI_INVALID_PARAMETER;

@@ -248,8 +301,9 @@ RedfishBuildUrl (
   } else {

     PathLen = StrLen (RelativePath);

   }

-  UrlLength = StrLen (HTTPS_FLAG) + StrLen (REDFISH_FIRST_URL) + 1 + StrLen(RedfishConfigServiceInfo->RedfishServiceLocation) + PathLen;

-  Url = AllocateZeroPool (UrlLength * sizeof (CHAR16));

+

+  UrlLength = StrLen (HTTPS_FLAG) + StrLen (REDFISH_FIRST_URL) + 1 + StrLen (RedfishConfigServiceInfo->RedfishServiceLocation) + PathLen;

+  Url       = AllocateZeroPool (UrlLength * sizeof (CHAR16));

   if (Url == NULL) {

     return EFI_OUT_OF_RESOURCES;

   }

@@ -272,30 +326,38 @@ RedfishBuildUrl (
   //

   // Copy abs_path

   //

-  if (RelativePath != NULL && PathLen != 0 ) {

+  if ((RelativePath != NULL) && (PathLen != 0)) {

     StrnCpyS (Url, UrlLength, RelativePath, PathLen);

   }

+

   *HttpUrl = UrlHead;

   return EFI_SUCCESS;

 }

 

-redfishService* createServiceEnumerator(REDFISH_CONFIG_SERVICE_INFORMATION *RedfishConfigServiceInfo, const char* rootUri, enumeratorAuthentication* auth, unsigned int flags)

+redfishService *

+createServiceEnumerator (

+  REDFISH_CONFIG_SERVICE_INFORMATION  *RedfishConfigServiceInfo,

+  const char                          *rootUri,

+  enumeratorAuthentication            *auth,

+  unsigned int                        flags

+  )

 {

-  EFI_STATUS           Status;

-  CHAR16               *HttpUrl;

-  CHAR8                *AsciiHost;

-  EFI_REST_EX_PROTOCOL *RestEx;

-  redfishService       *ret;

+  EFI_STATUS            Status;

+  CHAR16                *HttpUrl;

+  CHAR8                 *AsciiHost;

+  EFI_REST_EX_PROTOCOL  *RestEx;

+  redfishService        *ret;

 

-  HttpUrl = NULL;

+  HttpUrl   = NULL;

   AsciiHost = NULL;

-  RestEx = NULL;

-  ret = NULL;

+  RestEx    = NULL;

+  ret       = NULL;

 

   if (RedfishConfigServiceInfo->RedfishServiceRestExHandle == NULL) {

     goto ON_EXIT;

   }

-  Status = RedfishBuildUrl(RedfishConfigServiceInfo, NULL, &HttpUrl);

+

+  Status = RedfishBuildUrl (RedfishConfigServiceInfo, NULL, &HttpUrl);

   if (EFI_ERROR (Status)) {

     goto ON_EXIT;

   }

@@ -308,19 +370,20 @@ redfishService* createServiceEnumerator(REDFISH_CONFIG_SERVICE_INFORMATION *Redf
   }

 

   Status = gBS->HandleProtocol (

-             RedfishConfigServiceInfo->RedfishServiceRestExHandle,

-             &gEfiRestExProtocolGuid,

-             (VOID **)&RestEx

-             );

+                  RedfishConfigServiceInfo->RedfishServiceRestExHandle,

+                  &gEfiRestExProtocolGuid,

+                  (VOID **)&RestEx

+                  );

   if (EFI_ERROR (Status)) {

     goto ON_EXIT;

   }

-  if(auth == NULL) {

-    ret = createServiceEnumeratorNoAuth(AsciiHost, rootUri, true, flags, RestEx);

-  } else if(auth->authType == REDFISH_AUTH_BASIC) {

-    ret = createServiceEnumeratorBasicAuth(AsciiHost, rootUri, auth->authCodes.userPass.username, auth->authCodes.userPass.password, flags, RestEx);

-  } else if(auth->authType == REDFISH_AUTH_SESSION) {

-    ret = createServiceEnumeratorSessionAuth(AsciiHost, rootUri, auth->authCodes.userPass.username, auth->authCodes.userPass.password, flags, RestEx);

+

+  if (auth == NULL) {

+    ret = createServiceEnumeratorNoAuth (AsciiHost, rootUri, true, flags, RestEx);

+  } else if (auth->authType == REDFISH_AUTH_BASIC) {

+    ret = createServiceEnumeratorBasicAuth (AsciiHost, rootUri, auth->authCodes.userPass.username, auth->authCodes.userPass.password, flags, RestEx);

+  } else if (auth->authType == REDFISH_AUTH_SESSION) {

+    ret = createServiceEnumeratorSessionAuth (AsciiHost, rootUri, auth->authCodes.userPass.username, auth->authCodes.userPass.password, flags, RestEx);

   } else {

     goto ON_EXIT;

   }

@@ -338,31 +401,34 @@ ON_EXIT:
   return ret;

 }

 

-json_t* getUriFromService(redfishService* service, const char* uri, EFI_HTTP_STATUS_CODE** StatusCode)

+json_t *

+getUriFromService (

+  redfishService        *service,

+  const char            *uri,

+  EFI_HTTP_STATUS_CODE  **StatusCode

+  )

 {

-  char* url;

-  json_t* ret;

-  HTTP_IO_HEADER                    *HttpIoHeader = NULL;

-  EFI_STATUS                        Status;

-  EFI_HTTP_REQUEST_DATA             *RequestData = NULL;

-  EFI_HTTP_MESSAGE                  *RequestMsg = NULL;

-  EFI_HTTP_MESSAGE                  ResponseMsg;

-  EFI_HTTP_HEADER                   *ContentEncodedHeader;

-

-  if(service == NULL || uri == NULL || StatusCode == NULL)

-  {

-      return NULL;

+  char                   *url;

+  json_t                 *ret;

+  HTTP_IO_HEADER         *HttpIoHeader = NULL;

+  EFI_STATUS             Status;

+  EFI_HTTP_REQUEST_DATA  *RequestData = NULL;

+  EFI_HTTP_MESSAGE       *RequestMsg  = NULL;

+  EFI_HTTP_MESSAGE       ResponseMsg;

+  EFI_HTTP_HEADER        *ContentEncodedHeader;

+

+  if ((service == NULL) || (uri == NULL) || (StatusCode == NULL)) {

+    return NULL;

   }

 

   *StatusCode = NULL;

 

-  url = makeUrlForService(service, uri);

-  if(!url)

-  {

-      return NULL;

+  url = makeUrlForService (service, uri);

+  if (!url) {

+    return NULL;

   }

 

-  DEBUG((DEBUG_INFO, "libredfish: getUriFromService(): %a\n", url));

+  DEBUG ((DEBUG_INFO, "libredfish: getUriFromService(): %a\n", url));

 

   //

   // Step 1: Create HTTP request message with 4 headers:

@@ -373,8 +439,7 @@ json_t* getUriFromService(redfishService* service, const char* uri, EFI_HTTP_STA
     goto ON_EXIT;

   }

 

-  if(service->sessionToken)

-  {

+  if (service->sessionToken) {

     Status = HttpIoSetHeader (HttpIoHeader, "X-Auth-Token", service->sessionToken);

     ASSERT_EFI_ERROR (Status);

   } else if (service->basicAuthStr) {

@@ -403,7 +468,7 @@ json_t* getUriFromService(redfishService* service, const char* uri, EFI_HTTP_STA
   }

 

   RequestData->Method = HttpMethodGet;

-  RequestData->Url = C8ToC16 (url);

+  RequestData->Url    = C8ToC16 (url);

 

   //

   // Step 3: fill in EFI_HTTP_MESSAGE

@@ -445,7 +510,7 @@ json_t* getUriFromService(redfishService* service, const char* uri, EFI_HTTP_STA
     **StatusCode = ResponseMsg.Data.Response->StatusCode;

   }

 

-  if (ResponseMsg.BodyLength != 0 && ResponseMsg.Body != NULL) {

+  if ((ResponseMsg.BodyLength != 0) && (ResponseMsg.Body != NULL)) {

     //

     // Check if data is encoded.

     //

@@ -461,6 +526,7 @@ json_t* getUriFromService(redfishService* service, const char* uri, EFI_HTTP_STA
         goto ON_EXIT;

       }

     }

+

     ret = json_loadb (ResponseMsg.Body, ResponseMsg.BodyLength, 0, NULL);

   } else {

     //

@@ -491,33 +557,37 @@ ON_EXIT:
   return ret;

 }

 

-json_t* patchUriFromService(redfishService* service, const char* uri, const char* content, EFI_HTTP_STATUS_CODE** StatusCode)

+json_t *

+patchUriFromService (

+  redfishService        *service,

+  const char            *uri,

+  const char            *content,

+  EFI_HTTP_STATUS_CODE  **StatusCode

+  )

 {

-  char*               url;

-  json_t*             ret;

-  HTTP_IO_HEADER                    *HttpIoHeader = NULL;

-  EFI_STATUS                        Status;

-  EFI_HTTP_REQUEST_DATA             *RequestData = NULL;

-  EFI_HTTP_MESSAGE                  *RequestMsg = NULL;

-  EFI_HTTP_MESSAGE                  ResponseMsg;

-  CHAR8                             ContentLengthStr[80];

-  CHAR8                             *EncodedContent;

-  UINTN                             EncodedContentLen;

-

-  if(service == NULL || uri == NULL || content == NULL || StatusCode == NULL)

-  {

-      return NULL;

+  char                   *url;

+  json_t                 *ret;

+  HTTP_IO_HEADER         *HttpIoHeader = NULL;

+  EFI_STATUS             Status;

+  EFI_HTTP_REQUEST_DATA  *RequestData = NULL;

+  EFI_HTTP_MESSAGE       *RequestMsg  = NULL;

+  EFI_HTTP_MESSAGE       ResponseMsg;

+  CHAR8                  ContentLengthStr[80];

+  CHAR8                  *EncodedContent;

+  UINTN                  EncodedContentLen;

+

+  if ((service == NULL) || (uri == NULL) || (content == NULL) || (StatusCode == NULL)) {

+    return NULL;

   }

 

   *StatusCode = NULL;

 

-  url = makeUrlForService(service, uri);

-  if(!url)

-  {

-      return NULL;

+  url = makeUrlForService (service, uri);

+  if (!url) {

+    return NULL;

   }

 

-  DEBUG((DEBUG_INFO, "libredfish: patchUriFromService(): %a\n", url));

+  DEBUG ((DEBUG_INFO, "libredfish: patchUriFromService(): %a\n", url));

 

   //

   // Step 1: Create HTTP request message with 4 headers:

@@ -528,8 +598,7 @@ json_t* patchUriFromService(redfishService* service, const char* uri, const char
     goto ON_EXIT;

   }

 

-  if(service->sessionToken)

-  {

+  if (service->sessionToken) {

     Status = HttpIoSetHeader (HttpIoHeader, "X-Auth-Token", service->sessionToken);

     ASSERT_EFI_ERROR (Status);

   } else if (service->basicAuthStr) {

@@ -548,11 +617,11 @@ json_t* patchUriFromService(redfishService* service, const char* uri, const char
   Status = HttpIoSetHeader (HttpIoHeader, "Connection", "Keep-Alive");

   ASSERT_EFI_ERROR (Status);

 

-  AsciiSPrint(

+  AsciiSPrint (

     ContentLengthStr,

     sizeof (ContentLengthStr),

     "%lu",

-    (UINT64) strlen(content)

+    (UINT64)strlen (content)

     );

   Status = HttpIoSetHeader (HttpIoHeader, "Content-Length", ContentLengthStr);

   ASSERT_EFI_ERROR (Status);

@@ -569,7 +638,7 @@ json_t* patchUriFromService(redfishService* service, const char* uri, const char
   }

 

   RequestData->Method = HttpMethodPatch;

-  RequestData->Url = C8ToC16 (url);

+  RequestData->Url    = C8ToC16 (url);

 

   //

   // Step 3: fill in EFI_HTTP_MESSAGE

@@ -580,18 +649,18 @@ json_t* patchUriFromService(redfishService* service, const char* uri, const char
     goto ON_EXIT;

   }

 

-  EncodedContent = (CHAR8 *)content;

-  EncodedContentLen = strlen(content);

+  EncodedContent    = (CHAR8 *)content;

+  EncodedContentLen = strlen (content);

   //

   // We currently only support gzip Content-Encoding.

   //

   Status = EncodeRequestContent ((CHAR8 *)HTTP_CONTENT_ENCODING_GZIP, (CHAR8 *)content, (VOID **)&EncodedContent, &EncodedContentLen);

   if (Status == EFI_INVALID_PARAMETER) {

-    DEBUG((DEBUG_ERROR, "%a: Error to encode content.\n", __FUNCTION__));

+    DEBUG ((DEBUG_ERROR, "%a: Error to encode content.\n", __FUNCTION__));

     ret = NULL;

     goto ON_EXIT;

   } else if (Status == EFI_UNSUPPORTED) {

-    DEBUG((DEBUG_INFO, "No content coding for %a! Use raw data instead.\n", HTTP_CONTENT_ENCODING_GZIP));

+    DEBUG ((DEBUG_INFO, "No content coding for %a! Use raw data instead.\n", HTTP_CONTENT_ENCODING_GZIP));

     Status = HttpIoSetHeader (HttpIoHeader, "Content-Encoding", HTTP_CONTENT_ENCODING_IDENTITY);

     ASSERT_EFI_ERROR (Status);

   } else {

@@ -603,7 +672,7 @@ json_t* patchUriFromService(redfishService* service, const char* uri, const char
   RequestMsg->HeaderCount  = HttpIoHeader->HeaderCount;

   RequestMsg->Headers      = HttpIoHeader->Headers;

   RequestMsg->BodyLength   = EncodedContentLen;

-  RequestMsg->Body         = (VOID*) EncodedContent;

+  RequestMsg->Body         = (VOID *)EncodedContent;

 

   ZeroMem (&ResponseMsg, sizeof (ResponseMsg));

 

@@ -636,8 +705,7 @@ json_t* patchUriFromService(redfishService* service, const char* uri, const char
     FreePool (EncodedContent);

   }

 

-

-  if (ResponseMsg.BodyLength != 0 && ResponseMsg.Body != NULL) {

+  if ((ResponseMsg.BodyLength != 0) && (ResponseMsg.Body != NULL)) {

     ret = json_loadb (ResponseMsg.Body, ResponseMsg.BodyLength, 0, NULL);

   } else {

     //

@@ -668,38 +736,43 @@ ON_EXIT:
   return ret;

 }

 

-json_t* postUriFromService(redfishService* service, const char* uri, const char* content, size_t contentLength, const char* contentType, EFI_HTTP_STATUS_CODE** StatusCode)

+json_t *

+postUriFromService (

+  redfishService        *service,

+  const char            *uri,

+  const char            *content,

+  size_t                contentLength,

+  const char            *contentType,

+  EFI_HTTP_STATUS_CODE  **StatusCode

+  )

 {

-  char*               url = NULL;

-  json_t*             ret;

-  HTTP_IO_HEADER                    *HttpIoHeader = NULL;

-  EFI_STATUS                        Status;

-  EFI_HTTP_REQUEST_DATA             *RequestData = NULL;

-  EFI_HTTP_MESSAGE                  *RequestMsg = NULL;

-  EFI_HTTP_MESSAGE                  ResponseMsg;

-  CHAR8                             ContentLengthStr[80];

-  EFI_HTTP_HEADER                   *HttpHeader = NULL;

+  char                   *url = NULL;

+  json_t                 *ret;

+  HTTP_IO_HEADER         *HttpIoHeader = NULL;

+  EFI_STATUS             Status;

+  EFI_HTTP_REQUEST_DATA  *RequestData = NULL;

+  EFI_HTTP_MESSAGE       *RequestMsg  = NULL;

+  EFI_HTTP_MESSAGE       ResponseMsg;

+  CHAR8                  ContentLengthStr[80];

+  EFI_HTTP_HEADER        *HttpHeader = NULL;

 

   ret = NULL;

 

-  if(service == NULL || uri == NULL || content == NULL || StatusCode == NULL)

-  {

-      return NULL;

+  if ((service == NULL) || (uri == NULL) || (content == NULL) || (StatusCode == NULL)) {

+    return NULL;

   }

 

   *StatusCode = NULL;

 

-  url = makeUrlForService(service, uri);

-  if(!url)

-  {

-      return NULL;

+  url = makeUrlForService (service, uri);

+  if (!url) {

+    return NULL;

   }

 

-  DEBUG((DEBUG_INFO, "libredfish: postUriFromService(): %a\n", url));

+  DEBUG ((DEBUG_INFO, "libredfish: postUriFromService(): %a\n", url));

 

-  if(contentLength == 0)

-  {

-      contentLength = strlen(content);

+  if (contentLength == 0) {

+    contentLength = strlen (content);

   }

 

   //

@@ -710,8 +783,7 @@ json_t* postUriFromService(redfishService* service, const char* uri, const char*
     goto ON_EXIT;

   }

 

-  if(service->sessionToken)

-  {

+  if (service->sessionToken) {

     Status = HttpIoSetHeader (HttpIoHeader, "X-Auth-Token", service->sessionToken);

     ASSERT_EFI_ERROR (Status);

   } else if (service->basicAuthStr) {

@@ -719,13 +791,14 @@ json_t* postUriFromService(redfishService* service, const char* uri, const char*
     ASSERT_EFI_ERROR (Status);

   }

 

-  if(contentType == NULL) {

+  if (contentType == NULL) {

     Status = HttpIoSetHeader (HttpIoHeader, "Content-Type", "application/json");

     ASSERT_EFI_ERROR (Status);

   } else {

-    Status = HttpIoSetHeader (HttpIoHeader, "Content-Type", (CHAR8 *) contentType);

+    Status = HttpIoSetHeader (HttpIoHeader, "Content-Type", (CHAR8 *)contentType);

     ASSERT_EFI_ERROR (Status);

   }

+

   Status = HttpIoSetHeader (HttpIoHeader, "Host", service->HostHeaderValue);

   ASSERT_EFI_ERROR (Status);

   Status = HttpIoSetHeader (HttpIoHeader, "Accept", "application/json");

@@ -734,11 +807,11 @@ json_t* postUriFromService(redfishService* service, const char* uri, const char*
   ASSERT_EFI_ERROR (Status);

   Status = HttpIoSetHeader (HttpIoHeader, "Connection", "Keep-Alive");

   ASSERT_EFI_ERROR (Status);

-  AsciiSPrint(

+  AsciiSPrint (

     ContentLengthStr,

     sizeof (ContentLengthStr),

     "%lu",

-    (UINT64) contentLength

+    (UINT64)contentLength

     );

   Status = HttpIoSetHeader (HttpIoHeader, "Content-Length", ContentLengthStr);

   ASSERT_EFI_ERROR (Status);

@@ -754,7 +827,7 @@ json_t* postUriFromService(redfishService* service, const char* uri, const char*
   }

 

   RequestData->Method = HttpMethodPost;

-  RequestData->Url = C8ToC16 (url);

+  RequestData->Url    = C8ToC16 (url);

 

   //

   // Step 3: fill in EFI_HTTP_MESSAGE

@@ -768,7 +841,7 @@ json_t* postUriFromService(redfishService* service, const char* uri, const char*
   RequestMsg->HeaderCount  = HttpIoHeader->HeaderCount;

   RequestMsg->Headers      = HttpIoHeader->Headers;

   RequestMsg->BodyLength   = contentLength;

-  RequestMsg->Body         = (VOID*) content;

+  RequestMsg->Body         = (VOID *)content;

 

   ZeroMem (&ResponseMsg, sizeof (ResponseMsg));

 

@@ -795,21 +868,22 @@ json_t* postUriFromService(redfishService* service, const char* uri, const char*
     **StatusCode = ResponseMsg.Data.Response->StatusCode;

   }

 

-  if (ResponseMsg.BodyLength != 0 && ResponseMsg.Body != NULL) {

+  if ((ResponseMsg.BodyLength != 0) && (ResponseMsg.Body != NULL)) {

     ret = json_loadb (ResponseMsg.Body, ResponseMsg.BodyLength, 0, NULL);

   }

 

   //

   // Step 6: Parsing the HttpHeader to retrive the X-Auth-Token if the HTTP StatusCode is correct.

   //

-  if (ResponseMsg.Data.Response->StatusCode == HTTP_STATUS_200_OK ||

-      ResponseMsg.Data.Response->StatusCode == HTTP_STATUS_204_NO_CONTENT) {

+  if ((ResponseMsg.Data.Response->StatusCode == HTTP_STATUS_200_OK) ||

+      (ResponseMsg.Data.Response->StatusCode == HTTP_STATUS_204_NO_CONTENT))

+  {

     HttpHeader = HttpFindHeader (ResponseMsg.HeaderCount, ResponseMsg.Headers, "X-Auth-Token");

     if (HttpHeader != NULL) {

-      if(service->sessionToken)

-      {

-          free(service->sessionToken);

+      if (service->sessionToken) {

+        free (service->sessionToken);

       }

+

       service->sessionToken = AllocateCopyPool (AsciiStrSize (HttpHeader->FieldValue), HttpHeader->FieldValue);

     }

 

@@ -849,32 +923,35 @@ ON_EXIT:
   return ret;

 }

 

-json_t* deleteUriFromService(redfishService* service, const char* uri, EFI_HTTP_STATUS_CODE** StatusCode)

+json_t *

+deleteUriFromService (

+  redfishService        *service,

+  const char            *uri,

+  EFI_HTTP_STATUS_CODE  **StatusCode

+  )

 {

-  char*               url;

-  json_t*             ret;

-  HTTP_IO_HEADER                    *HttpIoHeader = NULL;

-  EFI_STATUS                        Status;

-  EFI_HTTP_REQUEST_DATA             *RequestData = NULL;

-  EFI_HTTP_MESSAGE                  *RequestMsg = NULL;

-  EFI_HTTP_MESSAGE                  ResponseMsg;

+  char                   *url;

+  json_t                 *ret;

+  HTTP_IO_HEADER         *HttpIoHeader = NULL;

+  EFI_STATUS             Status;

+  EFI_HTTP_REQUEST_DATA  *RequestData = NULL;

+  EFI_HTTP_MESSAGE       *RequestMsg  = NULL;

+  EFI_HTTP_MESSAGE       ResponseMsg;

 

   ret = NULL;

 

-  if(service == NULL || uri == NULL || StatusCode == NULL)

-  {

-      return NULL;

+  if ((service == NULL) || (uri == NULL) || (StatusCode == NULL)) {

+    return NULL;

   }

 

   *StatusCode = NULL;

 

-  url = makeUrlForService(service, uri);

-  if(!url)

-  {

-      return NULL;

+  url = makeUrlForService (service, uri);

+  if (!url) {

+    return NULL;

   }

 

-  DEBUG((DEBUG_INFO, "libredfish: deleteUriFromService(): %a\n", url));

+  DEBUG ((DEBUG_INFO, "libredfish: deleteUriFromService(): %a\n", url));

 

   //

   // Step 1: Create HTTP request message with 4 headers:

@@ -885,14 +962,14 @@ json_t* deleteUriFromService(redfishService* service, const char* uri, EFI_HTTP_
     goto ON_EXIT;

   }

 

-  if(service->sessionToken)

-  {

+  if (service->sessionToken) {

     Status = HttpIoSetHeader (HttpIoHeader, "X-Auth-Token", service->sessionToken);

     ASSERT_EFI_ERROR (Status);

   } else if (service->basicAuthStr) {

     Status = HttpIoSetHeader (HttpIoHeader, "Authorization", service->basicAuthStr);

     ASSERT_EFI_ERROR (Status);

   }

+

   Status = HttpIoSetHeader (HttpIoHeader, "Host", service->HostHeaderValue);

   ASSERT_EFI_ERROR (Status);

   Status = HttpIoSetHeader (HttpIoHeader, "User-Agent", "libredfish");

@@ -912,7 +989,7 @@ json_t* deleteUriFromService(redfishService* service, const char* uri, EFI_HTTP_
   }

 

   RequestData->Method = HttpMethodDelete;

-  RequestData->Url = C8ToC16 (url);

+  RequestData->Url    = C8ToC16 (url);

 

   //

   // Step 3: fill in EFI_HTTP_MESSAGE

@@ -954,7 +1031,7 @@ json_t* deleteUriFromService(redfishService* service, const char* uri, EFI_HTTP_
     **StatusCode = ResponseMsg.Data.Response->StatusCode;

   }

 

-  if (ResponseMsg.BodyLength != 0 && ResponseMsg.Body != NULL) {

+  if ((ResponseMsg.BodyLength != 0) && (ResponseMsg.Body != NULL)) {

     ret = json_loadb (ResponseMsg.Body, ResponseMsg.BodyLength, 0, NULL);

   }

 

@@ -980,169 +1057,191 @@ ON_EXIT:
   return ret;

 }

 

-redfishPayload* getRedfishServiceRoot(redfishService* service, const char* version, EFI_HTTP_STATUS_CODE** StatusCode)

+redfishPayload *

+getRedfishServiceRoot (

+  redfishService        *service,

+  const char            *version,

+  EFI_HTTP_STATUS_CODE  **StatusCode

+  )

 {

-    json_t* value;

-    json_t* versionNode;

-    const char* verUrl;

+  json_t      *value;

+  json_t      *versionNode;

+  const char  *verUrl;

 

-    if(version == NULL)

-    {

-        versionNode = json_object_get(service->versions, "v1");

-    }

-    else

-    {

-        versionNode = json_object_get(service->versions, version);

-    }

-    if(versionNode == NULL)

-    {

-        return NULL;

-    }

-    verUrl = json_string_value(versionNode);

-    if(verUrl == NULL)

-    {

-        return NULL;

-    }

-    value = getUriFromService(service, verUrl, StatusCode);

-    if(value == NULL)

-    {

-        if((service->flags & REDFISH_FLAG_SERVICE_NO_VERSION_DOC) == 0)

-        {

-            json_decref(versionNode);

-        }

-        return NULL;

+  if (version == NULL) {

+    versionNode = json_object_get (service->versions, "v1");

+  } else {

+    versionNode = json_object_get (service->versions, version);

+  }

+

+  if (versionNode == NULL) {

+    return NULL;

+  }

+

+  verUrl = json_string_value (versionNode);

+  if (verUrl == NULL) {

+    return NULL;

+  }

+

+  value = getUriFromService (service, verUrl, StatusCode);

+  if (value == NULL) {

+    if ((service->flags & REDFISH_FLAG_SERVICE_NO_VERSION_DOC) == 0) {

+      json_decref (versionNode);

     }

-    return createRedfishPayload(value, service);

+

+    return NULL;

+  }

+

+  return createRedfishPayload (value, service);

 }

 

-redfishPayload* getPayloadByPath(redfishService* service, const char* path, EFI_HTTP_STATUS_CODE** StatusCode)

+redfishPayload *

+getPayloadByPath (

+  redfishService        *service,

+  const char            *path,

+  EFI_HTTP_STATUS_CODE  **StatusCode

+  )

 {

-    redPathNode* redpath;

-    redfishPayload* root;

-    redfishPayload* ret;

+  redPathNode     *redpath;

+  redfishPayload  *root;

+  redfishPayload  *ret;

 

-    if(!service || !path || StatusCode == NULL)

-    {

-        return NULL;

-    }

+  if (!service || !path || (StatusCode == NULL)) {

+    return NULL;

+  }

 

-    *StatusCode = NULL;

+  *StatusCode = NULL;

 

-    redpath = parseRedPath(path);

-    if(!redpath)

-    {

-        return NULL;

-    }

-    if(!redpath->isRoot)

-    {

-        cleanupRedPath(redpath);

-        return NULL;

-    }

-    root = getRedfishServiceRoot(service, redpath->version, StatusCode);

-    if (*StatusCode == NULL || **StatusCode < HTTP_STATUS_200_OK || **StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT) {

-      cleanupRedPath(redpath);

-      return root;

-    }

+  redpath = parseRedPath (path);

+  if (!redpath) {

+    return NULL;

+  }

 

-    if(redpath->next == NULL)

-    {

-        cleanupRedPath(redpath);

-        return root;

-    }

+  if (!redpath->isRoot) {

+    cleanupRedPath (redpath);

+    return NULL;

+  }

 

-    FreePool (*StatusCode);

-    *StatusCode = NULL;

+  root = getRedfishServiceRoot (service, redpath->version, StatusCode);

+  if ((*StatusCode == NULL) || (**StatusCode < HTTP_STATUS_200_OK) || (**StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT)) {

+    cleanupRedPath (redpath);

+    return root;

+  }

 

-    ret = getPayloadForPath(root, redpath->next, StatusCode);

-    if (*StatusCode == NULL && ret != NULL) {

-      //

-      // In such a case, the Redfish resource is parsed from the input payload (root) directly.

-      // So, we still return HTTP_STATUS_200_OK.

-      //

-      *StatusCode = AllocateZeroPool (sizeof (EFI_HTTP_STATUS_CODE));

-      if (*StatusCode == NULL) {

-        ret = NULL;

-      } else {

-        **StatusCode = HTTP_STATUS_200_OK;

-      }

+  if (redpath->next == NULL) {

+    cleanupRedPath (redpath);

+    return root;

+  }

+

+  FreePool (*StatusCode);

+  *StatusCode = NULL;

+

+  ret = getPayloadForPath (root, redpath->next, StatusCode);

+  if ((*StatusCode == NULL) && (ret != NULL)) {

+    //

+    // In such a case, the Redfish resource is parsed from the input payload (root) directly.

+    // So, we still return HTTP_STATUS_200_OK.

+    //

+    *StatusCode = AllocateZeroPool (sizeof (EFI_HTTP_STATUS_CODE));

+    if (*StatusCode == NULL) {

+      ret = NULL;

+    } else {

+      **StatusCode = HTTP_STATUS_200_OK;

     }

-    cleanupPayload(root);

-    cleanupRedPath(redpath);

-    return ret;

+  }

+

+  cleanupPayload (root);

+  cleanupRedPath (redpath);

+  return ret;

 }

 

-void cleanupServiceEnumerator(redfishService* service)

+void

+cleanupServiceEnumerator (

+  redfishService  *service

+  )

 {

-  if(!service)

-  {

-      return;

+  if (!service) {

+    return;

   }

-  free(service->host);

-  json_decref(service->versions);

-  if(service->sessionToken != NULL)

-  {

-      ZeroMem (service->sessionToken, (UINTN)strlen(service->sessionToken));

-      FreePool(service->sessionToken);

+

+  free (service->host);

+  json_decref (service->versions);

+  if (service->sessionToken != NULL) {

+    ZeroMem (service->sessionToken, (UINTN)strlen (service->sessionToken));

+    FreePool (service->sessionToken);

   }

+

   if (service->basicAuthStr != NULL) {

-      ZeroMem (service->basicAuthStr, (UINTN)strlen(service->basicAuthStr));

-      FreePool (service->basicAuthStr);

+    ZeroMem (service->basicAuthStr, (UINTN)strlen (service->basicAuthStr));

+    FreePool (service->basicAuthStr);

   }

-  free(service);

+

+  free (service);

 }

 

-static int initRest(redfishService* service, void * restProtocol)

+static int

+initRest (

+  redfishService  *service,

+  void            *restProtocol

+  )

 {

   service->RestEx = restProtocol;

   return 0;

 }

 

-static redfishService* createServiceEnumeratorNoAuth(const char* host, const char* rootUri, bool enumerate, unsigned int flags, void * restProtocol)

+static redfishService *

+createServiceEnumeratorNoAuth (

+  const char    *host,

+  const char    *rootUri,

+  bool          enumerate,

+  unsigned int  flags,

+  void          *restProtocol

+  )

 {

-    redfishService* ret;

-    char  *HostStart;

-

-    ret = (redfishService*)calloc(1, sizeof(redfishService));

-    ZeroMem (ret, sizeof(redfishService));

-    if(initRest(ret, restProtocol) != 0)

-    {

-        free(ret);

-        return NULL;

-    }

-    ret->host = AllocateCopyPool(AsciiStrSize(host), host);

-    ret->flags = flags;

-    if(enumerate)

-    {

-        ret->versions = getVersions(ret, rootUri);

-    }

-    HostStart = strstr (ret->host, "//");

-    if (HostStart != NULL && (*(HostStart + 2) != '\0')) {

-      ret->HostHeaderValue = HostStart + 2;

-    }

+  redfishService  *ret;

+  char            *HostStart;

+

+  ret = (redfishService *)calloc (1, sizeof (redfishService));

+  ZeroMem (ret, sizeof (redfishService));

+  if (initRest (ret, restProtocol) != 0) {

+    free (ret);

+    return NULL;

+  }

+

+  ret->host  = AllocateCopyPool (AsciiStrSize (host), host);

+  ret->flags = flags;

+  if (enumerate) {

+    ret->versions = getVersions (ret, rootUri);

+  }

 

-    return ret;

+  HostStart = strstr (ret->host, "//");

+  if ((HostStart != NULL) && (*(HostStart + 2) != '\0')) {

+    ret->HostHeaderValue = HostStart + 2;

+  }

+

+  return ret;

 }

 

 EFI_STATUS

 createBasicAuthStr (

-  IN  redfishService*                         service,

-  IN  CONST CHAR8                             *UserId,

-  IN  CONST CHAR8                             *Password

+  IN  redfishService  *service,

+  IN  CONST CHAR8     *UserId,

+  IN  CONST CHAR8     *Password

   )

 {

-  EFI_STATUS                        Status;

-  CHAR8                             *RawAuthValue;

-  UINTN                             RawAuthBufSize;

-  CHAR8                             *EnAuthValue;

-  UINTN                             EnAuthValueSize;

-  CHAR8                             *BasicWithEnAuthValue;

-  UINTN                             BasicBufSize;

+  EFI_STATUS  Status;

+  CHAR8       *RawAuthValue;

+  UINTN       RawAuthBufSize;

+  CHAR8       *EnAuthValue;

+  UINTN       EnAuthValueSize;

+  CHAR8       *BasicWithEnAuthValue;

+  UINTN       BasicBufSize;

 

   EnAuthValue     = NULL;

   EnAuthValueSize = 0;

 

   RawAuthBufSize = AsciiStrLen (UserId) + AsciiStrLen (Password) + 2;

-  RawAuthValue = AllocatePool (RawAuthBufSize);

+  RawAuthValue   = AllocatePool (RawAuthBufSize);

   if (RawAuthValue == NULL) {

     return EFI_OUT_OF_RESOURCES;

   }

@@ -1162,20 +1261,20 @@ createBasicAuthStr (
   // Encoding RawAuthValue into Base64 format.

   //

   Status = Base64Encode (

-             (CONST UINT8 *) RawAuthValue,

+             (CONST UINT8 *)RawAuthValue,

              AsciiStrLen (RawAuthValue),

              EnAuthValue,

              &EnAuthValueSize

              );

   if (Status == EFI_BUFFER_TOO_SMALL) {

-    EnAuthValue = (CHAR8 *) AllocateZeroPool (EnAuthValueSize);

+    EnAuthValue = (CHAR8 *)AllocateZeroPool (EnAuthValueSize);

     if (EnAuthValue == NULL) {

       Status = EFI_OUT_OF_RESOURCES;

       return Status;

     }

 

     Status = Base64Encode (

-               (CONST UINT8 *) RawAuthValue,

+               (CONST UINT8 *)RawAuthValue,

                AsciiStrLen (RawAuthValue),

                EnAuthValue,

                &EnAuthValueSize

@@ -1186,7 +1285,7 @@ createBasicAuthStr (
     goto Exit;

   }

 

-  BasicBufSize = AsciiStrLen ("Basic ") + AsciiStrLen(EnAuthValue) + 2;

+  BasicBufSize         = AsciiStrLen ("Basic ") + AsciiStrLen (EnAuthValue) + 2;

   BasicWithEnAuthValue = AllocatePool (BasicBufSize);

   if (BasicWithEnAuthValue == NULL) {

     Status = EFI_OUT_OF_RESOURCES;

@@ -1220,177 +1319,205 @@ Exit:
   return Status;

 }

 

-static redfishService* createServiceEnumeratorBasicAuth(const char* host, const char* rootUri, const char* username, const char* password, unsigned int flags, void * restProtocol)

+static redfishService *

+createServiceEnumeratorBasicAuth (

+  const char    *host,

+  const char    *rootUri,

+  const char    *username,

+  const char    *password,

+  unsigned int  flags,

+  void          *restProtocol

+  )

 {

-    redfishService* ret;

-    EFI_STATUS   Status;

+  redfishService  *ret;

+  EFI_STATUS      Status;

 

-    ret = createServiceEnumeratorNoAuth(host, rootUri, false, flags, restProtocol);

+  ret = createServiceEnumeratorNoAuth (host, rootUri, false, flags, restProtocol);

 

-    // add basic auth str

-    Status = createBasicAuthStr (ret, username, password);

-    if (EFI_ERROR(Status)) {

-      cleanupServiceEnumerator (ret);

-      return NULL;

-    }

+  // add basic auth str

+  Status = createBasicAuthStr (ret, username, password);

+  if (EFI_ERROR (Status)) {

+    cleanupServiceEnumerator (ret);

+    return NULL;

+  }

 

-    ret->versions = getVersions(ret, rootUri);

-    return ret;

+  ret->versions = getVersions (ret, rootUri);

+  return ret;

 }

 

-static redfishService* createServiceEnumeratorSessionAuth(const char* host, const char* rootUri, const char* username, const char* password, unsigned int flags, void * restProtocol)

+static redfishService *

+createServiceEnumeratorSessionAuth (

+  const char    *host,

+  const char    *rootUri,

+  const char    *username,

+  const char    *password,

+  unsigned int  flags,

+  void          *restProtocol

+  )

 {

-    redfishService* ret;

-    redfishPayload* payload;

-    redfishPayload* links;

-    json_t* sessionPayload;

-    json_t* session;

-    json_t* odataId;

-    const char* uri;

-    json_t* post;

-    char* content;

-    EFI_HTTP_STATUS_CODE *StatusCode;

-

-    content = NULL;

-    StatusCode = NULL;

-

-    ret = createServiceEnumeratorNoAuth(host, rootUri, true, flags, restProtocol);

-    if(ret == NULL)

-    {

-        return NULL;

-    }

-    payload = getRedfishServiceRoot(ret, NULL, &StatusCode);

-    if(StatusCode == NULL || *StatusCode < HTTP_STATUS_200_OK || *StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT)

-    {

-        if (StatusCode != NULL) {

-          FreePool (StatusCode);

-        }

-

-        if (payload != NULL) {

-          cleanupPayload(payload);

-        }

-        cleanupServiceEnumerator(ret);

-        return NULL;

-    }

+  redfishService        *ret;

+  redfishPayload        *payload;

+  redfishPayload        *links;

+  json_t                *sessionPayload;

+  json_t                *session;

+  json_t                *odataId;

+  const char            *uri;

+  json_t                *post;

+  char                  *content;

+  EFI_HTTP_STATUS_CODE  *StatusCode;

+

+  content    = NULL;

+  StatusCode = NULL;

+

+  ret = createServiceEnumeratorNoAuth (host, rootUri, true, flags, restProtocol);

+  if (ret == NULL) {

+    return NULL;

+  }

 

+  payload = getRedfishServiceRoot (ret, NULL, &StatusCode);

+  if ((StatusCode == NULL) || (*StatusCode < HTTP_STATUS_200_OK) || (*StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT)) {

     if (StatusCode != NULL) {

       FreePool (StatusCode);

-      StatusCode = NULL;

     }

 

-    links = getPayloadByNodeName(payload, "Links", &StatusCode);

-    cleanupPayload(payload);

-    if(links == NULL)

-    {

-        cleanupServiceEnumerator(ret);

-        return NULL;

-    }

-    session = json_object_get(links->json, "Sessions");

-    if(session == NULL)

-    {

-        cleanupPayload(links);

-        cleanupServiceEnumerator(ret);

-        return NULL;

-    }

-    odataId = json_object_get(session, "@odata.id");

-    if(odataId == NULL)

-    {

-        cleanupPayload(links);

-        cleanupServiceEnumerator(ret);

-        return NULL;

-    }

-    uri = json_string_value(odataId);

-    post = json_object();

-    addStringToJsonObject(post, "UserName", username);

-    addStringToJsonObject(post, "Password", password);

-    content = json_dumps(post, 0);

-    json_decref(post);

-    sessionPayload = postUriFromService(ret, uri, content, 0, NULL, &StatusCode);

-

-    if (content != NULL) {

-      ZeroMem (content, (UINTN)strlen(content));

-      free(content);

+    if (payload != NULL) {

+      cleanupPayload (payload);

     }

 

-    if(sessionPayload == NULL || StatusCode == NULL || *StatusCode < HTTP_STATUS_200_OK || *StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT)

-    {

-        //Failed to create session!

+    cleanupServiceEnumerator (ret);

+    return NULL;

+  }

+

+  if (StatusCode != NULL) {

+    FreePool (StatusCode);

+    StatusCode = NULL;

+  }

+

+  links = getPayloadByNodeName (payload, "Links", &StatusCode);

+  cleanupPayload (payload);

+  if (links == NULL) {

+    cleanupServiceEnumerator (ret);

+    return NULL;

+  }

 

-        cleanupPayload(links);

-        cleanupServiceEnumerator(ret);

+  session = json_object_get (links->json, "Sessions");

+  if (session == NULL) {

+    cleanupPayload (links);

+    cleanupServiceEnumerator (ret);

+    return NULL;

+  }

 

-        if (StatusCode != NULL) {

-          FreePool (StatusCode);

-        }

+  odataId = json_object_get (session, "@odata.id");

+  if (odataId == NULL) {

+    cleanupPayload (links);

+    cleanupServiceEnumerator (ret);

+    return NULL;

+  }

+

+  uri  = json_string_value (odataId);

+  post = json_object ();

+  addStringToJsonObject (post, "UserName", username);

+  addStringToJsonObject (post, "Password", password);

+  content = json_dumps (post, 0);

+  json_decref (post);

+  sessionPayload = postUriFromService (ret, uri, content, 0, NULL, &StatusCode);

+

+  if (content != NULL) {

+    ZeroMem (content, (UINTN)strlen (content));

+    free (content);

+  }

+

+  if ((sessionPayload == NULL) || (StatusCode == NULL) || (*StatusCode < HTTP_STATUS_200_OK) || (*StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT)) {

+    // Failed to create session!

 

-        if (sessionPayload != NULL) {

-          json_decref(sessionPayload);

-        }

+    cleanupPayload (links);

+    cleanupServiceEnumerator (ret);

 

-        return NULL;

+    if (StatusCode != NULL) {

+      FreePool (StatusCode);

     }

-    json_decref(sessionPayload);

-    cleanupPayload(links);

-    FreePool (StatusCode);

-    return ret;

+

+    if (sessionPayload != NULL) {

+      json_decref (sessionPayload);

+    }

+

+    return NULL;

+  }

+

+  json_decref (sessionPayload);

+  cleanupPayload (links);

+  FreePool (StatusCode);

+  return ret;

 }

 

-static char* makeUrlForService(redfishService* service, const char* uri)

+static char *

+makeUrlForService (

+  redfishService  *service,

+  const char      *uri

+  )

 {

-    char* url;

-    if(service->host == NULL)

-    {

-        return NULL;

-    }

-    url = (char*)malloc(strlen(service->host)+strlen(uri)+1);

-    strcpy(url, service->host);

-    strcat(url, uri);

-    return url;

+  char  *url;

+

+  if (service->host == NULL) {

+    return NULL;

+  }

+

+  url = (char *)malloc (strlen (service->host)+strlen (uri)+1);

+  strcpy (url, service->host);

+  strcat (url, uri);

+  return url;

 }

 

-static json_t* getVersions(redfishService* service, const char* rootUri)

+static json_t *

+getVersions (

+  redfishService  *service,

+  const char      *rootUri

+  )

 {

-    json_t*         ret = NULL;

-    EFI_HTTP_STATUS_CODE* StatusCode = NULL;

-

-    if(service->flags & REDFISH_FLAG_SERVICE_NO_VERSION_DOC)

-    {

-        service->versions = json_object();

-        if(service->versions == NULL)

-        {

-            return NULL;

-        }

-        addStringToJsonObject(service->versions, "v1", "/redfish/v1");

-        return service->versions;

-    }

-    if(rootUri != NULL)

-    {

-        ret = getUriFromService(service, rootUri, &StatusCode);

-    }

-    else

-    {

-        ret = getUriFromService(service, "/redfish", &StatusCode);

-    }

+  json_t                *ret        = NULL;

+  EFI_HTTP_STATUS_CODE  *StatusCode = NULL;

 

-    if (ret == NULL || StatusCode == NULL || *StatusCode < HTTP_STATUS_200_OK || *StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT) {

-      if (ret != NULL) {

-        json_decref(ret);

-      }

-      ret = NULL;

+  if (service->flags & REDFISH_FLAG_SERVICE_NO_VERSION_DOC) {

+    service->versions = json_object ();

+    if (service->versions == NULL) {

+      return NULL;

     }

 

-    if (StatusCode != NULL) {

-      FreePool (StatusCode);

+    addStringToJsonObject (service->versions, "v1", "/redfish/v1");

+    return service->versions;

+  }

+

+  if (rootUri != NULL) {

+    ret = getUriFromService (service, rootUri, &StatusCode);

+  } else {

+    ret = getUriFromService (service, "/redfish", &StatusCode);

+  }

+

+  if ((ret == NULL) || (StatusCode == NULL) || (*StatusCode < HTTP_STATUS_200_OK) || (*StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT)) {

+    if (ret != NULL) {

+      json_decref (ret);

     }

 

-    return ret;

+    ret = NULL;

+  }

+

+  if (StatusCode != NULL) {

+    FreePool (StatusCode);

+  }

+

+  return ret;

 }

 

-static void addStringToJsonObject(json_t* object, const char* key, const char* value)

+static void

+addStringToJsonObject (

+  json_t      *object,

+  const char  *key,

+  const char  *value

+  )

 {

-    json_t* jValue = json_string(value);

+  json_t  *jValue = json_string (value);

 

-    json_object_set(object, key, jValue);

+  json_object_set (object, key, jValue);

 

-    json_decref(jValue);

+  json_decref (jValue);

 }