/******************************************************************************
* *
* Function: get_pinger_hosts *
* *
* Purpose: creates buffer which contains list of hosts to ping *
* *
* Parameters: *
* *
* Return value: SUCCEED - the file was created successfully *
* FAIL - otherwise *
* *
* Author: Alexei Vladishev, Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static void get_pinger_hosts(icmpitem_t **icmp_items, int *icmp_items_alloc, int *icmp_items_count)
{
const char *__function_name = "get_pinger_hosts";
DC_ITEM items[MAX_ITEMS];
int i, num, count, interval, size, timeout, rc;
char error[MAX_STRING_LEN], *addr = NULL;
icmpping_t icmpping;
icmppingsec_type_t type;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
num = DCconfig_get_poller_items(ZBX_POLLER_TYPE_PINGER, items, MAX_ITEMS);
for (i = 0; i < num; i++)
{
ZBX_STRDUP(items[i].key, items[i].key_orig);
rc = substitute_key_macros(&items[i].key, &items[i].host, NULL, MACRO_TYPE_ITEM_KEY,
error, sizeof(error));
if (SUCCEED == rc)
{
items[i].interface.addr = (1 == items[i].interface.useip ?
items[i].interface.ip_orig : items[i].interface.dns_orig);
rc = parse_key_params(items[i].key, items[i].interface.addr, &icmpping, &addr, &count,
&interval, &size, &timeout, &type, error, sizeof(error));
}
if (SUCCEED == rc)
{
add_icmpping_item(icmp_items, icmp_items_alloc, icmp_items_count, count, interval, size,
timeout, items[i].itemid, addr, icmpping, type);
}
else
{
zbx_timespec_t ts;
zbx_timespec(&ts);
dc_add_history(items[i].itemid, items[i].value_type, items[i].flags, NULL, &ts,
ITEM_STATUS_NOTSUPPORTED, error, 0, NULL, 0, 0, 0, 0);
DCrequeue_reachable_item(items[i].itemid, ITEM_STATUS_NOTSUPPORTED, ts.sec);
}
zbx_free(items[i].key);
}
DCconfig_clean_items(items, NULL, num);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%d", __function_name, *icmp_items_count);
}
/******************************************************************************
* *
* Function: process_value *
* *
* Purpose: process new item value *
* *
* Parameters: *
* *
* Return value: *
* *
* Author: Alexei Vladishev, Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static void process_value(zbx_uint64_t itemid, zbx_uint64_t *value_ui64, double *value_dbl, zbx_timespec_t *ts,
int ping_result, char *error)
{
const char *__function_name = "process_value";
DC_ITEM item;
int errcode;
AGENT_RESULT value;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
DCconfig_get_items_by_itemids(&item, &itemid, &errcode, 1);
if (SUCCEED != errcode)
goto clean;
if (ITEM_STATUS_ACTIVE != item.status)
goto clean;
if (HOST_STATUS_MONITORED != item.host.status)
goto clean;
if (NOTSUPPORTED == ping_result)
{
item.state = ITEM_STATE_NOTSUPPORTED;
dc_add_history(item.itemid, item.value_type, item.flags, NULL, ts, item.state, error);
}
else
{
init_result(&value);
if (NULL != value_ui64)
SET_UI64_RESULT(&value, *value_ui64);
else
SET_DBL_RESULT(&value, *value_dbl);
item.state = ITEM_STATE_NORMAL;
dc_add_history(item.itemid, item.value_type, item.flags, &value, ts, item.state, NULL);
free_result(&value);
}
clean:
DCrequeue_items(&item.itemid, &item.state, &ts->sec, NULL, NULL, &errcode, 1);
DCconfig_clean_items(&item, &errcode, 1);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
/******************************************************************************
* *
* Function: process_value *
* *
* Purpose: process new item value *
* *
* Parameters: *
* *
* Return value: *
* *
* Author: Alexei Vladishev, Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static void process_value(zbx_uint64_t itemid, zbx_uint64_t *value_ui64, double *value_dbl, zbx_timespec_t *ts,
int ping_result, char *error)
{
const char *__function_name = "process_value";
DC_ITEM item;
int errcode;
AGENT_RESULT value;
assert(value_ui64 || value_dbl);
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
DCconfig_get_items_by_itemids(&item, &itemid, &errcode, 1);
if (SUCCEED != errcode)
goto clean;
if (NOTSUPPORTED == ping_result)
{
dc_add_history(item.itemid, item.value_type, item.flags, NULL, ts,
ITEM_STATUS_NOTSUPPORTED, error, 0, NULL, 0, 0, 0, 0);
DCrequeue_reachable_item(item.itemid, ITEM_STATUS_NOTSUPPORTED, ts->sec);
}
else
{
init_result(&value);
if (NULL != value_ui64)
SET_UI64_RESULT(&value, *value_ui64);
else
SET_DBL_RESULT(&value, *value_dbl);
dc_add_history(item.itemid, item.value_type, item.flags, &value, ts,
ITEM_STATUS_ACTIVE, NULL, 0, NULL, 0, 0, 0, 0);
DCrequeue_reachable_item(item.itemid, ITEM_STATUS_ACTIVE, ts->sec);
free_result(&value);
}
clean:
DCconfig_clean_items(&item, &errcode, 1);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
/******************************************************************************
* *
* Function: process_trap_for_interface *
* *
* Purpose: add trap to all matching items for the specified interface *
* *
* Return value: SUCCEED - a matching item was found *
* FAIL - no matching item was found (including fallback items) *
* *
* Author: Rudolfs Kreicbergs *
* *
******************************************************************************/
static int process_trap_for_interface(zbx_uint64_t interfaceid, char *trap, zbx_timespec_t *ts)
{
DC_ITEM *items = NULL;
const char *regex;
char error[ITEM_ERROR_LEN_MAX];
size_t num, i;
int ret = FAIL, fb = -1, *lastclocks = NULL, *errcodes = NULL;
zbx_uint64_t *itemids = NULL;
unsigned char *states = NULL;
AGENT_RESULT *results = NULL;
AGENT_REQUEST request;
zbx_vector_ptr_t regexps;
zbx_vector_ptr_create(®exps);
num = DCconfig_get_snmp_items_by_interfaceid(interfaceid, &items);
itemids = zbx_malloc(itemids, sizeof(zbx_uint64_t) * num);
states = zbx_malloc(states, sizeof(unsigned char) * num);
lastclocks = zbx_malloc(lastclocks, sizeof(int) * num);
errcodes = zbx_malloc(errcodes, sizeof(int) * num);
results = zbx_malloc(results, sizeof(AGENT_RESULT) * num);
for (i = 0; i < num; i++)
{
init_result(&results[i]);
errcodes[i] = FAIL;
items[i].key = zbx_strdup(items[i].key, items[i].key_orig);
if (SUCCEED != substitute_key_macros(&items[i].key, NULL, &items[i], NULL,
MACRO_TYPE_ITEM_KEY, error, sizeof(error)))
{
SET_MSG_RESULT(&results[i], zbx_strdup(NULL, error));
errcodes[i] = NOTSUPPORTED;
continue;
}
if (0 == strcmp(items[i].key, "snmptrap.fallback"))
{
fb = i;
continue;
}
init_request(&request);
if (SUCCEED != parse_item_key(items[i].key, &request))
goto next;
if (0 != strcmp(get_rkey(&request), "snmptrap"))
goto next;
if (1 < get_rparams_num(&request))
goto next;
if (NULL != (regex = get_rparam(&request, 0)))
{
if ('@' == *regex)
{
DCget_expressions_by_name(®exps, regex + 1);
if (0 == regexps.values_num)
{
SET_MSG_RESULT(&results[i], zbx_dsprintf(NULL,
"Global regular expression \"%s\" does not exist.", regex + 1));
errcodes[i] = NOTSUPPORTED;
goto next;
}
}
if (SUCCEED != regexp_match_ex(®exps, trap, regex, ZBX_CASE_SENSITIVE))
goto next;
}
if (SUCCEED == set_result_type(&results[i], items[i].value_type, items[i].data_type, trap))
errcodes[i] = SUCCEED;
else
errcodes[i] = NOTSUPPORTED;
ret = SUCCEED;
next:
free_request(&request);
}
if (FAIL == ret && -1 != fb)
{
if (SUCCEED == set_result_type(&results[fb], items[fb].value_type, items[fb].data_type, trap))
errcodes[fb] = SUCCEED;
else
errcodes[fb] = NOTSUPPORTED;
ret = SUCCEED;
}
for (i = 0; i < num; i++)
{
switch (errcodes[i])
{
case SUCCEED:
if (ITEM_VALUE_TYPE_LOG == items[i].value_type)
{
calc_timestamp(results[i].log->value, &results[i].log->timestamp,
items[i].logtimefmt);
}
items[i].state = ITEM_STATE_NORMAL;
dc_add_history(items[i].itemid, items[i].value_type, items[i].flags, &results[i],
ts, items[i].state, NULL);
itemids[i] = items[i].itemid;
states[i] = items[i].state;
lastclocks[i] = ts->sec;
break;
case NOTSUPPORTED:
items[i].state = ITEM_STATE_NOTSUPPORTED;
dc_add_history(items[i].itemid, items[i].value_type, items[i].flags, NULL,
ts, items[i].state, results[i].msg);
itemids[i] = items[i].itemid;
states[i] = items[i].state;
lastclocks[i] = ts->sec;
break;
}
zbx_free(items[i].key);
free_result(&results[i]);
}
zbx_free(results);
DCrequeue_items(itemids, states, lastclocks, NULL, NULL, errcodes, num);
zbx_free(errcodes);
zbx_free(lastclocks);
zbx_free(states);
zbx_free(itemids);
DCconfig_clean_items(items, NULL, num);
zbx_free(items);
zbx_regexp_clean_expressions(®exps);
zbx_vector_ptr_destroy(®exps);
dc_flush_history();
return ret;
}
static int calcitem_evaluate_expression(DC_ITEM *dc_item, expression_t *exp, char *error, int max_error_len)
{
const char *__function_name = "calcitem_evaluate_expression";
function_t *f = NULL;
char *buf, replace[16], *errstr = NULL;
int i, ret = SUCCEED;
time_t now;
zbx_host_key_t *keys = NULL;
DC_ITEM *items = NULL;
int *errcodes = NULL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (0 == exp->functions_num)
return ret;
keys = zbx_malloc(keys, sizeof(zbx_host_key_t) * exp->functions_num);
items = zbx_malloc(items, sizeof(DC_ITEM) * exp->functions_num);
errcodes = zbx_malloc(errcodes, sizeof(int) * exp->functions_num);
for (i = 0; i < exp->functions_num; i++)
{
f = &exp->functions[i];
buf = get_param_dyn(f->params, 1); /* for first parameter result is not NULL */
if (SUCCEED != parse_host_key(buf, &f->host, &f->key))
{
zbx_snprintf(error, max_error_len,
"Invalid first parameter in function [%s(%s)].",
f->func, f->params);
ret = NOTSUPPORTED;
}
zbx_free(buf);
if (SUCCEED != ret)
goto out;
if (NULL == f->host)
f->host = strdup(dc_item->host.host);
keys[i].host = f->host;
keys[i].key = f->key;
remove_param(f->params, 1);
zabbix_log(LOG_LEVEL_DEBUG, "%s() function:'%s:%s.%s(%s)'",
__function_name, f->host, f->key, f->func, f->params);
}
DCconfig_get_items_by_keys(items, keys, errcodes, exp->functions_num);
now = time(NULL);
for (i = 0; i < exp->functions_num; i++)
{
f = &exp->functions[i];
if (SUCCEED != errcodes[i])
{
zbx_snprintf(error, max_error_len,
"Cannot evaluate function \"%s(%s)\":"
" item \"%s:%s\" does not exist.",
f->func, f->params, f->host, f->key);
ret = NOTSUPPORTED;
break;
}
if (ITEM_STATUS_ACTIVE != items[i].status)
{
zbx_snprintf(error, max_error_len,
"Cannot evaluate function \"%s(%s)\":"
" item \"%s:%s\" is disabled.",
f->func, f->params, f->host, f->key);
ret = NOTSUPPORTED;
break;
}
if (HOST_STATUS_MONITORED != items[i].host.status)
{
zbx_snprintf(error, max_error_len,
"Cannot evaluate function \"%s(%s)\":"
" item \"%s:%s\" belongs to a disabled host.",
f->func, f->params, f->host, f->key);
ret = NOTSUPPORTED;
break;
}
if (ITEM_STATE_NOTSUPPORTED == items[i].state)
{
zbx_snprintf(error, max_error_len,
"Cannot evaluate function \"%s(%s)\": item \"%s:%s\" not supported.",
f->func, f->params, f->host, f->key);
ret = NOTSUPPORTED;
break;
}
f->value = zbx_malloc(f->value, MAX_BUFFER_LEN);
if (SUCCEED != evaluate_function(f->value, &items[i], f->func, f->params, now, &errstr))
{
if (NULL != errstr)
{
zbx_snprintf(error, max_error_len, "Cannot evaluate function \"%s(%s)\": %s.",
f->func, f->params, errstr);
zbx_free(errstr);
}
else
{
zbx_snprintf(error, max_error_len, "Cannot evaluate function \"%s(%s)\".",
f->func, f->params);
}
ret = NOTSUPPORTED;
break;
}
if (SUCCEED != is_double_suffix(f->value) || '-' == *f->value)
{
char *wrapped;
wrapped = zbx_dsprintf(NULL, "(%s)", f->value);
zbx_free(f->value);
f->value = wrapped;
}
else
f->value = zbx_realloc(f->value, strlen(f->value) + 1);
zbx_snprintf(replace, sizeof(replace), "{%d}", f->functionid);
buf = string_replace(exp->exp, replace, f->value);
zbx_free(exp->exp);
exp->exp = buf;
}
DCconfig_clean_items(items, errcodes, exp->functions_num);
out:
zbx_free(errcodes);
zbx_free(items);
zbx_free(keys);
return ret;
}
static void process_step_data(zbx_uint64_t httpstepid, zbx_httpstat_t *stat, zbx_timespec_t *ts)
{
const char *__function_name = "process_step_data";
DB_RESULT result;
DB_ROW row;
unsigned char types[3], states[3];
DC_ITEM items[3];
zbx_uint64_t itemids[3];
int lastclocks[3], errcodes[3];
size_t i, num = 0;
AGENT_RESULT value;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() rspcode:%ld time:" ZBX_FS_DBL " speed:" ZBX_FS_DBL,
__function_name, stat->rspcode, stat->total_time, stat->speed_download);
result = DBselect("select type,itemid from httpstepitem where httpstepid=" ZBX_FS_UI64, httpstepid);
while (NULL != (row = DBfetch(result)))
{
if (3 == num)
{
THIS_SHOULD_NEVER_HAPPEN;
break;
}
if (ZBX_HTTPITEM_TYPE_RSPCODE != (types[num] = (unsigned char)atoi(row[0])) &&
ZBX_HTTPITEM_TYPE_TIME != types[num] && ZBX_HTTPITEM_TYPE_SPEED != types[num])
{
THIS_SHOULD_NEVER_HAPPEN;
continue;
}
ZBX_STR2UINT64(itemids[num], row[1]);
num++;
}
DBfree_result(result);
DCconfig_get_items_by_itemids(items, itemids, errcodes, num);
for (i = 0; i < num; i++)
{
if (SUCCEED != errcodes[i])
continue;
if (HOST_MAINTENANCE_STATUS_ON == items[i].host.maintenance_status &&
MAINTENANCE_TYPE_NODATA == items[i].host.maintenance_type)
{
continue;
}
init_result(&value);
switch (types[i])
{
case ZBX_HTTPITEM_TYPE_RSPCODE:
SET_UI64_RESULT(&value, stat->rspcode);
break;
case ZBX_HTTPITEM_TYPE_TIME:
SET_DBL_RESULT(&value, stat->total_time);
break;
case ZBX_HTTPITEM_TYPE_SPEED:
SET_DBL_RESULT(&value, stat->speed_download);
break;
}
items[i].state = ITEM_STATE_NORMAL;
dc_add_history(items[i].itemid, items[i].value_type, 0, &value, ts, items[i].state, NULL);
states[i] = items[i].state;
lastclocks[i] = ts->sec;
free_result(&value);
}
DCrequeue_items(itemids, states, lastclocks, NULL, NULL, errcodes, num);
DCconfig_clean_items(items, errcodes, num);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
static void process_test_data(zbx_uint64_t httptestid, int lastfailedstep, double speed_download,
const char *err_str, zbx_timespec_t *ts)
{
const char *__function_name = "process_test_data";
DB_RESULT result;
DB_ROW row;
unsigned char types[3], states[3];
DC_ITEM items[3];
zbx_uint64_t itemids[3];
int lastclocks[3], errcodes[3];
size_t i, num = 0;
AGENT_RESULT value;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
result = DBselect("select type,itemid from httptestitem where httptestid=" ZBX_FS_UI64, httptestid);
while (NULL != (row = DBfetch(result)))
{
if (3 == num)
{
THIS_SHOULD_NEVER_HAPPEN;
break;
}
switch (types[num] = (unsigned char)atoi(row[0]))
{
case ZBX_HTTPITEM_TYPE_SPEED:
case ZBX_HTTPITEM_TYPE_LASTSTEP:
break;
case ZBX_HTTPITEM_TYPE_LASTERROR:
if (NULL == err_str)
continue;
break;
default:
THIS_SHOULD_NEVER_HAPPEN;
continue;
}
ZBX_STR2UINT64(itemids[num], row[1]);
num++;
}
DBfree_result(result);
DCconfig_get_items_by_itemids(items, itemids, errcodes, num);
for (i = 0; i < num; i++)
{
if (SUCCEED != errcodes[i])
continue;
if (HOST_MAINTENANCE_STATUS_ON == items[i].host.maintenance_status &&
MAINTENANCE_TYPE_NODATA == items[i].host.maintenance_type)
{
continue;
}
init_result(&value);
switch (types[i])
{
case ZBX_HTTPITEM_TYPE_SPEED:
SET_UI64_RESULT(&value, speed_download);
break;
case ZBX_HTTPITEM_TYPE_LASTSTEP:
SET_UI64_RESULT(&value, lastfailedstep);
break;
case ZBX_HTTPITEM_TYPE_LASTERROR:
SET_STR_RESULT(&value, zbx_strdup(NULL, err_str));
break;
}
items[i].state = ITEM_STATE_NORMAL;
dc_add_history(items[i].itemid, items[i].value_type, 0, &value, ts, items[i].state, NULL);
states[i] = items[i].state;
lastclocks[i] = ts->sec;
free_result(&value);
}
DCrequeue_items(itemids, states, lastclocks, NULL, NULL, errcodes, num);
DCconfig_clean_items(items, errcodes, num);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
/******************************************************************************
* *
* Function: send_list_of_active_checks_json *
* *
* Purpose: send list of active checks to the host *
* *
* Parameters: sock - open socket of server-agent connection *
* json - request buffer *
* *
* Return value: SUCCEED - list of active checks sent successfully *
* FAIL - an error occurred *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
int send_list_of_active_checks_json(zbx_sock_t *sock, struct zbx_json_parse *jp)
{
const char *__function_name = "send_list_of_active_checks_json";
char host[HOST_HOST_LEN_MAX], *name_esc, params[MAX_STRING_LEN],
pattern[MAX_STRING_LEN], tmp[32],
key_severity[MAX_STRING_LEN], key_logeventid[MAX_STRING_LEN],
ip[INTERFACE_IP_LEN_MAX];
DB_RESULT result;
DB_ROW row;
struct zbx_json json;
int res = FAIL, refresh_unsupported, now;
zbx_uint64_t hostid;
char error[MAX_STRING_LEN], *key = NULL;
DC_ITEM dc_item;
unsigned short port;
char **regexp = NULL;
int regexp_alloc = 0;
int regexp_num = 0, n;
char *sql = NULL;
size_t sql_alloc = 2 * ZBX_KIBIBYTE, sql_offset = 0;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (FAIL == zbx_json_value_by_name(jp, ZBX_PROTO_TAG_HOST, host, sizeof(host)))
{
zbx_snprintf(error, MAX_STRING_LEN, "%s", zbx_json_strerror());
goto error;
}
if (FAIL == zbx_json_value_by_name(jp, ZBX_PROTO_TAG_IP, ip, sizeof(ip)))
strscpy(ip, get_ip_by_socket(sock));
if (FAIL == zbx_json_value_by_name(jp, ZBX_PROTO_TAG_PORT, tmp, sizeof(tmp)))
*tmp = '\0';
if (FAIL == is_ushort(tmp, &port))
port = ZBX_DEFAULT_AGENT_PORT;
if (FAIL == get_hostid_by_host(host, ip, port, &hostid, error))
goto error;
DCconfig_get_config_data(&refresh_unsupported, CONFIG_REFRESH_UNSUPPORTED);
now = time(NULL);
sql = zbx_malloc(sql, sql_alloc);
name_esc = DBdyn_escape_string(host);
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,
"select i.key_,i.delay,i.lastlogsize,i.mtime"
" from items i,hosts h"
" where i.hostid=h.hostid"
" and h.status=%d"
" and i.type=%d"
" and i.flags<>%d"
" and h.hostid=" ZBX_FS_UI64
" and h.proxy_hostid is null",
HOST_STATUS_MONITORED,
ITEM_TYPE_ZABBIX_ACTIVE,
ZBX_FLAG_DISCOVERY_CHILD,
hostid);
zbx_free(name_esc);
zbx_json_init(&json, ZBX_JSON_STAT_BUF_LEN);
zbx_json_addstring(&json, ZBX_PROTO_TAG_RESPONSE, ZBX_PROTO_VALUE_SUCCESS, ZBX_JSON_TYPE_STRING);
zbx_json_addarray(&json, ZBX_PROTO_TAG_DATA);
result = DBselect("%s", sql);
while (NULL != (row = DBfetch(result)))
{
if (FAIL == DCconfig_get_item_by_key(&dc_item, (zbx_uint64_t)0, host, row[0]))
{
zabbix_log(LOG_LEVEL_DEBUG, "%s() Item '%s' was not found in the server cache. Not sending now.", __function_name, row[0]);
continue;
}
if (ITEM_STATUS_NOTSUPPORTED == dc_item.status)
{
if (0 == refresh_unsupported || dc_item.lastclock + refresh_unsupported > now)
{
DCconfig_clean_items(&dc_item, NULL, 1);
continue;
}
}
zabbix_log(LOG_LEVEL_DEBUG, "%s() Item '%s' was successfully found in the server cache. Sending.", __function_name, row[0]);
ZBX_STRDUP(key, row[0]);
substitute_key_macros(&key, NULL, &dc_item, NULL, MACRO_TYPE_ITEM_KEY, NULL, 0);
DCconfig_clean_items(&dc_item, NULL, 1);
zbx_json_addobject(&json, NULL);
zbx_json_addstring(&json, ZBX_PROTO_TAG_KEY, key, ZBX_JSON_TYPE_STRING);
if (0 != strcmp(key, row[0]))
zbx_json_addstring(&json, ZBX_PROTO_TAG_KEY_ORIG, row[0], ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, ZBX_PROTO_TAG_DELAY, row[1], ZBX_JSON_TYPE_INT);
/* The agent expects ALWAYS to have lastlogsize and mtime tags. Removing those would cause older agents to fail. */
zbx_json_addstring(&json, ZBX_PROTO_TAG_LOGLASTSIZE, row[2], ZBX_JSON_TYPE_INT);
zbx_json_addstring(&json, ZBX_PROTO_TAG_MTIME, row[3], ZBX_JSON_TYPE_INT);
zbx_json_close(&json);
/* special processing for log[] and logrt[] items */
do { /* simple try realization */
/* log[filename,pattern,encoding,maxlinespersec] */
/* logrt[filename_format,pattern,encoding,maxlinespersec] */
if (0 != strncmp(key, "log[", 4) && 0 != strncmp(key, "logrt[", 6))
break;
if (2 != parse_command(key, NULL, 0, params, sizeof(params)))
break;
/* dealing with `pattern' parameter */
if (0 == get_param(params, 2, pattern, sizeof(pattern)) &&
*pattern == '@')
add_regexp_name(®exp, ®exp_alloc, ®exp_num, pattern + 1);
} while (0); /* simple try realization */
/* special processing for eventlog[] items */
do { /* simple try realization */
/* eventlog[filename,pattern,severity,source,logeventid,maxlinespersec] */
if (0 != strncmp(key, "eventlog[", 9))
break;
if (2 != parse_command(key, NULL, 0, params, sizeof(params)))
break;
/* dealing with `pattern' parameter */
if (0 == get_param(params, 2, pattern, sizeof(pattern)) &&
*pattern == '@')
add_regexp_name(®exp, ®exp_alloc, ®exp_num, pattern + 1);
/* dealing with `severity' parameter */
if (0 == get_param(params, 3, key_severity, sizeof(key_severity)) &&
*key_severity == '@')
add_regexp_name(®exp, ®exp_alloc, ®exp_num, key_severity + 1);
/* dealing with `logeventid' parameter */
if (0 == get_param(params, 5, key_logeventid, sizeof(key_logeventid)) &&
*key_logeventid == '@')
add_regexp_name(®exp, ®exp_alloc, ®exp_num, key_logeventid + 1);
} while (0); /* simple try realization */
zbx_free(key);
}
zbx_json_close(&json);
DBfree_result(result);
if (0 != regexp_num)
{
zbx_json_addarray(&json, ZBX_PROTO_TAG_REGEXP);
sql_offset = 0;
zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset,
"select r.name,e.expression,e.expression_type,e.exp_delimiter,e.case_sensitive"
" from regexps r,expressions e"
" where r.regexpid=e.regexpid"
" and r.name in (");
for (n = 0; n < regexp_num; n++)
{
name_esc = DBdyn_escape_string(regexp[n]);
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "%s'%s'",
n == 0 ? "" : ",",
name_esc);
zbx_free(name_esc);
zbx_free(regexp[n]);
}
zbx_chrcpy_alloc(&sql, &sql_alloc, &sql_offset, ')');
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, DB_NODE, DBnode_local("r.regexpid"));
result = DBselect("%s", sql);
while (NULL != (row = DBfetch(result)))
{
zbx_json_addobject(&json, NULL);
zbx_json_addstring(&json, "name", row[0], ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, "expression", row[1], ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, "expression_type", row[2], ZBX_JSON_TYPE_INT);
zbx_json_addstring(&json, "exp_delimiter", row[3], ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, "case_sensitive", row[4], ZBX_JSON_TYPE_INT);
zbx_json_close(&json);
}
DBfree_result(result);
}
zbx_free(regexp);
zabbix_log(LOG_LEVEL_DEBUG, "%s() sending [%s]", __function_name, json.buffer);
alarm(CONFIG_TIMEOUT);
if (SUCCEED != zbx_tcp_send(sock, json.buffer))
strscpy(error, zbx_tcp_strerror());
else
res = SUCCEED;
alarm(0);
zbx_json_free(&json);
zbx_free(sql);
goto out;
error:
zabbix_log(LOG_LEVEL_WARNING, "cannot send list of active checks to [%s]: %s", get_ip_by_socket(sock), error);
zbx_json_init(&json, ZBX_JSON_STAT_BUF_LEN);
zbx_json_addstring(&json, ZBX_PROTO_TAG_RESPONSE, ZBX_PROTO_VALUE_FAILED, ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, ZBX_PROTO_TAG_INFO, error, ZBX_JSON_TYPE_STRING);
zabbix_log(LOG_LEVEL_DEBUG, "%s() sending [%s]", __function_name, json.buffer);
res = zbx_tcp_send(sock, json.buffer);
zbx_json_free(&json);
out:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(res));
return res;
}
/******************************************************************************
* *
* Function: send_list_of_active_checks *
* *
* Purpose: send list of active checks to the host *
* *
* Parameters: sock - open socket of server-agent connection *
* request - request buffer *
* *
* Return value: SUCCEED - list of active checks sent successfully *
* FAIL - an error occurred *
* *
* Author: Alexei Vladishev *
* *
* Comments: format of the request: ZBX_GET_ACTIVE_CHECKS\n<host name>\n *
* format of the list: key:delay:last_log_size *
* *
******************************************************************************/
int send_list_of_active_checks(zbx_sock_t *sock, char *request)
{
const char *__function_name = "send_list_of_active_checks";
char *host = NULL, *p;
DB_RESULT result;
DB_ROW row;
char *buffer = NULL;
size_t buffer_alloc = 2 * ZBX_KIBIBYTE, buffer_offset = 0;
int res = FAIL, refresh_unsupported, now;
zbx_uint64_t hostid;
char error[MAX_STRING_LEN], ip[INTERFACE_IP_LEN_MAX];
DC_ITEM dc_item;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (NULL != (host = strchr(request, '\n')))
{
host++;
if (NULL != (p = strchr(host, '\n')))
*p = '\0';
}
else
{
zbx_snprintf(error, sizeof(error), "host is null");
goto out;
}
strscpy(ip, get_ip_by_socket(sock));
if (FAIL == get_hostid_by_host(host, ip, ZBX_DEFAULT_AGENT_PORT, &hostid, error))
goto out;
DCconfig_get_config_data(&refresh_unsupported, CONFIG_REFRESH_UNSUPPORTED);
now = time(NULL);
buffer = zbx_malloc(buffer, buffer_alloc);
buffer_offset = 0;
zbx_snprintf_alloc(&buffer, &buffer_alloc, &buffer_offset,
"select i.key_,i.delay,i.lastlogsize"
" from items i,hosts h"
" where i.hostid=h.hostid"
" and h.status=%d"
" and i.type=%d"
" and i.flags<>%d"
" and h.hostid=" ZBX_FS_UI64
" and h.proxy_hostid is null",
HOST_STATUS_MONITORED,
ITEM_TYPE_ZABBIX_ACTIVE,
ZBX_FLAG_DISCOVERY_CHILD,
hostid);
result = DBselect("%s", buffer);
buffer_offset = 0;
while (NULL != (row = DBfetch(result)))
{
if (FAIL == DCconfig_get_item_by_key(&dc_item, (zbx_uint64_t)0, host, row[0]))
{
zabbix_log(LOG_LEVEL_DEBUG, "%s() Item '%s' was not found in the server cache. Not sending now.",
__function_name, row[0]);
continue;
}
if (ITEM_STATUS_NOTSUPPORTED == dc_item.status)
{
if (0 == refresh_unsupported || dc_item.lastclock + refresh_unsupported > now)
{
DCconfig_clean_items(&dc_item, NULL, 1);
continue;
}
}
DCconfig_clean_items(&dc_item, NULL, 1);
zabbix_log(LOG_LEVEL_DEBUG, "%s() Item '%s' was successfully found in the server cache. Sending.",
__function_name, row[0]);
zbx_snprintf_alloc(&buffer, &buffer_alloc, &buffer_offset, "%s:%s:%s\n",
row[0], /* item key */
row[1], /* item delay */
row[2]); /* item lastlogsize */
}
DBfree_result(result);
zbx_strcpy_alloc(&buffer, &buffer_alloc, &buffer_offset, "ZBX_EOF\n");
zabbix_log(LOG_LEVEL_DEBUG, "%s() sending [%s]", __function_name, buffer);
alarm(CONFIG_TIMEOUT);
if (SUCCEED != zbx_tcp_send_raw(sock, buffer))
zbx_snprintf(error, MAX_STRING_LEN, "%s", zbx_tcp_strerror());
else
res = SUCCEED;
alarm(0);
zbx_free(buffer);
out:
if (FAIL == res)
zabbix_log(LOG_LEVEL_WARNING, "cannot send list of active checks to [%s]: %s", get_ip_by_socket(sock),
error);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(res));
return res;
}
/******************************************************************************
* *
* Function: evaluate_aggregate *
* *
* Parameters: item - [IN] aggregated item *
* grp_func - [IN] one of ZBX_GRP_FUNC_* *
* groups - [IN] list of comma-separated host groups *
* itemkey - [IN] item key to aggregate *
* item_func - [IN] one of ZBX_VALUE_FUNC_* *
* param - [IN] item_func parameter (optional) *
* *
* Return value: SUCCEED - aggregate item evaluated successfully *
* FAIL - otherwise *
* *
******************************************************************************/
static int evaluate_aggregate(DC_ITEM *item, AGENT_RESULT *res, int grp_func, const char *groups,
const char *itemkey, int item_func, const char *param)
{
const char *__function_name = "evaluate_aggregate";
zbx_vector_uint64_t itemids;
history_value_t value, item_result;
zbx_history_record_t group_value;
int ret = FAIL, now, *errcodes = NULL, i, count;
DC_ITEM *items = NULL;
zbx_vector_history_record_t values, group_values;
unsigned int seconds;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() grp_func:%d groups:'%s' itemkey:'%s' item_func:%d param:'%s'",
__function_name, grp_func, groups, itemkey, item_func, ZBX_NULL2STR(param));
now = time(NULL);
zbx_vector_uint64_create(&itemids);
aggregate_get_items(&itemids, groups, itemkey);
if (0 == itemids.values_num)
{
SET_MSG_RESULT(res, zbx_dsprintf(NULL, "No items for key \"%s\" in group(s) \"%s\".", itemkey, groups));
goto clean1;
}
memset(&value, 0, sizeof(value));
zbx_history_record_vector_create(&group_values);
items = zbx_malloc(items, sizeof(DC_ITEM) * itemids.values_num);
errcodes = zbx_malloc(errcodes, sizeof(int) * itemids.values_num);
DCconfig_get_items_by_itemids(items, itemids.values, errcodes, itemids.values_num);
if (ZBX_VALUE_FUNC_LAST == item_func)
{
count = 1;
seconds = 0;
}
else
{
if (FAIL == is_uint_suffix(param, &seconds))
{
SET_MSG_RESULT(res, zbx_strdup(NULL, "Invalid fourth parameter."));
goto clean2;
}
count = 0;
}
for (i = 0; i < itemids.values_num; i++)
{
if (SUCCEED != errcodes[i])
continue;
if (ITEM_STATUS_ACTIVE != items[i].status)
continue;
if (HOST_STATUS_MONITORED != items[i].host.status)
continue;
if (ITEM_VALUE_TYPE_FLOAT != items[i].value_type && ITEM_VALUE_TYPE_UINT64 != items[i].value_type)
continue;
zbx_history_record_vector_create(&values);
if (SUCCEED == zbx_vc_get_value_range(items[i].itemid, items[i].value_type, &values, seconds,
count, now) && 0 < values.values_num)
{
evaluate_history_func(&values, items[i].value_type, item_func, &item_result);
if (item->value_type == items[i].value_type)
group_value.value = item_result;
else
{
if (ITEM_VALUE_TYPE_UINT64 == item->value_type)
group_value.value.ui64 = (zbx_uint64_t)item_result.dbl;
else
group_value.value.dbl = (double)item_result.ui64;
}
zbx_vector_history_record_append_ptr(&group_values, &group_value);
}
zbx_history_record_vector_destroy(&values, items[i].value_type);
}
if (0 == group_values.values_num)
{
SET_MSG_RESULT(res, zbx_dsprintf(NULL, "No values for key \"%s\" in group(s) \"%s\"", itemkey, groups));
goto clean2;
}
evaluate_history_func(&group_values, item->value_type, grp_func, &value);
if (ITEM_VALUE_TYPE_FLOAT == item->value_type)
SET_DBL_RESULT(res, value.dbl);
else
SET_UI64_RESULT(res, value.ui64);
ret = SUCCEED;
clean2:
DCconfig_clean_items(items, errcodes, itemids.values_num);
zbx_free(errcodes);
zbx_free(items);
zbx_history_record_vector_destroy(&group_values, item->value_type);
clean1:
zbx_vector_uint64_destroy(&itemids);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* Function: send_list_of_active_checks_json *
* *
* Purpose: send list of active checks to the host *
* *
* Parameters: sock - open socket of server-agent connection *
* json - request buffer *
* *
* Return value: SUCCEED - list of active checks sent successfully *
* FAIL - an error occurred *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
int send_list_of_active_checks_json(zbx_socket_t *sock, struct zbx_json_parse *jp)
{
const char *__function_name = "send_list_of_active_checks_json";
char host[HOST_HOST_LEN_MAX], tmp[MAX_STRING_LEN], ip[INTERFACE_IP_LEN_MAX],
error[MAX_STRING_LEN], *host_metadata = NULL;
struct zbx_json json;
int ret = FAIL, i;
zbx_uint64_t hostid;
size_t host_metadata_alloc = 1; /* for at least NUL-termination char */
unsigned short port;
zbx_vector_uint64_t itemids;
zbx_vector_ptr_t regexps;
zbx_vector_str_t names;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
zbx_vector_ptr_create(®exps);
zbx_vector_str_create(&names);
if (FAIL == zbx_json_value_by_name(jp, ZBX_PROTO_TAG_HOST, host, sizeof(host)))
{
zbx_snprintf(error, MAX_STRING_LEN, "%s", zbx_json_strerror());
goto error;
}
host_metadata = zbx_malloc(host_metadata, host_metadata_alloc);
if (FAIL == zbx_json_value_by_name_dyn(jp, ZBX_PROTO_TAG_HOST_METADATA,
&host_metadata, &host_metadata_alloc))
{
*host_metadata = '\0';
}
if (FAIL == zbx_json_value_by_name(jp, ZBX_PROTO_TAG_IP, ip, sizeof(ip)))
strscpy(ip, sock->peer);
if (FAIL == zbx_json_value_by_name(jp, ZBX_PROTO_TAG_PORT, tmp, sizeof(tmp)))
*tmp = '\0';
if (FAIL == is_ushort(tmp, &port))
port = ZBX_DEFAULT_AGENT_PORT;
if (FAIL == get_hostid_by_host(sock, host, ip, port, host_metadata, &hostid, error))
goto error;
zbx_vector_uint64_create(&itemids);
get_list_of_active_checks(hostid, &itemids);
zbx_json_init(&json, ZBX_JSON_STAT_BUF_LEN);
zbx_json_addstring(&json, ZBX_PROTO_TAG_RESPONSE, ZBX_PROTO_VALUE_SUCCESS, ZBX_JSON_TYPE_STRING);
zbx_json_addarray(&json, ZBX_PROTO_TAG_DATA);
if (0 != itemids.values_num)
{
DC_ITEM *dc_items;
int *errcodes, now;
zbx_config_t cfg;
dc_items = zbx_malloc(NULL, sizeof(DC_ITEM) * itemids.values_num);
errcodes = zbx_malloc(NULL, sizeof(int) * itemids.values_num);
DCconfig_get_items_by_itemids(dc_items, itemids.values, errcodes, itemids.values_num);
zbx_config_get(&cfg, ZBX_CONFIG_FLAGS_REFRESH_UNSUPPORTED);
now = time(NULL);
for (i = 0; i < itemids.values_num; i++)
{
if (SUCCEED != errcodes[i])
{
zabbix_log(LOG_LEVEL_DEBUG, "%s() Item [" ZBX_FS_UI64 "] was not found in the"
" server cache. Not sending now.", __function_name, itemids.values[i]);
continue;
}
if (ITEM_STATUS_ACTIVE != dc_items[i].status)
continue;
if (HOST_STATUS_MONITORED != dc_items[i].host.status)
continue;
if (ITEM_STATE_NOTSUPPORTED == dc_items[i].state)
{
if (0 == cfg.refresh_unsupported)
continue;
if (dc_items[i].lastclock + cfg.refresh_unsupported > now)
continue;
}
dc_items[i].key = zbx_strdup(dc_items[i].key, dc_items[i].key_orig);
substitute_key_macros(&dc_items[i].key, NULL, &dc_items[i], NULL, MACRO_TYPE_ITEM_KEY, NULL, 0);
zbx_json_addobject(&json, NULL);
zbx_json_addstring(&json, ZBX_PROTO_TAG_KEY, dc_items[i].key, ZBX_JSON_TYPE_STRING);
if (0 != strcmp(dc_items[i].key, dc_items[i].key_orig))
{
zbx_json_addstring(&json, ZBX_PROTO_TAG_KEY_ORIG,
dc_items[i].key_orig, ZBX_JSON_TYPE_STRING);
}
zbx_json_adduint64(&json, ZBX_PROTO_TAG_DELAY, dc_items[i].delay);
/* The agent expects ALWAYS to have lastlogsize and mtime tags. */
/* Removing those would cause older agents to fail. */
zbx_json_adduint64(&json, ZBX_PROTO_TAG_LASTLOGSIZE, dc_items[i].lastlogsize);
zbx_json_adduint64(&json, ZBX_PROTO_TAG_MTIME, dc_items[i].mtime);
zbx_json_close(&json);
zbx_itemkey_extract_global_regexps(dc_items[i].key, &names);
zbx_free(dc_items[i].key);
}
zbx_config_clean(&cfg);
DCconfig_clean_items(dc_items, errcodes, itemids.values_num);
zbx_free(errcodes);
zbx_free(dc_items);
}
zbx_vector_uint64_destroy(&itemids);
zbx_json_close(&json);
DCget_expressions_by_names(®exps, (const char * const *)names.values, names.values_num);
if (0 < regexps.values_num)
{
char buffer[32];
zbx_json_addarray(&json, ZBX_PROTO_TAG_REGEXP);
for (i = 0; i < regexps.values_num; i++)
{
zbx_expression_t *regexp = regexps.values[i];
zbx_json_addobject(&json, NULL);
zbx_json_addstring(&json, "name", regexp->name, ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, "expression", regexp->expression, ZBX_JSON_TYPE_STRING);
zbx_snprintf(buffer, sizeof(buffer), "%d", regexp->expression_type);
zbx_json_addstring(&json, "expression_type", buffer, ZBX_JSON_TYPE_INT);
zbx_snprintf(buffer, sizeof(buffer), "%c", regexp->exp_delimiter);
zbx_json_addstring(&json, "exp_delimiter", buffer, ZBX_JSON_TYPE_STRING);
zbx_snprintf(buffer, sizeof(buffer), "%d", regexp->case_sensitive);
zbx_json_addstring(&json, "case_sensitive", buffer, ZBX_JSON_TYPE_INT);
zbx_json_close(&json);
}
zbx_json_close(&json);
}
zabbix_log(LOG_LEVEL_DEBUG, "%s() sending [%s]", __function_name, json.buffer);
zbx_alarm_on(CONFIG_TIMEOUT);
if (SUCCEED != zbx_tcp_send(sock, json.buffer))
strscpy(error, zbx_socket_strerror());
else
ret = SUCCEED;
zbx_alarm_off();
zbx_json_free(&json);
goto out;
error:
zabbix_log(LOG_LEVEL_WARNING, "cannot send list of active checks to \"%s\": %s", sock->peer, error);
zbx_json_init(&json, ZBX_JSON_STAT_BUF_LEN);
zbx_json_addstring(&json, ZBX_PROTO_TAG_RESPONSE, ZBX_PROTO_VALUE_FAILED, ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, ZBX_PROTO_TAG_INFO, error, ZBX_JSON_TYPE_STRING);
zabbix_log(LOG_LEVEL_DEBUG, "%s() sending [%s]", __function_name, json.buffer);
ret = zbx_tcp_send(sock, json.buffer);
zbx_json_free(&json);
out:
for (i = 0; i < names.values_num; i++)
zbx_free(names.values[i]);
zbx_vector_str_destroy(&names);
zbx_regexp_clean_expressions(®exps);
zbx_vector_ptr_destroy(®exps);
zbx_free(host_metadata);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* Function: send_list_of_active_checks *
* *
* Purpose: send list of active checks to the host (older version agent) *
* *
* Parameters: sock - open socket of server-agent connection *
* request - request buffer *
* *
* Return value: SUCCEED - list of active checks sent successfully *
* FAIL - an error occurred *
* *
* Comments: format of the request: ZBX_GET_ACTIVE_CHECKS\n<host name>\n *
* format of the list: key:delay:last_log_size *
* *
******************************************************************************/
int send_list_of_active_checks(zbx_socket_t *sock, char *request)
{
const char *__function_name = "send_list_of_active_checks";
char *host = NULL, *p, *buffer = NULL, error[MAX_STRING_LEN];
size_t buffer_alloc = 8 * ZBX_KIBIBYTE, buffer_offset = 0;
int ret = FAIL, i;
zbx_uint64_t hostid;
zbx_vector_uint64_t itemids;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (NULL != (host = strchr(request, '\n')))
{
host++;
if (NULL != (p = strchr(host, '\n')))
*p = '\0';
}
else
{
zbx_snprintf(error, sizeof(error), "host is null");
goto out;
}
/* no host metadata in older versions of agent */
if (FAIL == get_hostid_by_host(sock, host, sock->peer, ZBX_DEFAULT_AGENT_PORT, "", &hostid, error))
goto out;
zbx_vector_uint64_create(&itemids);
get_list_of_active_checks(hostid, &itemids);
buffer = zbx_malloc(buffer, buffer_alloc);
if (0 != itemids.values_num)
{
DC_ITEM *dc_items;
int *errcodes, now;
zbx_config_t cfg;
dc_items = zbx_malloc(NULL, sizeof(DC_ITEM) * itemids.values_num);
errcodes = zbx_malloc(NULL, sizeof(int) * itemids.values_num);
DCconfig_get_items_by_itemids(dc_items, itemids.values, errcodes, itemids.values_num);
zbx_config_get(&cfg, ZBX_CONFIG_FLAGS_REFRESH_UNSUPPORTED);
now = time(NULL);
for (i = 0; i < itemids.values_num; i++)
{
if (SUCCEED != errcodes[i])
{
zabbix_log(LOG_LEVEL_DEBUG, "%s() Item [" ZBX_FS_UI64 "] was not found in the"
" server cache. Not sending now.", __function_name, itemids.values[i]);
continue;
}
if (ITEM_STATUS_ACTIVE != dc_items[i].status)
continue;
if (HOST_STATUS_MONITORED != dc_items[i].host.status)
continue;
if (ITEM_STATE_NOTSUPPORTED == dc_items[i].state)
{
if (0 == cfg.refresh_unsupported)
continue;
if (dc_items[i].lastclock + cfg.refresh_unsupported > now)
continue;
}
zbx_snprintf_alloc(&buffer, &buffer_alloc, &buffer_offset, "%s:%d:" ZBX_FS_UI64 "\n",
dc_items[i].key_orig, dc_items[i].delay, dc_items[i].lastlogsize);
}
zbx_config_clean(&cfg);
DCconfig_clean_items(dc_items, errcodes, itemids.values_num);
zbx_free(errcodes);
zbx_free(dc_items);
}
zbx_vector_uint64_destroy(&itemids);
zbx_strcpy_alloc(&buffer, &buffer_alloc, &buffer_offset, "ZBX_EOF\n");
zabbix_log(LOG_LEVEL_DEBUG, "%s() sending [%s]", __function_name, buffer);
zbx_alarm_on(CONFIG_TIMEOUT);
if (SUCCEED != zbx_tcp_send_raw(sock, buffer))
zbx_strlcpy(error, zbx_socket_strerror(), MAX_STRING_LEN);
else
ret = SUCCEED;
zbx_alarm_off();
zbx_free(buffer);
out:
if (FAIL == ret)
zabbix_log(LOG_LEVEL_WARNING, "cannot send list of active checks to \"%s\": %s", sock->peer, error);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* Function: lld_filter_load *
* *
* Purpose: loads lld filter data *
* *
* Parameters: filter - [IN] the lld filter *
* lld_ruleid - [IN] the lld rule id *
* error - [OUT] the error description *
* *
******************************************************************************/
static int lld_filter_load(lld_filter_t *filter, zbx_uint64_t lld_ruleid, char **error)
{
DB_RESULT result;
DB_ROW row;
lld_condition_t *condition;
DC_ITEM item;
int errcode, ret = SUCCEED;
DCconfig_get_items_by_itemids(&item, &lld_ruleid, &errcode, 1);
if (SUCCEED != errcode)
{
*error = zbx_dsprintf(*error, "Invalid discovery rule ID [" ZBX_FS_UI64 "].",
lld_ruleid);
ret = FAIL;
goto out;
}
result = DBselect(
"select item_conditionid,macro,value"
" from item_condition"
" where itemid=" ZBX_FS_UI64,
lld_ruleid);
while (NULL != (row = DBfetch(result)))
{
condition = zbx_malloc(NULL, sizeof(lld_condition_t));
ZBX_STR2UINT64(condition->id, row[0]);
condition->macro = zbx_strdup(NULL, row[1]);
condition->regexp = zbx_strdup(NULL, row[2]);
zbx_vector_ptr_create(&condition->regexps);
zbx_vector_ptr_append(&filter->conditions, condition);
if ('@' == *condition->regexp)
{
DCget_expressions_by_name(&condition->regexps, condition->regexp + 1);
if (0 == condition->regexps.values_num)
{
*error = zbx_dsprintf(*error, "Global regular expression \"%s\" does not exist.",
condition->regexp + 1);
ret = FAIL;
break;
}
}
else
{
substitute_simple_macros(NULL, NULL, NULL, NULL, NULL, NULL, &item, NULL,
&condition->regexp, MACRO_TYPE_LLD_FILTER, NULL, 0);
}
}
DBfree_result(result);
if (SUCCEED != ret)
lld_conditions_free(&filter->conditions);
else if (CONDITION_EVAL_TYPE_AND_OR == filter->evaltype)
zbx_vector_ptr_sort(&filter->conditions, lld_condition_compare_by_macro);
out:
DCconfig_clean_items(&item, &errcode, 1);
return ret;
}
