static json_t *fan_listener_get(struct rest_uri_param *param)
{
int32 tzone_idx = 0;
int32 fan_idx = 0;
listener_dest_info_t *header = (listener_dest_info_t *)malloc(sizeof(listener_dest_info_t));
if (header == NULL) {
HTTPD_ERR("malloc failed\n");
return NULL;
}
tzone_idx = get_asset_idx(param, "zone_id", MC_TYPE_TZONE);
if (tzone_idx == -1) {
HTTPD_ERR("get cooling zone index fail\n");
return NULL;
}
fan_idx = get_asset_idx(param, "fan", MC_TYPE_PSU);
if (fan_idx == -1) {
HTTPD_ERR("get fan index fail\n");
return NULL;
}
memset(header, 0, sizeof(listener_dest_info_t));
libwrap_get_listeners_by_type(MC_REDFISH_FAN_COLL, tzone_idx, (tzone_idx - 1) * MAX_PWM_NUM + fan_idx, header);
return get_json_listener(header);
}
int32 rf_evt_info_init(rf_evt_svc_t *service, int32 *evt_types, const int8 *fmt, ...)
{
va_list args;
int32 rc = -1;
rc = get_fixed_info(&service->fixed);
if (rc != 0) {
HTTPD_ERR("get redfish fixed info error\n");
return -1;
}
rc = get_evt_support(evt_types);
if (rc != 0) {
HTTPD_ERR("get redfish event support error\n");
return -1;
}
va_start(args, fmt);
rc = get_evt_links(&service->links, fmt, args);
va_end(args);
if (rc != 0) {
HTTPD_ERR("get redfish event links error\n");
return -1;
}
return 0;
}
static json_t *fan_evt_get(struct rest_uri_param *param)
{
rf_evt_svc_t service = { { {0} } };
json_t *result = NULL;
int32 tzone_idx, fan_idx, reg = 0;
get_rf_base_info(&(service.base));
result = json_object();
if (result == NULL) {
HTTPD_ERR("result json object request error\n");
return NULL;
}
tzone_idx = get_asset_idx(param, "zone_id", MC_TYPE_TZONE);
if (tzone_idx == -1) {
HTTPD_ERR("get cooling zone index fail\n");
return NULL;
}
fan_idx = get_asset_idx(param, "fan_id", MC_TYPE_FAN);
if (fan_idx == -1) {
HTTPD_ERR("get psu zone index fail\n");
return NULL;
}
pack_rf_base_json(result, &(service.base));
reg = 1 << ((tzone_idx - 1) * MAX_PWM_NUM + (fan_idx - 1));
get_evt_links(&(service.links), MC_REDFISH_FAN_COLL, reg, RF_EVENT_FAN_FMT, tzone_idx, fan_idx);
pack_rf_evt_links(result, &(service.links));
return result;
}
static json_t *fan_evt_post(struct rest_uri_param *param)
{
json_t *req = NULL;
listener_dest_t listener;
int32 tzone_idx, fan_idx;
int32 mask = 0;
tzone_idx = get_asset_idx(param, "zone_id", MC_TYPE_TZONE);
if (tzone_idx == -1) {
HTTPD_ERR("get cooling zone index fail\n");
return NULL;
}
fan_idx = get_asset_idx(param, "fan_id", MC_TYPE_FAN);
if (fan_idx == -1) {
HTTPD_ERR("get psu zone index fail\n");
return NULL;
}
update_response_info(param, HTTP_APPLICATION_ERROR);
req = json_parse(param->json_data);
if (req == NULL) {
HTTPD_ERR("json parse error\n");
return NULL;
}
update_response_info(param, HTTP_ACCEPTED);
mask = 1 << ((tzone_idx - 1) * MAX_PWM_NUM + (fan_idx - 1));
return process_listener(req, &listener, mask, MC_REDFISH_FAN_COLL);
}
static json_t *rf_listener_del(struct rest_uri_param *param)
{
int8 *p_id = NULL;
int32 listener_id = 0;
int8 buff[8] = {0};
result_t rs = RESULT_OK;
evt_listener_t listener = {};
p_id = rest_path_value(param, "listener_id");
if (p_id == NULL) {
update_response_info(param, HTTP_BAD_REQUEST);
HTTPD_ERR("get value fail\n");
return NULL;
}
listener_id = (int32)str2int(p_id);
if (libwrap_del_evt_listener(RF_EVENT_MASK_ALL, listener_id) != RESULT_OK) {
update_response_info(param, HTTP_INTERNAL_SERVER_ERROR);
HTTPD_ERR("mbp listener info del fail\n");
return NULL;
}
update_response_info(param, HTTP_NO_CONTENT);
return NULL;
}
static json_t *fan_handle_change_state(json_t *req, int32 tzone_idx, int32 fan_idx, struct rest_uri_param *param)
{
int64 enabled_state = 0;
result_t rs = RESULT_OK;
enabled_state = json_integer_value(json_object_get(req, RMM_JSON_ENABLE_STATE));
if (!((enabled_state == FAN_STATE_ENABLED) || (enabled_state == FAN_STATE_DISABLED))) {
HTTPD_ERR("unknown fan state\n");
update_response_info(param, HTTP_APPLICATION_ERROR);
json_free(req);
return NULL;
}
rs = libwrap_post_fan_change_state(tzone_idx, fan_idx, enabled_state);
if (rs != RESULT_OK) {
HTTPD_ERR("fan state post fail, result is %d\n", rs);
update_response_info(param, HTTP_APPLICATION_ERROR);
} else {
update_response_info(param, HTTP_ACCEPTED);
}
json_free(req);
int8 buff[128] = {};
snprintf(buff, sizeof(buff), "%d", (tzone_idx - 1) * MAX_PWM_NUM + fan_idx);
rf_snmp_evt(INFO, MSGFanChange, buff, "enable state change");
return NULL;
}
static json_t *tzone_coll_get(struct rest_uri_param *param)
{
collections_t *tzone_collections = NULL;
uint32 tzone_num = 0;
result_t rs = RESULT_OK;
json_t *result = NULL;
json_t *tzone = NULL;
json_t *array = NULL;
int32 i;
int32 zone_num = 0;
zone_num = libwrap_get_asset_num(MC_TYPE_TZONE);
if (zone_num == 0) {
HTTPD_ERR("get thermal zone num fail\n");
return NULL;
}
tzone_collections = (collections_t *)malloc(zone_num * sizeof(collections_t));
if (tzone_collections == NULL)
return NULL;
memset(tzone_collections, 0, zone_num * sizeof(collections_t));
rs = libwrap_get_tzone_coll(tzone_collections, &tzone_num);
if (rs != RESULT_OK) {
HTTPD_ERR("get cooling zone collection fail, result is %d\n", rs);
return NULL;
}
result = json_object();
if (result == NULL) {
HTTPD_ERR("result json object request error\n");
return NULL;
}
array = json_array();
if (array == NULL) {
HTTPD_ERR("json array request error\n");
return NULL;
}
for (i = 0; i < tzone_num; i++) {
tzone = NULL;
tzone = json_object();
if (tzone != NULL) {
add_json_integer(tzone, RMM_JSON_ID, tzone_collections[i].id);
add_json_string(tzone, RMM_JSON_UUID, tzone_collections[i].uuid);
add_json_string(tzone, RMM_JSON_NAME, tzone_collections[i].name);
update_href_host(tzone_collections[i].href, HREF_URL_LEN, param->host);
add_json_string(tzone, RMM_JSON_HREF, tzone_collections[i].href);
json_array_add(array, tzone);
}
}
json_object_add(result, RMM_JSON_THERMAL_ZONES, array);
if (tzone_collections)
free(tzone_collections);
return result;
}
int32 subscribe_event(listener_dest_t *listener, int8 *evt_str)
{
memdb_integer evt_nid = 0;
memdb_integer listener_nid = 0;
int32 mask = 0;
int32 rc = 0;
int32 type = get_rf_evt_type(evt_str);
int32 root_type = get_root_evt_type(type);
listener_nid = libwrap_get_listener(listener->dest, &evt_nid, type);
if (listener_nid == -1) {
HTTPD_ERR("get redfish event listener error, type is %d\n", type);
return -1;
}
if (libwrap_evt_subscribe(listener, listener_nid, evt_nid) != 0)
return rc;
/* subscribe resource root */
listener_nid = libwrap_get_listener(listener->dest, &evt_nid, root_type);
if (listener_nid == -1) {
HTTPD_ERR("get redfish event listener error, type is %d\n", type);
return -1;
}
if (libwrap_evt_subscribe(listener, listener_nid, evt_nid) != 0)
return rc;
return 0;
}
static int32 is_event_types_valid(int32 array_size, json_t *event_types)
{
json_t *elem = NULL;
int32 i = 0;
int8 *event_type = NULL;
for (i = 0; i < array_size; i++) {
elem = NULL;
elem = json_array_get(event_types, i);
if (elem == NULL) {
HTTPD_ERR("get json array element error\n");
return -1;
}
event_type = json_string_value(elem);
if (event_type == NULL) {
HTTPD_ERR("get json string value error\n");
return -1;
}
if (get_rf_evt_type(event_type) == -1) {
HTTPD_ERR("Invalid event type:%s\n", event_type);
return -1;
}
}
return 0;
}
static json_t *rf_evt_get(struct rest_uri_param *param)
{
rf_evt_svc_t service = {};
json_t *result = NULL;
int32 rf_evt_support[MAX_EVT_ACTION_NUM] = {};
result = json_object();
if (result == NULL) {
update_response_info(param, HTTP_INTERNAL_SERVER_ERROR);
HTTPD_ERR("result json object request error\n");
return NULL;
}
if (rf_evt_info_init(&service, rf_evt_support, RF_EVENT_ROOT_FMT)!= 0) {
update_response_info(param, HTTP_RESOURCE_NOT_FOUND);
HTTPD_ERR("get redfish evt info error\n");
return NULL;
}
if (rf_evt_pack_json(result, rf_evt_support, &service) != 0) {
update_response_info(param, HTTP_INTERNAL_SERVER_ERROR);
HTTPD_ERR("pack redfish evt info error\n");
return NULL;
}
update_response_info(param, HTTP_OK);
return result;
}
static json_t *mbp_evt_post(struct rest_uri_param *param)
{
json_t *req = NULL;
int32 mask = 0;
listener_dest_t listener;
int32 idx;
idx = get_asset_idx(param, "mbp_id", MC_TYPE_CM);
if (idx == -1) {
HTTPD_ERR("get mbp index fail\n");
return NULL;
}
update_response_info(param, HTTP_APPLICATION_ERROR);
req = json_parse(param->json_data);
if (req == NULL) {
HTTPD_ERR("json parse error\n");
return NULL;
}
update_response_info(param, HTTP_ACCEPTED);
mask = 1 << (idx - 1);
return process_listener(req, &listener, mask, MC_REDFISH_MBP_COLL);
}
static json_t *fan_coll_evt_post(struct rest_uri_param *param)
{
json_t *req = NULL;
int32 reg = 0;
listener_dest_t listener;
int32 tzone_idx;
tzone_idx = get_asset_idx(param, "zone_id", MC_TYPE_TZONE);
if (tzone_idx == -1) {
HTTPD_ERR("get cooling zone index fail\n");
return NULL;
}
update_response_info(param, HTTP_APPLICATION_ERROR);
req = json_parse(param->json_data);
if (req == NULL) {
HTTPD_ERR("json parse error\n");
return NULL;
}
update_response_info(param, HTTP_ACCEPTED);
reg |= RF_EVENT_MASK_ALL;
return process_listener(req, &listener, reg, MC_REDFISH_FAN_COLL);
}
static json_t *mbp_evt_get(struct rest_uri_param *param)
{
rf_evt_svc_t service = { { {0} } };
json_t *result = NULL;
int32 idx, reg = 0;
get_rf_base_info(&(service.base));
result = json_object();
if (result == NULL) {
HTTPD_ERR("result json object request error\n");
return NULL;
}
idx = get_asset_idx(param, "mbp_id", MC_TYPE_CM);
if (idx == -1) {
HTTPD_ERR("get mbp index fail\n");
return NULL;
}
pack_rf_base_json(result, &(service.base));
reg = 1 << (idx - 1);
get_evt_links(&(service.links), MC_REDFISH_MBP_COLL, reg, RF_EVENT_MBP_FMT, idx);
pack_rf_evt_links(result, &(service.links));
return result;
}
int32 evt_listeners_pack_json(json_t *result, evt_listeners_t *listeners)
{
json_t *listener_array = NULL;
json_t * listener = NULL;
int32 i = 0;
json_object_add(result, RMM_JSON_ODATA_CONTEXT, json_string(listeners->odata_context));
json_object_add(result, RMM_JSON_ODATA_TYPE, json_string(listeners->odata_type));
json_object_add(result, RMM_JSON_NAME, json_string(listeners->name));
json_object_add(result, RMM_JSON_MEMBERS_ODATA_COUNT, json_integer(listeners->num));
listener_array = json_array();
if (listener_array == NULL) {
HTTPD_ERR("json array request fail\n");
return -1;
}
for (i = 0; i < listeners->num; i++) {
listener = json_object();
if (listener == NULL) {
HTTPD_ERR("json object request fail\n");
return -1;
}
json_object_add(listener, RMM_JSON_ODATA_ID, json_string(listeners->url[i]));
json_array_add(listener_array, listener);
}
json_object_add(result, RMM_JSON_MEMBERS, listener_array);
return 0;
}
static json_t *rf_listeners_get(struct rest_uri_param *param)
{
evt_listeners_t listeners = {};
json_t *result = NULL;
result = json_object();
if (result == NULL) {
update_response_info(param, HTTP_INTERNAL_SERVER_ERROR);
HTTPD_ERR("json object request fail\n");
return NULL;
}
if (evt_listeners_init(&listeners, RF_EVENT_MASK_ALL, RF_EVENT_ROOT_FMT) != 0){
update_response_info(param, HTTP_RESOURCE_NOT_FOUND);
HTTPD_ERR("mbp coll listeners info init fail\n");
return NULL;
}
if (evt_listeners_pack_json(result, &listeners) != 0) {
update_response_info(param, HTTP_INTERNAL_SERVER_ERROR);
HTTPD_ERR("mbp coll listeners pack json fail\n");
return NULL;
}
update_response_info(param, HTTP_OK);
return result;
}
int32 process_listener(json_t *req, listener_dest_t *listener, int32 mask)
{
int8 *event_type = NULL;
int8 *dest = NULL;
int8 *context = NULL;
int8 *protocol = NULL;
int8 *name = NULL;
int8 *description = NULL;
json_t *elem = NULL;
json_t *event_types = NULL;
int32 array_size, i = 0;
int32 rc = 0;
context = json_string_value(json_object_get(req, RMM_JSON_CONTEXT));
dest = json_string_value(json_object_get(req, RMM_JSON_DEST));
protocol = json_string_value(json_object_get(req, RMM_JSON_PROTOCOL));
event_types = json_object_get(req, RMM_JSON_RF_EVT_TYPES);
name = json_string_value(json_object_get(req, RMM_JSON_RF_NAME));
description = json_string_value(json_object_get(req, RMM_JSON_RF_DESC));
if (!(context && dest && protocol && event_types)) {
HTTPD_ERR("get json string error\n");
return -1;
}
snprintf_s_s(listener->name, sizeof(listener->name), "%s", name);
snprintf_s_s(listener->description, sizeof(listener->description), "%s", description);
snprintf_s_s(listener->context, sizeof(listener->context), "%s", context);
snprintf_s_s(listener->dest, sizeof(listener->dest), "%s", dest);
snprintf_s_s(listener->protocol, sizeof(listener->protocol), "%s", protocol);
listener->idx_mask = mask;
array_size = json_array_size(event_types);
if (is_event_types_valid(array_size, event_types) == -1)
return -1;
for (i = 0; i < array_size; i++) {
elem = NULL;
elem = json_array_get(event_types, i);
if (elem == NULL) {
HTTPD_ERR("get json array element error\n");
return -1;
}
event_type = json_string_value(elem);
if(event_type == NULL) {
HTTPD_ERR("get json string event error\n");
return -1;
}
if (subscribe_event(listener, event_type) != 0)
return -1;
}
return 0;
}
int32 evt_listener_init(evt_listener_t *listener, int32 mask, int32 listener_idx, const int8 *fmt, ...)
{
listener_t *header = NULL;
int8 format[256] = {0};
listener_t *tmp;
int8 prefix[PREFIX_LEN] = {0};
json_t *evt_type_item = NULL;
int32 rs = 0;
int32 count = 0;
va_list args;
rs = libwrap_get_evt_listeners_count(mask, &count);
if (rs != 0 || listener_idx > count) {
HTTPD_ERR("invalid listener index \n");
return -1;
}
snprintf_s_s(listener->copy_right, sizeof(listener->copy_right), "%s", RF_COPY_RIGHT);
rs = rmm_cfg_get_rest_prefix(prefix, PREFIX_LEN);
if (rs != 0) {
HTTPD_ERR("get rest prefix fail\n");
return -1;
}
snprintf_s_ssss(format, sizeof(format), "%s%s%s%s", prefix, (char *)fmt, RF_EVENT_ODATA_CONTEXT_STR, RF_EVENT_LISTENER_MEMBER_STR);
va_start(args, fmt);
vsnprintf(listener->odata_context, CONTEXT_LEN, format, args);
va_end(args);
evt_type_item = json_array();
if (evt_type_item == NULL) {
HTTPD_ERR("json array alloc fail\n");
return -1;
}
snprintf_s_ssssi(listener->odata_id, sizeof(listener->odata_id), "%s%s%s%s/%d", prefix
, (char *)fmt
, RF_EVENT_SERVICE_STR
, RF_EVENT_SUBSCRIBE_STR
, listener_idx);
snprintf_s_s(listener->odata_type, sizeof(listener->odata_type), "%s", RF_EVENT_ODATA_TYPE_DEST);
snprintf_s_i(listener->id, sizeof(listener->id), "%d", listener_idx);
rs = libwrap_get_evt_listener(mask, listener, listener_idx);
if (rs != 0) {
HTTPD_ERR("get listeners fail\n");
return -1;
}
// snprintf(listener->context, sizeof(listener->context), "%s", RF_EVENT_CONTEXT_STR);
// snprintf(listener->protocol, sizeof(listener->protocol), "%s", RF_EVENT_PROTOCOL_STR);
return 0;
}
static json_t *rf_listeners_post(struct rest_uri_param *param)
{
json_t *req = NULL;
json_t *obj = NULL;
int32 mask = 0;
listener_dest_t listener;
int32 listener_idx = 0;
uint32 ary_size = sizeof(sub_listener_attrs)/sizeof(input_attr_t);
req = json_parse(param->json_data);
if (req == NULL) {
update_response_info(param, HTTP_BAD_REQUEST);
HTTPD_ERR("json parse error\n");
return NULL;
}
if (libwrap_check_input_attrs(sub_listener_attrs, ary_size, req, NULL) != RESULT_OK) {
update_response_info(param, HTTP_BAD_REQUEST);
goto out;
}
obj = libwrap_get_attr_json(sub_listener_attrs, ary_size, "Protocol");
if (obj) {
int8 *input = NULL;
input = json_string_value(obj);
if (input && check_str_len(input, REST_EVENT_PROTOCOL)) {
if (strncmp("Redfish", input, strnlen_s("Redfish", RSIZE_MAX_STR)) !=0 ) {
update_response_info(param, HTTP_BAD_REQUEST);
goto out;
}
} else {
update_response_info(param, HTTP_BAD_REQUEST);
goto out;
}
}
mask |= RF_EVENT_MASK_ALL;
if (process_listener(req, &listener, mask) != 0) {
update_response_info(param, HTTP_BAD_REQUEST);
HTTPD_ERR("process listener error\n");
goto out;
}
listener_idx = libwrap_get_evt_listener_idx(mask, listener.dest);
snprintf_s_si(param->rsp, HREF_URL_LEN, "http://%s/redfish/v1/EventService/Subscriptions/%d", param->host, listener_idx);
update_response_info(param, HTTP_CREATED);
out:
if (req)
json_free(req);
return NULL;
}
json_t *process_listener(json_t *req, listener_dest_t *listener, int32 mask, int32 node_type)
{
int8 *action = NULL;
int8 *event_type = NULL;
int8 *dest = NULL;
int8 *type = NULL;
int8 *protocol = NULL;
json_t *elem = NULL;
json_t *event_types = NULL;
json_t *obj = NULL;
int32 array_size, i = 0;
action = json_string_value(json_object_get(req, RMM_JSON_ACTION));
type = json_string_value(json_object_get(req, RMM_JSON_TYPE));
dest = json_string_value(json_object_get(req, RMM_JSON_DEST));
protocol = json_string_value(json_object_get(req, RMM_JSON_PROTOCOL));
event_types = json_object_get(req, RMM_JSON_RF_EVT_TYPES);
if (!(action && type && dest && protocol && event_types)) {
HTTPD_ERR("get json string error\n");
return NULL;
}
snprintf(listener->type, sizeof(listener->type), "%s", type);
snprintf(listener->dest, sizeof(listener->dest), "%s", dest);
snprintf(listener->protocol, sizeof(listener->protocol), "%s", protocol);
listener->idx_mask = mask;
array_size = json_array_size(event_types);
for (i = 0; i < array_size; i++) {
elem = NULL;
elem = json_array_get(event_types, i);
if (elem == NULL) {
HTTPD_ERR("get json array element error\n");
return NULL;
}
if ((obj = json_object_get(elem, RMM_JSON_RF_EVT)) != NULL) {
event_type = json_string_value(obj);
if(event_type == NULL) {
HTTPD_ERR("get json string event error\n");
return NULL;
}
if (0 == strcmp(action, "subscribe"))
subscribe_event(listener, event_type, node_type);
else if (0 == strcmp(action, "unsubscribe"))
unsubscribe_event(listener, event_type, node_type);
}
}
return NULL;
}
static int32 open_listen_socket(uint16 port)
{
int32 fd;
int32 val;
int32 bind_try = 0;
struct sockaddr_in addr;
struct linger linger_opt = { 1, 1 }; /* Linger active, timeout 1s. */
fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0) {
HTTPD_ERR("Fail to open socket: %s\n", strerror(errno));
return -1;
}
fcntl(fd, F_SETFD, FD_CLOEXEC);
val = 1;
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void *)&val, sizeof(val)) < 0) {
HTTPD_ERR("Fail to setsockopt SO_REUSEADDR: %s\n", strerror(errno));
goto fail;
}
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = htonl(INADDR_ANY);
for (;;) {
if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
bind_try++;
if (bind_try >= 10) {
HTTPD_ERR("Fail to bind: %s\n", strerror(errno));
goto fail;
} else
sleep(1);
} else
break;
}
setsockopt(fd, SOL_SOCKET, SO_LINGER, &linger_opt, sizeof(linger_opt));
if (listen(fd, 1) < 0) {
HTTPD_ERR("Fail at socket listen: %s\n", strerror(errno));
goto fail;
}
return fd;
fail:
close(fd);
return -1;
}
void get_evt_links(rf_link_t *links, int32 type, int32 reg, const int8 *fmt, ...)
{
va_list args;
int32 port;
int8 ip_addr[WRAP_DB_MAX_VALUE_LEN] = {0};
memdb_integer nid = 0;
int32 mask, zone_reg = 0;
int8 fmt_hdr[256] = {0};
int8 format[2048] = {0};
int8 prefix[MAX_URL] = {0};
rmm_cfg_get_rest_prefix(prefix, MAX_URL);
if (libutils_get_ip((int8 *)ip_addr) < 0) {
memset(ip_addr, 0, WRAP_DB_MAX_VALUE_LEN);
strncpy_safe(ip_addr, "x", sizeof(ip_addr), 1);
}
port = rmm_cfg_get_port(RESTD_PORT);
if (port == 0) {
HTTPD_ERR("Failed to call rmm_cfg_get_restd_port\n");
exit(-1);
}
snprintf(fmt_hdr, sizeof(fmt_hdr), RF_EVENT_URL_FMT_HDR, ip_addr, port);
snprintf(format, sizeof(format), "%s%s%s", fmt_hdr, fmt, prefix);
va_start(args, fmt);
vsprintf(links->self, format, args);
va_end(args);
nid = libwrap_get_uniq_node_by_type(type);
libwrap_get_listener_links(reg, nid, links);
}
json_t *get_json_listener(listener_dest_info_t *header)
{
json_t *result = NULL;
json_t *jitem = NULL;
json_t *evt_type_item = NULL;
int32 i = 0;
int8 evt_type[128];
listener_dest_info_t *tmp;
result = json_array();
if (result == NULL) {
HTTPD_ERR("result json object request fail\n");
return NULL;
}
while (header) {
jitem = json_object();
json_object_add(jitem, RMM_JSON_RF_LINKS, json_string(header->dest));
evt_type_item = json_array();
for (i = 0; i < header->evt_index; i++) {
memset(evt_type, 0, 128);
get_event_type_by_nodeid(header->event_types[i], evt_type, sizeof(evt_type));
json_array_add(evt_type_item, json_string(evt_type));
}
json_object_add(jitem, RMM_JSON_RF_EVT_TYPES, evt_type_item);
json_array_add(result, jitem);
tmp = header->pnext;
free(header);
header = tmp;
}
return result;
}
void pack_rf_evt_links(json_t *result, rf_link_t *link)
{
int32 i = 0;
json_t *array = NULL;
json_t *listener = NULL;
array = json_array();
if (array == NULL) {
HTTPD_ERR("json array request fail\n");
return;
}
for (i = 0; i < RF_EVENT_MAX_LISTENER_NUM; i++) {
listener = NULL;
listener = json_object();
if (listener != NULL) {
if (strlen(link->subscription[i]) != 0) {
add_json_string(listener, RMM_JSON_RF_LISTENER, (uint8 *)(link->subscription[i]));
json_array_add(array, listener);
}
}
}
json_object_add(result, RMM_JSON_RF_SUBSCRIPTION, array);
add_json_string(result, RMM_JSON_RF_SELF, (uint8 *)link->self);
}
int32 evt_listeners_init(evt_listeners_t *listeners, int32 mask, const int8 * fmt, ...)
{
json_t *result = NULL;
json_t *jitem = NULL;
json_t *evt_type_item = NULL;
int32 i = 0;
int8 evt_type[128];
listener_t *tmp;
int8 format[256] = {0};
int8 prefix[PREFIX_LEN] = {0};
int8 buff[256] = {0};
int32 count = 0;
int32 rs = 0;
va_list args;
snprintf_s_s(listeners->copy_right, sizeof(listeners->copy_right), "%s", RF_COPY_RIGHT);
rs = rmm_cfg_get_rest_prefix(prefix, PREFIX_LEN);
if (rs != 0) {
HTTPD_ERR("get rest prefix fail\n");
return -1;
}
snprintf_s_ssss(format, sizeof(format), "%s%s%s%s", prefix, (char *)fmt, RF_EVENT_ODATA_CONTEXT_STR, RF_EVENT_EVT_MEMBER_STR);
va_start(args, fmt);
vsnprintf(listeners->odata_context, CONTEXT_LEN, format, args);
va_end(args);
snprintf_s_s(listeners->odata_type, sizeof(listeners->odata_type), "%s", RF_EVENT_ODATA_TYPE_DEST_COLL);
snprintf_s_s(listeners->name, sizeof(listeners->name), "%s", RF_EVENT_LISTENERS_NAME);
rs = libwrap_get_evt_listeners_count(mask, &count);
if (rs != 0) {
HTTPD_ERR("get listener count fail\n");
return -1;
}
listeners->num = count;
for (i = 0; i < count; i++) {
snprintf_s_ssssi(listeners->url[i], sizeof(listeners->url[i]), "%s%s%s%s/%d", prefix, (char *)fmt, RF_EVENT_SERVICE_STR, RF_EVENT_SUBSCRIBE_STR, (i + 1));
}
return 0;
}
static json_t *fan_handle_set_speed(json_t *req, int32 tzone_idx, int32 fan_idx, struct rest_uri_param *param)
{
int8 *unit_type = NULL;
int8 *speed = NULL;
uint32 u_type = 0;
result_t rs = RESULT_OK;
unit_type = json_string_value(json_object_get(req, RMM_JSON_UNIT_TYPE));
if (unit_type == NULL) {
HTTPD_ERR("failed to get json <unitType>.\n");
goto err;
}
if (0 == strcmp(unit_type, RMM_JSON_RPM))
u_type = 0;
else if ((0 == strcmp(unit_type, RMM_JSON_PWM)))
u_type = 1;
else {
HTTPD_ERR("json string <unitType> is not right.\n");
goto err;
}
speed = json_string_value(json_object_get(req, RMM_JSON_DESIRED_SPEED));
if (speed == NULL) {
HTTPD_ERR("failed to get json string <desiredSpeed>.\n");
goto err;
}
rs = libwrap_post_fan_set_speed(tzone_idx, fan_idx, u_type, speed);
if (rs != RESULT_OK) {
HTTPD_ERR("fan speed post fail, result is %d\n", rs);
update_response_info(param, HTTP_APPLICATION_ERROR);
} else {
update_response_info(param, HTTP_ACCEPTED);
}
int8 buff[128] = {};
snprintf(buff, sizeof(buff), "%d", (tzone_idx - 1) * MAX_PWM_NUM + fan_idx);
rf_snmp_evt(INFO, MSGFanChange, buff, "speed change");
err:
json_free(req);
return NULL;
}
int32 prepare_get_action(const avail_action_t *av_action, json_t *action, int32 index)
{
if (action == NULL) {
HTTPD_ERR("action json array request fail\n");
return -1;
}
if (0 != strcmp((int8 *)(av_action[index].action), ""))
add_json_string(action, RMM_JSON_ACTION, av_action[index].action);
return 0;
}
static json_t *mbp_post(struct rest_uri_param *param)
{
json_t *req;
int8 *action = NULL;
int32 cm_lid;
cm_lid = get_asset_idx(param, "mbp_id", MC_TYPE_CM);
if (cm_lid == -1) {
HTTPD_ERR("get cm loc lid fail\n");
return NULL;
}
update_response_info(param, HTTP_APPLICATION_ERROR);
req = json_parse_with_len(param->json_data, (int32)(param->content_length));
if (req == NULL) {
HTTPD_ERR("json parse error\n");
return NULL;
}
action = json_string_value(json_object_get(req, RMM_JSON_ACTION));
if (action == NULL) {
HTTPD_ERR("get action error\n");
json_free(req);
return NULL;
}
if (0 == strcmp(action, RMM_JSON_UPDATE)) {
HTTPD_INFO("processing mbp reset\n");
return mbp_process_update(req, cm_lid, param);
} else if (0 == strcmp(action, RMM_JSON_RESET)) {
HTTPD_INFO("processing mbp reset\n");
return mbp_process_reset(req, cm_lid, param);
} else if (0 == strcmp(action, RMM_JSON_SETUARTTARGET)) {
HTTPD_INFO("processing mbp set uart target\n");
return mbp_set_uart_target(req, cm_lid, param);
}
json_free(req);
return NULL;
}
static json_t *tzone_put(struct rest_uri_param *param)
{
json_t *req = NULL;
result_t rs = RESULT_OK;
put_tzone_t put_tzone_info = { {0} };
int8 *description = NULL;
json_t *rs_json = NULL;
int32 tzone_idx = 0;
tzone_idx = get_asset_idx(param, "zone_id", MC_TYPE_TZONE);
if (tzone_idx == -1) {
HTTPD_ERR("get cooling zone index fail\n");
return NULL;
}
rs = libwrap_pre_put_tzone_by_idx(tzone_idx, &put_tzone_info);
if (rs != RESULT_OK) {
HTTPD_ERR("cooling zone pre put fail, result is %d\n", rs);
return NULL;
}
req = json_parse(param->json_data);
if (req == NULL) {
HTTPD_ERR("json parse error\n");
return NULL;
}
put_prepare_str(req, put_tzone_info.descr, DESCRIPTION_LEN, RMM_JSON_DESC);
rs = libwrap_put_tzone_by_idx(tzone_idx, put_tzone_info);
if (rs != RESULT_OK) {
HTTPD_ERR("cooling zone put error, result is %d\n", rs);
return NULL;
}
json_free(req);
int8 buff[128] = {};
snprintf(buff, sizeof(buff), "%d", tzone_idx);
rf_log(INFO, MSGTZoneUpdate, buff);
return tzone_get(param);
}
int32 get_asset_idx(const struct rest_uri_param *param, const int8 *name, int32 type)
{
int8 *p_id = NULL;
int32 index;
p_id = rest_path_value(param, name);
if (p_id == NULL) {
HTTPD_ERR("get value fail\n");
return -1;
}
if (TRUE == is_str_uuid((const int8 *)p_id)) {
if (FALSE == get_index_by_uuid((const int8 *)p_id, type, &index)) {
HTTPD_ERR("uuid %s error!\n", p_id);
return -1;
}
} else
index = (uint32)str2int(p_id);
return index;
}
void get_event_type_by_nodeid(int32 nodeid, int8 *data, int32 data_len)
{
int32 i = 0;
for (i = 0; i < sizeof(nodeid_keys) / sizeof(id_evt_type_t); i++) {
if (nodeid_keys[i].node_id == nodeid) {
strncpy_safe(data, nodeid_keys[i].type_name, data_len, data_len - 1);
return;
}
}
HTTPD_ERR("nodeid input error: %d\n", nodeid);
}
