From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mx0b-002e3701.pphosted.com (mx0b-002e3701.pphosted.com [148.163.143.35]) by mx.groups.io with SMTP id smtpd.web12.22796.1628777908267822708 for ; Thu, 12 Aug 2021 07:18:28 -0700 Authentication-Results: mx.groups.io; dkim=pass header.i=@hpe.com header.s=pps0720 header.b=ouwL/ypr; spf=permerror, err=parse error for token &{10 18 %{ir}.%{v}.%{d}.spf.has.pphosted.com}: invalid domain name (domain: hpe.com, ip: 148.163.143.35, mailfrom: prvs=08587650f9=abner.chang@hpe.com) Received: from pps.filterd (m0150245.ppops.net [127.0.0.1]) by mx0b-002e3701.pphosted.com (8.16.0.43/8.16.0.43) with SMTP id 17CEHsOo020724; Thu, 12 Aug 2021 14:18:18 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=hpe.com; h=from : to : cc : subject : date : message-id : references : in-reply-to : content-type : content-transfer-encoding : mime-version; s=pps0720; bh=BWUsxwtQAf+lEexmi/h7hOGTYLNVH7PteQ2wHgCdqG4=; b=ouwL/ypr/t1rQEzjNGUuEcwrHwugjCGda9xvliH8+x7hFPVeUtDRA/h8Djk7Ir/MKPJX gQpa3yKUd4FhldVcmx8VJX4VLiOCiJjudILoGFkVX/nImPvFoRh/Kb2gcGkI/UDHz2OQ ipa3ejGO9fS5q23l+IMyZV4cXrMJQMBbihq/mhKnLjdJB+I6h0D67HVRT6Qy4G1/VRlz dWW0PFwQTRDDaisJX6QhfNs/FsiCHEnqauvFXNL371grIKmC4BqFIc/p6lQDykRKcrpV tktpBNL0RLtEsieZ8Yiiy76VO3O4ZRPENrys/YGdJz12LcD/lwQoHJcti4KrtWi0zt1R 4w== Received: from g2t2353.austin.hpe.com (g2t2353.austin.hpe.com [15.233.44.26]) by mx0b-002e3701.pphosted.com with ESMTP id 3ad0jp2cgp-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Thu, 12 Aug 2021 14:18:17 +0000 Received: from G9W8456.americas.hpqcorp.net (exchangepmrr1.us.hpecorp.net [16.216.161.95]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-SHA384 (256/256 bits)) (No client certificate requested) by g2t2353.austin.hpe.com (Postfix) with ESMTPS id 5EAE277; Thu, 12 Aug 2021 14:18:17 +0000 (UTC) Received: from G9W8453.americas.hpqcorp.net (2002:10d8:a0d3::10d8:a0d3) by G9W8456.americas.hpqcorp.net (2002:10d8:a15f::10d8:a15f) with Microsoft SMTP Server (TLS) id 15.0.1497.18; Thu, 12 Aug 2021 14:18:17 +0000 Received: from NAM12-DM6-obe.outbound.protection.outlook.com (15.241.52.13) by G9W8453.americas.hpqcorp.net (16.216.160.211) with Microsoft SMTP Server (TLS) id 15.0.1497.18 via Frontend Transport; Thu, 12 Aug 2021 14:18:16 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=GvvL7OJ+TgMRqr2IauHIMAAJSUIuVmQYvz4GYWnpxuvZooEYA7sRWKNid6+KCL7RoHY0Ri4Zf/v6lQ/jKoBV9WW4IIpnociC+AbP6M3vxdbmzs2Ao+DqjhDY8+KVr8wZOR/sXWHBPegEC3TdaMfM3NbbqhpOBDenDGK/sqCKMLNHMg0HVHDnY1uEA40F/cm+BggOvtvpcv7uG3yelPfGPMhfB8+AB/f/mLvjiy9PJloPQKhDXrK3QPflkxiXv1CHoDJCwHmzL2ctnoSnDjLhCrrgk//bkipVRCdOlRFHNtTO3nE8TX2/oT9MsaLIGH+UdiJzPaLXKD83sOtjiw8zxg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=BWUsxwtQAf+lEexmi/h7hOGTYLNVH7PteQ2wHgCdqG4=; b=IghN+yk3sRLH3mZcmlNoRYTH9F2R9y/7Rf7BPwKH+kTO8w+7gC/7MkHm3i8NoZ1pXxlGI73k9LzAnXgMAGgBhPXkNLJeUDVYD/IronBYjepKmdcpzx2XRf/TWzqP0kFjxuwVGPzCcxK2MT49L6XWpERynU6l5+ybEEtC64mUHN+QG7B0HYJzaGjbK4wQQzWaKw/PyHE/qJg0TZEZStQ8rwiDIeSmwF35nHnRzUaiqGVi6ptlGt/yzDYMaAvRNCfzHwPqg4A1uZXD8KYQQfnDis3o2haEkQKLkw8kEQ7mXf3PANWHk7TtXtnfiTpVxce3Y1QMrjqaYnekil0fZWHtZw== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=hpe.com; dmarc=pass action=none header.from=hpe.com; dkim=pass header.d=hpe.com; arc=none Received: from CS1PR8401MB1144.NAMPRD84.PROD.OUTLOOK.COM (2a01:111:e400:7508::16) by CS1PR8401MB0647.NAMPRD84.PROD.OUTLOOK.COM (2a01:111:e400:750d::15) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.4415.17; Thu, 12 Aug 2021 14:18:15 +0000 Received: from CS1PR8401MB1144.NAMPRD84.PROD.OUTLOOK.COM ([fe80::e5ca:7bef:3a1c:b46a]) by CS1PR8401MB1144.NAMPRD84.PROD.OUTLOOK.COM ([fe80::e5ca:7bef:3a1c:b46a%11]) with mapi id 15.20.4394.023; Thu, 12 Aug 2021 14:18:14 +0000 From: "Abner Chang" To: "Wang, Nickle (HPS SW)" , "devel@edk2.groups.io" CC: Liming Gao Subject: Re: [PATCH] RedfishClientPkg/ConvertLib: Common code and header files Thread-Topic: [PATCH] RedfishClientPkg/ConvertLib: Common code and header files Thread-Index: AQHXj0gjoljWCE7BAE2thHGCDIQQ7atvv+oAgAArIMA= Date: Thu, 12 Aug 2021 14:18:14 +0000 Message-ID: References: <20210812060733.28551-1-abner.chang@hpe.com> In-Reply-To: Accept-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: authentication-results: hpe.com; dkim=none (message not signed) header.d=none;hpe.com; dmarc=none action=none header.from=hpe.com; x-ms-publictraffictype: Email x-ms-office365-filtering-correlation-id: 3228d61b-2d66-468a-48b4-08d95d9c0632 x-ms-traffictypediagnostic: CS1PR8401MB0647: x-ms-exchange-transport-forked: True x-microsoft-antispam-prvs: x-ms-oob-tlc-oobclassifiers: OLM:9508; x-ms-exchange-senderadcheck: 1 x-ms-exchange-antispam-relay: 0 x-microsoft-antispam: BCL:0; x-microsoft-antispam-message-info: WRK+lqFwdI3oJQtjTfDx51udBz1QoQrl1DPHgijN5WOGzLJEgIZj/poZn0DzwQ7zdGyhkjzAQyauEW8McXFFQwURBnXwoZHuCTShfb72PxY6rNks8Zr15Dx+jq0x2U8O1wtot3vvJI8Wtq2DBsG42SlHgtGYO+YkWaS2lcC161KpRiSIkcw7g9jptIpNahlY/tfYuV2+xXRbAT62MlXOZVGHILKNPo8D8gUo4EZWTX+l5uEGKJH6s/lhYNMIKYweJ+LLlPXHwrVmkmfiQn6kIDJFGHREhZUyEiFmw3YRzKoEBqT4AdURe2QWQ6gvIiFFEhq7tgELP24wVDRh98ZF5nDSRCBws/wJlNgcmU/7Yz6gs2ZuWdsmk0yWsTyPrv8GyzcxGC98LhaOSoLhPSmdkmzQsEaTMhgR/B1k/AJgTmwPdh4WK1rQPO7Ilgkcy2bGTjcuEZkUIo8vP+2UIpkhOQAfyUg4DeGv9r940rZiAoVrUo2rm3FF9tKRl2KwA+/NeQxW4nnCkHHX4I9P1+riGPsQOQMRoGhiuccZHvrTprfKoQohoT2f2ZNvEP3E9oLuLFbmc/CoxZSmvWqAc6GAnJ/2mRc9cYnwh+yor3ILnssJYFN6goTaq9beOGZXMm00s26dGptww6nmLdtS+dzHg2AX6/6umWc4FAk/8Vfuw+nvngqLh+BkV/654f5Po/539EMLlUGcf62osyjrCObl2g== x-forefront-antispam-report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:CS1PR8401MB1144.NAMPRD84.PROD.OUTLOOK.COM;PTR:;CAT:NONE;SFS:(346002)(376002)(396003)(366004)(136003)(39860400002)(5660300002)(71200400001)(9686003)(2906002)(186003)(6506007)(53546011)(19627235002)(8936002)(110136005)(55236004)(7696005)(316002)(38070700005)(26005)(8676002)(4326008)(83380400001)(30864003)(76116006)(52536014)(64756008)(66556008)(66476007)(478600001)(66446008)(33656002)(122000001)(38100700002)(86362001)(55016002)(66946007)(559001)(579004);DIR:OUT;SFP:1102; x-ms-exchange-antispam-messagedata-chunkcount: 1 x-ms-exchange-antispam-messagedata-0: =?us-ascii?Q?axB8uZFB+Nx6XKBinWVi0ak5TpYu7m/8x9SOFxB+6Z1kEOsFAcmHqRH5if3t?= =?us-ascii?Q?dmjZQvOPOsxF40i1YWjgPxu156Uoq5Pd0y45PeQkS+31tyuKCwOuOhFYwctr?= =?us-ascii?Q?6BpuAJ2orHeSD2EWaWGp0y+txX0MVys4Sr7kk1xocx0i7ZB5FDiSmcIFpiHo?= =?us-ascii?Q?Kizo4T+kr+nD/eblIM/NUxCuACm6sf0rdzqdy0k5KgvWyFFwhYAKdQtFulpi?= =?us-ascii?Q?Ldzo9VUWCogHjDQRArJ01x10P/EDP08jQNbwbqoa1W/I8u8FVGpLUoCnJj7u?= =?us-ascii?Q?5z7I7hNB/uzIJPi2LnAdS/M318RviDkCjQUv7cNDcy0UUueDuY2Gk94fjGjF?= =?us-ascii?Q?NhJV0jdEAylt8HMgYBvmcHDJHHg9Cefl9q/z23FMhCscgSX0/4qlxIH56Aju?= =?us-ascii?Q?vKv91Ooyw1/FnjRJ85wFiBs4sxV4Fq4H1JZ/9jRzS7OZQiVdhDCXa52JV7Qh?= =?us-ascii?Q?cb3hw9xEC6YFSEzkFjaIKZYKZYf/iM3+kr2IPCd6iNIBoMewsFQuKRF54Iyu?= =?us-ascii?Q?fQe1ltOUoV8RUMk2oZIogRb1Up6Nc1hE7VEAA+9UP8agEvKk/w6Rdx2nsl8Q?= =?us-ascii?Q?K3uSMO2mxAOvF4TJGZrd29HTdOdeOoAq4DuPbj1AsTOwb33Fx6/nLfhyM9dC?= =?us-ascii?Q?lADCDGop/YHJ1a57zgr1h3nI5SKw3pEX9f2EnhfL7rPoWBBYqpzPoXtS5anK?= =?us-ascii?Q?Ygd96bQjFUdtqXQvTDtYqATCoC56L9x/4qvFdHPebcqmSwxVi7qywZY4gXWK?= =?us-ascii?Q?/Oc9ghx1QGxuN5Sj1qggds9oZparn0GkMxt8lUUqPnpIJvQktUdgqXCS3SY+?= =?us-ascii?Q?cw6OeSVx5RTfdXKaC5yEBgShDjh3cVoLoI+/Wok48Xq0/hqphH4ZXBVj7b5m?= =?us-ascii?Q?WhTk/GNGtvquAoZIvtHghqzDpm/fBlE2GA/evMEwcjBLab85mXfcpD/wrQWp?= =?us-ascii?Q?wZvunOWyXRQ4NekBZnDb7rJZrhD7P9cvp4br8CoLXsujcajgUSB/8ue2Ixdm?= =?us-ascii?Q?zWK0KbAsSgxz4fbAWB30KqFiHQP2R774/VwwUuND+Y5NLf1c0NpKzQqYM1EC?= =?us-ascii?Q?+YBEkzDJJTqG7kMag0WcEyESaPVt2Jq2o89UKYAXz6LZwkiQRHJtxT6U/TyV?= =?us-ascii?Q?xhZAx6LCRoLw0g4s3LXZHG+6hTI2J3TABmTMoy0/x2Jq9Ca+NSX1VJntFQ7I?= =?us-ascii?Q?BUqPyJnb/CuCIZBCGp58DUOInOR7UXqjU0VpFs6nlXwH5UYt4aJ+cBsNEFyP?= =?us-ascii?Q?48SgQj1hDdScHXaxgwltcrso/v+nZpJ5pNI4LNKjPxHayHKL2PB38eemwEc1?= =?us-ascii?Q?qhiQz7w0cBCAObylTd8U0vx+?= MIME-Version: 1.0 X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-AuthSource: CS1PR8401MB1144.NAMPRD84.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-Network-Message-Id: 3228d61b-2d66-468a-48b4-08d95d9c0632 X-MS-Exchange-CrossTenant-originalarrivaltime: 12 Aug 2021 14:18:14.8816 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: 105b2061-b669-4b31-92ac-24d304d195dc X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-CrossTenant-userprincipalname: HJoVP9QdHPO5PAxiWy8yF0u40m5gcSRzEdh2ZMDhIbvpswSlMlCNh06in2KrGi0PdEZNrqdWKBoN6zc8tD4p0Q== X-MS-Exchange-Transport-CrossTenantHeadersStamped: CS1PR8401MB0647 X-OriginatorOrg: hpe.com X-Proofpoint-GUID: jRwBxDc-w3PVr5EFGZCSOUGubrN8DIrh X-Proofpoint-ORIG-GUID: jRwBxDc-w3PVr5EFGZCSOUGubrN8DIrh X-HPE-SCL: -1 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:6.0.391,18.0.790 definitions=2021-08-12_05:2021-08-12,2021-08-12 signatures=0 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 malwarescore=0 lowpriorityscore=0 bulkscore=0 phishscore=0 impostorscore=0 mlxlogscore=999 clxscore=1015 spamscore=0 adultscore=0 mlxscore=0 suspectscore=0 priorityscore=1501 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2107140000 definitions=main-2108120093 Content-Language: en-US Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable Thanks for catching this. I missed to add function header. Abner > -----Original Message----- > From: Wang, Nickle (HPS SW) > Sent: Thursday, August 12, 2021 7:44 PM > To: Chang, Abner (HPS SW/FW Technologist) ; > devel@edk2.groups.io > Cc: Liming Gao > Subject: RE: [PATCH] RedfishClientPkg/ConvertLib: Common code and > header files >=20 > Looks like we miss function header in this patch... >=20 > Nickle >=20 > -----Original Message----- > From: Chang, Abner (HPS SW/FW Technologist) > Sent: Thursday, August 12, 2021 2:08 PM > To: devel@edk2.groups.io > Cc: Wang, Nickle (HPS SW) ; Liming Gao > > Subject: [PATCH] RedfishClientPkg/ConvertLib: Common code and header > files >=20 > 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 b= y > those libraries. >=20 > Signed-off-by: Abner Chang > Cc: Nickle Wang > Cc: Liming Gao > --- > .../ConverterLib/include/RedfishCsCommon.h | 122 +++ > .../ConverterLib/include/RedfishDataTypeDef.h | 45 + > .../src/RedfishCsMemoryInternal.h | 36 + > .../ConverterLib/src/RedfishCsCommon.c | 831 ++++++++++++++++++ > .../ConverterLib/src/RedfishCsMemory.c | 144 +++ > 5 files changed, 1178 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 >=20 > diff --git a/RedfishClientPkg/ConverterLib/include/RedfishCsCommon.h > b/RedfishClientPkg/ConverterLib/include/RedfishCsCommon.h > new file mode 100644 > index 0000000000..3810836123 > --- /dev/null > +++ b/RedfishClientPkg/ConverterLib/include/RedfishCsCommon.h > @@ -0,0 +1,122 @@ > +/** @file > + > + (C) Copyright 2018-2021 Hewlett Packard Enterprise Development LP
> + > + SPDX-License-Identifier: BSD-2-Clause-Patent > + > +**/ > +#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 =3D 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 =3D 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..8c903482aa > --- /dev/null > +++ b/RedfishClientPkg/ConverterLib/include/RedfishDataTypeDef.h > @@ -0,0 +1,45 @@ > +/** @file > + > + (C) Copyright 2018-2021 Hewlett Packard Enterprise Development LP
> + > + SPDX-License-Identifier: BSD-2-Clause-Patent > + > +**/ > +#ifndef REDFISH_CS_DATA_TYPE_H_ > +#define REDFISH_CS_DATA_TYPE_H_ > + > +#include > + > +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..689aff9519 > --- /dev/null > +++ b/RedfishClientPkg/ConverterLib/src/RedfishCsMemoryInternal.h > @@ -0,0 +1,36 @@ > +/** @file > + > + (C) Copyright 2018-2021 Hewlett Packard Enterprise Development LP
> + > + SPDX-License-Identifier: BSD-2-Clause-Patent **/ #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..cb80121831 > --- /dev/null > +++ b/RedfishClientPkg/ConverterLib/src/RedfishCsCommon.c > @@ -0,0 +1,831 @@ > +/** @file > + > + (C) Copyright 2018-2021 Hewlett Packard Enterprise Development LP
> + > + SPDX-License-Identifier: BSD-2-Clause-Patent > + > +**/ > + > +#include "RedfishCsCommon.h" > +#include "RedfishCsMemoryInternal.h" > +#include > +#include > +#include > + > +RedfishCS_status GetRedfishPropertyVague(void *Cs, json_t *JsonObj, > +char *Key, RedfishCS_Vague **DstBuffer); > + > +RedfishCS_Link *InitializeLinkHead (RedfishCS_Link *ListHead) { > + ListHead->ForwardLink =3D ListHead; > + ListHead->BackLink =3D ListHead; > + return ListHead; > +} > + > +RedfishCS_Link *InsertHeadLink (RedfishCS_Link *ListHead, > +RedfishCS_Link *Entry) { > + Entry->ForwardLink =3D ListHead->ForwardLink; > + Entry->BackLink =3D ListHead; > + Entry->ForwardLink->BackLink =3D Entry; > + ListHead->ForwardLink =3D Entry; > + return ListHead; > +} > + > +RedfishCS_Link * InsertTailLink (RedfishCS_Link *ListHead, > +RedfishCS_Link *Entry) { > + Entry->ForwardLink =3D ListHead; > + Entry->BackLink =3D ListHead->BackLink; > + Entry->BackLink->ForwardLink =3D Entry; > + ListHead->BackLink =3D Entry; > + return ListHead; > +} > + > +RedfishCS_Link *GetFirstLink (const RedfishCS_Link *List) { > + return List->ForwardLink; > +} > + > +RedfishCS_Link *GetLastLink (const RedfishCS_Link *List) { > + return List->BackLink; > +} > + > +RedfishCS_Link *GetNextLink (const RedfishCS_Link *List, const > +RedfishCS_Link *Node) { > + return Node->ForwardLink; > +} > + > +RedfishCS_Link *GetPreviousLink (const RedfishCS_Link *List, const > +RedfishCS_Link *Node) { > + return Node->BackLink; > +} > +RedfishCS_Link *RemoveLink ( const RedfishCS_Link *Link) { > + Link->ForwardLink->BackLink =3D Link->BackLink; > + Link->BackLink->ForwardLink =3D Link->ForwardLink; > + return Link->ForwardLink; > +} > + > +RedfishCS_bool IsLinkEmpty (const RedfishCS_Link *LinkHead) { return > +(RedfishCS_bool)(LinkHead->ForwardLink =3D=3D LinkHead); } > + > +RedfishCS_bool IsLinkAtEnd (const RedfishCS_Link *LinkHead, const > +RedfishCS_Link *ThisLink) { > + return (RedfishCS_bool)(ThisLink->ForwardLink =3D=3D LinkHead); } > + > +RedfishCS_status allocateDuplicateStr (void *Cs, char *Str, void > +**DstBuffer) { > + RedfishCS_status Status; > + > + if (Str =3D=3D NULL || strlen(Str) =3D=3D 0) { > + *DstBuffer =3D NULL; > + return RedfishCS_status_success; > + } > + Status =3D allocateRecordCsMemory(Cs, (RedfishCS_int)strlen(Str) + 1, > +(void **)DstBuffer); > + if (Status !=3D RedfishCS_status_success) { > + return Status; > + } > + memcpy (*DstBuffer, Str, strlen(Str) + 1); > + return RedfishCS_status_success; > +} > + > +RedfishCS_status CreateCsUriByOdataId (json_t *JsonOj, RedfishCS_char > +*ParentUri, RedfishCS_Type_Uri_Data **CsTypeUriData) { > + json_t *TempJsonObj; > + RedfishCS_Type_Uri_Data *CsTypeUri; > + > + CsTypeUri =3D NULL; > + TempJsonObj =3D json_object_get(JsonOj, "@odata.id"); > + if (TempJsonObj =3D=3D NULL) { > + return RedfishCS_status_not_found; > + } > + CsTypeUri =3D malloc (sizeof (RedfishCS_Type_Uri_Data)); > + if (CsTypeUri =3D=3D NULL) { > + return RedfishCS_status_insufficient_memory; > + } > + InitializeLinkHead (&CsTypeUri->Header.LinkEntry); > + CsTypeUri->Header.ResourceType =3D RedfishCS_Type_Uri; > + CsTypeUri->Header.ThisUri =3D ParentUri; > + CsTypeUri->Header.KeyName =3D (RedfishCS_char *)strdup ("@odata.id"); > + CsTypeUri->Uri =3D (RedfishCS_char *)strdup (json_string_value > +(TempJsonObj)); > + *CsTypeUriData =3D CsTypeUri; > + return RedfishCS_status_success; > +} > + > +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 =3D NULL; > + > + if (NodeName !=3D NULL) { > + TempJsonObj =3D json_object_get(JsonOj, NodeName); > + if (TempJsonObj =3D=3D NULL) { > + return RedfishCS_status_not_found; > + } > + } else { > + if (JsonOj =3D=3D NULL) { > + return RedfishCS_status_not_found; > + } > + TempJsonObj =3D JsonOj; > + } > + > + TempJsonObj2 =3D json_object_get(TempJsonObj, "@odata.id"); > + if (TempJsonObj2 !=3D NULL) { > + Status =3D allocateRecordCsMemory (Cs, sizeof (RedfishCS_Type_Uri_Da= ta), > (void **)&CsTypeUri); > + if (Status !=3D RedfishCS_status_success) { > + return Status; > + } > + InitializeLinkHead (&CsTypeUri->Header.LinkEntry); > + CsTypeUri->Header.ResourceType =3D RedfishCS_Type_Uri; > + CsTypeUri->Header.ThisUri =3D ParentUri; > + Status =3D allocateDuplicateStr (Cs, NodeName, (void **)&CsTypeUri- > >Header.KeyName); > + if (Status !=3D RedfishCS_status_success) { > + return Status; > + } > + *CsTypeUriData =3D CsTypeUri; > + Status =3D allocateDuplicateStr (Cs, (char *)json_string_value > (TempJsonObj2), (void **)&CsTypeUri->Uri); > + return Status; > + } > + return RedfishCS_status_invalid_parameter; > +} > + > +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 =3D NULL; > + if (NodeName !=3D NULL) { > + TempJsonObj =3D json_object_get(JsonObj, NodeName); > + if (TempJsonObj =3D=3D NULL) { > + return RedfishCS_status_not_found; > + } > + } else { > + // Dump JSON from JsonObj. > + TempJsonObj =3D JsonObj; > + } > + TempChar =3D json_dumps ((const json_t *)TempJsonObj, JSON_INDENT > (2)); > + if (TempChar !=3D NULL) { > + Status =3D allocateRecordCsMemory (Cs, sizeof > (RedfishCS_Type_JSON_Data), (void **)&CsTypeJson); > + if (Status !=3D RedfishCS_status_success) { > + return Status; > + } > + Status =3D allocateRecordCsMemory (Cs, (RedfishCS_int)strlen (TempCh= ar) > + 1, (void **)&DumpStr); > + if (Status !=3D RedfishCS_status_success) { > + return Status; > + } > + strncpy (DumpStr, TempChar, strlen (TempChar) + 1); > + InitializeLinkHead(&CsTypeJson->Header.LinkEntry); > + CsTypeJson->Header.ResourceType =3D RedfishCS_Type_JSON; > + CsTypeJson->Header.ThisUri =3D ParentUri; > + Status =3D allocateDuplicateStr (Cs, NodeName, (void **)&CsTypeJson- > >Header.KeyName); > + if (Status !=3D RedfishCS_status_success) { > + return Status; > + } > + CsTypeJson->JsonText =3D DumpStr; > + *CsTypeJsonData =3D CsTypeJson; > + return RedfishCS_status_success; > + } > + return RedfishCS_status_invalid_parameter; > +} > + > +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 =3D NULL; > + if (NodeName !=3D NULL) { > + TempJsonObj =3D json_object_get(JsonObj, NodeName); > + if (TempJsonObj =3D=3D NULL) { > + return RedfishCS_status_not_found; > + } > + } > + Status =3D allocateRecordCsMemory(Cs, > + sizeof(RedfishCS_Type_EmptyProp_CS_Data), (void > **)&CsTypeEmptyPropCS); if (Status !=3D RedfishCS_status_success) { > + return Status; > + } > + InitializeLinkHead(&CsTypeEmptyPropCS->Header.LinkEntry); > + CsTypeEmptyPropCS->Header.ResourceType =3D > RedfishCS_Type_CS_EmptyProp; > + CsTypeEmptyPropCS->Header.ThisUri =3D ParentUri; Status =3D > + allocateDuplicateStr(Cs, NodeName, (void > + **)&CsTypeEmptyPropCS->Header.KeyName); > + if (Status !=3D RedfishCS_status_success) { > + return Status; > + } > + CsTypeEmptyPropCS->NunmOfProperties =3D NunmOfProperties; // // > + Create instance for each key-value. > + // > + KeyValuePtr =3D &CsTypeEmptyPropCS->KeyValuePtr; > + json_object_foreach_safe(TempJsonObj, n, KeyName, KeyValueObj) { > + Status =3D allocateRecordCsMemory(Cs, > sizeof(RedfishCS_EmptyProp_KeyValue), (void **)&KeyValue); > + if (Status !=3D RedfishCS_status_success) { > + return Status; > + } > + Status =3D allocateDuplicateStr(Cs, (char *)KeyName, (void **)&KeyVa= lue- > >KeyNamePtr); > + if (Status !=3D RedfishCS_status_success) { > + return Status; > + } > + Status =3D GetRedfishPropertyVague(Cs, TempJsonObj, (char *)KeyName, > &KeyValue->Value); > + if (Status !=3D RedfishCS_status_success) { > + return Status; > + } > + > + *KeyValuePtr =3D KeyValue; > + KeyValuePtr =3D &KeyValue->NextKeyValuePtr; } > + > + *CsTypeEmptyPropCSData =3D CsTypeEmptyPropCS; > + return RedfishCS_status_success; > +} > + > +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; > +} > + > +RedfishCS_bool CheckEmptyPropJsonObject(json_t *JsonObj, > +RedfishCS_uint32 *NumOfProperty) { > + RedfishCS_char *NewKey; > + json_t *Value; > + RedfishCS_void *n; > + RedfishCS_uint32 Num; > + > + Num =3D 0; > + json_object_foreach_safe(JsonObj, n, NewKey, Value) { > + if (!CheckSupportedPropTypeInEmptyProperty(Value)) { > + return RedfishCS_boolean_false; > + } > + Num ++; > + } > + if (NumOfProperty !=3D NULL) { > + *NumOfProperty =3D Num; > + } > + return RedfishCS_boolean_true; > +} > + > +RedfishCS_bool SupportedRedfishResource (RedfishCS_char *Odata_Type, > +RedfishCS_char *NameSpace, RedfishCS_char *Version, RedfishCS_char > +*DataType) { > + RedfishCS_char *TargetDataType; > + > + if (Odata_Type =3D=3D NULL || NameSpace =3D=3D NULL || DataType =3D=3D= NULL) { > + return RedfishCS_boolean_false; > + } > + if (Version !=3D NULL) { > + TargetDataType =3D 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 =3D 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 =3D=3D NULL) { > + return RedfishCS_boolean_false; > + } > + TargetDataType [0] =3D 0; // Insert NULL terminator. > + strcat (TargetDataType, "#"); > + strcat (TargetDataType, NameSpace); > + strcat (TargetDataType, "."); > + if (Version !=3D NULL && (strcmp (Version, "noversioned") !=3D 0)) { > + strcat(TargetDataType, Version); > + strcat (TargetDataType, "."); > + } > + strcat (TargetDataType, DataType); > + if (strcmp (Odata_Type, TargetDataType) =3D=3D 0) { > + return RedfishCS_boolean_true; > + } > + free (TargetDataType); > + return RedfishCS_boolean_false; > +} > + > +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 =3D RedfishCS_status_invalid_parameter; > + JsonObjTemp =3D json_object_get (JsonObj, NodeName); > + if (JsonObjTemp =3D=3D NULL) { > + return RedfishCS_status_not_found; > + } > + if (json_object_size(JsonObjTemp) =3D=3D 1) { > + Status =3D CreateCsUriByNode (Cs, JsonObj, NodeName, ParentUri, > &CsTypeUri); > + if (Status =3D=3D RedfishCS_status_success) { > + InsertTailLink (LinkHead, &CsTypeUri->Header.LinkEntry); > + return RedfishCS_status_success; > + } > + } else { > + Status =3D CreateCsJsonByNode (Cs, JsonObj, NodeName, ParentUri, > &CsTypeJson); > + if (Status =3D=3D RedfishCS_status_success) { > + InsertTailLink (LinkHead, &CsTypeJson->Header.LinkEntry); > + return RedfishCS_status_success; > + } > + } > + return 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 =3D RedfishCS_status_invalid_parameter; > + JsonObjTemp =3D json_object_get (JsonObj, NodeName); > + if (JsonObjTemp =3D=3D NULL) { > + return RedfishCS_status_not_found; > + } > + if (json_array_size (JsonObjTemp) =3D=3D 0) { > + return RedfishCS_status_success; > + } > + for (ArrayIndex =3D 0; ArrayIndex < (RedfishCS_uint16)json_array_size > (JsonObjTemp); ArrayIndex ++) { > + JsonObjArray =3D json_array_get (JsonObjTemp, (size_t)ArrayIndex); > + if (JsonObjArray =3D=3D NULL) { > + continue; > + } > + if (json_object_size(JsonObjArray) =3D=3D 1) { > + Status =3D CreateCsUriByNode (Cs, JsonObjArray, NULL, ParentUri, > &CsTypeUri); > + if (Status =3D=3D RedfishCS_status_success) { > + InsertTailLink (LinkHead, &CsTypeUri->Header.LinkEntry); > + } > + } else { > + Status =3D CreateCsJsonByNode (Cs, JsonObjArray, NULL, ParentUri, > &CsTypeJson); > + if (Status =3D=3D RedfishCS_status_success) { > + InsertTailLink (LinkHead, &CsTypeJson->Header.LinkEntry); > + } > + } > + } > + return RedfishCS_status_success; > +} > + > +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 =3D=3D NULL || > + ResourceType =3D=3D NULL || > + TypeName =3D=3D NULL || > + Cs =3D=3D NULL || > + size =3D=3D 0 > + ) { > + return RedfishCS_status_invalid_parameter; > + } > + *JsonObjReturned =3D json_loads(JsonRawText, 0, NULL); > + if (*JsonObjReturned =3D=3D NULL) { > + return RedfishCS_status_unknown_error; > + } > + TempJsonObj =3D json_object_get(*JsonObjReturned, "@odata.type"); > + if (TempJsonObj =3D=3D NULL) { > + return RedfishCS_status_invalid_parameter; > + } > + TempChar =3D (RedfishCS_char *)json_string_value(TempJsonObj); > + if (TempChar =3D=3D NULL || ! SupportedRedfishResource (TempChar, > ResourceType, ResourceVersion, TypeName)) { > + return RedfishCS_status_unsupported; > + } > + TempCS =3D malloc (size); > + if (TempCS =3D=3D NULL) { > + return RedfishCS_status_insufficient_memory; > + } > + memset (TempCS, 0, size); > + Header =3D (RedfishCS_Header *)TempCS; > + Header->ResourceType =3D RedfishCS_Type_CS; > + Header->KeyName =3D NULL; > + InitializeLinkHead (&Header->LinkEntry); > + *Cs =3D TempCS; > + return recordCsRootMemory (TempCS); > +} > + > +RedfishCS_status GetRedfishPropertyStr (void *Cs, json_t *JsonObj, char > +*Key, RedfishCS_char **DstBuffer) { > + json_t *TempJsonObj; > + RedfishCS_status Status; > + > + if (DstBuffer =3D=3D NULL) { > + return RedfishCS_status_invalid_parameter; > + } > + *DstBuffer =3D NULL; > + > + TempJsonObj =3D json_object_get(JsonObj, Key); > + if (TempJsonObj =3D=3D NULL){ > + return RedfishCS_status_not_found; > + } > + Status =3D allocateDuplicateStr (Cs, (char > +*)json_string_value(TempJsonObj), (void **)DstBuffer); > + return Status; > +} > + > +RedfishCS_status GetRedfishPropertyBoolean (void *Cs, json_t *JsonObj, > +char *Key, RedfishCS_bool **DstBuffer) { > + json_t *TempJsonObj; > + RedfishCS_status Status; > + > + if (DstBuffer =3D=3D NULL) { > + return RedfishCS_status_not_found; > + } > + TempJsonObj =3D json_object_get(JsonObj, Key); > + if (TempJsonObj =3D=3D NULL){ > + return RedfishCS_status_not_found; > + } > + Status =3D allocateRecordCsMemory(Cs, sizeof(RedfishCS_bool), (void > +**)DstBuffer); > + if (Status !=3D RedfishCS_status_success){ > + return Status; > + } > + if (json_is_true(TempJsonObj)) { > + **DstBuffer =3D RedfishCS_boolean_true; > + } else { > + **DstBuffer =3D RedfishCS_boolean_false; > + } > + return RedfishCS_status_success; > +} > + > +RedfishCS_status GetRedfishPropertyInt64 (void *Cs, json_t *JsonObj, > +char *Key, RedfishCS_int64 **Dst) { > + RedfishCS_status Status; > + const json_t *TempJsonObj; > + > + if (Dst =3D=3D NULL) { > + return RedfishCS_status_invalid_parameter; > + } > + > + TempJsonObj =3D json_object_get(JsonObj, Key); > + if (TempJsonObj =3D=3D NULL) { > + return RedfishCS_status_not_found; > + } > + Status =3D allocateRecordCsMemory(Cs, sizeof(RedfishCS_int64), (void > +**)Dst); > + if (Status !=3D RedfishCS_status_success){ > + return Status; > + } > + **Dst =3D (RedfishCS_int64)json_integer_value(TempJsonObj); > + return RedfishCS_status_success; > +} > + > +RedfishCS_status GetRedfishPropertyVague (void *Cs, json_t *JsonObj, > +char *Key, RedfishCS_Vague **DstBuffer) { > + json_t *TempJsonObj; > + RedfishCS_status Status; > + RedfishCS_Vague *VagueData; > + > + if (DstBuffer =3D=3D NULL) { > + return RedfishCS_status_not_found; > + } > + TempJsonObj =3D json_object_get(JsonObj, Key); if (TempJsonObj =3D=3D > + NULL){ > + return RedfishCS_status_not_found; > + } > + Status =3D allocateRecordCsMemory(Cs, sizeof(RedfishCS_Vague), (void > + **)&VagueData); if (Status !=3D RedfishCS_status_success){ > + return Status; > + } > + > + if (json_is_string(TempJsonObj)) { > + VagueData->DataType =3D RedfishCS_Vague_DataType_String; > + Status =3D GetRedfishPropertyStr (Cs, JsonObj, Key, > +&VagueData->DataValue.CharPtr); > + } else if (json_is_integer(TempJsonObj)) { > + VagueData->DataType =3D RedfishCS_Vague_DataType_Int64; > + Status =3D GetRedfishPropertyInt64 (Cs, JsonObj, Key, > +&VagueData->DataValue.Int64Ptr); > + } else if (json_is_boolean(TempJsonObj)) { > + VagueData->DataType =3D RedfishCS_Vague_DataType_Bool; > + Status =3D GetRedfishPropertyBoolean (Cs, JsonObj, Key, > +&VagueData->DataValue.BoolPtr); > + } else if (json_is_null(TempJsonObj)) { > + *DstBuffer =3D NULL; // No value for this key > + free (VagueData); > + return RedfishCS_status_success; > + } else { > + return RedfishCS_status_unsupported; > + } > + if (Status =3D=3D RedfishCS_status_success) { > + *DstBuffer =3D VagueData; > + } > + return Status; > +} > + > +RedfishCS_status InsertJsonStringObj (json_t *ParentJsonObj, char *Key, > +RedfishCS_char *StringValue) { > + json_t *JsonValue; > + RedfishCS_char NullStr[] =3D ""; > + RedfishCS_char *InsertStr; > + > + InsertStr =3D StringValue; > + if (ParentJsonObj =3D=3D NULL) { > + return RedfishCS_status_invalid_parameter; > + } > + if (InsertStr =3D=3D (char *)NULL) { > + InsertStr =3D NullStr; > + } > + JsonValue =3D json_string(InsertStr); > + if (JsonValue =3D=3D NULL) { > + return RedfishCS_status_unsupported; > + } > + if (json_object_set_new (ParentJsonObj, Key, JsonValue) =3D=3D -1) { > + return RedfishCS_status_unsupported; > + } > + return RedfishCS_status_success; > +} > + > +RedfishCS_status InsertJsonBoolObj (json_t *ParentJsonObj, char *Key, > +RedfishCS_bool *BoolValue) { > + json_t *JsonValue; > + > + if (ParentJsonObj =3D=3D NULL) { > + return RedfishCS_status_invalid_parameter; > + } > + if (BoolValue =3D=3D (RedfishCS_bool *)NULL) { > + return RedfishCS_status_success; // No value for this key. > + } > + JsonValue =3D json_boolean((BOOLEAN)*BoolValue); > + if (JsonValue =3D=3D NULL) { > + return RedfishCS_status_unsupported; > + } > + if (json_object_set_new (ParentJsonObj, Key, JsonValue) =3D=3D -1) { > + return RedfishCS_status_unsupported; > + } > + return RedfishCS_status_success; > +} > + > +RedfishCS_status InsertJsonInt64Obj (json_t *ParentJsonObj, char *Key, > +RedfishCS_int64 *Int64Value) { > + json_t *JsonValue; > + > + if (ParentJsonObj =3D=3D NULL) { > + return RedfishCS_status_invalid_parameter; > + } > + if (Int64Value =3D=3D (RedfishCS_int64 *)NULL) { > + return RedfishCS_status_success; // No value for this key. > + } > + JsonValue =3D json_integer((json_int_t)*Int64Value); > + if (JsonValue =3D=3D NULL) { > + return RedfishCS_status_unsupported; > + } > + if (json_object_set_new (ParentJsonObj, Key, JsonValue) =3D=3D -1) { > + return RedfishCS_status_unsupported; > + } > + return RedfishCS_status_success; > +} > + > +RedfishCS_status InsertJsonVagueObj (json_t *ParentJsonObj, char *Key, > +RedfishCS_Vague *VagueValue) { > + json_t *JsonValue; > + RedfishCS_char NullStr[] =3D ""; > + > + if (ParentJsonObj =3D=3D NULL) { > + return RedfishCS_status_invalid_parameter; > + } > + if (VagueValue =3D=3D (RedfishCS_Vague *)NULL) { > + JsonValue =3D json_null(); // No value for this key. > + } else if (VagueValue->DataType =3D=3D RedfishCS_Vague_DataType_String= ) { > + if (VagueValue->DataValue.CharPtr =3D=3D NULL) { > + JsonValue =3D json_string(NullStr); > + } else { > + JsonValue =3D json_string(VagueValue->DataValue.CharPtr); > + } > + } else if (VagueValue->DataType =3D=3D RedfishCS_Vague_DataType_Int64)= { > + JsonValue =3D > +json_integer((json_int_t)*VagueValue->DataValue.Int64Ptr); > + } else if (VagueValue->DataType =3D=3D RedfishCS_Vague_DataType_Bool) = { > + JsonValue =3D json_boolean((BOOLEAN)*VagueValue->DataValue.BoolPtr); > + } else { > + return RedfishCS_status_invalid_parameter; > + } > + if (json_object_set_new (ParentJsonObj, Key, JsonValue) =3D=3D -1) { > + return RedfishCS_status_unsupported; > + } > + return RedfishCS_status_success; > +} > + > +RedfishCS_status InsertJsonLinkObj (json_t *JsonObj, char *Key, > +RedfishCS_Link *Link) { > + json_t *JsonTextObj; > + RedfishCS_Type_JSON_Data *CsJsonHeader; > + > + if (Link =3D=3D NULL || JsonObj =3D=3D NULL) { > + return RedfishCS_status_invalid_parameter; > + } > + if (IsLinkEmpty (Link)) { > + return RedfishCS_status_success; > + } > + > + CsJsonHeader =3D (RedfishCS_Type_JSON_Data *)GetFirstLink (Link); if > + (CsJsonHeader->Header.ResourceType !=3D RedfishCS_Type_JSON && > + CsJsonHeader->Header.ResourceType !=3D RedfishCS_Type_Uri) { > + // Only support JSON/URI property for CStructure to JSON > + return RedfishCS_status_unsupported; } if (CsJsonHeader->JsonText > + =3D=3D NULL) { > + return RedfishCS_status_invalid_parameter; > + } > + > + if (CsJsonHeader->Header.ResourceType =3D=3D RedfishCS_Type_JSON) { > + JsonTextObj =3D json_loads(CsJsonHeader->JsonText, 0, NULL); > + if (json_object_set_new (JsonObj, Key, JsonTextObj) =3D=3D -1) { > + return RedfishCS_status_unsupported; > + } > + } else { > + JsonTextObj =3D json_string (CsJsonHeader->JsonText); > + if (json_object_set_new (JsonObj, Key, JsonTextObj) =3D=3D -1) { > + return RedfishCS_status_unsupported; > + } > + } > + > + return RedfishCS_status_success; > +} > + > +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[] =3D ""; > + > + if (ParentJsonObj =3D=3D NULL) { > + return RedfishCS_status_invalid_parameter; > + } > + if (StringValueArray =3D=3D (RedfishCS_char_Array *)NULL) { > + return RedfishCS_status_success; // No value for this key. > + } > + ArrayJson =3D json_array(); > + if (ArrayJson =3D=3D NULL) { > + return RedfishCS_status_unsupported; } NextArray =3D > + StringValueArray; do { > + if (NextArray->ArrayValue =3D=3D NULL) { > + ArrayMember =3D json_string(NullStr); > + } else { > + ArrayMember =3D json_string(NextArray->ArrayValue); > + } > + if (json_array_append_new (ArrayJson, ArrayMember) !=3D 0) { > + return RedfishCS_status_unsupported; > + } > + NextArray =3D NextArray->Next; > + } while (NextArray !=3D NULL); > + > + if (json_object_set_new (ParentJsonObj, Key, ArrayJson) =3D=3D -1) { > + return RedfishCS_status_unsupported; > + } > + return RedfishCS_status_success; > +} > + > +RedfishCS_status InsertJsonBoolArrayObj (json_t *ParentJsonObj, char > +*Key, RedfishCS_bool_Array *BoolValueArray) { > + json_t *ArrayJson; > + json_t *ArrayMember; > + RedfishCS_bool_Array *NextArray; > + > + if (ParentJsonObj =3D=3D NULL) { > + return RedfishCS_status_invalid_parameter; > + } > + if (BoolValueArray =3D=3D (RedfishCS_bool_Array *)NULL) { > + return RedfishCS_status_success; // No value for this key. > + } > + ArrayJson =3D json_array(); > + if (ArrayJson =3D=3D NULL) { > + return RedfishCS_status_unsupported; } NextArray =3D > + BoolValueArray; do { > + ArrayMember =3D json_boolean((BOOLEAN)*NextArray->ArrayValue); > + if (json_array_append_new (ArrayJson, ArrayMember) !=3D 0) { > + return RedfishCS_status_unsupported; > + } > + NextArray =3D NextArray->Next; > + } while (NextArray !=3D NULL); > + > + if (json_object_set_new (ParentJsonObj, Key, ArrayJson) =3D=3D -1) { > + return RedfishCS_status_unsupported; > + } > + return RedfishCS_status_success; > +} > + > +RedfishCS_status InsertJsonInt64ArrayObj (json_t *ParentJsonObj, char > +*Key, RedfishCS_int64_Array *Int64ValueArray) { > + json_t *ArrayJson; > + json_t *ArrayMember; > + RedfishCS_int64_Array *NextArray; > + > + if (ParentJsonObj =3D=3D NULL) { > + return RedfishCS_status_invalid_parameter; > + } > + if (Int64ValueArray =3D=3D (RedfishCS_int64_Array *)NULL) { > + return RedfishCS_status_success; // No value for this key. > + } > + ArrayJson =3D json_array(); > + if (ArrayJson =3D=3D NULL) { > + return RedfishCS_status_unsupported; } NextArray =3D > + Int64ValueArray; do { > + ArrayMember =3D json_integer(*NextArray->ArrayValue); > + if (json_array_append_new (ArrayJson, ArrayMember) !=3D 0) { > + return RedfishCS_status_unsupported; > + } > + NextArray =3D NextArray->Next; > + } while (NextArray !=3D NULL); > + > + if (json_object_set_new (ParentJsonObj, Key, ArrayJson) =3D=3D -1) { > + return RedfishCS_status_unsupported; > + } > + return RedfishCS_status_success; > +} > + > +RedfishCS_status InsertJsonLinkArrayObj (json_t *ParentJsonObj, char > +*Key, RedfishCS_Link *LinkArray) { > + json_t *ArrayJson; > + json_t *ArrayMember; > + RedfishCS_Type_Uri_Data *ThisLink; > + > + if (ParentJsonObj =3D=3D NULL) { > + return RedfishCS_status_invalid_parameter; > + } > + > + if (IsLinkEmpty (LinkArray)) { > + return RedfishCS_status_success; > + } > + > + ArrayJson =3D json_array(); > + if (ArrayJson =3D=3D NULL) { > + return RedfishCS_status_unsupported; > + } > + ThisLink =3D (RedfishCS_Type_Uri_Data *)GetFirstLink (LinkArray); > + while (RedfishCS_boolean_true){ > + if (ThisLink->Header.ResourceType !=3D RedfishCS_Type_Uri) { > + return RedfishCS_status_invalid_parameter; > + } > + if (ThisLink->Uri !=3D (RedfishCS_char *)NULL) { > + ArrayMember =3D json_string(ThisLink->Uri); > + if (json_array_append_new (ArrayJson, ArrayMember) !=3D 0) { > + return RedfishCS_status_unsupported; > + } > + } > + if (IsLinkAtEnd (LinkArray, &ThisLink->Header.LinkEntry)) { > + if (json_object_set_new (ParentJsonObj, Key, ArrayJson) =3D=3D -1)= { > + return RedfishCS_status_unsupported; > + } > + return RedfishCS_status_success; > + } > + ThisLink =3D (RedfishCS_Type_Uri_Data *)GetNextLink(LinkArray, > +&ThisLink->Header.LinkEntry); > + }; > + return RedfishCS_status_success; > +} > + > +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 =3D (RedfishCS_Type_EmptyProp_CS_Data > + *)GetFirstLink(Link); if (EmptyProp_CS_Ptr->Header.ResourceType !=3D > RedfishCS_Type_CS_EmptyProp) { > + return RedfishCS_status_unsupported; > + } > + > + JsonObj =3D json_object(); > + KeyValuePtr =3D EmptyProp_CS_Ptr->KeyValuePtr; > + for (Index =3D 0; Index < EmptyProp_CS_Ptr->NunmOfProperties; Index++)= { > + Status =3D InsertJsonVagueObj(JsonObj, KeyValuePtr->KeyNamePtr, > KeyValuePtr->Value); > + if (Status !=3D RedfishCS_status_success) { > + return Status; > + } > + KeyValuePtr =3D KeyValuePtr->NextKeyValuePtr; > + } > + if (json_object_set_new(ParentJsonObj, Key, JsonObj) !=3D 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..9dbab2c0b1 > --- /dev/null > +++ b/RedfishClientPkg/ConverterLib/src/RedfishCsMemory.c > @@ -0,0 +1,144 @@ > +/** @file > + > + (C) Copyright 2018-2021 Hewlett Packard Enterprise Development LP
> + > + SPDX-License-Identifier: BSD-2-Clause-Patent > + > +**/ > + > +#include "RedfishCsMemoryInternal.h" > +#include > +#include > + > +RedfishCS_Link CsMemRoot =3D {&CsMemRoot, &CsMemRoot}; > + > +RedfishCS_status recordCsRootMemory (void *memCs) { > + RedfishCS_Internal_memory_root *memRoot; > + > + memRoot =3D malloc (sizeof(RedfishCS_Internal_memory_root)); > + if (memRoot =3D=3D NULL) { > + return RedfishCS_status_insufficient_memory; > + } > + InitializeLinkHead (&memRoot->nextRoot); > + InitializeLinkHead (&memRoot->memBlocks); > + memRoot->CsPtr =3D memCs; > + InsertTailLink (&CsMemRoot, &memRoot->nextRoot); > + return RedfishCS_status_success; > +} > + > +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 =3D (RedfishCS_Internal_memory_root *)GetFirstLink > + (&CsMemRoot); while (RedfishCS_boolean_true){ > + if (memRoot->CsPtr =3D=3D rootCs) { > + // Allocation memory and record it. > + memLink =3D malloc (sizeof(RedfishCS_Internal_memory_link)); > + if (memLink =3D=3D NULL) { > + return RedfishCS_status_insufficient_memory; > + } > + *Dst =3D malloc (size); > + if (*Dst =3D=3D 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 =3D *Dst; > + InsertTailLink (&memRoot->memBlocks, &memLink->nextLink); > + return RedfishCS_status_success; > + } > + if (IsLinkAtEnd (&CsMemRoot, (RedfishCS_Link *)&memRoot->nextRoot)) > { > + break; > + } > + memRoot =3D (RedfishCS_Internal_memory_root *)GetNextLink > + (&CsMemRoot, &memRoot->nextRoot); }; > + > + return RedfishCS_status_invalid_parameter; > +} > + > +RedfishCS_status allocateRecordCsZeroMemory (RedfishCS_void *rootCs, > +RedfishCS_uint32 size, RedfishCS_void **Dst) { > + RedfishCS_status Status; > + > + Status =3D allocateRecordCsMemory (rootCs, size, Dst); > + if (Status !=3D RedfishCS_status_success || *Dst =3D=3D NULL) { > + return Status; > + } > + memset (*Dst, 0, size); > + return RedfishCS_status_success; > +} > + > +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 =3D (RedfishCS_Internal_memory_root *)GetFirstLink > +(&CsMemRoot); > + while (RedfishCS_boolean_true){ > + if (memRoot->CsPtr =3D=3D rootCs) { > + if (IsLinkEmpty (&memRoot->memBlocks)) { > + return RedfishCS_status_success; > + } > + while (RedfishCS_boolean_true) { > + memLink =3D (RedfishCS_Internal_memory_link > *)GetLastLink(&memRoot->memBlocks); > + if (memLink->memoryPtr !=3D 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 =3D (RedfishCS_Internal_memory_root *)GetNextLink > +(&CsMemRoot, &memRoot->nextRoot); > + }; > + return RedfishCS_status_invalid_parameter; > +} > +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 =3D 0; Index < ArraySize; Index ++) { > + Status =3D allocateRecordCsMemory(rootCs, ArrayInstanceSize, > &ArrayInstance); > + if (Status !=3D RedfishCS_status_success) { > + return Status; > + } > + memset (ArrayInstance, 0, ArrayInstanceSize); > + if (Index =3D=3D 0) { > + *Dst =3D ArrayInstance; > + } else { > + SizeOfVoid =3D sizeof (RedfishCS_void *); > + if (SizeOfVoid =3D=3D sizeof (RedfishCS_uint32)) { > + *((RedfishCS_uint32 *)PreArrayInstance) =3D > (RedfishCS_uint32)(unsigned long long)ArrayInstance; // Next link. > + } else if (SizeOfVoid =3D=3D sizeof (RedfishCS_uint64)){ > + *((RedfishCS_uint64 *)PreArrayInstance) =3D > (RedfishCS_uint64)ArrayInstance; // Next link. > + } else { > + return RedfishCS_status_invalid_parameter; > + } > + } > + PreArrayInstance =3D ArrayInstance; > + } > + return RedfishCS_status_success; > +} > -- > 2.17.1