/******************************************************************************
* *
* Function: lld_validate_graph_field *
* *
******************************************************************************/
static void lld_validate_graph_field(zbx_lld_graph_t *graph, char **field, char **field_orig, zbx_uint64_t flag,
size_t field_len, char **error)
{
if (0 == (graph->flags & ZBX_FLAG_LLD_GRAPH_DISCOVERED))
return;
/* only new graphs or graphs with changed data will be validated */
if (0 != graph->graphid && 0 == (graph->flags & flag))
return;
if (SUCCEED != zbx_is_utf8(*field))
{
zbx_replace_invalid_utf8(*field);
*error = zbx_strdcatf(*error, "Cannot %s graph: value \"%s\" has invalid UTF-8 sequence.\n",
(0 != graph->graphid ? "update" : "create"), *field);
}
else if (zbx_strlen_utf8(*field) > field_len)
{
*error = zbx_strdcatf(*error, "Cannot %s graph: value \"%s\" is too long.\n",
(0 != graph->graphid ? "update" : "create"), *field);
}
else
return;
if (0 != graph->graphid)
lld_field_str_rollback(field, field_orig, &graph->flags, flag);
else
graph->flags &= ~ZBX_FLAG_LLD_GRAPH_DISCOVERED;
}
/******************************************************************************
* *
* Function: lld_validate_trigger_field *
* *
******************************************************************************/
static void lld_validate_trigger_field(zbx_lld_trigger_t *trigger, char **field, char **field_orig,
zbx_uint64_t flag, size_t field_len, char **error)
{
if (0 == (trigger->flags & ZBX_FLAG_LLD_TRIGGER_DISCOVERED))
return;
/* only new triggers or triggers with changed data will be validated */
if (0 != trigger->triggerid && 0 == (trigger->flags & flag))
return;
if (SUCCEED != zbx_is_utf8(*field))
{
zbx_replace_invalid_utf8(*field);
*error = zbx_strdcatf(*error, "Cannot %s trigger: value \"%s\" has invalid UTF-8 sequence.\n",
(0 != trigger->triggerid ? "update" : "create"), *field);
}
else if (zbx_strlen_utf8(*field) > field_len)
{
*error = zbx_strdcatf(*error, "Cannot %s trigger: value \"%s\" is too long.\n",
(0 != trigger->triggerid ? "update" : "create"), *field);
}
else
return;
if (0 != trigger->triggerid)
lld_field_str_rollback(field, field_orig, &trigger->flags, flag);
else
trigger->flags &= ~ZBX_FLAG_LLD_TRIGGER_DISCOVERED;
}
/******************************************************************************
* *
* Function: zbx_validate_config *
* *
* Purpose: validate configuration parameters *
* *
* Author: Vladimir Levijev *
* *
******************************************************************************/
static void zbx_validate_config(void)
{
if (NULL == CONFIG_HOSTNAME)
{
zabbix_log(LOG_LEVEL_CRIT, "hostname is not defined");
exit(EXIT_FAILURE);
}
if (NULL != CONFIG_HOST_METADATA && HOST_METADATA_LEN < zbx_strlen_utf8(CONFIG_HOST_METADATA))
{
zabbix_log(LOG_LEVEL_CRIT, "the value of \"HostMetadata\" configuration parameter cannot be longer than"
" %d characters", HOST_METADATA_LEN);
exit(EXIT_FAILURE);
}
if (FAIL == zbx_check_hostname(CONFIG_HOSTNAME))
{
zabbix_log(LOG_LEVEL_CRIT, "invalid host name: [%s]", CONFIG_HOSTNAME);
exit(EXIT_FAILURE);
}
/* make sure active or passive check is enabled */
if (0 == CONFIG_ACTIVE_FORKS && 0 == CONFIG_PASSIVE_FORKS)
{
zabbix_log(LOG_LEVEL_CRIT, "either active or passive checks must be enabled");
exit(EXIT_FAILURE);
}
}
static int DBpatch_2010195(void)
{
DB_RESULT result;
DB_ROW row;
char *key = NULL, *key_esc, error[64];
int ret = SUCCEED;
result = DBselect("select itemid,key_ from items where key_ like 'eventlog[%%'");
while (SUCCEED == ret && NULL != (row = DBfetch(result)))
{
key = zbx_strdup(key, row[1]);
if (SUCCEED != replace_key_params_dyn(&key, ZBX_KEY_TYPE_ITEM, replace_key_param, NULL,
error, sizeof(error)))
{
zabbix_log(LOG_LEVEL_WARNING, "cannot convert item key \"%s\": %s", row[1], error);
continue;
}
if (255 /* ITEM_KEY_LEN */ < zbx_strlen_utf8(key))
{
zabbix_log(LOG_LEVEL_WARNING, "cannot convert item key \"%s\": key is too long", row[1]);
continue;
}
if (0 != strcmp(key, row[1]))
{
key_esc = DBdyn_escape_string(key);
if (ZBX_DB_OK > DBexecute("update items set key_='%s' where itemid=%s", key_esc, row[0]))
ret = FAIL;
zbx_free(key_esc);
}
}
DBfree_result(result);
zbx_free(key);
return ret;
}
/******************************************************************************
* *
* Function: refresh_active_checks *
* *
* Purpose: Retrieve from Zabbix server list of active checks *
* *
* Parameters: host - IP or Hostname of Zabbix server *
* port - port of Zabbix server *
* *
* Return value: returns SUCCEED on successful parsing, *
* FAIL on other cases *
* *
* Author: Eugene Grigorjev, Alexei Vladishev (new json protocol) *
* *
* Comments: *
* *
******************************************************************************/
static int refresh_active_checks(const char *host, unsigned short port)
{
const char *__function_name = "refresh_active_checks";
zbx_sock_t s;
char *buf;
int ret;
struct zbx_json json;
static int last_ret = SUCCEED;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() host:'%s' port:%hu", __function_name, host, port);
zbx_json_init(&json, ZBX_JSON_STAT_BUF_LEN);
zbx_json_addstring(&json, ZBX_PROTO_TAG_REQUEST, ZBX_PROTO_VALUE_GET_ACTIVE_CHECKS, ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, ZBX_PROTO_TAG_HOST, CONFIG_HOSTNAME, ZBX_JSON_TYPE_STRING);
if (NULL != CONFIG_HOST_METADATA)
{
zbx_json_addstring(&json, ZBX_PROTO_TAG_HOST_METADATA, CONFIG_HOST_METADATA, ZBX_JSON_TYPE_STRING);
}
else if (NULL != CONFIG_HOST_METADATA_ITEM)
{
char **value;
AGENT_RESULT result;
init_result(&result);
if (SUCCEED == process(CONFIG_HOST_METADATA_ITEM, PROCESS_LOCAL_COMMAND, &result) &&
NULL != (value = GET_STR_RESULT(&result)) && NULL != *value)
{
if (SUCCEED != zbx_is_utf8(*value))
{
zabbix_log(LOG_LEVEL_WARNING, "cannot get host metadata using \"%s\" item specified by"
" \"HostMetadataItem\" configuration parameter: returned value is not"
" an UTF-8 string", CONFIG_HOST_METADATA_ITEM);
}
else
{
if (HOST_METADATA_LEN < zbx_strlen_utf8(*value))
{
size_t bytes;
zabbix_log(LOG_LEVEL_WARNING, "the returned value of \"%s\" item specified by"
" \"HostMetadataItem\" configuration parameter is too long,"
" using first %d characters", CONFIG_HOST_METADATA_ITEM,
HOST_METADATA_LEN);
bytes = zbx_strlen_utf8_n(*value, HOST_METADATA_LEN);
(*value)[bytes] = '\0';
}
zbx_json_addstring(&json, ZBX_PROTO_TAG_HOST_METADATA, *value, ZBX_JSON_TYPE_STRING);
}
}
else
zabbix_log(LOG_LEVEL_WARNING, "cannot get host metadata using \"%s\" item specified by"
" \"HostMetadataItem\" configuration parameter", CONFIG_HOST_METADATA_ITEM);
free_result(&result);
}
if (NULL != CONFIG_LISTEN_IP)
{
char *p;
if (NULL != (p = strchr(CONFIG_LISTEN_IP, ',')))
*p = '\0';
zbx_json_addstring(&json, ZBX_PROTO_TAG_IP, CONFIG_LISTEN_IP, ZBX_JSON_TYPE_STRING);
if (NULL != p)
*p = ',';
}
if (ZBX_DEFAULT_AGENT_PORT != CONFIG_LISTEN_PORT)
zbx_json_adduint64(&json, ZBX_PROTO_TAG_PORT, CONFIG_LISTEN_PORT);
if (SUCCEED == (ret = zbx_tcp_connect(&s, CONFIG_SOURCE_IP, host, port, CONFIG_TIMEOUT)))
{
zabbix_log(LOG_LEVEL_DEBUG, "sending [%s]", json.buffer);
if (SUCCEED == (ret = zbx_tcp_send(&s, json.buffer)))
{
zabbix_log(LOG_LEVEL_DEBUG, "before read");
if (SUCCEED == (ret = SUCCEED_OR_FAIL(zbx_tcp_recv_ext(&s, &buf, ZBX_TCP_READ_UNTIL_CLOSE, 0))))
{
zabbix_log(LOG_LEVEL_DEBUG, "got [%s]", buf);
if (SUCCEED != last_ret)
{
zabbix_log(LOG_LEVEL_WARNING, "active check configuration update from [%s:%hu]"
" is working again", host, port);
}
parse_list_of_checks(buf, host, port);
}
}
zbx_tcp_close(&s);
}
if (SUCCEED != ret && SUCCEED == last_ret)
{
zabbix_log(LOG_LEVEL_WARNING,
"active check configuration update from [%s:%hu] started to fail (%s)",
host, port, zbx_tcp_strerror());
}
last_ret = ret;
zbx_json_free(&json);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
static int DBpatch_2010101(void)
{
DB_RESULT result;
DB_ROW row;
int ret = SUCCEED;
char *key = NULL;
size_t key_alloc = 0, key_offset;
result = DBselect(
"select i.itemid,i.key_,i.params,h.name"
" from items i,hosts h"
" where i.hostid=h.hostid"
" and i.type=%d",
ITEM_TYPE_DB_MONITOR);
while (NULL != (row = DBfetch(result)) && SUCCEED == ret)
{
char *user = NULL, *password = NULL, *dsn = NULL, *sql = NULL, *error_message = NULL;
zbx_uint64_t itemid;
size_t key_len;
key_len = strlen(row[1]);
parse_db_monitor_item_params(row[2], &dsn, &user, &password, &sql);
if (0 != strncmp(row[1], "db.odbc.select[", 15) || ']' != row[1][key_len - 1])
error_message = zbx_dsprintf(error_message, "key \"%s\" is invalid", row[1]);
else if (ITEM_USERNAME_LEN < strlen(user))
error_message = zbx_dsprintf(error_message, "ODBC username \"%s\" is too long", user);
else if (ITEM_PASSWORD_LEN < strlen(password))
error_message = zbx_dsprintf(error_message, "ODBC password \"%s\" is too long", password);
else
{
char *param = NULL;
size_t param_alloc = 0, param_offset = 0;
int nparam;
zbx_strncpy_alloc(¶m, ¶m_alloc, ¶m_offset, row[1] + 15, key_len - 16);
if (1 != (nparam = num_param(param)))
quote_key_param(¶m, 0);
quote_key_param(&dsn, 0);
key_offset = 0;
zbx_snprintf_alloc(&key, &key_alloc, &key_offset, "db.odbc.select[%s,%s]", param, dsn);
zbx_free(param);
if (255 /* ITEM_KEY_LEN */ < zbx_strlen_utf8(key))
error_message = zbx_dsprintf(error_message, "key \"%s\" is too long", row[1]);
}
if (NULL == error_message)
{
char *username_esc, *password_esc, *params_esc, *key_esc;
ZBX_STR2UINT64(itemid, row[0]);
username_esc = DBdyn_escape_string(user);
password_esc = DBdyn_escape_string(password);
params_esc = DBdyn_escape_string(sql);
key_esc = DBdyn_escape_string(key);
if (ZBX_DB_OK > DBexecute("update items set username='******',password='******',key_='%s',params='%s'"
" where itemid=" ZBX_FS_UI64,
username_esc, password_esc, key_esc, params_esc, itemid))
{
ret = FAIL;
}
zbx_free(username_esc);
zbx_free(password_esc);
zbx_free(params_esc);
zbx_free(key_esc);
}
else
{
zabbix_log(LOG_LEVEL_WARNING, "Failed to convert host \"%s\" db monitoring item because"
" %s. See upgrade notes for manual database monitor item conversion.",
row[3], error_message);
}
zbx_free(error_message);
zbx_free(user);
zbx_free(password);
zbx_free(dsn);
zbx_free(sql);
}
DBfree_result(result);
zbx_free(key);
return ret;
}
static int DBpatch_2030095(void)
{
DB_RESULT result;
DB_ROW row;
int ret = SUCCEED;
char *p, *q, *params = NULL, *params_esc;
size_t params_alloc = 0, params_offset;
result = DBselect("select itemid,params from items where type=%d", 15 /* ITEM_TYPE_CALCULATED */);
while (SUCCEED == ret && NULL != (row = DBfetch(result)))
{
params_offset = 0;
for (p = row[1]; '\0' != *p; p++)
{
if (NULL != strchr(ZBX_WHITESPACE, *p))
{
if (' ' != *p || (0 != params_offset &&
NULL == strchr(ZBX_WHITESPACE, params[params_offset - 1])))
{
zbx_chrcpy_alloc(¶ms, ¶ms_alloc, ¶ms_offset, *p);
}
continue;
}
if (NULL != strchr("#&|", *p))
{
if ('#' == *p && 0 != params_offset && '{' == params[params_offset - 1])
{
zbx_chrcpy_alloc(¶ms, ¶ms_alloc, ¶ms_offset, *p);
continue;
}
if (('&' == *p || '|' == *p) && 0 != params_offset &&
NULL == strchr(ZBX_WHITESPACE, params[params_offset - 1]))
{
zbx_chrcpy_alloc(¶ms, ¶ms_alloc, ¶ms_offset, ' ');
}
switch (*p)
{
case '#':
zbx_strcpy_alloc(¶ms, ¶ms_alloc, ¶ms_offset, "<>");
break;
case '&':
zbx_strcpy_alloc(¶ms, ¶ms_alloc, ¶ms_offset, "and");
break;
case '|':
zbx_strcpy_alloc(¶ms, ¶ms_alloc, ¶ms_offset, "or");
break;
}
if (('&' == *p || '|' == *p) && NULL == strchr(ZBX_WHITESPACE, *(p + 1)))
zbx_chrcpy_alloc(¶ms, ¶ms_alloc, ¶ms_offset, ' ');
continue;
}
q = p;
if (SUCCEED == parse_function(&q, NULL, NULL))
{
zbx_strncpy_alloc(¶ms, ¶ms_alloc, ¶ms_offset, p, q - p);
p = q - 1;
continue;
}
zbx_chrcpy_alloc(¶ms, ¶ms_alloc, ¶ms_offset, *p);
}
#if defined(HAVE_IBM_DB2) || defined(HAVE_ORACLE)
if (2048 < params_offset && 2048 /* ITEM_PARAM_LEN */ < zbx_strlen_utf8(params))
#else
if (65535 < params_offset && 65535 /* ITEM_PARAM_LEN */ < zbx_strlen_utf8(params))
#endif
{
zabbix_log(LOG_LEVEL_WARNING, "cannot convert calculated item expression \"%s\":"
" resulting expression is too long", row[1]);
}
else if (0 != strcmp(row[1], params))
{
params_esc = DBdyn_escape_string(params);
if (ZBX_DB_OK > DBexecute("update items set params='%s' where itemid=%s", params_esc, row[0]))
ret = FAIL;
zbx_free(params_esc);
}
}
DBfree_result(result);
zbx_free(params);
return ret;
}
static int DBpatch_2030094(void)
{
DB_RESULT result;
DB_ROW row;
int ret = SUCCEED;
char *p, *expr = NULL, *expr_esc;
size_t expr_alloc = 0, expr_offset;
result = DBselect("select triggerid,expression from triggers");
while (SUCCEED == ret && NULL != (row = DBfetch(result)))
{
expr_offset = 0;
for (p = row[1]; '\0' != *p; p++)
{
if (NULL == strchr("#&|", *p))
{
if (' ' != *p || (0 != expr_offset && ' ' != expr[expr_offset - 1]))
zbx_chrcpy_alloc(&expr, &expr_alloc, &expr_offset, *p);
continue;
}
if ('#' == *p && 0 != expr_offset && '{' == expr[expr_offset - 1])
{
zbx_chrcpy_alloc(&expr, &expr_alloc, &expr_offset, *p);
continue;
}
if (('&' == *p || '|' == *p) && 0 != expr_offset && ' ' != expr[expr_offset - 1])
zbx_chrcpy_alloc(&expr, &expr_alloc, &expr_offset, ' ');
switch (*p)
{
case '#':
zbx_strcpy_alloc(&expr, &expr_alloc, &expr_offset, "<>");
break;
case '&':
zbx_strcpy_alloc(&expr, &expr_alloc, &expr_offset, "and");
break;
case '|':
zbx_strcpy_alloc(&expr, &expr_alloc, &expr_offset, "or");
break;
}
if (('&' == *p || '|' == *p) && ' ' != *(p + 1))
zbx_chrcpy_alloc(&expr, &expr_alloc, &expr_offset, ' ');
}
if (2048 < expr_offset && 2048 /* TRIGGER_EXPRESSION_LEN */ < zbx_strlen_utf8(expr))
{
zabbix_log(LOG_LEVEL_WARNING, "cannot convert trigger expression \"%s\":"
" resulting expression is too long", row[1]);
}
else if (0 != strcmp(row[1], expr))
{
expr_esc = DBdyn_escape_string(expr);
if (ZBX_DB_OK > DBexecute("update triggers set expression='%s' where triggerid=%s",
expr_esc, row[0]))
{
ret = FAIL;
}
zbx_free(expr_esc);
}
}
DBfree_result(result);
zbx_free(expr);
return ret;
}
