static int lld_rows_get(char *value, lld_filter_t *filter, zbx_vector_ptr_t *lld_rows, char **error)
{
const char *__function_name = "lld_rows_get";
struct zbx_json_parse jp, jp_data, jp_row;
const char *p;
zbx_lld_row_t *lld_row;
int ret = FAIL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (SUCCEED != zbx_json_open(value, &jp))
{
*error = zbx_strdup(*error, "Value should be a JSON object.");
goto out;
}
/* {"data":[{"{#IFNAME}":"eth0"},{"{#IFNAME}":"lo"},...]} */
/* ^-------------------------------------------^ */
if (SUCCEED != zbx_json_brackets_by_name(&jp, ZBX_PROTO_TAG_DATA, &jp_data))
{
*error = zbx_dsprintf(*error, "Cannot find the \"%s\" array in the received JSON object.",
ZBX_PROTO_TAG_DATA);
goto out;
}
p = NULL;
/* {"data":[{"{#IFNAME}":"eth0"},{"{#IFNAME}":"lo"},...]} */
/* ^ */
while (NULL != (p = zbx_json_next(&jp_data, p)))
{
/* {"data":[{"{#IFNAME}":"eth0"},{"{#IFNAME}":"lo"},...]} */
/* ^------------------^ */
if (FAIL == zbx_json_brackets_open(p, &jp_row))
continue;
if (SUCCEED != filter_evaluate(filter, &jp_row))
continue;
lld_row = zbx_malloc(NULL, sizeof(zbx_lld_row_t));
lld_row->jp_row = jp_row;
zbx_vector_ptr_create(&lld_row->item_links);
zbx_vector_ptr_append(lld_rows, lld_row);
}
ret = SUCCEED;
out:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* Function: parse_list_of_checks *
* *
* Purpose: Parse list of active checks received from server *
* *
* Parameters: str - NULL terminated string received from server *
* *
* Return value: returns SUCCEED on succesfull parsing, *
* FAIL on an incoorrect format of string *
* *
* Author: Eugene Grigorjev, Alexei Vladishev (new json protocol) *
* *
* Comments: *
* String reprents as "ZBX_EOF" termination list *
* With '\n' delimeter between elements. *
* Each element represents as: *
* <key>:<refresh time>:<last log size> *
* *
******************************************************************************/
static int parse_list_of_checks(char *str)
{
const char *p;
char name[MAX_STRING_LEN], key_orig[MAX_STRING_LEN], expression[MAX_STRING_LEN], tmp[MAX_STRING_LEN],
exp_delimiter;
int delay, lastlogsize, expression_type, case_sensitive;
struct zbx_json_parse jp;
struct zbx_json_parse jp_data, jp_row;
zabbix_log(LOG_LEVEL_DEBUG, "In parse_list_of_checks()");
disable_all_metrics();
if (SUCCEED != zbx_json_open(str, &jp))
goto json_error;
if (SUCCEED != zbx_json_value_by_name(&jp, ZBX_PROTO_TAG_RESPONSE, tmp, sizeof(tmp)))
goto json_error;
if (0 != strcmp(tmp, ZBX_PROTO_VALUE_SUCCESS))
{
zabbix_log(LOG_LEVEL_ERR, "Unsucesfull response received from server");
return FAIL;
}
if (SUCCEED != zbx_json_brackets_by_name(&jp, ZBX_PROTO_TAG_DATA, &jp_data))
goto json_error;
p = NULL;
while (NULL != (p = zbx_json_next(&jp_data, p)))
{
/* {"data":[{"key":"system.cpu.num",...,...},{...},...]}
* ^------------------------------^
*/ if (SUCCEED != zbx_json_brackets_open(p, &jp_row))
goto json_error;
if (SUCCEED != zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_KEY, name, sizeof(name)) || *name == '\0')
{
zabbix_log(LOG_LEVEL_WARNING, "Unable to retrieve value of tag \"%s\"",
ZBX_PROTO_TAG_KEY);
continue;
}
if (SUCCEED != zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_KEY_ORIG, key_orig, sizeof(key_orig)) || *key_orig == '\0')
zbx_strlcpy(key_orig, name, sizeof(key_orig));
if (SUCCEED != zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_DELAY, tmp, sizeof(tmp)) || *tmp == '\0')
{
zabbix_log(LOG_LEVEL_WARNING, "Unable to retrieve value of tag \"%s\"",
ZBX_PROTO_TAG_DELAY);
continue;
}
delay = atoi(tmp);
if (SUCCEED != zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_LOGLASTSIZE, tmp, sizeof(tmp)) || *tmp == '\0')
{
zabbix_log(LOG_LEVEL_WARNING, "Unable to retrieve value of tag \"%s\"",
ZBX_PROTO_TAG_LOGLASTSIZE);
continue;
}
lastlogsize = atoi(tmp);
add_check(name, key_orig, delay, lastlogsize);
}
clean_regexps_ex(regexps, ®exps_num);
if (SUCCEED == zbx_json_brackets_by_name(&jp, ZBX_PROTO_TAG_REGEXP, &jp_data))
{
p = NULL;
while (NULL != (p = zbx_json_next(&jp_data, p)))
{
/* {"regexp":[{"name":"regexp1",...,...},{...},...]}
* ^------------------------^
*/ if (SUCCEED != zbx_json_brackets_open(p, &jp_row))
goto json_error;
if (SUCCEED != zbx_json_value_by_name(&jp_row, "name", name, sizeof(name)))
{
zabbix_log(LOG_LEVEL_WARNING, "Unable to retrieve value of tag \"%s\"",
"name");
continue;
}
if (SUCCEED != zbx_json_value_by_name(&jp_row, "expression", expression, sizeof(expression)) || *expression == '\0')
{
zabbix_log(LOG_LEVEL_WARNING, "Unable to retrieve value of tag \"%s\"",
"expression");
continue;
}
if (SUCCEED != zbx_json_value_by_name(&jp_row, "expression_type", tmp, sizeof(tmp)) || *tmp == '\0')
{
zabbix_log(LOG_LEVEL_WARNING, "Unable to retrieve value of tag \"%s\"",
"expression_type");
continue;
}
expression_type = atoi(tmp);
if (SUCCEED != zbx_json_value_by_name(&jp_row, "exp_delimiter", tmp, sizeof(tmp)))
{
zabbix_log(LOG_LEVEL_WARNING, "Unable to retrieve value of tag \"%s\"",
"exp_delimiter");
continue;
}
exp_delimiter = tmp[0];
if (SUCCEED != zbx_json_value_by_name(&jp_row, "case_sensitive", tmp, sizeof(tmp)) || *tmp == '\0')
{
zabbix_log(LOG_LEVEL_WARNING, "Unable to retrieve value of tag \"%s\"",
"case_sensitive");
continue;
}
case_sensitive = atoi(tmp);
add_regexp_ex(®exps, ®exps_alloc, ®exps_num,
name, expression, expression_type, exp_delimiter, case_sensitive);
}
}
return SUCCEED;
json_error:
zabbix_log(LOG_LEVEL_ERR, "Can't parse list of active checks. %s",
zbx_json_strerror());
return FAIL;
}
static int lld_rows_get(char *value, char *filter, zbx_vector_ptr_t *lld_rows, char **error)
{
const char *__function_name = "lld_rows_get";
struct zbx_json_parse jp, jp_data, jp_row;
char *f_macro = NULL, *f_regexp = NULL;
const char *p;
zbx_vector_ptr_t regexps;
zbx_lld_row_t *lld_row;
int ret = FAIL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (SUCCEED != zbx_json_open(value, &jp))
{
*error = zbx_strdup(*error, "Value should be a JSON object.");
goto out;
}
/* {"data":[{"{#IFNAME}":"eth0"},{"{#IFNAME}":"lo"},...]} */
/* ^-------------------------------------------^ */
if (SUCCEED != zbx_json_brackets_by_name(&jp, ZBX_PROTO_TAG_DATA, &jp_data))
{
*error = zbx_dsprintf(*error, "Cannot find the \"%s\" array in the received JSON object.",
ZBX_PROTO_TAG_DATA);
goto out;
}
zbx_vector_ptr_create(®exps);
if (NULL != (f_regexp = strchr(filter, ':')))
{
f_macro = filter;
*f_regexp++ = '\0';
if ('@' == *f_regexp)
DCget_expressions_by_name(®exps, f_regexp + 1);
zabbix_log(LOG_LEVEL_DEBUG, "%s() f_macro:'%s' f_regexp:'%s'", __function_name, f_macro, f_regexp);
}
p = NULL;
/* {"data":[{"{#IFNAME}":"eth0"},{"{#IFNAME}":"lo"},...]} */
/* ^ */
while (NULL != (p = zbx_json_next(&jp_data, p)))
{
/* {"data":[{"{#IFNAME}":"eth0"},{"{#IFNAME}":"lo"},...]} */
/* ^------------------^ */
if (FAIL == zbx_json_brackets_open(p, &jp_row))
continue;
if (NULL != f_macro && SUCCEED != lld_check_record(&jp_row, f_macro, f_regexp, ®exps))
continue;
lld_row = zbx_malloc(NULL, sizeof(zbx_lld_row_t));
memcpy(&lld_row->jp_row, &jp_row, sizeof(struct zbx_json_parse));
zbx_vector_ptr_create(&lld_row->item_links);
zbx_vector_ptr_append(lld_rows, lld_row);
}
zbx_regexp_clean_expressions(®exps);
zbx_vector_ptr_destroy(®exps);
ret = SUCCEED;
out:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
static int parse_response(DC_ITEM *items, AGENT_RESULT *results, int *errcodes, int num,
char *response, char *error, int max_error_len)
{
const char *p;
struct zbx_json_parse jp, jp_data, jp_row;
char *value = NULL;
size_t value_alloc = 0;
int i, ret = GATEWAY_ERROR;
if (SUCCEED == zbx_json_open(response, &jp))
{
if (SUCCEED != zbx_json_value_by_name_dyn(&jp, ZBX_PROTO_TAG_RESPONSE, &value, &value_alloc))
{
zbx_snprintf(error, max_error_len, "No '%s' tag in received JSON", ZBX_PROTO_TAG_RESPONSE);
goto exit;
}
if (0 == strcmp(value, ZBX_PROTO_VALUE_SUCCESS))
{
if (SUCCEED != zbx_json_brackets_by_name(&jp, ZBX_PROTO_TAG_DATA, &jp_data))
{
zbx_strlcpy(error, "Cannot open data array in received JSON", max_error_len);
goto exit;
}
p = NULL;
for (i = 0; i < num; i++)
{
if (SUCCEED != errcodes[i])
continue;
if (NULL == (p = zbx_json_next(&jp_data, p)))
{
zbx_strlcpy(error, "Not all values included in received JSON", max_error_len);
goto exit;
}
if (SUCCEED != zbx_json_brackets_open(p, &jp_row))
{
zbx_strlcpy(error, "Cannot open value object in received JSON", max_error_len);
goto exit;
}
if (SUCCEED == zbx_json_value_by_name_dyn(&jp_row, ZBX_PROTO_TAG_VALUE, &value, &value_alloc))
{
if (SUCCEED == set_result_type(&results[i],
items[i].value_type, items[i].data_type, value))
errcodes[i] = SUCCEED;
else
errcodes[i] = NOTSUPPORTED;
}
else if (SUCCEED == zbx_json_value_by_name_dyn(&jp_row, ZBX_PROTO_TAG_ERROR, &value, &value_alloc))
{
SET_MSG_RESULT(&results[i], zbx_strdup(NULL, value));
errcodes[i] = NOTSUPPORTED;
}
else
{
SET_MSG_RESULT(&results[i], zbx_strdup(NULL, "Cannot get item value or error message"));
errcodes[i] = AGENT_ERROR;
}
}
ret = SUCCEED;
}
else if (0 == strcmp(value, ZBX_PROTO_VALUE_FAILED))
{
if (SUCCEED == zbx_json_value_by_name(&jp, ZBX_PROTO_TAG_ERROR, error, max_error_len))
ret = NETWORK_ERROR;
else
zbx_strlcpy(error, "Cannot get error message describing reasons for failure", max_error_len);
goto exit;
}
else
{
zbx_snprintf(error, max_error_len, "Bad '%s' tag value '%s' in received JSON",
ZBX_PROTO_TAG_RESPONSE, value);
goto exit;
}
}
else
{
zbx_strlcpy(error, "Cannot open received JSON", max_error_len);
goto exit;
}
exit:
zbx_free(value);
return ret;
}
/******************************************************************************
* *
* Function: process_new_values *
* *
* Purpose: process values sent by active agents and senders *
* *
* Parameters: *
* *
* Return value: SUCCEED - processed successfully *
* FAIL - an error occured *
* *
* Author: Alexei Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static int process_new_values(zbx_sock_t *sock, struct zbx_json_parse *jp, const zbx_uint64_t proxy_hostid)
{
struct zbx_json_parse jp_data, jp_row;
const char *p;
char info[MAX_STRING_LEN], tmp[MAX_STRING_LEN];
int ret = SUCCEED;
int processed = 0;
double sec;
time_t now, proxy_timediff = 0;
#define VALUES_MAX 256
static AGENT_VALUE *values = NULL, *av;
int value_num = 0;
zabbix_log(LOG_LEVEL_DEBUG, "In process_new_values()");
now = time(NULL);
sec = zbx_time();
if (NULL == values)
values = zbx_malloc(values, VALUES_MAX * sizeof(AGENT_VALUE));
if (SUCCEED == zbx_json_value_by_name(jp, ZBX_PROTO_TAG_CLOCK, tmp, sizeof(tmp)))
proxy_timediff = now - atoi(tmp);
/* {"request":"ZBX_SENDER_DATA","data":[{"key":"system.cpu.num",...,...},{...},...]}
* ^
*/ if (NULL == (p = zbx_json_pair_by_name(jp, ZBX_PROTO_TAG_DATA)))
{
zabbix_log(LOG_LEVEL_WARNING, "Can't find \"data\" pair");
ret = FAIL;
}
if(SUCCEED == ret)
{
/* {"request":"ZBX_SENDER_DATA","data":[{"key":"system.cpu.num",...,...},{...},...]}
* ^------------------------------------------^
*/ if (FAIL == (ret = zbx_json_brackets_open(p, &jp_data)))
zabbix_log(LOG_LEVEL_WARNING, "Can't proceed jason request. %s",
zbx_json_strerror());
}
/* {"request":"ZBX_SENDER_DATA","data":[{"key":"system.cpu.num",...,...},{...},...]}
* ^
*/ p = NULL;
while (SUCCEED == ret && NULL != (p = zbx_json_next(&jp_data, p)))
{
/* {"request":"ZBX_SENDER_DATA","data":[{"key":"system.cpu.num",...,...},{...},...]}
* ^------------------------------^
*/ if (FAIL == (ret = zbx_json_brackets_open(p, &jp_row)))
break;
/* zabbix_log(LOG_LEVEL_DEBUG, "Next \"%.*s\"",
jp_row.end - jp_row.start + 1,
jp_row.start);*/
av = &values[value_num];
memset(av, 0, sizeof(AGENT_VALUE));
if (SUCCEED == zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_CLOCK, tmp, sizeof(tmp)))
av->clock = atoi(tmp) + proxy_timediff;
else
av->clock = now;
if (FAIL == zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_HOST, av->host_name, sizeof(av->host_name)))
continue;
if (FAIL == zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_KEY, av->key, sizeof(av->key)))
continue;
if (FAIL == zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_VALUE, tmp, sizeof(tmp)))
continue;
av->value = strdup(tmp);
if (SUCCEED == zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_LOGLASTSIZE, tmp, sizeof(tmp)))
av->lastlogsize = atoi(tmp);
if (SUCCEED == zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_LOGTIMESTAMP, tmp, sizeof(tmp)))
av->timestamp = atoi(tmp);
if (SUCCEED == zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_LOGSOURCE, tmp, sizeof(tmp)))
av->source = strdup(tmp);
if (SUCCEED == zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_LOGSEVERITY, tmp, sizeof(tmp)))
av->severity = atoi(tmp);
value_num ++;
if (value_num == VALUES_MAX) {
process_mass_data(sock, proxy_hostid, values, value_num, &processed, proxy_timediff);
clean_agent_values(values, value_num);
value_num = 0;
}
}
if (value_num > 0)
process_mass_data(sock, proxy_hostid, values, value_num, &processed, proxy_timediff);
clean_agent_values(values, value_num);
zbx_snprintf(info, sizeof(info), "Processed %d Failed %d Total %d Seconds spent " ZBX_FS_DBL,
processed,
value_num - processed,
value_num,
zbx_time() - sec);
if (send_result(sock, ret, info) != SUCCEED)
{
zabbix_log( LOG_LEVEL_WARNING, "Error sending result back");
zabbix_syslog("Trapper: error sending result back");
}
return ret;
}
/******************************************************************************
* *
* Function: *
* *
* Purpose: *
* *
* Parameters: *
* *
* Return value: *
* *
* Comments: *
* *
******************************************************************************/
char *evaluate_jobnetstatusrq(zbx_sock_t * sock,
struct zbx_json_parse *jp, int *ret,
JOBARG_JOBNET_INFO * ji)
{
struct zbx_json_parse jp_row;
char *message = NULL;
char value[MAX_STRING_LEN];
const char *p;
int version;
zbx_uint64_t registrynumber;
static JOBARG_EXEC_REQUEST er;
init_exec_request(&er);
if (SUCCEED ==
zbx_json_value_by_name(jp, JA_PROTO_TAG_VERSION, value,
sizeof(value))) {
version = atoi(value);
if (version != JA_PROTO_VALUE_VERSION_1) {
ja_log("JATRAPPER200027", 0, NULL, 0,
JA_PROTO_VALUE_VERSION_1);
*ret = FAIL;
return zbx_dsprintf(message,
"Received message error: [version] is not correct.");
}
} else {
ja_log("JATRAPPER200028", 0, NULL, 0);
*ret = FAIL;
return zbx_dsprintf(message,
"Received message error: [version] not found");
}
if (NULL == (p = zbx_json_pair_by_name(jp, JA_PROTO_TAG_DATA))) {
ja_log("JATRAPPER200029", 0, NULL, 0);
*ret = FAIL;
return zbx_dsprintf(message,
"Received message error: [data] not found");
} else {
if (FAIL == (*ret = zbx_json_brackets_open(p, &jp_row))) {
ja_log("JATRAPPER200030", 0, NULL, 0);
*ret = FAIL;
return zbx_dsprintf(message,
"Received message error: Cannot open [data] object");
} else {
if (SUCCEED ==
zbx_json_value_by_name(&jp_row, JA_PROTO_TAG_USERNAME,
value, sizeof(value))) {
er.username = strdup(value);
} else {
ja_log("JATRAPPER200032", 0, NULL, 0);
*ret = FAIL;
return zbx_dsprintf(message,
"Received message error: [username] not found");
}
if (SUCCEED ==
zbx_json_value_by_name(&jp_row, JA_PROTO_TAG_PASSWORD,
value, sizeof(value))) {
er.password = strdup(value);
} else {
ja_log("JATRAPPER200033", 0, NULL, 0);
zbx_free(er.username);
*ret = FAIL;
return zbx_dsprintf(message,
"Received message error: [password] not found");
}
if (SUCCEED ==
zbx_json_value_by_name(&jp_row,
JA_PROTO_TAG_REGISTRYNUMBER,
value, sizeof(value))) {
ZBX_STR2UINT64(registrynumber, value);
} else {
ja_log("JATRAPPER200052", 0, NULL, 0);
zbx_free(er.username);
zbx_free(er.password);
*ret = FAIL;
return zbx_dsprintf(message,
"Received message error: [registrynumber] not found");
}
if (SUCCEED != get_jobnet_info(registrynumber, &er, ji)) {
zbx_free(er.username);
zbx_free(er.password);
*ret = FAIL;
return zbx_dsprintf(message,
"jobnet specified by the registry number is not found");
}
if (SUCCEED == (job_exec_auth(er))) {
zbx_free(er.username);
zbx_free(er.password);
*ret = SUCCEED;
return zbx_dsprintf(message, "OK.");
} else {
zbx_free(er.username);
zbx_free(er.password);
*ret = FAIL;
return zbx_dsprintf(message, "Authentication failure.");
}
}
}
}
/******************************************************************************
* *
* Function: *
* *
* Purpose: *
* *
* Parameters: *
* *
* Return value: *
* *
* Comments: *
* *
******************************************************************************/
char *evaluate_jobnetrun(zbx_sock_t * sock, struct zbx_json_parse *jp,
int *ret)
{
DB_RESULT result;
DB_ROW row;
struct zbx_json_parse jp_row;
struct zbx_json_parse jp_row2;
char *message = NULL;
char value[MAX_STRING_LEN];
const char *p;
const char *p2;
const char *p3 = NULL;
int version;
int res;
int i;
int count;
zbx_uint64_t inner_jobnet_id;
static JOBARG_EXEC_REQUEST er;
init_exec_request(&er);
if (SUCCEED ==
zbx_json_value_by_name(jp, JA_PROTO_TAG_VERSION, value,
sizeof(value))) {
version = atoi(value);
if (version != JA_PROTO_VALUE_VERSION_1) {
ja_log("JATRAPPER200027", 0, NULL, 0,
JA_PROTO_VALUE_VERSION_1);
*ret = FAIL;
return zbx_dsprintf(message,
"Received message error: [version] is not correct.");
}
} else {
ja_log("JATRAPPER200028", 0, NULL, 0);
*ret = FAIL;
return zbx_dsprintf(message,
"Received message error: [version] not found");
}
if (NULL == (p = zbx_json_pair_by_name(jp, JA_PROTO_TAG_DATA))) {
ja_log("JATRAPPER200021", 0, NULL, 0);
*ret = FAIL;
return zbx_dsprintf(message,
"Received message error: [data] not found");
} else {
if (FAIL == (*ret = zbx_json_brackets_open(p, &jp_row))) {
ja_log("JATRAPPER200022", 0, NULL, 0);
*ret = FAIL;
return zbx_dsprintf(message,
"Received message error: Cannot open [data] object");
} else {
if (SUCCEED ==
zbx_json_value_by_name(&jp_row, JA_PROTO_TAG_USERNAME,
value, sizeof(value))) {
er.username = strdup(value);
} else {
ja_log("JATRAPPER200032", 0, NULL, 0);
*ret = FAIL;
return zbx_dsprintf(message,
"Received message error: [username] not found");
}
if (SUCCEED ==
zbx_json_value_by_name(&jp_row, JA_PROTO_TAG_PASSWORD,
value, sizeof(value))) {
er.password = strdup(value);
} else {
ja_log("JATRAPPER200033", 0, NULL, 0);
zbx_free(er.username);
*ret = FAIL;
return zbx_dsprintf(message,
"Received message error: [password] not found");
}
if (SUCCEED ==
zbx_json_value_by_name(&jp_row, JA_PROTO_TAG_JOBNETID,
value, sizeof(value))) {
er.jobnetid = strdup(value);
} else {
ja_log("JATRAPPER200034", 0, NULL, 0);
zbx_free(er.username);
zbx_free(er.password);
*ret = FAIL;
return zbx_dsprintf(message,
"Received message error: [jobnetid] not found");
}
if (SUCCEED ==
zbx_json_value_by_name(&jp_row, JA_PROTO_TAG_STARTTIME,
value, sizeof(value))) {
er.starttime = strdup(value);
res = time_passed_check(er.starttime);
if (res == FAIL) {
zbx_free(er.username);
zbx_free(er.password);
zbx_free(er.jobnetid);
zbx_free(er.starttime);
*ret = FAIL;
return zbx_dsprintf(message,
"Received message error: [start_time] already passed.");
}
}
i = 0;
if (NULL !=
(p2 = zbx_json_pair_by_name(&jp_row, JA_PROTO_TAG_ENV))) {
if (FAIL == (*ret = zbx_json_brackets_open(p2, &jp_row2))) {
ja_log("JATRAPPER200051", 0, er.jobnetid, 0);
zbx_free(er.username);
zbx_free(er.password);
zbx_free(er.jobnetid);
zbx_free(er.starttime);
*ret = FAIL;
return zbx_dsprintf(message,
"Received message error: Cannot open [env] object");
} else {
while (NULL !=
(p3 =
zbx_json_pair_next(&jp_row2, p3, value,
sizeof(value)))) {
er.env[i] = strdup(value);
zbx_json_value_by_name(&jp_row2, er.env[i], value,
sizeof(value));
er.value[i] = strdup(value);
i++;
}
er.env[i] = '\0';
}
}
if (SUCCEED ==
zbx_json_value_by_name(&jp_row, JA_PROTO_TAG_DETERRENCE,
value, sizeof(value))) {
er.deterrence = atoi(value);
}
if (SUCCEED == (job_exec_auth(er))) {
DBbegin();
/* double check start-up suppression time specified */
if (er.starttime != NULL && er.deterrence == 1) {
result = DBselect("select count(*) from ja_run_jobnet_table"
" where scheduled_time = %s and jobnet_id = '%s' and run_type = %d",
er.starttime, er.jobnetid, JA_JOBNET_RUN_TYPE_SCHEDULED);
if (NULL == (row = DBfetch(result))) {
zbx_snprintf(msgwork, sizeof(msgwork), "%s %s %d", er.starttime, er.jobnetid, JA_JOBNET_RUN_TYPE_SCHEDULED);
ja_log("JATRAPPER200057", 0, er.jobnetid, 0, "ja_run_jobnet_table", msgwork);
DBfree_result(result);
DBrollback();
clean_exec_request(&er, i);
*ret = FAIL;
return zbx_dsprintf(message, "ja_run_jobnet_table select error.");
}
count = atoi(row[0]);
DBfree_result(result);
if (count > 0) {
DBrollback();
clean_exec_request(&er, i);
*ret = FAIL;
return zbx_dsprintf(message, "Received message error: Double registration detection of time starting jobnet.");
}
}
if (SUCCEED ==
(register_db_table(er, &inner_jobnet_id, i))) {
DBcommit();
clean_exec_request(&er, i);
return zbx_dsprintf(message,
"Registry number : [" ZBX_FS_UI64
"]", inner_jobnet_id);
} else {
DBrollback();
clean_exec_request(&er, i);
*ret = FAIL;
return zbx_dsprintf(message, "ja_run_jobnet_table insert error.");
}
} else {
clean_exec_request(&er, i);
*ret = FAIL;
return zbx_dsprintf(message, "Authentication failure.");
}
}
}
}
/******************************************************************************
* *
* Function: parse_list_of_checks *
* *
* Purpose: Parse list of active checks received from server *
* *
* Parameters: str - NULL terminated string received from server *
* host - address of host *
* port - port number on host *
* *
* Return value: returns SUCCEED on successful parsing, *
* FAIL on an incorrect format of string *
* *
* Author: Eugene Grigorjev, Alexei Vladishev (new json protocol) *
* *
* Comments: *
* String represented as "ZBX_EOF" termination list *
* With '\n' delimiter between elements. *
* Each element represented as: *
* <key>:<refresh time>:<last log size>:<modification time> *
* *
******************************************************************************/
static int parse_list_of_checks(char *str, const char *host, unsigned short port)
{
const char *p;
char name[MAX_STRING_LEN], key_orig[MAX_STRING_LEN], expression[MAX_STRING_LEN],
tmp[MAX_STRING_LEN], exp_delimiter;
int delay, mtime, expression_type, case_sensitive;
zbx_uint64_t lastlogsize;
struct zbx_json_parse jp;
struct zbx_json_parse jp_data, jp_row;
zabbix_log(LOG_LEVEL_DEBUG, "In parse_list_of_checks()");
disable_all_metrics();
if (SUCCEED != zbx_json_open(str, &jp))
goto json_error;
if (SUCCEED != zbx_json_value_by_name(&jp, ZBX_PROTO_TAG_RESPONSE, tmp, sizeof(tmp)))
goto json_error;
if (0 != strcmp(tmp, ZBX_PROTO_VALUE_SUCCESS))
{
if (SUCCEED == zbx_json_value_by_name(&jp, ZBX_PROTO_TAG_INFO, tmp, sizeof(tmp)))
zabbix_log(LOG_LEVEL_WARNING, "no active checks on server [%s:%hu]: %s", host, port, tmp);
else
zabbix_log(LOG_LEVEL_WARNING, "no active checks on server");
return FAIL;
}
if (SUCCEED != zbx_json_brackets_by_name(&jp, ZBX_PROTO_TAG_DATA, &jp_data))
goto json_error;
p = NULL;
while (NULL != (p = zbx_json_next(&jp_data, p)))
{
/* {"data":[{"key":"system.cpu.num",...,...},{...},...]}
* ^------------------------------^
*/ if (SUCCEED != zbx_json_brackets_open(p, &jp_row))
goto json_error;
if (SUCCEED != zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_KEY, name, sizeof(name)) || '\0' == *name)
{
zabbix_log(LOG_LEVEL_WARNING, "cannot retrieve value of tag \"%s\"", ZBX_PROTO_TAG_KEY);
continue;
}
if (SUCCEED != zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_KEY_ORIG, key_orig, sizeof(key_orig))
|| '\0' == *key_orig) {
zbx_strlcpy(key_orig, name, sizeof(key_orig));
}
if (SUCCEED != zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_DELAY, tmp, sizeof(tmp)) || '\0' == *tmp)
{
zabbix_log(LOG_LEVEL_WARNING, "cannot retrieve value of tag \"%s\"", ZBX_PROTO_TAG_DELAY);
continue;
}
delay = atoi(tmp);
if (SUCCEED != zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_LOGLASTSIZE, tmp, sizeof(tmp)) ||
SUCCEED != is_uint64(tmp, &lastlogsize))
{
zabbix_log(LOG_LEVEL_WARNING, "cannot retrieve value of tag \"%s\"", ZBX_PROTO_TAG_LOGLASTSIZE);
continue;
}
if (SUCCEED != zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_MTIME, tmp, sizeof(tmp)) || '\0' == *tmp)
{
zabbix_log(LOG_LEVEL_WARNING, "cannot retrieve value of tag \"%s\"", ZBX_PROTO_TAG_MTIME);
mtime = 0;
}
else
mtime = atoi(tmp);
add_check(name, key_orig, delay, lastlogsize, mtime);
}
zbx_regexp_clean_expressions(®exps);
if (SUCCEED == zbx_json_brackets_by_name(&jp, ZBX_PROTO_TAG_REGEXP, &jp_data))
{
p = NULL;
while (NULL != (p = zbx_json_next(&jp_data, p)))
{
/* {"regexp":[{"name":"regexp1",...,...},{...},...]}
* ^------------------------^
*/ if (SUCCEED != zbx_json_brackets_open(p, &jp_row))
goto json_error;
if (SUCCEED != zbx_json_value_by_name(&jp_row, "name", name, sizeof(name)))
{
zabbix_log(LOG_LEVEL_WARNING, "cannot retrieve value of tag \"%s\"", "name");
continue;
}
if (SUCCEED != zbx_json_value_by_name(&jp_row, "expression", expression, sizeof(expression)) ||
'\0' == *expression)
{
zabbix_log(LOG_LEVEL_WARNING, "cannot retrieve value of tag \"%s\"", "expression");
continue;
}
if (SUCCEED != zbx_json_value_by_name(&jp_row, "expression_type", tmp, sizeof(tmp)) ||
'\0' == *tmp)
{
zabbix_log(LOG_LEVEL_WARNING, "cannot retrieve value of tag \"%s\"", "expression_type");
continue;
}
expression_type = atoi(tmp);
if (SUCCEED != zbx_json_value_by_name(&jp_row, "exp_delimiter", tmp, sizeof(tmp)))
{
zabbix_log(LOG_LEVEL_WARNING, "cannot retrieve value of tag \"%s\"", "exp_delimiter");
continue;
}
exp_delimiter = tmp[0];
if (SUCCEED != zbx_json_value_by_name(&jp_row, "case_sensitive", tmp,
sizeof(tmp)) || '\0' == *tmp)
{
zabbix_log(LOG_LEVEL_WARNING, "cannot retrieve value of tag \"%s\"", "case_sensitive");
continue;
}
case_sensitive = atoi(tmp);
add_regexp_ex(®exps, name, expression, expression_type, exp_delimiter, case_sensitive);
}
}
return SUCCEED;
json_error:
zabbix_log(LOG_LEVEL_ERR, "cannot parse list of active checks: %s", zbx_json_strerror());
return FAIL;
}
