/** @file
|
This file is cloned from DMTF libredfish library tag v1.0.0 and maintained
|
by EDKII.
|
|
//----------------------------------------------------------------------------
|
// Copyright Notice:
|
// Copyright 2017 Distributed Management Task Force, Inc. All rights reserved.
|
// License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libredfish/LICENSE.md
|
//----------------------------------------------------------------------------
|
|
Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
|
(C) Copyright 2021 Hewlett Packard Enterprise Development LP<BR>
|
|
SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
**/
|
#include <redfishPayload.h>
|
|
static redfishPayload* getOpResult(redfishPayload* payload, const char* propName, const char* op, const char* value, EFI_HTTP_STATUS_CODE** StatusCode);
|
static redfishPayload* collectionEvalOp(redfishPayload* payload, const char* propName, const char* op, const char* value, EFI_HTTP_STATUS_CODE** StatusCode);
|
static redfishPayload* arrayEvalOp(redfishPayload* payload, const char* propName, const char* op, const char* value, EFI_HTTP_STATUS_CODE** StatusCode);
|
static redfishPayload* createCollection(redfishService* service, size_t count, redfishPayload** payloads);
|
static json_t* json_object_get_by_index(json_t* json, size_t index);
|
|
bool isPayloadCollection(redfishPayload* payload)
|
{
|
json_t* members;
|
json_t* count;
|
|
if(!payload || !json_is_object(payload->json))
|
{
|
return false;
|
}
|
members = json_object_get(payload->json, "Members");
|
count = json_object_get(payload->json, "Members@odata.count");
|
return ((members != NULL) && (count != NULL));
|
}
|
|
size_t getCollectionSize(redfishPayload* payload)
|
{
|
json_t* members;
|
json_t* count;
|
|
if(!payload || !json_is_object(payload->json))
|
{
|
return 0;
|
}
|
members = json_object_get(payload->json, "Members");
|
count = json_object_get(payload->json, "Members@odata.count");
|
if(!members || !count)
|
{
|
return 0;
|
}
|
return (size_t)json_integer_value(count);
|
}
|
|
bool isPayloadArray(redfishPayload* payload)
|
{
|
if(!payload || !json_is_array(payload->json))
|
{
|
return false;
|
}
|
return true;
|
}
|
|
char* payloadToString(redfishPayload* payload, bool prettyPrint)
|
{
|
size_t flags = 0;
|
if(!payload)
|
{
|
return NULL;
|
}
|
if(prettyPrint)
|
{
|
flags = JSON_INDENT(2);
|
}
|
return json_dumps(payload->json, flags);
|
}
|
|
redfishPayload* createRedfishPayload(json_t* value, redfishService* service)
|
{
|
redfishPayload* payload;
|
payload = (redfishPayload*)malloc(sizeof(redfishPayload));
|
if(payload != NULL)
|
{
|
payload->json = value;
|
payload->service = service;
|
}
|
return payload;
|
}
|
|
redfishPayload* getPayloadByNodeName(redfishPayload* payload, const char* nodeName, EFI_HTTP_STATUS_CODE** StatusCode)
|
{
|
json_t* value;
|
json_t* odataId;
|
const char* uri;
|
|
if(!payload || !nodeName || StatusCode == NULL)
|
{
|
return NULL;
|
}
|
|
*StatusCode = NULL;
|
|
value = json_object_get(payload->json, nodeName);
|
if(value == NULL)
|
{
|
return NULL;
|
}
|
json_incref(value);
|
if(json_object_size(value) == 1)
|
{
|
odataId = json_object_get(value, "@odata.id");
|
if(odataId != NULL)
|
{
|
json_incref(odataId);
|
uri = json_string_value(odataId);
|
json_decref(value);
|
value = getUriFromService(payload->service, uri, StatusCode);
|
json_decref(odataId);
|
if(value == NULL || *StatusCode == NULL)
|
{
|
return NULL;
|
}
|
}
|
}
|
if (*StatusCode == NULL || (**StatusCode >= HTTP_STATUS_200_OK && **StatusCode <= HTTP_STATUS_206_PARTIAL_CONTENT)) {
|
if(json_is_string(value))
|
{
|
odataId = json_object();
|
json_object_set(odataId, nodeName, value);
|
json_decref(value);
|
value = odataId;
|
}
|
}
|
|
return createRedfishPayload(value, payload->service);
|
}
|
|
redfishPayload* getPayloadByIndex(redfishPayload* payload, size_t index, EFI_HTTP_STATUS_CODE** StatusCode)
|
{
|
json_t* value = NULL;
|
json_t* odataId;
|
const char* uri;
|
BOOLEAN FromServerFlag = FALSE;
|
|
if(!payload || StatusCode == NULL)
|
{
|
return NULL;
|
}
|
|
*StatusCode = NULL;
|
|
if(isPayloadCollection(payload))
|
{
|
redfishPayload* members = getPayloadByNodeName(payload, "Members", StatusCode);
|
if ((*StatusCode == NULL && members == NULL) ||
|
(*StatusCode != NULL && (**StatusCode < HTTP_STATUS_200_OK || **StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT))) {
|
return members;
|
}
|
|
if (*StatusCode != NULL) {
|
//
|
// The Payload (members) are retrived from server.
|
//
|
FreePool (*StatusCode);
|
*StatusCode = NULL;
|
FromServerFlag = TRUE;
|
}
|
|
redfishPayload* ret = getPayloadByIndex(members, index, StatusCode);
|
if (*StatusCode == NULL && ret != NULL && FromServerFlag) {
|
//
|
// In such a case, the Redfish resource is parsed from the input payload (members) directly.
|
// Since the members are retrived from server, we still return HTTP_STATUS_200_OK.
|
//
|
*StatusCode = AllocateZeroPool (sizeof (EFI_HTTP_STATUS_CODE));
|
if (*StatusCode == NULL) {
|
ret = NULL;
|
} else {
|
**StatusCode = HTTP_STATUS_200_OK;
|
}
|
}
|
|
cleanupPayload(members);
|
return ret;
|
}
|
|
if(json_is_array(payload->json))
|
{
|
//
|
// The valid range for index is from 0 to the return value of json_array_size() minus 1
|
//
|
value = json_array_get(payload->json, index);
|
}
|
else if(json_is_object(payload->json))
|
{
|
value = json_object_get_by_index(payload->json, index);
|
}
|
|
if(value == NULL)
|
{
|
return NULL;
|
}
|
|
json_incref(value);
|
if(json_object_size(value) == 1)
|
{
|
odataId = json_object_get(value, "@odata.id");
|
if(odataId != NULL)
|
{
|
uri = json_string_value(odataId);
|
json_decref(value);
|
value = getUriFromService(payload->service, uri, StatusCode);
|
if(value == NULL)
|
{
|
return NULL;
|
}
|
}
|
}
|
return createRedfishPayload(value, payload->service);
|
}
|
|
redfishPayload* getPayloadForPath(redfishPayload* payload, redPathNode* redpath, EFI_HTTP_STATUS_CODE** StatusCode)
|
{
|
redfishPayload* ret = NULL;
|
redfishPayload* tmp;
|
|
if(!payload || !redpath || StatusCode == NULL)
|
{
|
return NULL;
|
}
|
|
*StatusCode = NULL;
|
BOOLEAN FromServerFlag = FALSE;
|
|
if(redpath->nodeName)
|
{
|
ret = getPayloadByNodeName(payload, redpath->nodeName, StatusCode);
|
if ((*StatusCode == NULL && ret == NULL) ||
|
(*StatusCode != NULL && (**StatusCode < HTTP_STATUS_200_OK || **StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT))) {
|
//
|
// Any error happen, return directly.
|
//
|
return ret;
|
}
|
}
|
else if(redpath->isIndex)
|
{
|
ASSERT (redpath->index >= 1);
|
ret = getPayloadByIndex(payload, redpath->index - 1, StatusCode);
|
if ((*StatusCode == NULL && ret == NULL) ||
|
(*StatusCode != NULL && (**StatusCode < HTTP_STATUS_200_OK || **StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT))) {
|
//
|
// Any error happen, return directly.
|
//
|
return ret;
|
}
|
}
|
else if(redpath->op)
|
{
|
ret = getOpResult(payload, redpath->propName, redpath->op, redpath->value, StatusCode);
|
if ((*StatusCode == NULL && ret == NULL) ||
|
(*StatusCode != NULL && (**StatusCode < HTTP_STATUS_200_OK || **StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT))) {
|
//
|
// Any error happen, return directly.
|
//
|
return ret;
|
}
|
}
|
else
|
{
|
return NULL;
|
}
|
|
if(redpath->next == NULL || ret == NULL)
|
{
|
return ret;
|
}
|
else
|
{
|
if (*StatusCode != NULL) {
|
FreePool (*StatusCode);
|
*StatusCode = NULL;
|
FromServerFlag = TRUE;
|
}
|
|
tmp = getPayloadForPath(ret, redpath->next, StatusCode);
|
if (*StatusCode == NULL && tmp != NULL && FromServerFlag) {
|
//
|
// In such a case, the Redfish resource is parsed from the input payload (ret) directly.
|
// Since the ret are retrived from server, we still return HTTP_STATUS_200_OK.
|
//
|
*StatusCode = AllocateZeroPool (sizeof (EFI_HTTP_STATUS_CODE));
|
if (*StatusCode == NULL) {
|
tmp = NULL;
|
} else {
|
**StatusCode = HTTP_STATUS_200_OK;
|
}
|
}
|
|
cleanupPayload(ret);
|
return tmp;
|
}
|
}
|
|
redfishPayload* getPayloadForPathString(redfishPayload* payload, const char* string, EFI_HTTP_STATUS_CODE** StatusCode)
|
{
|
redPathNode* redpath;
|
redfishPayload* ret;
|
|
if(!string || StatusCode == NULL)
|
{
|
return NULL;
|
}
|
|
*StatusCode = NULL;
|
|
redpath = parseRedPath(string);
|
if(redpath == NULL)
|
{
|
return NULL;
|
}
|
ret = getPayloadForPath(payload, redpath, StatusCode);
|
cleanupRedPath(redpath);
|
return ret;
|
}
|
|
redfishPayload* patchPayload(redfishPayload* target, redfishPayload* payload, EFI_HTTP_STATUS_CODE** StatusCode)
|
{
|
json_t* json;
|
char* content;
|
char* uri;
|
|
if(!target || !payload || StatusCode == NULL)
|
{
|
return NULL;
|
}
|
|
*StatusCode = NULL;
|
|
json = json_object_get(target->json, "@odata.id");
|
if(json == NULL)
|
{
|
return NULL;
|
}
|
uri = strdup(json_string_value(json));
|
|
content = json_dumps(payload->json, 0);
|
json_decref(json);
|
|
json = patchUriFromService(target->service, uri, content, StatusCode);
|
free(uri);
|
free(content);
|
if(json == NULL)
|
{
|
return NULL;
|
}
|
|
return createRedfishPayload(json, target->service);
|
}
|
|
redfishPayload* postContentToPayload(redfishPayload* target, const char* data, size_t dataSize, const char* contentType, EFI_HTTP_STATUS_CODE** StatusCode)
|
{
|
json_t* json;
|
char* uri;
|
|
if(!target || !data || StatusCode == NULL)
|
{
|
return NULL;
|
}
|
|
*StatusCode = NULL;
|
|
json = json_object_get(target->json, "@odata.id");
|
if(json == NULL)
|
{
|
json = json_object_get(target->json, "target");
|
if(json == NULL)
|
{
|
return NULL;
|
}
|
}
|
uri = strdup(json_string_value(json));
|
json = postUriFromService(target->service, uri, data, dataSize, contentType, StatusCode);
|
free(uri);
|
if(json == NULL)
|
{
|
return NULL;
|
}
|
|
return createRedfishPayload(json, target->service);
|
}
|
|
redfishPayload* postPayload(redfishPayload* target, redfishPayload* payload, EFI_HTTP_STATUS_CODE** StatusCode)
|
{
|
char* content;
|
redfishPayload* ret;
|
|
if(!target || !payload || StatusCode == NULL)
|
{
|
return NULL;
|
}
|
|
*StatusCode = NULL;
|
|
if(!json_is_object(payload->json))
|
{
|
return NULL;
|
}
|
content = payloadToString(payload, false);
|
ret = postContentToPayload(target, content, strlen(content), NULL, StatusCode);
|
free(content);
|
return ret;
|
}
|
|
void cleanupPayload(redfishPayload* payload)
|
{
|
if(!payload)
|
{
|
return;
|
}
|
json_decref(payload->json);
|
//Don't free payload->service, let the caller handle cleaning up the service
|
free(payload);
|
}
|
|
static redfishPayload* getOpResult(redfishPayload* payload, const char* propName, const char* op, const char* value, EFI_HTTP_STATUS_CODE** StatusCode)
|
{
|
const char* propStr;
|
json_t* stringProp;
|
bool ret = false;
|
redfishPayload* prop;
|
long long intVal, intPropVal;
|
json_type jsonType;
|
|
if(isPayloadCollection(payload))
|
{
|
return collectionEvalOp(payload, propName, op, value, StatusCode);
|
}
|
if(isPayloadArray(payload))
|
{
|
return arrayEvalOp(payload, propName, op, value, StatusCode);
|
}
|
|
prop = getPayloadByNodeName(payload, propName, StatusCode);
|
if ((*StatusCode == NULL && prop == NULL) ||
|
(*StatusCode != NULL && (**StatusCode < HTTP_STATUS_200_OK || **StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT))) {
|
return prop;
|
}
|
stringProp = prop->json;
|
jsonType = prop->json->type;
|
switch(jsonType)
|
{
|
case JSON_OBJECT:
|
stringProp = json_object_get(prop->json, propName);
|
case JSON_STRING:
|
if(strcmp(op, "=") == 0)
|
{
|
propStr = json_string_value(stringProp);
|
if(propStr == NULL)
|
{
|
cleanupPayload(prop);
|
return NULL;
|
}
|
ret = (strcmp(propStr, value) == 0);
|
} else if(strcmp(op, "~") == 0)
|
{
|
propStr = json_string_value(stringProp);
|
if(propStr == NULL)
|
{
|
cleanupPayload(prop);
|
return NULL;
|
}
|
ret = (strcasecmp(propStr, value) == 0);
|
}
|
break;
|
case JSON_TRUE:
|
if(strcmp(op, "=") == 0)
|
{
|
ret = (strcmp(value, "true") == 0);
|
}
|
break;
|
case JSON_FALSE:
|
if(strcmp(op, "=") == 0)
|
{
|
ret = (strcmp(value, "false") == 0);
|
}
|
break;
|
case JSON_INTEGER:
|
intPropVal = json_integer_value(prop->json);
|
intVal = strtoll(value, NULL, 0);
|
if(strcmp(op, "=") == 0)
|
{
|
ret = (intPropVal == intVal);
|
}
|
else if(strcmp(op, "<") == 0)
|
{
|
ret = (intPropVal < intVal);
|
}
|
else if(strcmp(op, ">") == 0)
|
{
|
ret = (intPropVal > intVal);
|
}
|
else if(strcmp(op, "<=") == 0)
|
{
|
ret = (intPropVal <= intVal);
|
}
|
else if(strcmp(op, ">=") == 0)
|
{
|
ret = (intPropVal >= intVal);
|
}
|
break;
|
default:
|
break;
|
}
|
cleanupPayload(prop);
|
if(ret)
|
{
|
return payload;
|
}
|
else
|
{
|
return NULL;
|
}
|
}
|
|
static redfishPayload* collectionEvalOp(redfishPayload* payload, const char* propName, const char* op, const char* value, EFI_HTTP_STATUS_CODE** StatusCode)
|
{
|
redfishPayload* ret;
|
redfishPayload* tmp;
|
redfishPayload* members;
|
redfishPayload** valid;
|
size_t validMax;
|
size_t validCount = 0;
|
size_t i;
|
|
validMax = getCollectionSize(payload);
|
if(validMax == 0)
|
{
|
return NULL;
|
}
|
|
valid = (redfishPayload**)calloc(validMax, sizeof(redfishPayload*));
|
if(valid == NULL)
|
{
|
return NULL;
|
}
|
/*Technically getPayloadByIndex would do this, but this optimizes things*/
|
members = getPayloadByNodeName(payload, "Members", StatusCode);
|
if ((*StatusCode == NULL && members == NULL) ||
|
(*StatusCode != NULL && (**StatusCode < HTTP_STATUS_200_OK || **StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT))) {
|
return members;
|
}
|
|
for(i = 0; i < validMax; i++)
|
{
|
if (*StatusCode != NULL) {
|
FreePool (*StatusCode);
|
*StatusCode = NULL;
|
}
|
|
tmp = getPayloadByIndex(members, i, StatusCode);
|
if ((*StatusCode == NULL && tmp == NULL) ||
|
(*StatusCode != NULL && (**StatusCode < HTTP_STATUS_200_OK || **StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT))) {
|
return tmp;
|
}
|
|
if (*StatusCode != NULL) {
|
FreePool (*StatusCode);
|
*StatusCode = NULL;
|
}
|
|
valid[validCount] = getOpResult(tmp, propName, op, value, StatusCode);
|
/*
|
if ((*StatusCode == NULL && valid[validCount] == NULL) ||
|
(*StatusCode != NULL && (**StatusCode < HTTP_STATUS_200_OK || **StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT))) {
|
return valid[validCount];
|
}
|
*/
|
if(valid[validCount] != NULL)
|
{
|
validCount++;
|
}
|
else
|
{
|
cleanupPayload(tmp);
|
}
|
}
|
cleanupPayload(members);
|
if(validCount == 0)
|
{
|
free(valid);
|
return NULL;
|
}
|
if(validCount == 1)
|
{
|
ret = valid[0];
|
free(valid);
|
return ret;
|
}
|
else
|
{
|
ret = createCollection(payload->service, validCount, valid);
|
free(valid);
|
return ret;
|
}
|
}
|
|
static redfishPayload* arrayEvalOp(redfishPayload* payload, const char* propName, const char* op, const char* value, EFI_HTTP_STATUS_CODE** StatusCode)
|
{
|
redfishPayload* ret;
|
redfishPayload* tmp;
|
redfishPayload** valid;
|
size_t validMax;
|
size_t validCount = 0;
|
size_t i;
|
|
validMax = json_array_size(payload->json);
|
if(validMax == 0)
|
{
|
return NULL;
|
}
|
|
valid = (redfishPayload**)calloc(validMax, sizeof(redfishPayload*));
|
if(valid == NULL)
|
{
|
return NULL;
|
}
|
for(i = 0; i < validMax; i++)
|
{
|
if (*StatusCode != NULL) {
|
FreePool (*StatusCode);
|
*StatusCode = NULL;
|
}
|
|
tmp = getPayloadByIndex(payload, i, StatusCode);
|
if ((*StatusCode == NULL && tmp == NULL) ||
|
(*StatusCode != NULL && (**StatusCode < HTTP_STATUS_200_OK || **StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT))) {
|
return tmp;
|
}
|
|
if (*StatusCode != NULL) {
|
FreePool (*StatusCode);
|
*StatusCode = NULL;
|
}
|
|
valid[validCount] = getOpResult(tmp, propName, op, value, StatusCode);
|
/*
|
if ((*StatusCode == NULL && valid[validCount] == NULL) ||
|
(*StatusCode != NULL && (**StatusCode < HTTP_STATUS_200_OK || **StatusCode > HTTP_STATUS_206_PARTIAL_CONTENT))) {
|
return valid[validCount];
|
}
|
*/
|
|
if(valid[validCount] != NULL)
|
{
|
validCount++;
|
}
|
else
|
{
|
cleanupPayload(tmp);
|
}
|
}
|
if(validCount == 0)
|
{
|
free(valid);
|
return NULL;
|
}
|
if(validCount == 1)
|
{
|
ret = valid[0];
|
free(valid);
|
return ret;
|
}
|
else
|
{
|
ret = createCollection(payload->service, validCount, valid);
|
free(valid);
|
return ret;
|
}
|
}
|
|
static redfishPayload* createCollection(redfishService* service, size_t count, redfishPayload** payloads)
|
{
|
redfishPayload* ret;
|
json_t* collectionJson = json_object();
|
json_t* jcount = json_integer((json_int_t)count);
|
json_t* members = json_array();
|
size_t i;
|
|
if(!collectionJson)
|
{
|
return NULL;
|
}
|
if(!members)
|
{
|
json_decref(collectionJson);
|
return NULL;
|
}
|
json_object_set(collectionJson, "Members@odata.count", jcount);
|
json_decref(jcount);
|
for(i = 0; i < count; i++)
|
{
|
json_array_append(members, payloads[i]->json);
|
cleanupPayload(payloads[i]);
|
}
|
json_object_set(collectionJson, "Members", members);
|
json_decref(members);
|
|
ret = createRedfishPayload(collectionJson, service);
|
return ret;
|
}
|
|
static json_t* json_object_get_by_index(json_t* json, size_t index)
|
{
|
void* iter;
|
size_t i;
|
|
iter = json_object_iter(json);
|
for(i = 0; i < index; i++)
|
{
|
iter = json_object_iter_next(json, iter);
|
if(iter == NULL) break;
|
}
|
if(iter == NULL)
|
{
|
return NULL;
|
}
|
return json_object_iter_value(iter);
|
}
|
/* vim: set tabstop=4 shiftwidth=4 expandtab: */
|
