[v1] RedfishClientPkg/ConvertLib: Common code and header files

[edk2-devel] [edk2-redfish-client][PATCH] RedfishClientPkg/ConvertLib: Common code and header files

Posted by Chang, Abner via groups.io 11 months, 4 weeks ago

From: Abner Chang <abner.chang@amd.com>

ConverterLib/* is the folder of script-generated JSON
to C library for the each Redfish schema. The common
code and header files in this patch are used by those
libraries.

Signed-off-by: Abner Chang <abner.chang@amd.com>
Cc: Nickle Wang <nicklew@nvidia.com>
Cc: Igor Kulchytskyy <igork@ami.com>
---
 .../ConverterLib/include/RedfishCsCommon.h    |  203 +++
 .../ConverterLib/include/RedfishDataTypeDef.h |   47 +
 .../src/RedfishCsMemoryInternal.h             |   83 +
 .../ConverterLib/src/RedfishCsCommon.c        | 1465 +++++++++++++++++
 .../ConverterLib/src/RedfishCsMemory.c        |  238 +++
 5 files changed, 2036 insertions(+)
 create mode 100644 RedfishClientPkg/ConverterLib/include/RedfishCsCommon.h
 create mode 100644 RedfishClientPkg/ConverterLib/include/RedfishDataTypeDef.h
 create mode 100644 RedfishClientPkg/ConverterLib/src/RedfishCsMemoryInternal.h
 create mode 100644 RedfishClientPkg/ConverterLib/src/RedfishCsCommon.c
 create mode 100644 RedfishClientPkg/ConverterLib/src/RedfishCsMemory.c

diff --git a/RedfishClientPkg/ConverterLib/include/RedfishCsCommon.h b/RedfishClientPkg/ConverterLib/include/RedfishCsCommon.h
new file mode 100644
index 0000000000..5cdec02ffd
--- /dev/null
+++ b/RedfishClientPkg/ConverterLib/include/RedfishCsCommon.h
@@ -0,0 +1,203 @@
+/** @file
+
+  (C) Copyright 2018-2021 Hewlett Packard Enterprise Development LP<BR>
+
+  SPDX-License-Identifier: BSD-2-Clause-Patent
+
+  Copyright Notice:
+  Copyright 2019-2021 Distributed Management Task Force, Inc. All rights reserved.
+  License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/Redfish-JSON-C-Struct-Converter/blob/master/LICENSE.md
+**/
+
+#ifndef REDFISH_CS_COMMON_H_
+#define REDFISH_CS_COMMON_H_
+
+#include "RedfishDataTypeDef.h"
+
+RedfishCS_Link *
+InitializeLinkHead (
+  RedfishCS_Link  *LinkHead
+  );
+
+RedfishCS_Link *
+InsertHeadLink (
+  RedfishCS_Link  *ListHead,
+  RedfishCS_Link  *Entry
+  );
+
+RedfishCS_Link *
+InsertTailLink (
+  RedfishCS_Link  *ListHead,
+  RedfishCS_Link  *Entry
+  );
+
+RedfishCS_Link *
+GetFirstLink (
+  const RedfishCS_Link  *List
+  );
+
+RedfishCS_Link *
+GetLastLink (
+  const RedfishCS_Link  *List
+  );
+
+RedfishCS_Link *
+GetNextLink (
+  const RedfishCS_Link  *List,
+  const RedfishCS_Link  *Node
+  );
+
+RedfishCS_Link *
+GetPreviousLink (
+  const RedfishCS_Link  *List,
+  const RedfishCS_Link  *Node
+  );
+
+RedfishCS_Link *
+RemoveLink (
+  const RedfishCS_Link  *Link
+  );
+
+RedfishCS_bool
+IsLinkEmpty (
+  const RedfishCS_Link  *LinkHead
+  );
+
+RedfishCS_bool
+IsLinkAtEnd (
+  const RedfishCS_Link  *LinkHead,
+  const RedfishCS_Link  *ThisLink
+  );
+
+RedfishCS_status
+recordCsRootMemory (
+  void  *memCs
+  );
+
+RedfishCS_status
+allocateRecordCsMemory (
+  RedfishCS_void    *rootCs,
+  RedfishCS_uint32  size,
+  RedfishCS_void    **Dst
+  );
+
+RedfishCS_status
+allocateRecordCsZeroMemory (
+  RedfishCS_void    *rootCs,
+  RedfishCS_uint32  size,
+  RedfishCS_void    **Dst
+  );
+
+RedfishCS_status
+allocateArrayRecordCsMemory (
+  RedfishCS_void    *rootCs,
+  RedfishCS_uint32  ArrayInstanceSize,
+  RedfishCS_uint64  ArraySize,
+  RedfishCS_void    **Dst
+  );
+
+RedfishCS_status
+allocateDuplicateStr (
+  void  *Cs,
+  char  *Str,
+  void  **DstBuffer
+  );
+
+RedfishCS_status
+DestoryCsMemory (
+  RedfishCS_void  *rootCs
+  );
+
+typedef struct _RedfishCS_char_Array          RedfishCS_char_Array;
+typedef struct _RedfishCS_int64_Array         RedfishCS_int64_Array;
+typedef struct _RedfishCS_bool_Array          RedfishCS_bool_Array;
+typedef struct _RedfishCS_Link_Array          RedfishCS_Link_Array;
+typedef struct _RedfishCS_EmptyProp_KeyValue  RedfishCS_EmptyProp_KeyValue;
+
+typedef enum {
+  RedfishCS_Type_CS = 1,
+  RedfishCS_Type_CS_EmptyProp,
+  RedfishCS_Type_JSON,
+  RedfishCS_Type_Uri
+} RedfishCS_Type;
+
+typedef struct _RedfishCS_Header {
+  RedfishCS_Link    LinkEntry;
+  RedfishCS_Type    ResourceType;
+  RedfishCS_char    *KeyName;
+  RedfishCS_char    *ThisUri;
+} RedfishCS_Header;
+
+typedef struct _RedfishCS_Type_Uri_Data {
+  RedfishCS_Header    Header;
+  RedfishCS_char      *Uri;
+} RedfishCS_Type_Uri_Data;
+
+typedef struct _RedfishCS_Type_CS_Data {
+  RedfishCS_Header    Header;
+  //
+  // Followed by C structure of resource.
+  //
+} RedfishCS_Type_CS_Data;
+
+typedef struct _RedfishCS_Type_JSON_Data {
+  RedfishCS_Header    Header;
+  RedfishCS_char      *JsonText;
+} RedfishCS_Type_JSON_Data;
+
+typedef struct _RedfishCS_Number {
+  RedfishCS_uint16    Value;
+  RedfishCS_uint16    MaxValue;
+  RedfishCS_uint16    MinValue;
+} RedfishCS_Number;
+
+typedef struct _RedfishCS_char_Array  {
+  RedfishCS_char_Array    *Next;
+  RedfishCS_char          *ArrayValue;
+} RedfishCS_char_Array;
+
+typedef struct _RedfishCS_int64_Array  {
+  RedfishCS_int64_Array    *Next;
+  RedfishCS_int64          *ArrayValue;
+} RedfishCS_int64_Array;
+
+typedef struct _RedfishCS_bool_Array  {
+  RedfishCS_bool_Array    *Next;
+  RedfishCS_bool          *ArrayValue;
+} RedfishCS_bool_Array;
+
+typedef struct _RedfishCS_Link_Array  {
+  RedfishCS_Link_Array    *Next;
+  RedfishCS_Link          *ArrayValue;
+} RedfishCS_Link_Array;
+
+typedef enum {
+  RedfishCS_Vague_DataType_String = 1,
+  RedfishCS_Vague_DataType_Int64,
+  RedfishCS_Vague_DataType_Bool
+} RedfishCS_Vague_DataType;
+
+typedef union {
+  RedfishCS_char     *CharPtr;
+  RedfishCS_bool     *BoolPtr;
+  RedfishCS_int64    *Int64Ptr;
+} RedfishCS_Vague_Ptr;
+
+typedef struct _RedfishCS_Vague  {
+  RedfishCS_Vague_DataType    DataType;
+  RedfishCS_Vague_Ptr         DataValue;
+} RedfishCS_Vague;
+
+typedef struct _RedfishCS_EmptyProp_KeyValue  {
+  RedfishCS_EmptyProp_KeyValue    *NextKeyValuePtr;
+  RedfishCS_char                  *KeyNamePtr;
+  RedfishCS_Vague                 *Value;
+} RedfishCS_EmptyProp_KeyValue;
+
+typedef struct _RedfishCS_Type_EmptyProp_CS_Data {
+  RedfishCS_Header                Header;
+  RedfishCS_uint32                NunmOfProperties;
+  RedfishCS_EmptyProp_KeyValue    *KeyValuePtr;
+} RedfishCS_Type_EmptyProp_CS_Data;
+
+#endif
diff --git a/RedfishClientPkg/ConverterLib/include/RedfishDataTypeDef.h b/RedfishClientPkg/ConverterLib/include/RedfishDataTypeDef.h
new file mode 100644
index 0000000000..96eebc66e7
--- /dev/null
+++ b/RedfishClientPkg/ConverterLib/include/RedfishDataTypeDef.h
@@ -0,0 +1,47 @@
+/** @file
+
+  (C) Copyright 2018-2021 Hewlett Packard Enterprise Development LP<BR>
+
+  SPDX-License-Identifier: BSD-2-Clause-Patent
+
+  Copyright Notice:
+  Copyright 2019-2021 Distributed Management Task Force, Inc. All rights reserved.
+  License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/Redfish-JSON-C-Struct-Converter/blob/master/LICENSE.md
+**/
+
+#ifndef REDFISH_CS_DATA_TYPE_H_
+#define REDFISH_CS_DATA_TYPE_H_
+
+#include <jansson.h>
+
+typedef char                RedfishCS_char;
+typedef int                 RedfishCS_bool;
+typedef signed char         RedfishCS_int8;
+typedef unsigned char       RedfishCS_uint8;
+typedef int                 RedfishCS_int16;
+typedef int                 RedfishCS_int;
+typedef unsigned int        RedfishCS_uint16;
+typedef long int            RedfishCS_int32;
+typedef unsigned long int   RedfishCS_uint32;
+typedef long long           RedfishCS_int64;
+typedef unsigned long long  RedfishCS_uint64;
+typedef void                RedfishCS_void;
+
+#define RedfishCS_boolean_false  0
+#define RedfishCS_boolean_true   1
+
+typedef RedfishCS_int64 RedfishCS_status;
+#define RedfishCS_status_success              0
+#define RedfishCS_status_unsupported          -1
+#define RedfishCS_status_invalid_parameter    -2
+#define RedfishCS_status_insufficient_memory  -3
+#define RedfishCS_status_not_found            -4
+#define RedfishCS_status_unknown_error        -5
+
+typedef struct _RedfishCS_Link RedfishCS_Link;
+struct _RedfishCS_Link {
+  RedfishCS_Link    *BackLink;
+  RedfishCS_Link    *ForwardLink;
+};
+
+#endif
diff --git a/RedfishClientPkg/ConverterLib/src/RedfishCsMemoryInternal.h b/RedfishClientPkg/ConverterLib/src/RedfishCsMemoryInternal.h
new file mode 100644
index 0000000000..acf2b15a16
--- /dev/null
+++ b/RedfishClientPkg/ConverterLib/src/RedfishCsMemoryInternal.h
@@ -0,0 +1,83 @@
+/** @file
+
+  (C) Copyright 2018-2021 Hewlett Packard Enterprise Development LP<BR>
+
+  SPDX-License-Identifier: BSD-2-Clause-Patent
+
+  Copyright Notice:
+  Copyright 2019-2021 Distributed Management Task Force, Inc. All rights reserved.
+  License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/Redfish-JSON-C-Struct-Converter/blob/master/LICENSE.md
+**/
+
+#ifndef REDFISH_CS_MEMORY_INTERNAL_H_
+#define REDFISH_CS_MEMORY_INTERNAL_H_
+
+#include "RedfishDataTypeDef.h"
+
+RedfishCS_Link *
+InitializeLinkHead (
+  RedfishCS_Link  *LinkHead
+  );
+
+RedfishCS_Link *
+InsertHeadLink (
+  RedfishCS_Link  *ListHead,
+  RedfishCS_Link  *Entry
+  );
+
+RedfishCS_Link *
+InsertTailLink (
+  RedfishCS_Link  *ListHead,
+  RedfishCS_Link  *Entry
+  );
+
+RedfishCS_Link *
+GetFirstLink (
+  const RedfishCS_Link  *List
+  );
+
+RedfishCS_Link *
+GetLastLink (
+  const RedfishCS_Link  *List
+  );
+
+RedfishCS_Link *
+GetNextLink (
+  const RedfishCS_Link  *List,
+  const RedfishCS_Link  *Node
+  );
+
+RedfishCS_Link *
+GetPreviousLink (
+  const RedfishCS_Link  *List,
+  const RedfishCS_Link  *Node
+  );
+
+RedfishCS_Link *
+RemoveLink (
+  const RedfishCS_Link  *Link
+  );
+
+RedfishCS_bool
+IsLinkEmpty (
+  const RedfishCS_Link  *LinkHead
+  );
+
+RedfishCS_bool
+IsLinkAtEnd (
+  const RedfishCS_Link  *LinkHead,
+  const RedfishCS_Link  *ThisLink
+  );
+
+typedef struct _RedfishCS_Internal_memory_link {
+  RedfishCS_Link    nextLink;
+  void              *memoryPtr;
+} RedfishCS_Internal_memory_link;
+
+typedef struct _RedfishCS_Internal_memory_root {
+  RedfishCS_Link    nextRoot;
+  RedfishCS_Link    memBlocks;
+  void              *CsPtr;
+} RedfishCS_Internal_memory_root;
+
+#endif
diff --git a/RedfishClientPkg/ConverterLib/src/RedfishCsCommon.c b/RedfishClientPkg/ConverterLib/src/RedfishCsCommon.c
new file mode 100644
index 0000000000..212f0de1a8
--- /dev/null
+++ b/RedfishClientPkg/ConverterLib/src/RedfishCsCommon.c
@@ -0,0 +1,1465 @@
+/** @file
+
+  (C) Copyright 2018-2021 Hewlett Packard Enterprise Development LP<BR>
+
+  SPDX-License-Identifier: BSD-2-Clause-Patent
+
+  Copyright Notice:
+  Copyright 2019-2021 Distributed Management Task Force, Inc. All rights reserved.
+  License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/Redfish-JSON-C-Struct-Converter/blob/master/LICENSE.md
+**/
+
+#include "RedfishCsCommon.h"
+#include "RedfishCsMemoryInternal.h"
+#include <jansson.h>
+#include <stdlib.h>
+#include <string.h>
+
+RedfishCS_status
+GetRedfishPropertyVague (
+  void             *Cs,
+  json_t           *JsonObj,
+  char             *Key,
+  RedfishCS_Vague  **DstBuffer
+  );
+
+/**
+  This function initiates a Redfish C Structure link.
+
+  ListHead            The link list entry.
+  Return the list head.
+
+**/
+RedfishCS_Link *
+InitializeLinkHead (
+  RedfishCS_Link  *ListHead
+  )
+{
+  ListHead->ForwardLink = ListHead;
+  ListHead->BackLink    = ListHead;
+  return ListHead;
+}
+
+/**
+  This function inserts the list to list head.
+
+  ListHead            The link list head.
+  Entry               The list to insert.
+
+  Return the list head.
+
+**/
+RedfishCS_Link *
+InsertHeadLink (
+  RedfishCS_Link  *ListHead,
+  RedfishCS_Link  *Entry
+  )
+{
+  Entry->ForwardLink           = ListHead->ForwardLink;
+  Entry->BackLink              = ListHead;
+  Entry->ForwardLink->BackLink = Entry;
+  ListHead->ForwardLink        = Entry;
+  return ListHead;
+}
+
+/**
+  This function inserts the list to list tail.
+
+  ListHead            The link list head.
+  Entry               The list to insert.
+
+  Return the list head.
+
+**/
+RedfishCS_Link *
+InsertTailLink (
+  RedfishCS_Link  *ListHead,
+  RedfishCS_Link  *Entry
+  )
+{
+  Entry->ForwardLink           = ListHead;
+  Entry->BackLink              = ListHead->BackLink;
+  Entry->BackLink->ForwardLink = Entry;
+  ListHead->BackLink           = Entry;
+  return ListHead;
+}
+
+/**
+  This function gets the first list from the list head.
+
+  List            The link list head.
+
+  Return the first list *
+
+**/
+RedfishCS_Link *
+GetFirstLink (
+  const RedfishCS_Link  *List
+  )
+{
+  return List->ForwardLink;
+}
+
+/**
+  This function gets the last list from the list head.
+
+  List            The link list head.
+
+  Return the last list.
+
+**/
+RedfishCS_Link *
+GetLastLink (
+  const RedfishCS_Link  *List
+  )
+{
+  return List->BackLink;
+}
+
+/**
+  This function gets the next list of Node.
+
+  List      The link list head.
+  Node      The list we will get the next list from.
+
+  Return the next list.
+
+**/
+RedfishCS_Link *
+GetNextLink (
+  const RedfishCS_Link  *List,
+  const RedfishCS_Link  *Node
+  )
+{
+  return Node->ForwardLink;
+}
+
+/**
+  This function gets the previous list of Node.
+
+  List      The link list head.
+  Node      The list we will get the previous list from.
+
+  Return the previous RedfishCS_Link *
+
+**/
+RedfishCS_Link *
+GetPreviousLink (
+  const RedfishCS_Link  *List,
+  const RedfishCS_Link  *Node
+  )
+{
+  return Node->BackLink;
+}
+
+/**
+  This function removes a list.
+
+  Link      The list to be removed.
+
+  Return the next list.
+
+**/
+RedfishCS_Link *
+RemoveLink (
+  const RedfishCS_Link  *Link
+  )
+{
+  Link->ForwardLink->BackLink = Link->BackLink;
+  Link->BackLink->ForwardLink = Link->ForwardLink;
+  return Link->ForwardLink;
+}
+
+/**
+  This function checks if the list is empty.
+
+  LinkHead      The list head.
+
+  Return true if it is empty otherwise it is not empty.
+
+**/
+RedfishCS_bool
+IsLinkEmpty (
+  const RedfishCS_Link  *LinkHead
+  )
+{
+  return (RedfishCS_bool)(LinkHead->ForwardLink == LinkHead);
+}
+
+/**
+  This function checks if the list is at the end.
+
+  LinkHead      The list head.
+  ThisLink      The list to check.
+
+  Return true if it is at the end otherwise it is not.
+
+**/
+RedfishCS_bool
+IsLinkAtEnd (
+  const RedfishCS_Link  *LinkHead,
+  const RedfishCS_Link  *ThisLink
+  )
+{
+  return (RedfishCS_bool)(ThisLink->ForwardLink == LinkHead);
+}
+
+/**
+  This function duplicates a string.
+
+  Cs        The CStructure instance that owns the string.
+  Str       String to be duplicated.
+  DstBuffer The buffer to retrieve the string.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+allocateDuplicateStr (
+  void  *Cs,
+  char  *Str,
+  void  **DstBuffer
+  )
+{
+  RedfishCS_status  Status;
+
+  if ((Str == NULL) || (strlen (Str) == 0)) {
+    *DstBuffer = NULL;
+    return RedfishCS_status_success;
+  }
+
+  Status = allocateRecordCsMemory (Cs, (RedfishCS_int)strlen (Str) + 1, (void **)DstBuffer);
+  if (Status != RedfishCS_status_success) {
+    return Status;
+  }
+
+  memcpy (*DstBuffer, Str, strlen (Str) + 1);
+  return RedfishCS_status_success;
+}
+
+/**
+  This function creates an URI type CS by the Odata ID.
+
+  JsonOj        JSON object which has odata ID  key.
+  ParentUri     The parent URI of odata ID.
+  CsTypeUriData The pointer to retrieve the RedfishCS_Type_Uri_Data.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+CreateCsUriByOdataId (
+  json_t                   *JsonOj,
+  RedfishCS_char           *ParentUri,
+  RedfishCS_Type_Uri_Data  **CsTypeUriData
+  )
+{
+  json_t                   *TempJsonObj;
+  RedfishCS_Type_Uri_Data  *CsTypeUri;
+
+  CsTypeUri   = NULL;
+  TempJsonObj = json_object_get (JsonOj, "@odata.id");
+  if (TempJsonObj == NULL) {
+    return RedfishCS_status_not_found;
+  }
+
+  CsTypeUri = malloc (sizeof (RedfishCS_Type_Uri_Data));
+  if (CsTypeUri == NULL) {
+    return RedfishCS_status_insufficient_memory;
+  }
+
+  InitializeLinkHead (&CsTypeUri->Header.LinkEntry);
+  CsTypeUri->Header.ResourceType = RedfishCS_Type_Uri;
+  CsTypeUri->Header.ThisUri      = ParentUri;
+  CsTypeUri->Header.KeyName      = (RedfishCS_char *)strdup ("@odata.id");
+  CsTypeUri->Uri                 = (RedfishCS_char *)strdup (json_string_value (TempJsonObj));
+  *CsTypeUriData                 = CsTypeUri;
+  return RedfishCS_status_success;
+}
+
+/**
+  This function creates URI type CS by node.
+
+  Cs            The CStructure instance owns the string.
+  JsonOj        JSON object which has NodeName key.
+  NodeName      The JSON key name.
+  ParentUri     The parent URI of odata ID.
+  CsTypeUriData The pointer to retrieve the RedfishCS_Type_Uri_Data.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+CreateCsUriByNode (
+  void                     *Cs,
+  json_t                   *JsonOj,
+  RedfishCS_char           *NodeName,
+  RedfishCS_char           *ParentUri,
+  RedfishCS_Type_Uri_Data  **CsTypeUriData
+  )
+{
+  json_t                   *TempJsonObj;
+  json_t                   *TempJsonObj2;
+  RedfishCS_Type_Uri_Data  *CsTypeUri;
+  RedfishCS_status         Status;
+
+  CsTypeUri = NULL;
+
+  if (NodeName != NULL) {
+    TempJsonObj = json_object_get (JsonOj, NodeName);
+    if (TempJsonObj == NULL) {
+      return RedfishCS_status_not_found;
+    }
+  } else {
+    if (JsonOj == NULL) {
+      return RedfishCS_status_not_found;
+    }
+
+    TempJsonObj = JsonOj;
+  }
+
+  TempJsonObj2 = json_object_get (TempJsonObj, "@odata.id");
+  if (TempJsonObj2 != NULL) {
+    Status = allocateRecordCsMemory (Cs, sizeof (RedfishCS_Type_Uri_Data), (void **)&CsTypeUri);
+    if (Status != RedfishCS_status_success) {
+      return Status;
+    }
+
+    InitializeLinkHead (&CsTypeUri->Header.LinkEntry);
+    CsTypeUri->Header.ResourceType = RedfishCS_Type_Uri;
+    CsTypeUri->Header.ThisUri      = ParentUri;
+    Status                         = allocateDuplicateStr (Cs, NodeName, (void **)&CsTypeUri->Header.KeyName);
+    if (Status != RedfishCS_status_success) {
+      return Status;
+    }
+
+    *CsTypeUriData = CsTypeUri;
+    Status         = allocateDuplicateStr (Cs, (char *)json_string_value (TempJsonObj2), (void **)&CsTypeUri->Uri);
+    return Status;
+  }
+
+  return RedfishCS_status_invalid_parameter;
+}
+
+/**
+  This function creates JSON type CS by node.
+
+  Cs             The CStructure instance owns the string.
+  JsonOj         JSON object which has NodeName key.
+  NodeName       The JSON key name.
+  ParentUri      The parent URI of odata ID.
+  CsTypeJsonData The pointer to retrieve the RedfishCS_Type_JSON_Data.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+CreateCsJsonByNode (
+  void                      *Cs,
+  json_t                    *JsonObj,
+  RedfishCS_char            *NodeName,
+  RedfishCS_char            *ParentUri,
+  RedfishCS_Type_JSON_Data  **CsTypeJsonData
+  )
+{
+  json_t                    *TempJsonObj;
+  RedfishCS_Type_JSON_Data  *CsTypeJson;
+  RedfishCS_char            *TempChar;
+  RedfishCS_char            *DumpStr;
+  RedfishCS_status          Status;
+
+  CsTypeJson = NULL;
+  if (NodeName != NULL) {
+    TempJsonObj = json_object_get (JsonObj, NodeName);
+    if (TempJsonObj == NULL) {
+      return RedfishCS_status_not_found;
+    }
+  } else {
+    // Dump JSON from JsonObj.
+    TempJsonObj = JsonObj;
+  }
+
+  TempChar = json_dumps ((json_t *)TempJsonObj, JSON_INDENT (2));
+  if (TempChar != NULL) {
+    Status = allocateRecordCsMemory (Cs, sizeof (RedfishCS_Type_JSON_Data), (void **)&CsTypeJson);
+    if (Status != RedfishCS_status_success) {
+      return Status;
+    }
+
+    Status = allocateRecordCsMemory (Cs, (RedfishCS_int)strlen (TempChar) + 1, (void **)&DumpStr);
+    if (Status != RedfishCS_status_success) {
+      return Status;
+    }
+
+    strncpy (DumpStr, TempChar, strlen (TempChar) + 1);
+    InitializeLinkHead (&CsTypeJson->Header.LinkEntry);
+    CsTypeJson->Header.ResourceType = RedfishCS_Type_JSON;
+    CsTypeJson->Header.ThisUri      = ParentUri;
+    Status                          = allocateDuplicateStr (Cs, NodeName, (void **)&CsTypeJson->Header.KeyName);
+    if (Status != RedfishCS_status_success) {
+      return Status;
+    }
+
+    CsTypeJson->JsonText = DumpStr;
+    *CsTypeJsonData      = CsTypeJson;
+    return RedfishCS_status_success;
+  }
+
+  return RedfishCS_status_invalid_parameter;
+}
+
+/**
+  This function creates an empty property type CS by node.
+
+  Cs                    The CStructure instance owns the string.
+  JsonOj                JSON object which has the NodeName.
+  NodeName              The JSON key name.
+  ParentUri             The parent URI of odata ID.
+  CsTypeEmptyPropCSData The pointer to retrieve the CsTypeEmptyPropCSData.
+  NunmOfProperties      Number of properties in CS.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+CreateEmptyPropCsJson (
+  RedfishCS_void                    *Cs,
+  json_t                            *JsonObj,
+  RedfishCS_char                    *NodeName,
+  RedfishCS_char                    *ParentUri,
+  RedfishCS_Type_EmptyProp_CS_Data  **CsTypeEmptyPropCSData,
+  RedfishCS_uint32                  NunmOfProperties
+  )
+{
+  json_t                            *TempJsonObj;
+  RedfishCS_status                  Status;
+  RedfishCS_Type_EmptyProp_CS_Data  *CsTypeEmptyPropCS;
+  RedfishCS_char                    *KeyName;
+  json_t                            *KeyValueObj;
+  RedfishCS_void                    *n;
+  RedfishCS_EmptyProp_KeyValue      **KeyValuePtr;
+  RedfishCS_EmptyProp_KeyValue      *KeyValue;
+
+  CsTypeEmptyPropCS = NULL;
+  if (NodeName != NULL) {
+    TempJsonObj = json_object_get (JsonObj, NodeName);
+    if (TempJsonObj == NULL) {
+      return RedfishCS_status_not_found;
+    }
+  }
+
+  Status = allocateRecordCsMemory (Cs, sizeof (RedfishCS_Type_EmptyProp_CS_Data), (void **)&CsTypeEmptyPropCS);
+  if (Status != RedfishCS_status_success) {
+    return Status;
+  }
+
+  InitializeLinkHead (&CsTypeEmptyPropCS->Header.LinkEntry);
+  CsTypeEmptyPropCS->Header.ResourceType = RedfishCS_Type_CS_EmptyProp;
+  CsTypeEmptyPropCS->Header.ThisUri      = ParentUri;
+  Status                                 = allocateDuplicateStr (Cs, NodeName, (void **)&CsTypeEmptyPropCS->Header.KeyName);
+  if (Status != RedfishCS_status_success) {
+    return Status;
+  }
+
+  CsTypeEmptyPropCS->NunmOfProperties = NunmOfProperties;
+  //
+  // Create instance for each key-value.
+  //
+  KeyValuePtr = &CsTypeEmptyPropCS->KeyValuePtr;
+  json_object_foreach_safe (TempJsonObj, n, KeyName, KeyValueObj) {
+    Status = allocateRecordCsMemory (Cs, sizeof (RedfishCS_EmptyProp_KeyValue), (void **)&KeyValue);
+    if (Status != RedfishCS_status_success) {
+      return Status;
+    }
+
+    Status = allocateDuplicateStr (Cs, (char *)KeyName, (void **)&KeyValue->KeyNamePtr);
+    if (Status != RedfishCS_status_success) {
+      return Status;
+    }
+
+    Status = GetRedfishPropertyVague (Cs, TempJsonObj, (char *)KeyName, &KeyValue->Value);
+    if (Status != RedfishCS_status_success) {
+      return Status;
+    }
+
+    *KeyValuePtr = KeyValue;
+    KeyValuePtr  = &KeyValue->NextKeyValuePtr;
+  }
+
+  *CsTypeEmptyPropCSData = CsTypeEmptyPropCS;
+  return RedfishCS_status_success;
+}
+
+/**
+  This function checks if property type is supported.
+
+  JsonOj     JSON object of this property.
+
+  Return RedfishCS_bool.
+
+**/
+RedfishCS_bool
+CheckSupportedPropTypeInEmptyProperty (
+  json_t  *JsonObj
+  )
+{
+  //
+  // Only support below property types for the property is declared as
+  // empty property in schema.
+  //  e.g. "properties": {}
+  //
+  if (json_is_string (JsonObj) ||
+      json_is_integer (JsonObj) ||
+      // json_is_real(JsonObj) ||
+      json_is_number (JsonObj) ||
+      json_is_boolean (JsonObj))
+  {
+    return RedfishCS_boolean_true;
+  }
+
+  return RedfishCS_boolean_false;
+}
+
+/**
+  This function checks the properties in a empty property type JSON object.
+  Also returns the number of properties in NumOfProperty.
+
+  JsonOj         JSON object
+  NumOfProperty  Pointer to retrieve the number of property in JSON object.
+
+  Return RedfishCS_bool.
+
+**/
+RedfishCS_bool
+CheckEmptyPropJsonObject (
+  json_t            *JsonObj,
+  RedfishCS_uint32  *NumOfProperty
+  )
+{
+  RedfishCS_char    *NewKey;
+  json_t            *Value;
+  RedfishCS_void    *n;
+  RedfishCS_uint32  Num;
+
+  Num = 0;
+  json_object_foreach_safe (JsonObj, n, NewKey, Value) {
+    if (!CheckSupportedPropTypeInEmptyProperty (Value)) {
+      return RedfishCS_boolean_false;
+    }
+
+    Num++;
+  }
+  if (NumOfProperty != NULL) {
+    *NumOfProperty = Num;
+  }
+
+  return RedfishCS_boolean_true;
+}
+
+/**
+  This function checks if this is a supported Redfish resource.
+
+  Odata_Type    The string to Odata type.
+  NameSpace     The string to the Redfish schema name space.
+  Version       The string to the Redfish schema version.
+  DataType      The string to the data type defined in Redfish schema.
+
+  Return RedfishCS_bool.
+
+**/
+RedfishCS_bool
+SupportedRedfishResource (
+  RedfishCS_char  *Odata_Type,
+  RedfishCS_char  *NameSpace,
+  RedfishCS_char  *Version,
+  RedfishCS_char  *DataType
+  )
+{
+  RedfishCS_char  *TargetDataType;
+
+  if ((Odata_Type == NULL) || (NameSpace == NULL) || (DataType == NULL)) {
+    return RedfishCS_boolean_false;
+  }
+
+  if (Version != NULL) {
+    TargetDataType = malloc (strlen (NameSpace) + strlen (Version) + strlen (DataType) + 16); // Plus 16 bytes to make more room.
+                                                                                              // Actually we just need 1 byte for "#"
+                                                                                              // Two bytes for "." and one byte for NULL terminator.
+  } else {
+    TargetDataType = malloc (strlen (NameSpace) + strlen (DataType) + 16); // Plus 16 bytes to make more room.
+                                                                           // Actually we just need 1 byte for "#"
+                                                                           // Two bytes for "." and one byte for NULL terminator.
+  }
+
+  if (TargetDataType == NULL) {
+    return RedfishCS_boolean_false;
+  }
+
+  TargetDataType[0] = 0;  // Insert NULL terminator.
+  strcat (TargetDataType, "#");
+  strcat (TargetDataType, NameSpace);
+  strcat (TargetDataType, ".");
+  if ((Version != NULL) && (strcmp (Version, "noversioned") != 0)) {
+    strcat (TargetDataType, Version);
+    strcat (TargetDataType, ".");
+  }
+
+  strcat (TargetDataType, DataType);
+  if (strcmp (Odata_Type, TargetDataType) == 0) {
+    return RedfishCS_boolean_true;
+  }
+
+  free (TargetDataType);
+  return RedfishCS_boolean_false;
+}
+
+/**
+  This function creates JSON or URI type CS according to the
+  number of properties in JSON object.
+
+  Cs            he CStructure instance owns the new created CS.
+  JsonObj       JSON object which has NodeName key.
+  NodeName      The key name in JSON object.
+  ParentUri     The parent URI.
+  LinkHead      The list head to link with the new CS.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+CreateCsUriOrJsonByNode (
+  void            *Cs,
+  json_t          *JsonObj,
+  RedfishCS_char  *NodeName,
+  RedfishCS_char  *ParentUri,
+  RedfishCS_Link  *LinkHead
+  )
+{
+  json_t                    *JsonObjTemp;
+  RedfishCS_Type_Uri_Data   *CsTypeUri;
+  RedfishCS_Type_JSON_Data  *CsTypeJson;
+  RedfishCS_status          Status;
+
+  Status      = RedfishCS_status_invalid_parameter;
+  JsonObjTemp = json_object_get (JsonObj, NodeName);
+  if (JsonObjTemp == NULL) {
+    return RedfishCS_status_not_found;
+  }
+
+  if (json_object_size (JsonObjTemp) == 1) {
+    Status = CreateCsUriByNode (Cs, JsonObj, NodeName, ParentUri, &CsTypeUri);
+    if (Status == RedfishCS_status_success) {
+      InsertTailLink (LinkHead, &CsTypeUri->Header.LinkEntry);
+      return RedfishCS_status_success;
+    }
+  } else {
+    Status = CreateCsJsonByNode (Cs, JsonObj, NodeName, ParentUri, &CsTypeJson);
+    if (Status == RedfishCS_status_success) {
+      InsertTailLink (LinkHead, &CsTypeJson->Header.LinkEntry);
+      return RedfishCS_status_success;
+    }
+  }
+
+  return Status;
+}
+
+/**
+  This function creates JSON or URI array type CS according to the
+  number of properties in JSON object.
+
+  Cs            he CStructure instance owns the new created CS.
+  JsonObj       JSON object which has NodeName.
+  NodeName      The key name in JSON object.
+  ParentUri     The parent URI.
+  LinkHead      The list head to link with the new CS.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+CreateCsUriOrJsonByNodeArray (
+  void            *Cs,
+  json_t          *JsonObj,
+  RedfishCS_char  *NodeName,
+  RedfishCS_char  *ParentUri,
+  RedfishCS_Link  *LinkHead
+  )
+{
+  json_t                    *JsonObjTemp;
+  json_t                    *JsonObjArray;
+  RedfishCS_Type_Uri_Data   *CsTypeUri;
+  RedfishCS_Type_JSON_Data  *CsTypeJson;
+  RedfishCS_status          Status;
+  RedfishCS_uint16          ArrayIndex;
+
+  Status      = RedfishCS_status_invalid_parameter;
+  JsonObjTemp = json_object_get (JsonObj, NodeName);
+  if (JsonObjTemp == NULL) {
+    return RedfishCS_status_not_found;
+  }
+
+  if (json_array_size (JsonObjTemp) == 0) {
+    return RedfishCS_status_success;
+  }
+
+  for (ArrayIndex = 0; ArrayIndex < (RedfishCS_uint16)json_array_size (JsonObjTemp); ArrayIndex++) {
+    JsonObjArray = json_array_get (JsonObjTemp, (size_t)ArrayIndex);
+    if (JsonObjArray == NULL) {
+      continue;
+    }
+
+    if (json_object_size (JsonObjArray) == 1) {
+      Status = CreateCsUriByNode (Cs, JsonObjArray, NULL, ParentUri, &CsTypeUri);
+      if (Status == RedfishCS_status_success) {
+        InsertTailLink (LinkHead, &CsTypeUri->Header.LinkEntry);
+      }
+    } else {
+      Status = CreateCsJsonByNode (Cs, JsonObjArray, NULL, ParentUri, &CsTypeJson);
+      if (Status == RedfishCS_status_success) {
+        InsertTailLink (LinkHead, &CsTypeJson->Header.LinkEntry);
+      }
+    }
+  }
+
+  return RedfishCS_status_success;
+}
+
+/**
+  This function creates JSON object and CS.
+
+  JsonRawText     JSON raw text.
+  ResourceType    The Redfish resource type.
+  ResourceVersion The Redfish resource version.
+  TypeName        The Redfish type name.
+  JsonObjReturned Pointer to retrieve JSON object.
+  Cs              Pointer to retrieve CS.
+  size            The size of CS.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+CreateJsonPayloadAndCs (
+  char    *JsonRawText,
+  char    *ResourceType,
+  char    *ResourceVersion,
+  char    *TypeName,
+  json_t  **JsonObjReturned,
+  void    **Cs,
+  int     size
+  )
+{
+  json_t            *TempJsonObj;
+  RedfishCS_char    *TempChar;
+  RedfishCS_Header  *Header;
+  void              *TempCS;
+
+  if ((JsonRawText == NULL) ||
+      (ResourceType == NULL) ||
+      (TypeName == NULL) ||
+      (Cs == NULL) ||
+      (size == 0)
+      )
+  {
+    return RedfishCS_status_invalid_parameter;
+  }
+
+  *JsonObjReturned = json_loads (JsonRawText, 0, NULL);
+  if (*JsonObjReturned == NULL) {
+    return RedfishCS_status_unknown_error;
+  }
+
+  TempJsonObj = json_object_get (*JsonObjReturned, "@odata.type");
+  if (TempJsonObj == NULL) {
+    return RedfishCS_status_invalid_parameter;
+  }
+
+  TempChar = (RedfishCS_char *)json_string_value (TempJsonObj);
+  if ((TempChar == NULL) || !SupportedRedfishResource (TempChar, ResourceType, ResourceVersion, TypeName)) {
+    return RedfishCS_status_unsupported;
+  }
+
+  TempCS = malloc (size);
+  if (TempCS == NULL) {
+    return RedfishCS_status_insufficient_memory;
+  }
+
+  memset (TempCS, 0, size);
+  Header               = (RedfishCS_Header *)TempCS;
+  Header->ResourceType = RedfishCS_Type_CS;
+  Header->KeyName      = NULL;
+  InitializeLinkHead (&Header->LinkEntry);
+  *Cs = TempCS;
+  return recordCsRootMemory (TempCS);
+}
+
+/**
+  This function returns a Redfish string property.
+
+  Cs         The owner of this property.
+  JsonObj    The JSON object has the Key.
+  Key        The key in JSON object.
+  DstBuffer  Pointer to retrieve a string.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+GetRedfishPropertyStr (
+  void            *Cs,
+  json_t          *JsonObj,
+  char            *Key,
+  RedfishCS_char  **DstBuffer
+  )
+{
+  json_t            *TempJsonObj;
+  RedfishCS_status  Status;
+
+  if (DstBuffer == NULL) {
+    return RedfishCS_status_invalid_parameter;
+  }
+
+  *DstBuffer = NULL;
+
+  TempJsonObj = json_object_get (JsonObj, Key);
+  if (TempJsonObj == NULL) {
+    return RedfishCS_status_not_found;
+  }
+
+  Status = allocateDuplicateStr (Cs, (char *)json_string_value (TempJsonObj), (void **)DstBuffer);
+  return Status;
+}
+
+/**
+  This function returns a Redfish bool property.
+
+  Cs         The owner of this property.
+  JsonObj    The JSON object has the Key.
+  Key        The key in JSON object.
+  DstBuffer  Pointer to retrieve a boolean.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+GetRedfishPropertyBoolean (
+  void            *Cs,
+  json_t          *JsonObj,
+  char            *Key,
+  RedfishCS_bool  **DstBuffer
+  )
+{
+  json_t            *TempJsonObj;
+  RedfishCS_status  Status;
+
+  if (DstBuffer == NULL) {
+    return RedfishCS_status_not_found;
+  }
+
+  TempJsonObj = json_object_get (JsonObj, Key);
+  if (TempJsonObj == NULL) {
+    return RedfishCS_status_not_found;
+  }
+
+  Status = allocateRecordCsMemory (Cs, sizeof (RedfishCS_bool), (void **)DstBuffer);
+  if (Status != RedfishCS_status_success) {
+    return Status;
+  }
+
+  if (json_is_true (TempJsonObj)) {
+    **DstBuffer = RedfishCS_boolean_true;
+  } else {
+    **DstBuffer = RedfishCS_boolean_false;
+  }
+
+  return RedfishCS_status_success;
+}
+
+/**
+  This function returns Redfish a long long property.
+
+  Cs         The owner of this property.
+  JsonObj    The JSON object has the Key.
+  Key        The key in JSON object.
+  DstBuffer  Pointer to retrieve a long long value.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+GetRedfishPropertyInt64 (
+  void             *Cs,
+  json_t           *JsonObj,
+  char             *Key,
+  RedfishCS_int64  **Dst
+  )
+{
+  RedfishCS_status  Status;
+  json_t            *TempJsonObj;
+
+  if (Dst == NULL) {
+    return RedfishCS_status_invalid_parameter;
+  }
+
+  TempJsonObj = json_object_get (JsonObj, Key);
+  if (TempJsonObj == NULL) {
+    return RedfishCS_status_not_found;
+  }
+
+  Status = allocateRecordCsMemory (Cs, sizeof (RedfishCS_int64), (void **)Dst);
+  if (Status != RedfishCS_status_success) {
+    return Status;
+  }
+
+  **Dst = (RedfishCS_int64)json_integer_value (TempJsonObj);
+  return RedfishCS_status_success;
+}
+
+/**
+  This function returns a type-agnostic property.
+
+  Cs         The owner of this property.
+  JsonObj    The JSON object has the Key.
+  Key        The key in JSON object.
+  DstBuffer  Pointer to retrieve a type agnostic value.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+GetRedfishPropertyVague (
+  void             *Cs,
+  json_t           *JsonObj,
+  char             *Key,
+  RedfishCS_Vague  **DstBuffer
+  )
+{
+  json_t            *TempJsonObj;
+  RedfishCS_status  Status;
+  RedfishCS_Vague   *VagueData;
+
+  if (DstBuffer == NULL) {
+    return RedfishCS_status_not_found;
+  }
+
+  TempJsonObj = json_object_get (JsonObj, Key);
+  if (TempJsonObj == NULL) {
+    return RedfishCS_status_not_found;
+  }
+
+  Status = allocateRecordCsMemory (Cs, sizeof (RedfishCS_Vague), (void **)&VagueData);
+  if (Status != RedfishCS_status_success) {
+    return Status;
+  }
+
+  if (json_is_string (TempJsonObj)) {
+    VagueData->DataType = RedfishCS_Vague_DataType_String;
+    Status              = GetRedfishPropertyStr (Cs, JsonObj, Key, &VagueData->DataValue.CharPtr);
+  } else if (json_is_integer (TempJsonObj)) {
+    VagueData->DataType = RedfishCS_Vague_DataType_Int64;
+    Status              = GetRedfishPropertyInt64 (Cs, JsonObj, Key, &VagueData->DataValue.Int64Ptr);
+  } else if (json_is_boolean (TempJsonObj)) {
+    VagueData->DataType = RedfishCS_Vague_DataType_Bool;
+    Status              = GetRedfishPropertyBoolean (Cs, JsonObj, Key, &VagueData->DataValue.BoolPtr);
+  } else if (json_is_null (TempJsonObj)) {
+    *DstBuffer = NULL; // No value for this key
+    free (VagueData);
+    return RedfishCS_status_success;
+  } else {
+    return RedfishCS_status_unsupported;
+  }
+
+  if (Status == RedfishCS_status_success) {
+    *DstBuffer = VagueData;
+  }
+
+  return Status;
+}
+
+/**
+  This function inserts a string JSON object.
+
+  ParentJsonObj  The parent JSON object
+  Key            JSON key to insert.
+  StringValue    Value of string to insert.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+InsertJsonStringObj (
+  json_t          *ParentJsonObj,
+  char            *Key,
+  RedfishCS_char  *StringValue
+  )
+{
+  json_t          *JsonValue;
+  RedfishCS_char  NullStr[] = "";
+  RedfishCS_char  *InsertStr;
+
+  InsertStr = StringValue;
+  if (ParentJsonObj == NULL) {
+    return RedfishCS_status_invalid_parameter;
+  }
+
+  if (InsertStr == (char *)NULL) {
+    InsertStr = NullStr;
+  }
+
+  JsonValue = json_string (InsertStr);
+  if (JsonValue == NULL) {
+    return RedfishCS_status_unsupported;
+  }
+
+  if (json_object_set_new (ParentJsonObj, Key, JsonValue) == -1) {
+    return RedfishCS_status_unsupported;
+  }
+
+  return RedfishCS_status_success;
+}
+
+/**
+  This function inserts a bool JSON object.
+
+  ParentJsonObj  The parent JSON object
+  Key            JSON key to insert.
+  BoolValue      Value of a bool to insert.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+InsertJsonBoolObj (
+  json_t          *ParentJsonObj,
+  char            *Key,
+  RedfishCS_bool  *BoolValue
+  )
+{
+  json_t  *JsonValue;
+
+  if (ParentJsonObj == NULL) {
+    return RedfishCS_status_invalid_parameter;
+  }
+
+  if (BoolValue == (RedfishCS_bool *)NULL) {
+    return RedfishCS_status_success; // No value for this key.
+  }
+
+  JsonValue = json_boolean ((BOOLEAN)*BoolValue);
+  if (JsonValue == NULL) {
+    return RedfishCS_status_unsupported;
+  }
+
+  if (json_object_set_new (ParentJsonObj, Key, JsonValue) == -1) {
+    return RedfishCS_status_unsupported;
+  }
+
+  return RedfishCS_status_success;
+}
+
+/**
+  This function inserts a long long value JSON object.
+
+  ParentJsonObj  The parent JSON object
+  Key            JSON key to insert.
+  Int64Value     Value of a long long to insert.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+InsertJsonInt64Obj (
+  json_t           *ParentJsonObj,
+  char             *Key,
+  RedfishCS_int64  *Int64Value
+  )
+{
+  json_t  *JsonValue;
+
+  if (ParentJsonObj == NULL) {
+    return RedfishCS_status_invalid_parameter;
+  }
+
+  if (Int64Value == (RedfishCS_int64 *)NULL) {
+    return RedfishCS_status_success; // No value for this key.
+  }
+
+  JsonValue = json_integer ((json_int_t)*Int64Value);
+  if (JsonValue == NULL) {
+    return RedfishCS_status_unsupported;
+  }
+
+  if (json_object_set_new (ParentJsonObj, Key, JsonValue) == -1) {
+    return RedfishCS_status_unsupported;
+  }
+
+  return RedfishCS_status_success;
+}
+
+/**
+  This function inserts a type-agnostic JSON object.
+
+  ParentJsonObj  The parent JSON object
+  Key            JSON key to insert.
+  VagueValue     Value of a type agnostic value to insert.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+InsertJsonVagueObj (
+  json_t           *ParentJsonObj,
+  char             *Key,
+  RedfishCS_Vague  *VagueValue
+  )
+{
+  json_t          *JsonValue;
+  RedfishCS_char  NullStr[] = "";
+
+  if (ParentJsonObj == NULL) {
+    return RedfishCS_status_invalid_parameter;
+  }
+
+  if (VagueValue == (RedfishCS_Vague *)NULL) {
+    JsonValue = json_null (); // No value for this key.
+  } else if (VagueValue->DataType == RedfishCS_Vague_DataType_String) {
+    if (VagueValue->DataValue.CharPtr == NULL) {
+      JsonValue = json_string (NullStr);
+    } else {
+      JsonValue = json_string (VagueValue->DataValue.CharPtr);
+    }
+  } else if (VagueValue->DataType == RedfishCS_Vague_DataType_Int64) {
+    JsonValue = json_integer ((json_int_t)*VagueValue->DataValue.Int64Ptr);
+  } else if (VagueValue->DataType == RedfishCS_Vague_DataType_Bool) {
+    JsonValue = json_boolean ((BOOLEAN)*VagueValue->DataValue.BoolPtr);
+  } else {
+    return RedfishCS_status_invalid_parameter;
+  }
+
+  if (json_object_set_new (ParentJsonObj, Key, JsonValue) == -1) {
+    return RedfishCS_status_unsupported;
+  }
+
+  return RedfishCS_status_success;
+}
+
+/**
+  This function inserts a link type JSON object.
+
+  ParentJsonObj  The parent JSON object
+  Key            JSON key to insert.
+  Link           Value of a link type to insert.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+InsertJsonLinkObj (
+  json_t          *JsonObj,
+  char            *Key,
+  RedfishCS_Link  *Link
+  )
+{
+  json_t                    *JsonTextObj;
+  RedfishCS_Type_JSON_Data  *CsJsonHeader;
+
+  if ((Link == NULL) || (JsonObj == NULL)) {
+    return RedfishCS_status_invalid_parameter;
+  }
+
+  if (IsLinkEmpty (Link)) {
+    return RedfishCS_status_success;
+  }
+
+  CsJsonHeader = (RedfishCS_Type_JSON_Data *)GetFirstLink (Link);
+  if ((CsJsonHeader->Header.ResourceType != RedfishCS_Type_JSON) &&
+      (CsJsonHeader->Header.ResourceType != RedfishCS_Type_Uri))
+  {
+    // Only support JSON/URI property for CStructure to JSON
+    return RedfishCS_status_unsupported;
+  }
+
+  if (CsJsonHeader->JsonText == NULL) {
+    return RedfishCS_status_invalid_parameter;
+  }
+
+  if (CsJsonHeader->Header.ResourceType == RedfishCS_Type_JSON) {
+    JsonTextObj = json_loads (CsJsonHeader->JsonText, 0, NULL);
+    if (json_object_set_new (JsonObj, Key, JsonTextObj) == -1) {
+      return RedfishCS_status_unsupported;
+    }
+  } else {
+    JsonTextObj = json_string (CsJsonHeader->JsonText);
+    if (json_object_set_new (JsonObj, Key, JsonTextObj) == -1) {
+      return RedfishCS_status_unsupported;
+    }
+  }
+
+  return RedfishCS_status_success;
+}
+
+/**
+  This function inserts an array of string JSON object.
+
+  ParentJsonObj    The parent JSON object
+  Key              JSON key to insert.
+  StringValueArray Value of a string array to insert.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+InsertJsonStringArrayObj (
+  json_t                *ParentJsonObj,
+  char                  *Key,
+  RedfishCS_char_Array  *StringValueArray
+  )
+{
+  json_t                *ArrayJson;
+  json_t                *ArrayMember;
+  RedfishCS_char_Array  *NextArray;
+  RedfishCS_char        NullStr[] = "";
+
+  if (ParentJsonObj == NULL) {
+    return RedfishCS_status_invalid_parameter;
+  }
+
+  if (StringValueArray == (RedfishCS_char_Array *)NULL) {
+    return RedfishCS_status_success; // No value for this key.
+  }
+
+  ArrayJson = json_array ();
+  if (ArrayJson == NULL) {
+    return RedfishCS_status_unsupported;
+  }
+
+  NextArray = StringValueArray;
+  do {
+    if (NextArray->ArrayValue == NULL) {
+      ArrayMember = json_string (NullStr);
+    } else {
+      ArrayMember = json_string (NextArray->ArrayValue);
+    }
+
+    if (json_array_append_new (ArrayJson, ArrayMember) != 0) {
+      return RedfishCS_status_unsupported;
+    }
+
+    NextArray = NextArray->Next;
+  } while (NextArray != NULL);
+
+  if (json_object_set_new (ParentJsonObj, Key, ArrayJson) == -1) {
+    return RedfishCS_status_unsupported;
+  }
+
+  return RedfishCS_status_success;
+}
+
+/**
+  This function inserts an array of bool JSON object.
+
+  ParentJsonObj    The parent JSON object
+  Key              JSON key to insert.
+  BoolValueArray   Value of a bool array to insert.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+InsertJsonBoolArrayObj (
+  json_t                *ParentJsonObj,
+  char                  *Key,
+  RedfishCS_bool_Array  *BoolValueArray
+  )
+{
+  json_t                *ArrayJson;
+  json_t                *ArrayMember;
+  RedfishCS_bool_Array  *NextArray;
+
+  if (ParentJsonObj == NULL) {
+    return RedfishCS_status_invalid_parameter;
+  }
+
+  if (BoolValueArray == (RedfishCS_bool_Array *)NULL) {
+    return RedfishCS_status_success; // No value for this key.
+  }
+
+  ArrayJson = json_array ();
+  if (ArrayJson == NULL) {
+    return RedfishCS_status_unsupported;
+  }
+
+  NextArray = BoolValueArray;
+  do {
+    ArrayMember = json_boolean ((BOOLEAN)*NextArray->ArrayValue);
+    if (json_array_append_new (ArrayJson, ArrayMember) != 0) {
+      return RedfishCS_status_unsupported;
+    }
+
+    NextArray = NextArray->Next;
+  } while (NextArray != NULL);
+
+  if (json_object_set_new (ParentJsonObj, Key, ArrayJson) == -1) {
+    return RedfishCS_status_unsupported;
+  }
+
+  return RedfishCS_status_success;
+}
+
+/**
+  This function inserts an array of long long value JSON object.
+
+  ParentJsonObj    The parent JSON object
+  Key              JSON key to insert.
+  Int64ValueArray  Value of a long long array to insert.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+InsertJsonInt64ArrayObj (
+  json_t                 *ParentJsonObj,
+  char                   *Key,
+  RedfishCS_int64_Array  *Int64ValueArray
+  )
+{
+  json_t                 *ArrayJson;
+  json_t                 *ArrayMember;
+  RedfishCS_int64_Array  *NextArray;
+
+  if (ParentJsonObj == NULL) {
+    return RedfishCS_status_invalid_parameter;
+  }
+
+  if (Int64ValueArray == (RedfishCS_int64_Array *)NULL) {
+    return RedfishCS_status_success; // No value for this key.
+  }
+
+  ArrayJson = json_array ();
+  if (ArrayJson == NULL) {
+    return RedfishCS_status_unsupported;
+  }
+
+  NextArray = Int64ValueArray;
+  do {
+    ArrayMember = json_integer (*NextArray->ArrayValue);
+    if (json_array_append_new (ArrayJson, ArrayMember) != 0) {
+      return RedfishCS_status_unsupported;
+    }
+
+    NextArray = NextArray->Next;
+  } while (NextArray != NULL);
+
+  if (json_object_set_new (ParentJsonObj, Key, ArrayJson) == -1) {
+    return RedfishCS_status_unsupported;
+  }
+
+  return RedfishCS_status_success;
+}
+
+/**
+  This function inserts an array of link JSON object.
+
+  ParentJsonObj    The parent JSON object
+  Key              JSON key to insert.
+  LinkArray        Value of a link array to insert.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+InsertJsonLinkArrayObj (
+  json_t          *ParentJsonObj,
+  char            *Key,
+  RedfishCS_Link  *LinkArray
+  )
+{
+  json_t                   *ArrayJson;
+  json_t                   *ArrayMember;
+  RedfishCS_Type_Uri_Data  *ThisLink;
+
+  if (ParentJsonObj == NULL) {
+    return RedfishCS_status_invalid_parameter;
+  }
+
+  if (IsLinkEmpty (LinkArray)) {
+    return RedfishCS_status_success;
+  }
+
+  ArrayJson = json_array ();
+  if (ArrayJson == NULL) {
+    return RedfishCS_status_unsupported;
+  }
+
+  ThisLink = (RedfishCS_Type_Uri_Data *)GetFirstLink (LinkArray);
+  while (RedfishCS_boolean_true) {
+    if (ThisLink->Header.ResourceType != RedfishCS_Type_Uri) {
+      return RedfishCS_status_invalid_parameter;
+    }
+
+    if (ThisLink->Uri != (RedfishCS_char *)NULL) {
+      ArrayMember = json_string (ThisLink->Uri);
+      if (json_array_append_new (ArrayJson, ArrayMember) != 0) {
+        return RedfishCS_status_unsupported;
+      }
+    }
+
+    if (IsLinkAtEnd (LinkArray, &ThisLink->Header.LinkEntry)) {
+      if (json_object_set_new (ParentJsonObj, Key, ArrayJson) == -1) {
+        return RedfishCS_status_unsupported;
+      }
+
+      return RedfishCS_status_success;
+    }
+
+    ThisLink = (RedfishCS_Type_Uri_Data *)GetNextLink (LinkArray, &ThisLink->Header.LinkEntry);
+  }
+
+  return RedfishCS_status_success;
+}
+
+/**
+  This function inserts an empty property type JSON object.
+
+  ParentJsonObj    The parent JSON object
+  Key              JSON key to insert.
+  Link             Value of an empty property type link.
+
+  Return RedfishCS_status.
+
+**/
+RedfishCS_status
+CsEmptyPropLinkToJson (
+  json_t          *ParentJsonObj,
+  char            *Key,
+  RedfishCS_Link  *Link
+  )
+{
+  RedfishCS_uint32                  Index;
+  RedfishCS_Type_EmptyProp_CS_Data  *EmptyProp_CS_Ptr;
+  RedfishCS_EmptyProp_KeyValue      *KeyValuePtr;
+  json_t                            *JsonObj;
+  RedfishCS_status                  Status;
+
+  EmptyProp_CS_Ptr = (RedfishCS_Type_EmptyProp_CS_Data *)GetFirstLink (Link);
+  if (EmptyProp_CS_Ptr->Header.ResourceType != RedfishCS_Type_CS_EmptyProp) {
+    return RedfishCS_status_unsupported;
+  }
+
+  JsonObj     = json_object ();
+  KeyValuePtr = EmptyProp_CS_Ptr->KeyValuePtr;
+  for (Index = 0; Index < EmptyProp_CS_Ptr->NunmOfProperties; Index++) {
+    Status = InsertJsonVagueObj (JsonObj, KeyValuePtr->KeyNamePtr, KeyValuePtr->Value);
+    if (Status != RedfishCS_status_success) {
+      return Status;
+    }
+
+    KeyValuePtr = KeyValuePtr->NextKeyValuePtr;
+  }
+
+  if (json_object_set_new (ParentJsonObj, Key, JsonObj) != 0) {
+    return RedfishCS_status_unknown_error;
+  }
+
+  return RedfishCS_status_success;
+}
diff --git a/RedfishClientPkg/ConverterLib/src/RedfishCsMemory.c b/RedfishClientPkg/ConverterLib/src/RedfishCsMemory.c
new file mode 100644
index 0000000000..aec03ead6f
--- /dev/null
+++ b/RedfishClientPkg/ConverterLib/src/RedfishCsMemory.c
@@ -0,0 +1,238 @@
+/** @file
+
+  (C) Copyright 2018-2021 Hewlett Packard Enterprise Development LP<BR>
+
+  SPDX-License-Identifier: BSD-2-Clause-Patent
+
+  Copyright Notice:
+  Copyright 2019-2021 Distributed Management Task Force, Inc. All rights reserved.
+  License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/Redfish-JSON-C-Struct-Converter/blob/master/LICENSE.md
+**/
+
+#include "RedfishCsMemoryInternal.h"
+#include <stdlib.h>
+#include <string.h>
+
+RedfishCS_Link  CsMemRoot = { &CsMemRoot, &CsMemRoot };
+
+/**
+  This function records the memory allocation to
+  the C Structure instance that owns the memory block.
+
+  memCs          C Structure instance.
+  Return RedfishCS_status
+
+**/
+RedfishCS_status
+recordCsRootMemory (
+  void  *memCs
+  )
+{
+  RedfishCS_Internal_memory_root  *memRoot;
+
+  memRoot = malloc (sizeof (RedfishCS_Internal_memory_root));
+  if (memRoot == NULL) {
+    return RedfishCS_status_insufficient_memory;
+  }
+
+  InitializeLinkHead (&memRoot->nextRoot);
+  InitializeLinkHead (&memRoot->memBlocks);
+  memRoot->CsPtr = memCs;
+  InsertTailLink (&CsMemRoot, &memRoot->nextRoot);
+  return RedfishCS_status_success;
+}
+
+/**
+  This function allocates and records the memory allocation
+  to the C Structure instance that owns the memory block.
+
+  rootCs          C Structure instance.
+  size            The size to allocate.
+  Dst             Pointer to retrieve the pointer to memory
+                  block.
+  Return RedfishCS_status
+
+**/
+RedfishCS_status
+allocateRecordCsMemory (
+  RedfishCS_void    *rootCs,
+  RedfishCS_uint32  size,
+  RedfishCS_void    **Dst
+  )
+{
+  RedfishCS_Internal_memory_root  *memRoot;
+  RedfishCS_Internal_memory_link  *memLink;
+
+  if (IsLinkEmpty (&CsMemRoot)) {
+    return RedfishCS_status_invalid_parameter;
+  }
+
+  memRoot = (RedfishCS_Internal_memory_root *)GetFirstLink (&CsMemRoot);
+  while (RedfishCS_boolean_true) {
+    if (memRoot->CsPtr == rootCs) {
+      // Allocation memory and record it.
+      memLink = malloc (sizeof (RedfishCS_Internal_memory_link));
+      if (memLink == NULL) {
+        return RedfishCS_status_insufficient_memory;
+      }
+
+      *Dst = malloc (size);
+      if (*Dst == NULL) {
+        free (memLink);
+        return RedfishCS_status_insufficient_memory;
+      }
+
+      memset (*Dst, 0, size);
+      memset (memLink, 0, sizeof (RedfishCS_Internal_memory_link));
+      InitializeLinkHead (&memLink->nextLink);
+      memLink->memoryPtr = *Dst;
+      InsertTailLink (&memRoot->memBlocks, &memLink->nextLink);
+      return RedfishCS_status_success;
+    }
+
+    if (IsLinkAtEnd (&CsMemRoot, (RedfishCS_Link *)&memRoot->nextRoot)) {
+      break;
+    }
+
+    memRoot = (RedfishCS_Internal_memory_root *)GetNextLink (&CsMemRoot, &memRoot->nextRoot);
+  }
+
+  return RedfishCS_status_invalid_parameter;
+}
+
+/**
+  This function allocates, records and zero out the memory
+  to the C Structure instance that owns the memory block.
+
+  rootCs          C Structure instance.
+  size            The size to allocate.
+  Dst             Pointer to retrieve the pointer to memory
+                  block.
+  Return RedfishCS_status
+
+**/
+RedfishCS_status
+allocateRecordCsZeroMemory (
+  RedfishCS_void    *rootCs,
+  RedfishCS_uint32  size,
+  RedfishCS_void    **Dst
+  )
+{
+  RedfishCS_status  Status;
+
+  Status = allocateRecordCsMemory (rootCs, size, Dst);
+  if ((Status != RedfishCS_status_success) || (*Dst == NULL)) {
+    return Status;
+  }
+
+  memset (*Dst, 0, size);
+  return RedfishCS_status_success;
+}
+
+/**
+  This function destroies all memory allocations belong
+  to the C Structure instance.
+
+  rootCs          C Structure instance.
+
+  Return RedfishCS_status
+
+**/
+RedfishCS_status
+DestoryCsMemory (
+  RedfishCS_void  *rootCs
+  )
+{
+  RedfishCS_Internal_memory_root  *memRoot;
+  RedfishCS_Internal_memory_link  *memLink;
+
+  if (IsLinkEmpty (&CsMemRoot)) {
+    return RedfishCS_status_invalid_parameter;
+  }
+
+  memRoot = (RedfishCS_Internal_memory_root *)GetFirstLink (&CsMemRoot);
+  while (RedfishCS_boolean_true) {
+    if (memRoot->CsPtr == rootCs) {
+      if (IsLinkEmpty (&memRoot->memBlocks)) {
+        return RedfishCS_status_success;
+      }
+
+      while (RedfishCS_boolean_true) {
+        memLink = (RedfishCS_Internal_memory_link *)GetLastLink (&memRoot->memBlocks);
+        if (memLink->memoryPtr != NULL) {
+          free (memLink->memoryPtr);
+          RemoveLink (&memLink->nextLink);
+          free (memLink);
+        }
+
+        if (IsLinkEmpty (&memRoot->memBlocks)) {
+          RemoveLink (&memRoot->nextRoot);
+          free (memRoot);
+          free (rootCs);
+          return RedfishCS_status_success;
+        }
+      }
+    }
+
+    if (IsLinkAtEnd (&CsMemRoot, (RedfishCS_Link *)&memRoot->nextRoot)) {
+      break;
+    }
+
+    memRoot = (RedfishCS_Internal_memory_root *)GetNextLink (&CsMemRoot, &memRoot->nextRoot);
+  }
+
+  return RedfishCS_status_invalid_parameter;
+}
+
+/**
+  This function allocates an array of memory blocks owned
+  by the C Structure instance.
+
+  rootCs            C Structure instance.
+  ArrayInstanceSize Number of items in array.
+  ArraySize         The size of each array.
+  Dst               Pointer to retrieve the pointer to memory
+                    block.
+
+  Return RedfishCS_status
+
+**/
+RedfishCS_status
+allocateArrayRecordCsMemory (
+  RedfishCS_void    *rootCs,
+  RedfishCS_uint32  ArrayInstanceSize,
+  RedfishCS_uint64  ArraySize,
+  RedfishCS_void    **Dst
+  )
+{
+  RedfishCS_uint16  Index;
+  RedfishCS_void    *ArrayInstance;
+  RedfishCS_void    *PreArrayInstance;
+  RedfishCS_status  Status;
+  RedfishCS_uint16  SizeOfVoid;
+
+  for (Index = 0; Index < ArraySize; Index++) {
+    Status = allocateRecordCsMemory (rootCs, ArrayInstanceSize, &ArrayInstance);
+    if (Status != RedfishCS_status_success) {
+      return Status;
+    }
+
+    memset (ArrayInstance, 0, ArrayInstanceSize);
+    if (Index == 0) {
+      *Dst = ArrayInstance;
+    } else {
+      SizeOfVoid = sizeof (RedfishCS_void *);
+      if (SizeOfVoid == sizeof (RedfishCS_uint32)) {
+        *((RedfishCS_uint32 *)PreArrayInstance) = (RedfishCS_uint32)(unsigned long long)ArrayInstance; // Next link.
+      } else if (SizeOfVoid == sizeof (RedfishCS_uint64)) {
+        *((RedfishCS_uint64 *)PreArrayInstance) = (RedfishCS_uint64)ArrayInstance; // Next link.
+      } else {
+        return RedfishCS_status_invalid_parameter;
+      }
+    }
+
+    PreArrayInstance = ArrayInstance;
+  }
+
+  return RedfishCS_status_success;
+}
-- 
2.37.1.windows.1



