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 *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;
}
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 *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 *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 *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 *rf_mr_get(struct rest_uri_param *param)
{
json_t *result = NULL;
update_response_info(param, HTTP_OK);
result = rf_get_standard_msg_reg_json();
return result;
}
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;
}
static json_t *mbp_coll_evt_post(struct rest_uri_param *param)
{
json_t *req = NULL;
int32 mask = 0;
listener_dest_t listener;
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 |= RF_EVENT_MASK_ALL;
return process_listener(req, &listener, mask, MC_REDFISH_MBP_COLL);
}
static json_t *rf_listener_get(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 = {};
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;
}
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 (evt_listener_init(&listener, RF_EVENT_MASK_ALL, listener_id, RF_EVENT_ROOT_FMT) != 0) {
update_response_info(param, HTTP_RESOURCE_NOT_FOUND);
HTTPD_ERR("mbp listener info init fail\n");
return NULL;
}
if (evt_listener_pack_json(result, &listener) != 0) {
update_response_info(param, HTTP_INTERNAL_SERVER_ERROR);
HTTPD_ERR("mbp listener pack json fail\n");
return NULL;
}
update_response_info(param, HTTP_OK);
return result;
}
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;
}
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 *mbp_set_uart_target(json_t *req, int32 cm_lid, struct rest_uri_param *param)
{
int64 reset_type = 0;
result_t rs = RESULT_OK;
int32 reset_mode = 0;
int32 reset_sys_result;
int32 tgt_idx = 0;
int32 tray_idx = 0;
if (is_platform_bdcr()) {
tray_idx = json_integer_value(json_object_get(req, RMM_JSON_TARGET_TRAY));
if (tray_idx == -1) {
HTTPD_ERR("get tray index error\n");
json_free(req);
return NULL;
}
}
tgt_idx = json_integer_value(json_object_get(req, RMM_JSON_TARGET_INDEX));
if (tgt_idx == -1) {
HTTPD_ERR("get target index error\n");
json_free(req);
return NULL;
}
rs = libwrap_mbp_uart_switch(cm_lid, tray_idx, tgt_idx);
if (rs != RESULT_OK) {
HTTPD_ERR("set uart switch fail, result is %d\n", rs);
return NULL;
}
update_response_info(param, HTTP_ACCEPTED);
json_free(req);
int8 buff[128] = {};
snprintf(buff, sizeof(buff), "%d",cm_lid);
rf_snmp_evt(INFO, MSGMbpChange, buff, "set uart target");
return NULL;
}
static json_t *mbp_process_reset(json_t *req, int32 idx, struct rest_uri_param *param)
{
int64 reset_type = 0;
result_t rs = RESULT_OK;
int32 reset_mode = 0;
int32 reset_sys_result;
rs = libwrap_mbp_hard_reset(idx, &reset_sys_result);
if (rs != RESULT_OK) {
HTTPD_ERR("reset mbp fail, result is %d\n", rs);
return NULL;
}
update_response_info(param, HTTP_ACCEPTED);
json_free(req);
int8 buff[128] = {};
snprintf(buff, sizeof(buff), "%d", idx);
rf_snmp_evt(INFO, MSGMbpChange, buff, RMM_JSON_RESETED_BIG);
return NULL;
}
static json_t *rack_evt_patch(struct rest_uri_param *param)
{
update_response_info(param, HTTP_METHOD_NOT_ALLOWED);
return NULL;
}
static json_t *mbp_process_update(json_t *req, int32 idx, struct rest_uri_param *param)
{
json_t *result = NULL;
int8 *image_data = NULL;
json_t *image_obj = NULL;
int32 rc = -1;
int32 cm_lid = 0;
int8 cm_dev[64] = {0};
/* check update capability */
if(libwrap_check_update_capability() != RESULT_OK) {
HTTPD_ERR("firmware update is not supported.\n");
return NULL;
}
if (!libwrap_get_firmware_update_status()) {
HTTPD_ERR("get firmware update status fail\n");
return NULL;
}
libwrap_set_firmware_update_status(0);
result = json_object();
if (result == NULL) {
update_response_info(param, HTTP_APPLICATION_ERROR);
libwrap_set_firmware_update_status(1);
return NULL;
}
rc = libwrap_check_tftp_service();
if (rc == -1) {
json_free(req);
json_object_add(result, RMM_JSON_FRU_RESULT, json_string("tftp server not ready"));
update_response_info(param, HTTP_NOT_ACCEPTABLE);
libwrap_set_firmware_update_status(1);
return result;
}
image_obj = json_object_get(req, RMM_JSON_IMAGE);
if (image_obj == NULL) {
json_free(req);
json_object_add(result, RMM_JSON_FRU_RESULT, json_string("invalid image"));
update_response_info(param, HTTP_NOT_ACCEPTABLE);
libwrap_set_firmware_update_status(1);
return result;
}
image_data = json_string_value(image_obj);
if (image_data == NULL) {
json_free(req);
json_object_add(result, RMM_JSON_FRU_RESULT, json_string("invalid image"));
update_response_info(param, HTTP_NOT_ACCEPTABLE);
libwrap_set_firmware_update_status(1);
return result;
}
cm_lid = idx;
if ((cm_lid == 1) || (cm_lid == 2)) {
snprintf(cm_dev, sizeof(cm_dev), "/dev/ttyCm%dIPMI", cm_lid);
rc = process_firmware_update(cm_lid, cm_dev, image_data, strlen(image_data));
} else {
HTTPD_ERR("invalid cm loc id\n");
json_free(req);
libwrap_set_firmware_update_status(1);
return NULL;
}
if (rc == 0) {
json_free(req);
json_object_add(result, RMM_JSON_FRU_RESULT, json_string(RMM_JSON_UPDATING));
update_response_info(param, HTTP_ACCEPTED);
return result;
} else {
libwrap_set_firmware_update_status(1);
}
json_free(req);
int8 buff[128] = {};
snprintf(buff, sizeof(buff), "%d", idx);
rf_snmp_evt(INFO, MSGMbpChange, buff, RMM_JSON_UPDATE_BIG);
return NULL;
}
