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_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);
}
ZBX_THREAD_ENTRY(listener_thread, args)
{
int ret, local_request_failed = 0;
zbx_sock_t s;
assert(args);
assert(((zbx_thread_args_t *)args)->args);
process_type = ((zbx_thread_args_t *)args)->process_type;
server_num = ((zbx_thread_args_t *)args)->server_num;
process_num = ((zbx_thread_args_t *)args)->process_num;
zabbix_log(LOG_LEVEL_INFORMATION, "%s #%d started [%s #%d]", get_daemon_type_string(daemon_type),
server_num, get_process_type_string(process_type), process_num);
memcpy(&s, (zbx_sock_t *)((zbx_thread_args_t *)args)->args, sizeof(zbx_sock_t));
zbx_free(args);
while (ZBX_IS_RUNNING())
{
zbx_setproctitle("listener #%d [waiting for connection]", process_num);
if (SUCCEED == (ret = zbx_tcp_accept(&s)))
{
local_request_failed = 0; /* reset consecutive errors counter */
zbx_setproctitle("listener #%d [processing request]", process_num);
if (SUCCEED == (ret = zbx_tcp_check_security(&s, CONFIG_HOSTS_ALLOWED, 0)))
process_listener(&s);
zbx_tcp_unaccept(&s);
}
if (SUCCEED == ret || EINTR == zbx_sock_last_error())
continue;
zabbix_log(LOG_LEVEL_DEBUG, "failed to accept an incoming connection: %s", zbx_tcp_strerror());
if (local_request_failed++ > 1000)
{
zabbix_log(LOG_LEVEL_WARNING, "too many failures to accept an incoming connection");
local_request_failed = 0;
}
if (ZBX_IS_RUNNING())
zbx_sleep(1);
}
#ifdef _WINDOWS
ZBX_DO_EXIT();
zbx_thread_exit(EXIT_SUCCESS);
#endif
}
ZBX_THREAD_ENTRY(listener_thread, args)
{
int ret, local_request_failed = 0;
zbx_sock_t s;
assert(args);
assert(((zbx_thread_args_t *)args)->args);
zabbix_log(LOG_LEVEL_WARNING, "agent #%d started [listener]", ((zbx_thread_args_t *)args)->thread_num);
memcpy(&s, (zbx_sock_t *)((zbx_thread_args_t *)args)->args, sizeof(zbx_sock_t));
zbx_free(args);
while (ZBX_IS_RUNNING())
{
zbx_setproctitle("listener [waiting for connection]");
if (SUCCEED == (ret = zbx_tcp_accept(&s)))
{
local_request_failed = 0; /* reset consecutive errors counter */
zbx_setproctitle("listener [processing request]");
zabbix_log(LOG_LEVEL_DEBUG, "Processing request.");
if (SUCCEED == (ret = zbx_tcp_check_security(&s, CONFIG_HOSTS_ALLOWED, 0)))
process_listener(&s);
zbx_tcp_unaccept(&s);
}
if (SUCCEED == ret)
continue;
zabbix_log(LOG_LEVEL_DEBUG, "Listener error: %s", zbx_tcp_strerror());
if (local_request_failed++ > 1000)
{
zabbix_log(LOG_LEVEL_WARNING, "Too many consecutive errors on accept() call.");
local_request_failed = 0;
}
if (ZBX_IS_RUNNING())
zbx_sleep(1);
}
#ifdef _WINDOWS
zabbix_log(LOG_LEVEL_INFORMATION, "zabbix_agentd listener stopped");
ZBX_DO_EXIT();
zbx_thread_exit(0);
#endif
}
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;
}
ZBX_THREAD_ENTRY(listener_thread, pSock)
{
int
ret,
local_request_failed = 0;
zbx_sock_t s;
assert(pSock);
zbx_setproctitle("listener waiting for connection");
zabbix_log( LOG_LEVEL_INFORMATION, "zabbix_agentd listener started");
memcpy(&s, ((zbx_sock_t *)pSock), sizeof(zbx_sock_t));
while(ZBX_IS_RUNNING)
{
if( SUCCEED == (ret = zbx_tcp_accept(&s)) )
{
local_request_failed = 0; /* Reset consecutive errors counter */
zbx_setproctitle("processing request");
zabbix_log(LOG_LEVEL_DEBUG, "Processing request.");
if( SUCCEED == (ret = zbx_tcp_check_security(&s, CONFIG_HOSTS_ALLOWED, 0)) )
{
process_listener(&s);
}
zbx_tcp_unaccept(&s);
}
zbx_setproctitle("listener waiting for connection");
if( SUCCEED == ret ) continue;
zabbix_log(LOG_LEVEL_DEBUG, "Listener error: %s", zbx_tcp_strerror());
if (local_request_failed++ > 1000)
{
zabbix_log( LOG_LEVEL_WARNING, "Too many consecutive errors on accept() call.");
local_request_failed = 0;
}
if(ZBX_IS_RUNNING)
zbx_sleep(1);
}
zabbix_log( LOG_LEVEL_INFORMATION, "zabbix_agentd listener stopped");
ZBX_DO_EXIT();
zbx_tread_exit(0);
}
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);
}
ZBX_THREAD_ENTRY(listener_thread, args)
{
#if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL)
char *msg = NULL;
#endif
int ret;
zbx_socket_t s;
assert(args);
assert(((zbx_thread_args_t *)args)->args);
process_type = ((zbx_thread_args_t *)args)->process_type;
server_num = ((zbx_thread_args_t *)args)->server_num;
process_num = ((zbx_thread_args_t *)args)->process_num;
zabbix_log(LOG_LEVEL_INFORMATION, "%s #%d started [%s #%d]", get_program_type_string(program_type),
server_num, get_process_type_string(process_type), process_num);
memcpy(&s, (zbx_socket_t *)((zbx_thread_args_t *)args)->args, sizeof(zbx_socket_t));
zbx_free(args);
#if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL)
zbx_tls_init_child();
#endif
while (ZBX_IS_RUNNING())
{
zbx_setproctitle("listener #%d [waiting for connection]", process_num);
ret = zbx_tcp_accept(&s, configured_tls_accept_modes);
zbx_update_env(zbx_time());
if (SUCCEED == ret)
{
zbx_setproctitle("listener #%d [processing request]", process_num);
if ('\0' != *CONFIG_HOSTS_ALLOWED &&
SUCCEED == (ret = zbx_tcp_check_allowed_peers(&s, CONFIG_HOSTS_ALLOWED)))
{
#if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL)
if (ZBX_TCP_SEC_TLS_CERT != s.connection_type ||
SUCCEED == (ret = zbx_check_server_issuer_subject(&s, &msg)))
#endif
{
process_listener(&s);
}
}
zbx_tcp_unaccept(&s);
}
if (SUCCEED == ret || EINTR == zbx_socket_last_error())
continue;
#if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL)
if (NULL != msg)
{
zabbix_log(LOG_LEVEL_WARNING, "failed to accept an incoming connection: %s", msg);
zbx_free(msg);
}
else
#endif
{
zabbix_log(LOG_LEVEL_WARNING, "failed to accept an incoming connection: %s",
zbx_socket_strerror());
}
if (ZBX_IS_RUNNING())
zbx_sleep(1);
}
#ifdef _WINDOWS
ZBX_DO_EXIT();
zbx_thread_exit(EXIT_SUCCESS);
#endif
}