-=-=-=-=-=-=-=-=-=-=-=-
Groups.io Links: You receive all messages sent to this group.
View/Reply Online (#103896): https://edk2.groups.io/g/devel/message/103896
Mute This Topic: https://groups.io/mt/98657292/1787277
Group Owner: devel+owner@edk2.groups.io
Unsubscribe: https://edk2.groups.io/g/devel/unsub [importer@patchew.org]
-=-=-=-=-=-=-=-=-=-=-=-

Re: [edk2-devel] [edk2-redfish-client][PATCH] RedfishClientPkg/ConvertLib: Common code and header files

Posted by Nickle Wang via groups.io 11 months, 4 weeks ago

Reviewed-by: Nickle Wang <nicklew@nvidia.com>

Regards,
Nickle

> -----Original Message-----
> From: abner.chang@amd.com <abner.chang@amd.com>
> Sent: Wednesday, May 3, 2023 4:17 PM
> To: devel@edk2.groups.io
> Cc: Nickle Wang <nicklew@nvidia.com>; Igor Kulchytskyy <igork@ami.com>
> Subject: [edk2-redfish-client][PATCH] RedfishClientPkg/ConvertLib: Common
> code and header files
>
> External email: Use caution opening links or attachments
>
>
> From: Abner Chang <abner.chang@amd.com>
>
> ConverterLib/* is the folder of script-generated JSON
> to C library for the each Redfish schema. The common
> code and header files in this patch are used by those
> libraries.
>
> Signed-off-by: Abner Chang <abner.chang@amd.com>
> Cc: Nickle Wang <nicklew@nvidia.com>
> Cc: Igor Kulchytskyy <igork@ami.com>
> ---
>  .../ConverterLib/include/RedfishCsCommon.h    |  203 +++
>  .../ConverterLib/include/RedfishDataTypeDef.h |   47 +
>  .../src/RedfishCsMemoryInternal.h             |   83 +
>  .../ConverterLib/src/RedfishCsCommon.c        | 1465 +++++++++++++++++
>  .../ConverterLib/src/RedfishCsMemory.c        |  238 +++
>  5 files changed, 2036 insertions(+)
>  create mode 100644
> RedfishClientPkg/ConverterLib/include/RedfishCsCommon.h
>  create mode 100644
> RedfishClientPkg/ConverterLib/include/RedfishDataTypeDef.h
>  create mode 100644
> RedfishClientPkg/ConverterLib/src/RedfishCsMemoryInternal.h
>  create mode 100644 RedfishClientPkg/ConverterLib/src/RedfishCsCommon.c
>  create mode 100644 RedfishClientPkg/ConverterLib/src/RedfishCsMemory.c
>
> diff --git a/RedfishClientPkg/ConverterLib/include/RedfishCsCommon.h
> b/RedfishClientPkg/ConverterLib/include/RedfishCsCommon.h
> new file mode 100644
> index 0000000000..5cdec02ffd
> --- /dev/null
> +++ b/RedfishClientPkg/ConverterLib/include/RedfishCsCommon.h
> @@ -0,0 +1,203 @@
> +/** @file
> +
> +  (C) Copyright 2018-2021 Hewlett Packard Enterprise Development LP<BR>
> +
> +  SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +  Copyright Notice:
> +  Copyright 2019-2021 Distributed Management Task Force, Inc. All rights
> reserved.
> +  License: BSD 3-Clause License. For full text see link:
> https://github.c/
> om%2FDMTF%2FRedfish-JSON-C-Struct-
> Converter%2Fblob%2Fmaster%2FLICENSE.md&data=05%7C01%7Cnicklew%40n
> vidia.com%7C6c287e287fb44d40c3e308db4baed8a2%7C43083d15727340c1b7d
> b39efd9ccc17a%7C0%7C0%7C638186986569209689%7CUnknown%7CTWFpbG
> Zsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn
> 0%3D%7C3000%7C%7C%7C&sdata=VKor2rANpdKrvHJ7pEDkfh2XrTqQdtRVZjryv
> urM1ms%3D&reserved=0
> +**/
> +
> +#ifndef REDFISH_CS_COMMON_H_
> +#define REDFISH_CS_COMMON_H_
> +
> +#include "RedfishDataTypeDef.h"
> +
> +RedfishCS_Link *
> +InitializeLinkHead (
> +  RedfishCS_Link  *LinkHead
> +  );
> +
> +RedfishCS_Link *
> +InsertHeadLink (
> +  RedfishCS_Link  *ListHead,
> +  RedfishCS_Link  *Entry
> +  );
> +
> +RedfishCS_Link *
> +InsertTailLink (
> +  RedfishCS_Link  *ListHead,
> +  RedfishCS_Link  *Entry
> +  );
> +
> +RedfishCS_Link *
> +GetFirstLink (
> +  const RedfishCS_Link  *List
> +  );
> +
> +RedfishCS_Link *
> +GetLastLink (
> +  const RedfishCS_Link  *List
> +  );
> +
> +RedfishCS_Link *
> +GetNextLink (
> +  const RedfishCS_Link  *List,
> +  const RedfishCS_Link  *Node
> +  );
> +
> +RedfishCS_Link *
> +GetPreviousLink (
> +  const RedfishCS_Link  *List,
> +  const RedfishCS_Link  *Node
> +  );
> +
> +RedfishCS_Link *
> +RemoveLink (
> +  const RedfishCS_Link  *Link
> +  );
> +
> +RedfishCS_bool
> +IsLinkEmpty (
> +  const RedfishCS_Link  *LinkHead
> +  );
> +
> +RedfishCS_bool
> +IsLinkAtEnd (
> +  const RedfishCS_Link  *LinkHead,
> +  const RedfishCS_Link  *ThisLink
> +  );
> +
> +RedfishCS_status
> +recordCsRootMemory (
> +  void  *memCs
> +  );
> +
> +RedfishCS_status
> +allocateRecordCsMemory (
> +  RedfishCS_void    *rootCs,
> +  RedfishCS_uint32  size,
> +  RedfishCS_void    **Dst
> +  );
> +
> +RedfishCS_status
> +allocateRecordCsZeroMemory (
> +  RedfishCS_void    *rootCs,
> +  RedfishCS_uint32  size,
> +  RedfishCS_void    **Dst
> +  );
> +
> +RedfishCS_status
> +allocateArrayRecordCsMemory (
> +  RedfishCS_void    *rootCs,
> +  RedfishCS_uint32  ArrayInstanceSize,
> +  RedfishCS_uint64  ArraySize,
> +  RedfishCS_void    **Dst
> +  );
> +
> +RedfishCS_status
> +allocateDuplicateStr (
> +  void  *Cs,
> +  char  *Str,
> +  void  **DstBuffer
> +  );
> +
> +RedfishCS_status
> +DestoryCsMemory (
> +  RedfishCS_void  *rootCs
> +  );
> +
> +typedef struct _RedfishCS_char_Array          RedfishCS_char_Array;
> +typedef struct _RedfishCS_int64_Array         RedfishCS_int64_Array;
> +typedef struct _RedfishCS_bool_Array          RedfishCS_bool_Array;
> +typedef struct _RedfishCS_Link_Array          RedfishCS_Link_Array;
> +typedef struct _RedfishCS_EmptyProp_KeyValue
> RedfishCS_EmptyProp_KeyValue;
> +
> +typedef enum {
> +  RedfishCS_Type_CS = 1,
> +  RedfishCS_Type_CS_EmptyProp,
> +  RedfishCS_Type_JSON,
> +  RedfishCS_Type_Uri
> +} RedfishCS_Type;
> +
> +typedef struct _RedfishCS_Header {
> +  RedfishCS_Link    LinkEntry;
> +  RedfishCS_Type    ResourceType;
> +  RedfishCS_char    *KeyName;
> +  RedfishCS_char    *ThisUri;
> +} RedfishCS_Header;
> +
> +typedef struct _RedfishCS_Type_Uri_Data {
> +  RedfishCS_Header    Header;
> +  RedfishCS_char      *Uri;
> +} RedfishCS_Type_Uri_Data;
> +
> +typedef struct _RedfishCS_Type_CS_Data {
> +  RedfishCS_Header    Header;
> +  //
> +  // Followed by C structure of resource.
> +  //
> +} RedfishCS_Type_CS_Data;
> +
> +typedef struct _RedfishCS_Type_JSON_Data {
> +  RedfishCS_Header    Header;
> +  RedfishCS_char      *JsonText;
> +} RedfishCS_Type_JSON_Data;
> +
> +typedef struct _RedfishCS_Number {
> +  RedfishCS_uint16    Value;
> +  RedfishCS_uint16    MaxValue;
> +  RedfishCS_uint16    MinValue;
> +} RedfishCS_Number;
> +
> +typedef struct _RedfishCS_char_Array  {
> +  RedfishCS_char_Array    *Next;
> +  RedfishCS_char          *ArrayValue;
> +} RedfishCS_char_Array;
> +
> +typedef struct _RedfishCS_int64_Array  {
> +  RedfishCS_int64_Array    *Next;
> +  RedfishCS_int64          *ArrayValue;
> +} RedfishCS_int64_Array;
> +
> +typedef struct _RedfishCS_bool_Array  {
> +  RedfishCS_bool_Array    *Next;
> +  RedfishCS_bool          *ArrayValue;
> +} RedfishCS_bool_Array;
> +
> +typedef struct _RedfishCS_Link_Array  {
> +  RedfishCS_Link_Array    *Next;
> +  RedfishCS_Link          *ArrayValue;
> +} RedfishCS_Link_Array;
> +
> +typedef enum {
> +  RedfishCS_Vague_DataType_String = 1,
> +  RedfishCS_Vague_DataType_Int64,
> +  RedfishCS_Vague_DataType_Bool
> +} RedfishCS_Vague_DataType;
> +
> +typedef union {
> +  RedfishCS_char     *CharPtr;
> +  RedfishCS_bool     *BoolPtr;
> +  RedfishCS_int64    *Int64Ptr;
> +} RedfishCS_Vague_Ptr;
> +
> +typedef struct _RedfishCS_Vague  {
> +  RedfishCS_Vague_DataType    DataType;
> +  RedfishCS_Vague_Ptr         DataValue;
> +} RedfishCS_Vague;
> +
> +typedef struct _RedfishCS_EmptyProp_KeyValue  {
> +  RedfishCS_EmptyProp_KeyValue    *NextKeyValuePtr;
> +  RedfishCS_char                  *KeyNamePtr;
> +  RedfishCS_Vague                 *Value;
> +} RedfishCS_EmptyProp_KeyValue;
> +
> +typedef struct _RedfishCS_Type_EmptyProp_CS_Data {
> +  RedfishCS_Header                Header;
> +  RedfishCS_uint32                NunmOfProperties;
> +  RedfishCS_EmptyProp_KeyValue    *KeyValuePtr;
> +} RedfishCS_Type_EmptyProp_CS_Data;
> +
> +#endif
> diff --git a/RedfishClientPkg/ConverterLib/include/RedfishDataTypeDef.h
> b/RedfishClientPkg/ConverterLib/include/RedfishDataTypeDef.h
> new file mode 100644
> index 0000000000..96eebc66e7
> --- /dev/null
> +++ b/RedfishClientPkg/ConverterLib/include/RedfishDataTypeDef.h
> @@ -0,0 +1,47 @@
> +/** @file
> +
> +  (C) Copyright 2018-2021 Hewlett Packard Enterprise Development LP<BR>
> +
> +  SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +  Copyright Notice:
> +  Copyright 2019-2021 Distributed Management Task Force, Inc. All rights
> reserved.
> +  License: BSD 3-Clause License. For full text see link:
> https://github.c/
> om%2FDMTF%2FRedfish-JSON-C-Struct-
> Converter%2Fblob%2Fmaster%2FLICENSE.md&data=05%7C01%7Cnicklew%40n
> vidia.com%7C6c287e287fb44d40c3e308db4baed8a2%7C43083d15727340c1b7d
> b39efd9ccc17a%7C0%7C0%7C638186986569209689%7CUnknown%7CTWFpbG
> Zsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn
> 0%3D%7C3000%7C%7C%7C&sdata=VKor2rANpdKrvHJ7pEDkfh2XrTqQdtRVZjryv
> urM1ms%3D&reserved=0
> +**/
> +
> +#ifndef REDFISH_CS_DATA_TYPE_H_
> +#define REDFISH_CS_DATA_TYPE_H_
> +
> +#include <jansson.h>
> +
> +typedef char                RedfishCS_char;
> +typedef int                 RedfishCS_bool;
> +typedef signed char         RedfishCS_int8;
> +typedef unsigned char       RedfishCS_uint8;
> +typedef int                 RedfishCS_int16;
> +typedef int                 RedfishCS_int;
> +typedef unsigned int        RedfishCS_uint16;
> +typedef long int            RedfishCS_int32;
> +typedef unsigned long int   RedfishCS_uint32;
> +typedef long long           RedfishCS_int64;
> +typedef unsigned long long  RedfishCS_uint64;
> +typedef void                RedfishCS_void;
> +
> +#define RedfishCS_boolean_false  0
> +#define RedfishCS_boolean_true   1
> +
> +typedef RedfishCS_int64 RedfishCS_status;
> +#define RedfishCS_status_success              0
> +#define RedfishCS_status_unsupported          -1
> +#define RedfishCS_status_invalid_parameter    -2
> +#define RedfishCS_status_insufficient_memory  -3
> +#define RedfishCS_status_not_found            -4
> +#define RedfishCS_status_unknown_error        -5
> +
> +typedef struct _RedfishCS_Link RedfishCS_Link;
> +struct _RedfishCS_Link {
> +  RedfishCS_Link    *BackLink;
> +  RedfishCS_Link    *ForwardLink;
> +};
> +
> +#endif
> diff --git a/RedfishClientPkg/ConverterLib/src/RedfishCsMemoryInternal.h
> b/RedfishClientPkg/ConverterLib/src/RedfishCsMemoryInternal.h
> new file mode 100644
> index 0000000000..acf2b15a16
> --- /dev/null
> +++ b/RedfishClientPkg/ConverterLib/src/RedfishCsMemoryInternal.h
> @@ -0,0 +1,83 @@
> +/** @file
> +
> +  (C) Copyright 2018-2021 Hewlett Packard Enterprise Development LP<BR>
> +
> +  SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +  Copyright Notice:
> +  Copyright 2019-2021 Distributed Management Task Force, Inc. All rights
> reserved.
> +  License: BSD 3-Clause License. For full text see link:
> https://github.c/
> om%2FDMTF%2FRedfish-JSON-C-Struct-
> Converter%2Fblob%2Fmaster%2FLICENSE.md&data=05%7C01%7Cnicklew%40n
> vidia.com%7C6c287e287fb44d40c3e308db4baed8a2%7C43083d15727340c1b7d
> b39efd9ccc17a%7C0%7C0%7C638186986569209689%7CUnknown%7CTWFpbG
> Zsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn
> 0%3D%7C3000%7C%7C%7C&sdata=VKor2rANpdKrvHJ7pEDkfh2XrTqQdtRVZjryv
> urM1ms%3D&reserved=0
> +**/
> +
> +#ifndef REDFISH_CS_MEMORY_INTERNAL_H_
> +#define REDFISH_CS_MEMORY_INTERNAL_H_
> +
> +#include "RedfishDataTypeDef.h"
> +
> +RedfishCS_Link *
> +InitializeLinkHead (
> +  RedfishCS_Link  *LinkHead
> +  );
> +
> +RedfishCS_Link *
> +InsertHeadLink (
> +  RedfishCS_Link  *ListHead,
> +  RedfishCS_Link  *Entry
> +  );
> +
> +RedfishCS_Link *
> +InsertTailLink (
> +  RedfishCS_Link  *ListHead,
> +  RedfishCS_Link  *Entry
> +  );
> +
> +RedfishCS_Link *
> +GetFirstLink (
> +  const RedfishCS_Link  *List
> +  );
> +
> +RedfishCS_Link *
> +GetLastLink (
> +  const RedfishCS_Link  *List
> +  );
> +
> +RedfishCS_Link *
> +GetNextLink (
> +  const RedfishCS_Link  *List,
> +  const RedfishCS_Link  *Node
> +  );
> +
> +RedfishCS_Link *
> +GetPreviousLink (
> +  const RedfishCS_Link  *List,
> +  const RedfishCS_Link  *Node
> +  );
> +
> +RedfishCS_Link *
> +RemoveLink (
> +  const RedfishCS_Link  *Link
> +  );
> +
> +RedfishCS_bool
> +IsLinkEmpty (
> +  const RedfishCS_Link  *LinkHead
> +  );
> +
> +RedfishCS_bool
> +IsLinkAtEnd (
> +  const RedfishCS_Link  *LinkHead,
> +  const RedfishCS_Link  *ThisLink
> +  );
> +
> +typedef struct _RedfishCS_Internal_memory_link {
> +  RedfishCS_Link    nextLink;
> +  void              *memoryPtr;
> +} RedfishCS_Internal_memory_link;
> +
> +typedef struct _RedfishCS_Internal_memory_root {
> +  RedfishCS_Link    nextRoot;
> +  RedfishCS_Link    memBlocks;
> +  void              *CsPtr;
> +} RedfishCS_Internal_memory_root;
> +
> +#endif
> diff --git a/RedfishClientPkg/ConverterLib/src/RedfishCsCommon.c
> b/RedfishClientPkg/ConverterLib/src/RedfishCsCommon.c
> new file mode 100644
> index 0000000000..212f0de1a8
> --- /dev/null
> +++ b/RedfishClientPkg/ConverterLib/src/RedfishCsCommon.c
> @@ -0,0 +1,1465 @@
> +/** @file
> +
> +  (C) Copyright 2018-2021 Hewlett Packard Enterprise Development LP<BR>
> +
> +  SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +  Copyright Notice:
> +  Copyright 2019-2021 Distributed Management Task Force, Inc. All rights
> reserved.
> +  License: BSD 3-Clause License. For full text see link:
> https://github.c/
> om%2FDMTF%2FRedfish-JSON-C-Struct-
> Converter%2Fblob%2Fmaster%2FLICENSE.md&data=05%7C01%7Cnicklew%40n
> vidia.com%7C6c287e287fb44d40c3e308db4baed8a2%7C43083d15727340c1b7d
> b39efd9ccc17a%7C0%7C0%7C638186986569209689%7CUnknown%7CTWFpbG
> Zsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn
> 0%3D%7C3000%7C%7C%7C&sdata=VKor2rANpdKrvHJ7pEDkfh2XrTqQdtRVZjryv
> urM1ms%3D&reserved=0
> +**/
> +
> +#include "RedfishCsCommon.h"
> +#include "RedfishCsMemoryInternal.h"
> +#include <jansson.h>
> +#include <stdlib.h>
> +#include <string.h>
> +
> +RedfishCS_status
> +GetRedfishPropertyVague (
> +  void             *Cs,
> +  json_t           *JsonObj,
> +  char             *Key,
> +  RedfishCS_Vague  **DstBuffer
> +  );
> +
> +/**
> +  This function initiates a Redfish C Structure link.
> +
> +  ListHead            The link list entry.
> +  Return the list head.
> +
> +**/
> +RedfishCS_Link *
> +InitializeLinkHead (
> +  RedfishCS_Link  *ListHead
> +  )
> +{
> +  ListHead->ForwardLink = ListHead;
> +  ListHead->BackLink    = ListHead;
> +  return ListHead;
> +}
> +
> +/**
> +  This function inserts the list to list head.
> +
> +  ListHead            The link list head.
> +  Entry               The list to insert.
> +
> +  Return the list head.
> +
> +**/
> +RedfishCS_Link *
> +InsertHeadLink (
> +  RedfishCS_Link  *ListHead,
> +  RedfishCS_Link  *Entry
> +  )
> +{
> +  Entry->ForwardLink           = ListHead->ForwardLink;
> +  Entry->BackLink              = ListHead;
> +  Entry->ForwardLink->BackLink = Entry;
> +  ListHead->ForwardLink        = Entry;
> +  return ListHead;
> +}
> +
> +/**
> +  This function inserts the list to list tail.
> +
> +  ListHead            The link list head.
> +  Entry               The list to insert.
> +
> +  Return the list head.
> +
> +**/
> +RedfishCS_Link *
> +InsertTailLink (
> +  RedfishCS_Link  *ListHead,
> +  RedfishCS_Link  *Entry
> +  )
> +{
> +  Entry->ForwardLink           = ListHead;
> +  Entry->BackLink              = ListHead->BackLink;
> +  Entry->BackLink->ForwardLink = Entry;
> +  ListHead->BackLink           = Entry;
> +  return ListHead;
> +}
> +
> +/**
> +  This function gets the first list from the list head.
> +
> +  List            The link list head.
> +
> +  Return the first list *
> +
> +**/
> +RedfishCS_Link *
> +GetFirstLink (
> +  const RedfishCS_Link  *List
> +  )
> +{
> +  return List->ForwardLink;
> +}
> +
> +/**
> +  This function gets the last list from the list head.
> +
> +  List            The link list head.
> +
> +  Return the last list.
> +
> +**/
> +RedfishCS_Link *
> +GetLastLink (
> +  const RedfishCS_Link  *List
> +  )
> +{
> +  return List->BackLink;
> +}
> +
> +/**
> +  This function gets the next list of Node.
> +
> +  List      The link list head.
> +  Node      The list we will get the next list from.
> +
> +  Return the next list.
> +
> +**/
> +RedfishCS_Link *
> +GetNextLink (
> +  const RedfishCS_Link  *List,
> +  const RedfishCS_Link  *Node
> +  )
> +{
> +  return Node->ForwardLink;
> +}
> +
> +/**
> +  This function gets the previous list of Node.
> +
> +  List      The link list head.
> +  Node      The list we will get the previous list from.
> +
> +  Return the previous RedfishCS_Link *
> +
> +**/
> +RedfishCS_Link *
> +GetPreviousLink (
> +  const RedfishCS_Link  *List,
> +  const RedfishCS_Link  *Node
> +  )
> +{
> +  return Node->BackLink;
> +}
> +
> +/**
> +  This function removes a list.
> +
> +  Link      The list to be removed.
> +
> +  Return the next list.
> +
> +**/
> +RedfishCS_Link *
> +RemoveLink (
> +  const RedfishCS_Link  *Link
> +  )
> +{
> +  Link->ForwardLink->BackLink = Link->BackLink;
> +  Link->BackLink->ForwardLink = Link->ForwardLink;
> +  return Link->ForwardLink;
> +}
> +
> +/**
> +  This function checks if the list is empty.
> +
> +  LinkHead      The list head.
> +
> +  Return true if it is empty otherwise it is not empty.
> +
> +**/
> +RedfishCS_bool
> +IsLinkEmpty (
> +  const RedfishCS_Link  *LinkHead
> +  )
> +{
> +  return (RedfishCS_bool)(LinkHead->ForwardLink == LinkHead);
> +}
> +
> +/**
> +  This function checks if the list is at the end.
> +
> +  LinkHead      The list head.
> +  ThisLink      The list to check.
> +
> +  Return true if it is at the end otherwise it is not.
> +
> +**/
> +RedfishCS_bool
> +IsLinkAtEnd (
> +  const RedfishCS_Link  *LinkHead,
> +  const RedfishCS_Link  *ThisLink
> +  )
> +{
> +  return (RedfishCS_bool)(ThisLink->ForwardLink == LinkHead);
> +}
> +
> +/**
> +  This function duplicates a string.
> +
> +  Cs        The CStructure instance that owns the string.
> +  Str       String to be duplicated.
> +  DstBuffer The buffer to retrieve the string.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +allocateDuplicateStr (
> +  void  *Cs,
> +  char  *Str,
> +  void  **DstBuffer
> +  )
> +{
> +  RedfishCS_status  Status;
> +
> +  if ((Str == NULL) || (strlen (Str) == 0)) {
> +    *DstBuffer = NULL;
> +    return RedfishCS_status_success;
> +  }
> +
> +  Status = allocateRecordCsMemory (Cs, (RedfishCS_int)strlen (Str) + 1, (void
> **)DstBuffer);
> +  if (Status != RedfishCS_status_success) {
> +    return Status;
> +  }
> +
> +  memcpy (*DstBuffer, Str, strlen (Str) + 1);
> +  return RedfishCS_status_success;
> +}
> +
> +/**
> +  This function creates an URI type CS by the Odata ID.
> +
> +  JsonOj        JSON object which has odata ID  key.
> +  ParentUri     The parent URI of odata ID.
> +  CsTypeUriData The pointer to retrieve the RedfishCS_Type_Uri_Data.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +CreateCsUriByOdataId (
> +  json_t                   *JsonOj,
> +  RedfishCS_char           *ParentUri,
> +  RedfishCS_Type_Uri_Data  **CsTypeUriData
> +  )
> +{
> +  json_t                   *TempJsonObj;
> +  RedfishCS_Type_Uri_Data  *CsTypeUri;
> +
> +  CsTypeUri   = NULL;
> +  TempJsonObj = json_object_get (JsonOj, "@odata.id");
> +  if (TempJsonObj == NULL) {
> +    return RedfishCS_status_not_found;
> +  }
> +
> +  CsTypeUri = malloc (sizeof (RedfishCS_Type_Uri_Data));
> +  if (CsTypeUri == NULL) {
> +    return RedfishCS_status_insufficient_memory;
> +  }
> +
> +  InitializeLinkHead (&CsTypeUri->Header.LinkEntry);
> +  CsTypeUri->Header.ResourceType = RedfishCS_Type_Uri;
> +  CsTypeUri->Header.ThisUri      = ParentUri;
> +  CsTypeUri->Header.KeyName      = (RedfishCS_char *)strdup ("@odata.id");
> +  CsTypeUri->Uri                 = (RedfishCS_char *)strdup (json_string_value
> (TempJsonObj));
> +  *CsTypeUriData                 = CsTypeUri;
> +  return RedfishCS_status_success;
> +}
> +
> +/**
> +  This function creates URI type CS by node.
> +
> +  Cs            The CStructure instance owns the string.
> +  JsonOj        JSON object which has NodeName key.
> +  NodeName      The JSON key name.
> +  ParentUri     The parent URI of odata ID.
> +  CsTypeUriData The pointer to retrieve the RedfishCS_Type_Uri_Data.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +CreateCsUriByNode (
> +  void                     *Cs,
> +  json_t                   *JsonOj,
> +  RedfishCS_char           *NodeName,
> +  RedfishCS_char           *ParentUri,
> +  RedfishCS_Type_Uri_Data  **CsTypeUriData
> +  )
> +{
> +  json_t                   *TempJsonObj;
> +  json_t                   *TempJsonObj2;
> +  RedfishCS_Type_Uri_Data  *CsTypeUri;
> +  RedfishCS_status         Status;
> +
> +  CsTypeUri = NULL;
> +
> +  if (NodeName != NULL) {
> +    TempJsonObj = json_object_get (JsonOj, NodeName);
> +    if (TempJsonObj == NULL) {
> +      return RedfishCS_status_not_found;
> +    }
> +  } else {
> +    if (JsonOj == NULL) {
> +      return RedfishCS_status_not_found;
> +    }
> +
> +    TempJsonObj = JsonOj;
> +  }
> +
> +  TempJsonObj2 = json_object_get (TempJsonObj, "@odata.id");
> +  if (TempJsonObj2 != NULL) {
> +    Status = allocateRecordCsMemory (Cs, sizeof (RedfishCS_Type_Uri_Data),
> (void **)&CsTypeUri);
> +    if (Status != RedfishCS_status_success) {
> +      return Status;
> +    }
> +
> +    InitializeLinkHead (&CsTypeUri->Header.LinkEntry);
> +    CsTypeUri->Header.ResourceType = RedfishCS_Type_Uri;
> +    CsTypeUri->Header.ThisUri      = ParentUri;
> +    Status                         = allocateDuplicateStr (Cs, NodeName, (void
> **)&CsTypeUri->Header.KeyName);
> +    if (Status != RedfishCS_status_success) {
> +      return Status;
> +    }
> +
> +    *CsTypeUriData = CsTypeUri;
> +    Status         = allocateDuplicateStr (Cs, (char *)json_string_value
> (TempJsonObj2), (void **)&CsTypeUri->Uri);
> +    return Status;
> +  }
> +
> +  return RedfishCS_status_invalid_parameter;
> +}
> +
> +/**
> +  This function creates JSON type CS by node.
> +
> +  Cs             The CStructure instance owns the string.
> +  JsonOj         JSON object which has NodeName key.
> +  NodeName       The JSON key name.
> +  ParentUri      The parent URI of odata ID.
> +  CsTypeJsonData The pointer to retrieve the RedfishCS_Type_JSON_Data.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +CreateCsJsonByNode (
> +  void                      *Cs,
> +  json_t                    *JsonObj,
> +  RedfishCS_char            *NodeName,
> +  RedfishCS_char            *ParentUri,
> +  RedfishCS_Type_JSON_Data  **CsTypeJsonData
> +  )
> +{
> +  json_t                    *TempJsonObj;
> +  RedfishCS_Type_JSON_Data  *CsTypeJson;
> +  RedfishCS_char            *TempChar;
> +  RedfishCS_char            *DumpStr;
> +  RedfishCS_status          Status;
> +
> +  CsTypeJson = NULL;
> +  if (NodeName != NULL) {
> +    TempJsonObj = json_object_get (JsonObj, NodeName);
> +    if (TempJsonObj == NULL) {
> +      return RedfishCS_status_not_found;
> +    }
> +  } else {
> +    // Dump JSON from JsonObj.
> +    TempJsonObj = JsonObj;
> +  }
> +
> +  TempChar = json_dumps ((json_t *)TempJsonObj, JSON_INDENT (2));
> +  if (TempChar != NULL) {
> +    Status = allocateRecordCsMemory (Cs, sizeof (RedfishCS_Type_JSON_Data),
> (void **)&CsTypeJson);
> +    if (Status != RedfishCS_status_success) {
> +      return Status;
> +    }
> +
> +    Status = allocateRecordCsMemory (Cs, (RedfishCS_int)strlen (TempChar) + 1,
> (void **)&DumpStr);
> +    if (Status != RedfishCS_status_success) {
> +      return Status;
> +    }
> +
> +    strncpy (DumpStr, TempChar, strlen (TempChar) + 1);
> +    InitializeLinkHead (&CsTypeJson->Header.LinkEntry);
> +    CsTypeJson->Header.ResourceType = RedfishCS_Type_JSON;
> +    CsTypeJson->Header.ThisUri      = ParentUri;
> +    Status                          = allocateDuplicateStr (Cs, NodeName, (void
> **)&CsTypeJson->Header.KeyName);
> +    if (Status != RedfishCS_status_success) {
> +      return Status;
> +    }
> +
> +    CsTypeJson->JsonText = DumpStr;
> +    *CsTypeJsonData      = CsTypeJson;
> +    return RedfishCS_status_success;
> +  }
> +
> +  return RedfishCS_status_invalid_parameter;
> +}
> +
> +/**
> +  This function creates an empty property type CS by node.
> +
> +  Cs                    The CStructure instance owns the string.
> +  JsonOj                JSON object which has the NodeName.
> +  NodeName              The JSON key name.
> +  ParentUri             The parent URI of odata ID.
> +  CsTypeEmptyPropCSData The pointer to retrieve the CsTypeEmptyPropCSData.
> +  NunmOfProperties      Number of properties in CS.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +CreateEmptyPropCsJson (
> +  RedfishCS_void                    *Cs,
> +  json_t                            *JsonObj,
> +  RedfishCS_char                    *NodeName,
> +  RedfishCS_char                    *ParentUri,
> +  RedfishCS_Type_EmptyProp_CS_Data  **CsTypeEmptyPropCSData,
> +  RedfishCS_uint32                  NunmOfProperties
> +  )
> +{
> +  json_t                            *TempJsonObj;
> +  RedfishCS_status                  Status;
> +  RedfishCS_Type_EmptyProp_CS_Data  *CsTypeEmptyPropCS;
> +  RedfishCS_char                    *KeyName;
> +  json_t                            *KeyValueObj;
> +  RedfishCS_void                    *n;
> +  RedfishCS_EmptyProp_KeyValue      **KeyValuePtr;
> +  RedfishCS_EmptyProp_KeyValue      *KeyValue;
> +
> +  CsTypeEmptyPropCS = NULL;
> +  if (NodeName != NULL) {
> +    TempJsonObj = json_object_get (JsonObj, NodeName);
> +    if (TempJsonObj == NULL) {
> +      return RedfishCS_status_not_found;
> +    }
> +  }
> +
> +  Status = allocateRecordCsMemory (Cs, sizeof
> (RedfishCS_Type_EmptyProp_CS_Data), (void **)&CsTypeEmptyPropCS);
> +  if (Status != RedfishCS_status_success) {
> +    return Status;
> +  }
> +
> +  InitializeLinkHead (&CsTypeEmptyPropCS->Header.LinkEntry);
> +  CsTypeEmptyPropCS->Header.ResourceType =
> RedfishCS_Type_CS_EmptyProp;
> +  CsTypeEmptyPropCS->Header.ThisUri      = ParentUri;
> +  Status                                 = allocateDuplicateStr (Cs, NodeName, (void
> **)&CsTypeEmptyPropCS->Header.KeyName);
> +  if (Status != RedfishCS_status_success) {
> +    return Status;
> +  }
> +
> +  CsTypeEmptyPropCS->NunmOfProperties = NunmOfProperties;
> +  //
> +  // Create instance for each key-value.
> +  //
> +  KeyValuePtr = &CsTypeEmptyPropCS->KeyValuePtr;
> +  json_object_foreach_safe (TempJsonObj, n, KeyName, KeyValueObj) {
> +    Status = allocateRecordCsMemory (Cs, sizeof
> (RedfishCS_EmptyProp_KeyValue), (void **)&KeyValue);
> +    if (Status != RedfishCS_status_success) {
> +      return Status;
> +    }
> +
> +    Status = allocateDuplicateStr (Cs, (char *)KeyName, (void **)&KeyValue-
> >KeyNamePtr);
> +    if (Status != RedfishCS_status_success) {
> +      return Status;
> +    }
> +
> +    Status = GetRedfishPropertyVague (Cs, TempJsonObj, (char *)KeyName,
> &KeyValue->Value);
> +    if (Status != RedfishCS_status_success) {
> +      return Status;
> +    }
> +
> +    *KeyValuePtr = KeyValue;
> +    KeyValuePtr  = &KeyValue->NextKeyValuePtr;
> +  }
> +
> +  *CsTypeEmptyPropCSData = CsTypeEmptyPropCS;
> +  return RedfishCS_status_success;
> +}
> +
> +/**
> +  This function checks if property type is supported.
> +
> +  JsonOj     JSON object of this property.
> +
> +  Return RedfishCS_bool.
> +
> +**/
> +RedfishCS_bool
> +CheckSupportedPropTypeInEmptyProperty (
> +  json_t  *JsonObj
> +  )
> +{
> +  //
> +  // Only support below property types for the property is declared as
> +  // empty property in schema.
> +  //  e.g. "properties": {}
> +  //
> +  if (json_is_string (JsonObj) ||
> +      json_is_integer (JsonObj) ||
> +      // json_is_real(JsonObj) ||
> +      json_is_number (JsonObj) ||
> +      json_is_boolean (JsonObj))
> +  {
> +    return RedfishCS_boolean_true;
> +  }
> +
> +  return RedfishCS_boolean_false;
> +}
> +
> +/**
> +  This function checks the properties in a empty property type JSON object.
> +  Also returns the number of properties in NumOfProperty.
> +
> +  JsonOj         JSON object
> +  NumOfProperty  Pointer to retrieve the number of property in JSON object.
> +
> +  Return RedfishCS_bool.
> +
> +**/
> +RedfishCS_bool
> +CheckEmptyPropJsonObject (
> +  json_t            *JsonObj,
> +  RedfishCS_uint32  *NumOfProperty
> +  )
> +{
> +  RedfishCS_char    *NewKey;
> +  json_t            *Value;
> +  RedfishCS_void    *n;
> +  RedfishCS_uint32  Num;
> +
> +  Num = 0;
> +  json_object_foreach_safe (JsonObj, n, NewKey, Value) {
> +    if (!CheckSupportedPropTypeInEmptyProperty (Value)) {
> +      return RedfishCS_boolean_false;
> +    }
> +
> +    Num++;
> +  }
> +  if (NumOfProperty != NULL) {
> +    *NumOfProperty = Num;
> +  }
> +
> +  return RedfishCS_boolean_true;
> +}
> +
> +/**
> +  This function checks if this is a supported Redfish resource.
> +
> +  Odata_Type    The string to Odata type.
> +  NameSpace     The string to the Redfish schema name space.
> +  Version       The string to the Redfish schema version.
> +  DataType      The string to the data type defined in Redfish schema.
> +
> +  Return RedfishCS_bool.
> +
> +**/
> +RedfishCS_bool
> +SupportedRedfishResource (
> +  RedfishCS_char  *Odata_Type,
> +  RedfishCS_char  *NameSpace,
> +  RedfishCS_char  *Version,
> +  RedfishCS_char  *DataType
> +  )
> +{
> +  RedfishCS_char  *TargetDataType;
> +
> +  if ((Odata_Type == NULL) || (NameSpace == NULL) || (DataType == NULL)) {
> +    return RedfishCS_boolean_false;
> +  }
> +
> +  if (Version != NULL) {
> +    TargetDataType = malloc (strlen (NameSpace) + strlen (Version) + strlen
> (DataType) + 16); // Plus 16 bytes to make more room.
> +                                                                                              // Actually we just need 1
> byte for "#"
> +                                                                                              // Two bytes for "." and
> one byte for NULL terminator.
> +  } else {
> +    TargetDataType = malloc (strlen (NameSpace) + strlen (DataType) + 16); //
> Plus 16 bytes to make more room.
> +                                                                           // Actually we just need 1 byte for "#"
> +                                                                           // Two bytes for "." and one byte for
> NULL terminator.
> +  }
> +
> +  if (TargetDataType == NULL) {
> +    return RedfishCS_boolean_false;
> +  }
> +
> +  TargetDataType[0] = 0;  // Insert NULL terminator.
> +  strcat (TargetDataType, "#");
> +  strcat (TargetDataType, NameSpace);
> +  strcat (TargetDataType, ".");
> +  if ((Version != NULL) && (strcmp (Version, "noversioned") != 0)) {
> +    strcat (TargetDataType, Version);
> +    strcat (TargetDataType, ".");
> +  }
> +
> +  strcat (TargetDataType, DataType);
> +  if (strcmp (Odata_Type, TargetDataType) == 0) {
> +    return RedfishCS_boolean_true;
> +  }
> +
> +  free (TargetDataType);
> +  return RedfishCS_boolean_false;
> +}
> +
> +/**
> +  This function creates JSON or URI type CS according to the
> +  number of properties in JSON object.
> +
> +  Cs            he CStructure instance owns the new created CS.
> +  JsonObj       JSON object which has NodeName key.
> +  NodeName      The key name in JSON object.
> +  ParentUri     The parent URI.
> +  LinkHead      The list head to link with the new CS.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +CreateCsUriOrJsonByNode (
> +  void            *Cs,
> +  json_t          *JsonObj,
> +  RedfishCS_char  *NodeName,
> +  RedfishCS_char  *ParentUri,
> +  RedfishCS_Link  *LinkHead
> +  )
> +{
> +  json_t                    *JsonObjTemp;
> +  RedfishCS_Type_Uri_Data   *CsTypeUri;
> +  RedfishCS_Type_JSON_Data  *CsTypeJson;
> +  RedfishCS_status          Status;
> +
> +  Status      = RedfishCS_status_invalid_parameter;
> +  JsonObjTemp = json_object_get (JsonObj, NodeName);
> +  if (JsonObjTemp == NULL) {
> +    return RedfishCS_status_not_found;
> +  }
> +
> +  if (json_object_size (JsonObjTemp) == 1) {
> +    Status = CreateCsUriByNode (Cs, JsonObj, NodeName, ParentUri,
> &CsTypeUri);
> +    if (Status == RedfishCS_status_success) {
> +      InsertTailLink (LinkHead, &CsTypeUri->Header.LinkEntry);
> +      return RedfishCS_status_success;
> +    }
> +  } else {
> +    Status = CreateCsJsonByNode (Cs, JsonObj, NodeName, ParentUri,
> &CsTypeJson);
> +    if (Status == RedfishCS_status_success) {
> +      InsertTailLink (LinkHead, &CsTypeJson->Header.LinkEntry);
> +      return RedfishCS_status_success;
> +    }
> +  }
> +
> +  return Status;
> +}
> +
> +/**
> +  This function creates JSON or URI array type CS according to the
> +  number of properties in JSON object.
> +
> +  Cs            he CStructure instance owns the new created CS.
> +  JsonObj       JSON object which has NodeName.
> +  NodeName      The key name in JSON object.
> +  ParentUri     The parent URI.
> +  LinkHead      The list head to link with the new CS.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +CreateCsUriOrJsonByNodeArray (
> +  void            *Cs,
> +  json_t          *JsonObj,
> +  RedfishCS_char  *NodeName,
> +  RedfishCS_char  *ParentUri,
> +  RedfishCS_Link  *LinkHead
> +  )
> +{
> +  json_t                    *JsonObjTemp;
> +  json_t                    *JsonObjArray;
> +  RedfishCS_Type_Uri_Data   *CsTypeUri;
> +  RedfishCS_Type_JSON_Data  *CsTypeJson;
> +  RedfishCS_status          Status;
> +  RedfishCS_uint16          ArrayIndex;
> +
> +  Status      = RedfishCS_status_invalid_parameter;
> +  JsonObjTemp = json_object_get (JsonObj, NodeName);
> +  if (JsonObjTemp == NULL) {
> +    return RedfishCS_status_not_found;
> +  }
> +
> +  if (json_array_size (JsonObjTemp) == 0) {
> +    return RedfishCS_status_success;
> +  }
> +
> +  for (ArrayIndex = 0; ArrayIndex < (RedfishCS_uint16)json_array_size
> (JsonObjTemp); ArrayIndex++) {
> +    JsonObjArray = json_array_get (JsonObjTemp, (size_t)ArrayIndex);
> +    if (JsonObjArray == NULL) {
> +      continue;
> +    }
> +
> +    if (json_object_size (JsonObjArray) == 1) {
> +      Status = CreateCsUriByNode (Cs, JsonObjArray, NULL, ParentUri,
> &CsTypeUri);
> +      if (Status == RedfishCS_status_success) {
> +        InsertTailLink (LinkHead, &CsTypeUri->Header.LinkEntry);
> +      }
> +    } else {
> +      Status = CreateCsJsonByNode (Cs, JsonObjArray, NULL, ParentUri,
> &CsTypeJson);
> +      if (Status == RedfishCS_status_success) {
> +        InsertTailLink (LinkHead, &CsTypeJson->Header.LinkEntry);
> +      }
> +    }
> +  }
> +
> +  return RedfishCS_status_success;
> +}
> +
> +/**
> +  This function creates JSON object and CS.
> +
> +  JsonRawText     JSON raw text.
> +  ResourceType    The Redfish resource type.
> +  ResourceVersion The Redfish resource version.
> +  TypeName        The Redfish type name.
> +  JsonObjReturned Pointer to retrieve JSON object.
> +  Cs              Pointer to retrieve CS.
> +  size            The size of CS.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +CreateJsonPayloadAndCs (
> +  char    *JsonRawText,
> +  char    *ResourceType,
> +  char    *ResourceVersion,
> +  char    *TypeName,
> +  json_t  **JsonObjReturned,
> +  void    **Cs,
> +  int     size
> +  )
> +{
> +  json_t            *TempJsonObj;
> +  RedfishCS_char    *TempChar;
> +  RedfishCS_Header  *Header;
> +  void              *TempCS;
> +
> +  if ((JsonRawText == NULL) ||
> +      (ResourceType == NULL) ||
> +      (TypeName == NULL) ||
> +      (Cs == NULL) ||
> +      (size == 0)
> +      )
> +  {
> +    return RedfishCS_status_invalid_parameter;
> +  }
> +
> +  *JsonObjReturned = json_loads (JsonRawText, 0, NULL);
> +  if (*JsonObjReturned == NULL) {
> +    return RedfishCS_status_unknown_error;
> +  }
> +
> +  TempJsonObj = json_object_get (*JsonObjReturned, "@odata.type");
> +  if (TempJsonObj == NULL) {
> +    return RedfishCS_status_invalid_parameter;
> +  }
> +
> +  TempChar = (RedfishCS_char *)json_string_value (TempJsonObj);
> +  if ((TempChar == NULL) || !SupportedRedfishResource (TempChar,
> ResourceType, ResourceVersion, TypeName)) {
> +    return RedfishCS_status_unsupported;
> +  }
> +
> +  TempCS = malloc (size);
> +  if (TempCS == NULL) {
> +    return RedfishCS_status_insufficient_memory;
> +  }
> +
> +  memset (TempCS, 0, size);
> +  Header               = (RedfishCS_Header *)TempCS;
> +  Header->ResourceType = RedfishCS_Type_CS;
> +  Header->KeyName      = NULL;
> +  InitializeLinkHead (&Header->LinkEntry);
> +  *Cs = TempCS;
> +  return recordCsRootMemory (TempCS);
> +}
> +
> +/**
> +  This function returns a Redfish string property.
> +
> +  Cs         The owner of this property.
> +  JsonObj    The JSON object has the Key.
> +  Key        The key in JSON object.
> +  DstBuffer  Pointer to retrieve a string.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +GetRedfishPropertyStr (
> +  void            *Cs,
> +  json_t          *JsonObj,
> +  char            *Key,
> +  RedfishCS_char  **DstBuffer
> +  )
> +{
> +  json_t            *TempJsonObj;
> +  RedfishCS_status  Status;
> +
> +  if (DstBuffer == NULL) {
> +    return RedfishCS_status_invalid_parameter;
> +  }
> +
> +  *DstBuffer = NULL;
> +
> +  TempJsonObj = json_object_get (JsonObj, Key);
> +  if (TempJsonObj == NULL) {
> +    return RedfishCS_status_not_found;
> +  }
> +
> +  Status = allocateDuplicateStr (Cs, (char *)json_string_value (TempJsonObj),
> (void **)DstBuffer);
> +  return Status;
> +}
> +
> +/**
> +  This function returns a Redfish bool property.
> +
> +  Cs         The owner of this property.
> +  JsonObj    The JSON object has the Key.
> +  Key        The key in JSON object.
> +  DstBuffer  Pointer to retrieve a boolean.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +GetRedfishPropertyBoolean (
> +  void            *Cs,
> +  json_t          *JsonObj,
> +  char            *Key,
> +  RedfishCS_bool  **DstBuffer
> +  )
> +{
> +  json_t            *TempJsonObj;
> +  RedfishCS_status  Status;
> +
> +  if (DstBuffer == NULL) {
> +    return RedfishCS_status_not_found;
> +  }
> +
> +  TempJsonObj = json_object_get (JsonObj, Key);
> +  if (TempJsonObj == NULL) {
> +    return RedfishCS_status_not_found;
> +  }
> +
> +  Status = allocateRecordCsMemory (Cs, sizeof (RedfishCS_bool), (void
> **)DstBuffer);
> +  if (Status != RedfishCS_status_success) {
> +    return Status;
> +  }
> +
> +  if (json_is_true (TempJsonObj)) {
> +    **DstBuffer = RedfishCS_boolean_true;
> +  } else {
> +    **DstBuffer = RedfishCS_boolean_false;
> +  }
> +
> +  return RedfishCS_status_success;
> +}
> +
> +/**
> +  This function returns Redfish a long long property.
> +
> +  Cs         The owner of this property.
> +  JsonObj    The JSON object has the Key.
> +  Key        The key in JSON object.
> +  DstBuffer  Pointer to retrieve a long long value.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +GetRedfishPropertyInt64 (
> +  void             *Cs,
> +  json_t           *JsonObj,
> +  char             *Key,
> +  RedfishCS_int64  **Dst
> +  )
> +{
> +  RedfishCS_status  Status;
> +  json_t            *TempJsonObj;
> +
> +  if (Dst == NULL) {
> +    return RedfishCS_status_invalid_parameter;
> +  }
> +
> +  TempJsonObj = json_object_get (JsonObj, Key);
> +  if (TempJsonObj == NULL) {
> +    return RedfishCS_status_not_found;
> +  }
> +
> +  Status = allocateRecordCsMemory (Cs, sizeof (RedfishCS_int64), (void **)Dst);
> +  if (Status != RedfishCS_status_success) {
> +    return Status;
> +  }
> +
> +  **Dst = (RedfishCS_int64)json_integer_value (TempJsonObj);
> +  return RedfishCS_status_success;
> +}
> +
> +/**
> +  This function returns a type-agnostic property.
> +
> +  Cs         The owner of this property.
> +  JsonObj    The JSON object has the Key.
> +  Key        The key in JSON object.
> +  DstBuffer  Pointer to retrieve a type agnostic value.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +GetRedfishPropertyVague (
> +  void             *Cs,
> +  json_t           *JsonObj,
> +  char             *Key,
> +  RedfishCS_Vague  **DstBuffer
> +  )
> +{
> +  json_t            *TempJsonObj;
> +  RedfishCS_status  Status;
> +  RedfishCS_Vague   *VagueData;
> +
> +  if (DstBuffer == NULL) {
> +    return RedfishCS_status_not_found;
> +  }
> +
> +  TempJsonObj = json_object_get (JsonObj, Key);
> +  if (TempJsonObj == NULL) {
> +    return RedfishCS_status_not_found;
> +  }
> +
> +  Status = allocateRecordCsMemory (Cs, sizeof (RedfishCS_Vague), (void
> **)&VagueData);
> +  if (Status != RedfishCS_status_success) {
> +    return Status;
> +  }
> +
> +  if (json_is_string (TempJsonObj)) {
> +    VagueData->DataType = RedfishCS_Vague_DataType_String;
> +    Status              = GetRedfishPropertyStr (Cs, JsonObj, Key, &VagueData-
> >DataValue.CharPtr);
> +  } else if (json_is_integer (TempJsonObj)) {
> +    VagueData->DataType = RedfishCS_Vague_DataType_Int64;
> +    Status              = GetRedfishPropertyInt64 (Cs, JsonObj, Key, &VagueData-
> >DataValue.Int64Ptr);
> +  } else if (json_is_boolean (TempJsonObj)) {
> +    VagueData->DataType = RedfishCS_Vague_DataType_Bool;
> +    Status              = GetRedfishPropertyBoolean (Cs, JsonObj, Key, &VagueData-
> >DataValue.BoolPtr);
> +  } else if (json_is_null (TempJsonObj)) {
> +    *DstBuffer = NULL; // No value for this key
> +    free (VagueData);
> +    return RedfishCS_status_success;
> +  } else {
> +    return RedfishCS_status_unsupported;
> +  }
> +
> +  if (Status == RedfishCS_status_success) {
> +    *DstBuffer = VagueData;
> +  }
> +
> +  return Status;
> +}
> +
> +/**
> +  This function inserts a string JSON object.
> +
> +  ParentJsonObj  The parent JSON object
> +  Key            JSON key to insert.
> +  StringValue    Value of string to insert.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +InsertJsonStringObj (
> +  json_t          *ParentJsonObj,
> +  char            *Key,
> +  RedfishCS_char  *StringValue
> +  )
> +{
> +  json_t          *JsonValue;
> +  RedfishCS_char  NullStr[] = "";
> +  RedfishCS_char  *InsertStr;
> +
> +  InsertStr = StringValue;
> +  if (ParentJsonObj == NULL) {
> +    return RedfishCS_status_invalid_parameter;
> +  }
> +
> +  if (InsertStr == (char *)NULL) {
> +    InsertStr = NullStr;
> +  }
> +
> +  JsonValue = json_string (InsertStr);
> +  if (JsonValue == NULL) {
> +    return RedfishCS_status_unsupported;
> +  }
> +
> +  if (json_object_set_new (ParentJsonObj, Key, JsonValue) == -1) {
> +    return RedfishCS_status_unsupported;
> +  }
> +
> +  return RedfishCS_status_success;
> +}
> +
> +/**
> +  This function inserts a bool JSON object.
> +
> +  ParentJsonObj  The parent JSON object
> +  Key            JSON key to insert.
> +  BoolValue      Value of a bool to insert.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +InsertJsonBoolObj (
> +  json_t          *ParentJsonObj,
> +  char            *Key,
> +  RedfishCS_bool  *BoolValue
> +  )
> +{
> +  json_t  *JsonValue;
> +
> +  if (ParentJsonObj == NULL) {
> +    return RedfishCS_status_invalid_parameter;
> +  }
> +
> +  if (BoolValue == (RedfishCS_bool *)NULL) {
> +    return RedfishCS_status_success; // No value for this key.
> +  }
> +
> +  JsonValue = json_boolean ((BOOLEAN)*BoolValue);
> +  if (JsonValue == NULL) {
> +    return RedfishCS_status_unsupported;
> +  }
> +
> +  if (json_object_set_new (ParentJsonObj, Key, JsonValue) == -1) {
> +    return RedfishCS_status_unsupported;
> +  }
> +
> +  return RedfishCS_status_success;
> +}
> +
> +/**
> +  This function inserts a long long value JSON object.
> +
> +  ParentJsonObj  The parent JSON object
> +  Key            JSON key to insert.
> +  Int64Value     Value of a long long to insert.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +InsertJsonInt64Obj (
> +  json_t           *ParentJsonObj,
> +  char             *Key,
> +  RedfishCS_int64  *Int64Value
> +  )
> +{
> +  json_t  *JsonValue;
> +
> +  if (ParentJsonObj == NULL) {
> +    return RedfishCS_status_invalid_parameter;
> +  }
> +
> +  if (Int64Value == (RedfishCS_int64 *)NULL) {
> +    return RedfishCS_status_success; // No value for this key.
> +  }
> +
> +  JsonValue = json_integer ((json_int_t)*Int64Value);
> +  if (JsonValue == NULL) {
> +    return RedfishCS_status_unsupported;
> +  }
> +
> +  if (json_object_set_new (ParentJsonObj, Key, JsonValue) == -1) {
> +    return RedfishCS_status_unsupported;
> +  }
> +
> +  return RedfishCS_status_success;
> +}
> +
> +/**
> +  This function inserts a type-agnostic JSON object.
> +
> +  ParentJsonObj  The parent JSON object
> +  Key            JSON key to insert.
> +  VagueValue     Value of a type agnostic value to insert.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +InsertJsonVagueObj (
> +  json_t           *ParentJsonObj,
> +  char             *Key,
> +  RedfishCS_Vague  *VagueValue
> +  )
> +{
> +  json_t          *JsonValue;
> +  RedfishCS_char  NullStr[] = "";
> +
> +  if (ParentJsonObj == NULL) {
> +    return RedfishCS_status_invalid_parameter;
> +  }
> +
> +  if (VagueValue == (RedfishCS_Vague *)NULL) {
> +    JsonValue = json_null (); // No value for this key.
> +  } else if (VagueValue->DataType == RedfishCS_Vague_DataType_String) {
> +    if (VagueValue->DataValue.CharPtr == NULL) {
> +      JsonValue = json_string (NullStr);
> +    } else {
> +      JsonValue = json_string (VagueValue->DataValue.CharPtr);
> +    }
> +  } else if (VagueValue->DataType == RedfishCS_Vague_DataType_Int64) {
> +    JsonValue = json_integer ((json_int_t)*VagueValue->DataValue.Int64Ptr);
> +  } else if (VagueValue->DataType == RedfishCS_Vague_DataType_Bool) {
> +    JsonValue = json_boolean ((BOOLEAN)*VagueValue->DataValue.BoolPtr);
> +  } else {
> +    return RedfishCS_status_invalid_parameter;
> +  }
> +
> +  if (json_object_set_new (ParentJsonObj, Key, JsonValue) == -1) {
> +    return RedfishCS_status_unsupported;
> +  }
> +
> +  return RedfishCS_status_success;
> +}
> +
> +/**
> +  This function inserts a link type JSON object.
> +
> +  ParentJsonObj  The parent JSON object
> +  Key            JSON key to insert.
> +  Link           Value of a link type to insert.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +InsertJsonLinkObj (
> +  json_t          *JsonObj,
> +  char            *Key,
> +  RedfishCS_Link  *Link
> +  )
> +{
> +  json_t                    *JsonTextObj;
> +  RedfishCS_Type_JSON_Data  *CsJsonHeader;
> +
> +  if ((Link == NULL) || (JsonObj == NULL)) {
> +    return RedfishCS_status_invalid_parameter;
> +  }
> +
> +  if (IsLinkEmpty (Link)) {
> +    return RedfishCS_status_success;
> +  }
> +
> +  CsJsonHeader = (RedfishCS_Type_JSON_Data *)GetFirstLink (Link);
> +  if ((CsJsonHeader->Header.ResourceType != RedfishCS_Type_JSON) &&
> +      (CsJsonHeader->Header.ResourceType != RedfishCS_Type_Uri))
> +  {
> +    // Only support JSON/URI property for CStructure to JSON
> +    return RedfishCS_status_unsupported;
> +  }
> +
> +  if (CsJsonHeader->JsonText == NULL) {
> +    return RedfishCS_status_invalid_parameter;
> +  }
> +
> +  if (CsJsonHeader->Header.ResourceType == RedfishCS_Type_JSON) {
> +    JsonTextObj = json_loads (CsJsonHeader->JsonText, 0, NULL);
> +    if (json_object_set_new (JsonObj, Key, JsonTextObj) == -1) {
> +      return RedfishCS_status_unsupported;
> +    }
> +  } else {
> +    JsonTextObj = json_string (CsJsonHeader->JsonText);
> +    if (json_object_set_new (JsonObj, Key, JsonTextObj) == -1) {
> +      return RedfishCS_status_unsupported;
> +    }
> +  }
> +
> +  return RedfishCS_status_success;
> +}
> +
> +/**
> +  This function inserts an array of string JSON object.
> +
> +  ParentJsonObj    The parent JSON object
> +  Key              JSON key to insert.
> +  StringValueArray Value of a string array to insert.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +InsertJsonStringArrayObj (
> +  json_t                *ParentJsonObj,
> +  char                  *Key,
> +  RedfishCS_char_Array  *StringValueArray
> +  )
> +{
> +  json_t                *ArrayJson;
> +  json_t                *ArrayMember;
> +  RedfishCS_char_Array  *NextArray;
> +  RedfishCS_char        NullStr[] = "";
> +
> +  if (ParentJsonObj == NULL) {
> +    return RedfishCS_status_invalid_parameter;
> +  }
> +
> +  if (StringValueArray == (RedfishCS_char_Array *)NULL) {
> +    return RedfishCS_status_success; // No value for this key.
> +  }
> +
> +  ArrayJson = json_array ();
> +  if (ArrayJson == NULL) {
> +    return RedfishCS_status_unsupported;
> +  }
> +
> +  NextArray = StringValueArray;
> +  do {
> +    if (NextArray->ArrayValue == NULL) {
> +      ArrayMember = json_string (NullStr);
> +    } else {
> +      ArrayMember = json_string (NextArray->ArrayValue);
> +    }
> +
> +    if (json_array_append_new (ArrayJson, ArrayMember) != 0) {
> +      return RedfishCS_status_unsupported;
> +    }
> +
> +    NextArray = NextArray->Next;
> +  } while (NextArray != NULL);
> +
> +  if (json_object_set_new (ParentJsonObj, Key, ArrayJson) == -1) {
> +    return RedfishCS_status_unsupported;
> +  }
> +
> +  return RedfishCS_status_success;
> +}
> +
> +/**
> +  This function inserts an array of bool JSON object.
> +
> +  ParentJsonObj    The parent JSON object
> +  Key              JSON key to insert.
> +  BoolValueArray   Value of a bool array to insert.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +InsertJsonBoolArrayObj (
> +  json_t                *ParentJsonObj,
> +  char                  *Key,
> +  RedfishCS_bool_Array  *BoolValueArray
> +  )
> +{
> +  json_t                *ArrayJson;
> +  json_t                *ArrayMember;
> +  RedfishCS_bool_Array  *NextArray;
> +
> +  if (ParentJsonObj == NULL) {
> +    return RedfishCS_status_invalid_parameter;
> +  }
> +
> +  if (BoolValueArray == (RedfishCS_bool_Array *)NULL) {
> +    return RedfishCS_status_success; // No value for this key.
> +  }
> +
> +  ArrayJson = json_array ();
> +  if (ArrayJson == NULL) {
> +    return RedfishCS_status_unsupported;
> +  }
> +
> +  NextArray = BoolValueArray;
> +  do {
> +    ArrayMember = json_boolean ((BOOLEAN)*NextArray->ArrayValue);
> +    if (json_array_append_new (ArrayJson, ArrayMember) != 0) {
> +      return RedfishCS_status_unsupported;
> +    }
> +
> +    NextArray = NextArray->Next;
> +  } while (NextArray != NULL);
> +
> +  if (json_object_set_new (ParentJsonObj, Key, ArrayJson) == -1) {
> +    return RedfishCS_status_unsupported;
> +  }
> +
> +  return RedfishCS_status_success;
> +}
> +
> +/**
> +  This function inserts an array of long long value JSON object.
> +
> +  ParentJsonObj    The parent JSON object
> +  Key              JSON key to insert.
> +  Int64ValueArray  Value of a long long array to insert.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +InsertJsonInt64ArrayObj (
> +  json_t                 *ParentJsonObj,
> +  char                   *Key,
> +  RedfishCS_int64_Array  *Int64ValueArray
> +  )
> +{
> +  json_t                 *ArrayJson;
> +  json_t                 *ArrayMember;
> +  RedfishCS_int64_Array  *NextArray;
> +
> +  if (ParentJsonObj == NULL) {
> +    return RedfishCS_status_invalid_parameter;
> +  }
> +
> +  if (Int64ValueArray == (RedfishCS_int64_Array *)NULL) {
> +    return RedfishCS_status_success; // No value for this key.
> +  }
> +
> +  ArrayJson = json_array ();
> +  if (ArrayJson == NULL) {
> +    return RedfishCS_status_unsupported;
> +  }
> +
> +  NextArray = Int64ValueArray;
> +  do {
> +    ArrayMember = json_integer (*NextArray->ArrayValue);
> +    if (json_array_append_new (ArrayJson, ArrayMember) != 0) {
> +      return RedfishCS_status_unsupported;
> +    }
> +
> +    NextArray = NextArray->Next;
> +  } while (NextArray != NULL);
> +
> +  if (json_object_set_new (ParentJsonObj, Key, ArrayJson) == -1) {
> +    return RedfishCS_status_unsupported;
> +  }
> +
> +  return RedfishCS_status_success;
> +}
> +
> +/**
> +  This function inserts an array of link JSON object.
> +
> +  ParentJsonObj    The parent JSON object
> +  Key              JSON key to insert.
> +  LinkArray        Value of a link array to insert.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +InsertJsonLinkArrayObj (
> +  json_t          *ParentJsonObj,
> +  char            *Key,
> +  RedfishCS_Link  *LinkArray
> +  )
> +{
> +  json_t                   *ArrayJson;
> +  json_t                   *ArrayMember;
> +  RedfishCS_Type_Uri_Data  *ThisLink;
> +
> +  if (ParentJsonObj == NULL) {
> +    return RedfishCS_status_invalid_parameter;
> +  }
> +
> +  if (IsLinkEmpty (LinkArray)) {
> +    return RedfishCS_status_success;
> +  }
> +
> +  ArrayJson = json_array ();
> +  if (ArrayJson == NULL) {
> +    return RedfishCS_status_unsupported;
> +  }
> +
> +  ThisLink = (RedfishCS_Type_Uri_Data *)GetFirstLink (LinkArray);
> +  while (RedfishCS_boolean_true) {
> +    if (ThisLink->Header.ResourceType != RedfishCS_Type_Uri) {
> +      return RedfishCS_status_invalid_parameter;
> +    }
> +
> +    if (ThisLink->Uri != (RedfishCS_char *)NULL) {
> +      ArrayMember = json_string (ThisLink->Uri);
> +      if (json_array_append_new (ArrayJson, ArrayMember) != 0) {
> +        return RedfishCS_status_unsupported;
> +      }
> +    }
> +
> +    if (IsLinkAtEnd (LinkArray, &ThisLink->Header.LinkEntry)) {
> +      if (json_object_set_new (ParentJsonObj, Key, ArrayJson) == -1) {
> +        return RedfishCS_status_unsupported;
> +      }
> +
> +      return RedfishCS_status_success;
> +    }
> +
> +    ThisLink = (RedfishCS_Type_Uri_Data *)GetNextLink (LinkArray, &ThisLink-
> >Header.LinkEntry);
> +  }
> +
> +  return RedfishCS_status_success;
> +}
> +
> +/**
> +  This function inserts an empty property type JSON object.
> +
> +  ParentJsonObj    The parent JSON object
> +  Key              JSON key to insert.
> +  Link             Value of an empty property type link.
> +
> +  Return RedfishCS_status.
> +
> +**/
> +RedfishCS_status
> +CsEmptyPropLinkToJson (
> +  json_t          *ParentJsonObj,
> +  char            *Key,
> +  RedfishCS_Link  *Link
> +  )
> +{
> +  RedfishCS_uint32                  Index;
> +  RedfishCS_Type_EmptyProp_CS_Data  *EmptyProp_CS_Ptr;
> +  RedfishCS_EmptyProp_KeyValue      *KeyValuePtr;
> +  json_t                            *JsonObj;
> +  RedfishCS_status                  Status;
> +
> +  EmptyProp_CS_Ptr = (RedfishCS_Type_EmptyProp_CS_Data *)GetFirstLink
> (Link);
> +  if (EmptyProp_CS_Ptr->Header.ResourceType !=
> RedfishCS_Type_CS_EmptyProp) {
> +    return RedfishCS_status_unsupported;
> +  }
> +
> +  JsonObj     = json_object ();
> +  KeyValuePtr = EmptyProp_CS_Ptr->KeyValuePtr;
> +  for (Index = 0; Index < EmptyProp_CS_Ptr->NunmOfProperties; Index++) {
> +    Status = InsertJsonVagueObj (JsonObj, KeyValuePtr->KeyNamePtr,
> KeyValuePtr->Value);
> +    if (Status != RedfishCS_status_success) {
> +      return Status;
> +    }
> +
> +    KeyValuePtr = KeyValuePtr->NextKeyValuePtr;
> +  }
> +
> +  if (json_object_set_new (ParentJsonObj, Key, JsonObj) != 0) {
> +    return RedfishCS_status_unknown_error;
> +  }
> +
> +  return RedfishCS_status_success;
> +}
> diff --git a/RedfishClientPkg/ConverterLib/src/RedfishCsMemory.c
> b/RedfishClientPkg/ConverterLib/src/RedfishCsMemory.c
> new file mode 100644
> index 0000000000..aec03ead6f
> --- /dev/null
> +++ b/RedfishClientPkg/ConverterLib/src/RedfishCsMemory.c
> @@ -0,0 +1,238 @@
> +/** @file
> +
> +  (C) Copyright 2018-2021 Hewlett Packard Enterprise Development LP<BR>
> +
> +  SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +  Copyright Notice:
> +  Copyright 2019-2021 Distributed Management Task Force, Inc. All rights
> reserved.
> +  License: BSD 3-Clause License. For full text see link:
> https://github.c/
> om%2FDMTF%2FRedfish-JSON-C-Struct-
> Converter%2Fblob%2Fmaster%2FLICENSE.md&data=05%7C01%7Cnicklew%40n
> vidia.com%7C6c287e287fb44d40c3e308db4baed8a2%7C43083d15727340c1b7d
> b39efd9ccc17a%7C0%7C0%7C638186986569209689%7CUnknown%7CTWFpbG
> Zsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn
> 0%3D%7C3000%7C%7C%7C&sdata=VKor2rANpdKrvHJ7pEDkfh2XrTqQdtRVZjryv
> urM1ms%3D&reserved=0
> +**/
> +
> +#include "RedfishCsMemoryInternal.h"
> +#include <stdlib.h>
> +#include <string.h>
> +
> +RedfishCS_Link  CsMemRoot = { &CsMemRoot, &CsMemRoot };
> +
> +/**
> +  This function records the memory allocation to
> +  the C Structure instance that owns the memory block.
> +
> +  memCs          C Structure instance.
> +  Return RedfishCS_status
> +
> +**/
> +RedfishCS_status
> +recordCsRootMemory (
> +  void  *memCs
> +  )
> +{
> +  RedfishCS_Internal_memory_root  *memRoot;
> +
> +  memRoot = malloc (sizeof (RedfishCS_Internal_memory_root));
> +  if (memRoot == NULL) {
> +    return RedfishCS_status_insufficient_memory;
> +  }
> +
> +  InitializeLinkHead (&memRoot->nextRoot);
> +  InitializeLinkHead (&memRoot->memBlocks);
> +  memRoot->CsPtr = memCs;
> +  InsertTailLink (&CsMemRoot, &memRoot->nextRoot);
> +  return RedfishCS_status_success;
> +}
> +
> +/**
> +  This function allocates and records the memory allocation
> +  to the C Structure instance that owns the memory block.
> +
> +  rootCs          C Structure instance.
> +  size            The size to allocate.
> +  Dst             Pointer to retrieve the pointer to memory
> +                  block.
> +  Return RedfishCS_status
> +
> +**/
> +RedfishCS_status
> +allocateRecordCsMemory (
> +  RedfishCS_void    *rootCs,
> +  RedfishCS_uint32  size,
> +  RedfishCS_void    **Dst
> +  )
> +{
> +  RedfishCS_Internal_memory_root  *memRoot;
> +  RedfishCS_Internal_memory_link  *memLink;
> +
> +  if (IsLinkEmpty (&CsMemRoot)) {
> +    return RedfishCS_status_invalid_parameter;
> +  }
> +
> +  memRoot = (RedfishCS_Internal_memory_root *)GetFirstLink (&CsMemRoot);
> +  while (RedfishCS_boolean_true) {
> +    if (memRoot->CsPtr == rootCs) {
> +      // Allocation memory and record it.
> +      memLink = malloc (sizeof (RedfishCS_Internal_memory_link));
> +      if (memLink == NULL) {
> +        return RedfishCS_status_insufficient_memory;
> +      }
> +
> +      *Dst = malloc (size);
> +      if (*Dst == NULL) {
> +        free (memLink);
> +        return RedfishCS_status_insufficient_memory;
> +      }
> +
> +      memset (*Dst, 0, size);
> +      memset (memLink, 0, sizeof (RedfishCS_Internal_memory_link));
> +      InitializeLinkHead (&memLink->nextLink);
> +      memLink->memoryPtr = *Dst;
> +      InsertTailLink (&memRoot->memBlocks, &memLink->nextLink);
> +      return RedfishCS_status_success;
> +    }
> +
> +    if (IsLinkAtEnd (&CsMemRoot, (RedfishCS_Link *)&memRoot->nextRoot)) {
> +      break;
> +    }
> +
> +    memRoot = (RedfishCS_Internal_memory_root *)GetNextLink
> (&CsMemRoot, &memRoot->nextRoot);
> +  }
> +
> +  return RedfishCS_status_invalid_parameter;
> +}
> +
> +/**
> +  This function allocates, records and zero out the memory
> +  to the C Structure instance that owns the memory block.
> +
> +  rootCs          C Structure instance.
> +  size            The size to allocate.
> +  Dst             Pointer to retrieve the pointer to memory
> +                  block.
> +  Return RedfishCS_status
> +
> +**/
> +RedfishCS_status
> +allocateRecordCsZeroMemory (
> +  RedfishCS_void    *rootCs,
> +  RedfishCS_uint32  size,
> +  RedfishCS_void    **Dst
> +  )
> +{
> +  RedfishCS_status  Status;
> +
> +  Status = allocateRecordCsMemory (rootCs, size, Dst);
> +  if ((Status != RedfishCS_status_success) || (*Dst == NULL)) {
> +    return Status;
> +  }
> +
> +  memset (*Dst, 0, size);
> +  return RedfishCS_status_success;
> +}
> +
> +/**
> +  This function destroies all memory allocations belong
> +  to the C Structure instance.
> +
> +  rootCs          C Structure instance.
> +
> +  Return RedfishCS_status
> +
> +**/
> +RedfishCS_status
> +DestoryCsMemory (
> +  RedfishCS_void  *rootCs
> +  )
> +{
> +  RedfishCS_Internal_memory_root  *memRoot;
> +  RedfishCS_Internal_memory_link  *memLink;
> +
> +  if (IsLinkEmpty (&CsMemRoot)) {
> +    return RedfishCS_status_invalid_parameter;
> +  }
> +
> +  memRoot = (RedfishCS_Internal_memory_root *)GetFirstLink (&CsMemRoot);
> +  while (RedfishCS_boolean_true) {
> +    if (memRoot->CsPtr == rootCs) {
> +      if (IsLinkEmpty (&memRoot->memBlocks)) {
> +        return RedfishCS_status_success;
> +      }
> +
> +      while (RedfishCS_boolean_true) {
> +        memLink = (RedfishCS_Internal_memory_link *)GetLastLink (&memRoot-
> >memBlocks);
> +        if (memLink->memoryPtr != NULL) {
> +          free (memLink->memoryPtr);
> +          RemoveLink (&memLink->nextLink);
> +          free (memLink);
> +        }
> +
> +        if (IsLinkEmpty (&memRoot->memBlocks)) {
> +          RemoveLink (&memRoot->nextRoot);
> +          free (memRoot);
> +          free (rootCs);
> +          return RedfishCS_status_success;
> +        }
> +      }
> +    }
> +
> +    if (IsLinkAtEnd (&CsMemRoot, (RedfishCS_Link *)&memRoot->nextRoot)) {
> +      break;
> +    }
> +
> +    memRoot = (RedfishCS_Internal_memory_root *)GetNextLink
> (&CsMemRoot, &memRoot->nextRoot);
> +  }
> +
> +  return RedfishCS_status_invalid_parameter;
> +}
> +
> +/**
> +  This function allocates an array of memory blocks owned
> +  by the C Structure instance.
> +
> +  rootCs            C Structure instance.
> +  ArrayInstanceSize Number of items in array.
> +  ArraySize         The size of each array.
> +  Dst               Pointer to retrieve the pointer to memory
> +                    block.
> +
> +  Return RedfishCS_status
> +
> +**/
> +RedfishCS_status
> +allocateArrayRecordCsMemory (
> +  RedfishCS_void    *rootCs,
> +  RedfishCS_uint32  ArrayInstanceSize,
> +  RedfishCS_uint64  ArraySize,
> +  RedfishCS_void    **Dst
> +  )
> +{
> +  RedfishCS_uint16  Index;
> +  RedfishCS_void    *ArrayInstance;
> +  RedfishCS_void    *PreArrayInstance;
> +  RedfishCS_status  Status;
> +  RedfishCS_uint16  SizeOfVoid;
> +
> +  for (Index = 0; Index < ArraySize; Index++) {
> +    Status = allocateRecordCsMemory (rootCs, ArrayInstanceSize,
> &ArrayInstance);
> +    if (Status != RedfishCS_status_success) {
> +      return Status;
> +    }
> +
> +    memset (ArrayInstance, 0, ArrayInstanceSize);
> +    if (Index == 0) {
> +      *Dst = ArrayInstance;
> +    } else {
> +      SizeOfVoid = sizeof (RedfishCS_void *);
> +      if (SizeOfVoid == sizeof (RedfishCS_uint32)) {
> +        *((RedfishCS_uint32 *)PreArrayInstance) = (RedfishCS_uint32)(unsigned
> long long)ArrayInstance; // Next link.
> +      } else if (SizeOfVoid == sizeof (RedfishCS_uint64)) {
> +        *((RedfishCS_uint64 *)PreArrayInstance) =
> (RedfishCS_uint64)ArrayInstance; // Next link.
> +      } else {
> +        return RedfishCS_status_invalid_parameter;
> +      }
> +    }
> +
> +    PreArrayInstance = ArrayInstance;
> +  }
> +
> +  return RedfishCS_status_success;
> +}
> --
> 2.37.1.windows.1



-=-=-=-=-=-=-=-=-=-=-=-
Groups.io Links: You receive all messages sent to this group.
View/Reply Online (#103901): https://edk2.groups.io/g/devel/message/103901
Mute This Topic: https://groups.io/mt/98657292/1787277
Group Owner: devel+owner@edk2.groups.io
Unsubscribe: https://edk2.groups.io/g/devel/unsub [importer@patchew.org]
-=-=-=-=-=-=-=-=-=-=-=-