static void DBdrop_index_sql(char **sql, size_t *sql_alloc, size_t *sql_offset,
const char *table_name, const char *index_name)
{
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "drop index %s", index_name);
#ifdef HAVE_MYSQL
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, " on %s", table_name);
#endif
}
/******************************************************************************
* *
* Function: op_groups_del *
* *
* Purpose: delete groups from discovered host *
* *
* Parameters: event - [IN] event data *
* groupids - [IN] IDs of groups to delete *
* *
* Author: Alexei Vladishev *
* *
******************************************************************************/
void op_groups_del(const DB_EVENT *event, zbx_vector_uint64_t *groupids)
{
const char *__function_name = "op_groups_del";
DB_RESULT result;
zbx_uint64_t hostid;
char *sql = NULL;
size_t sql_alloc = 256, sql_offset = 0;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (event->source != EVENT_SOURCE_DISCOVERY)
return;
if (event->object != EVENT_OBJECT_DHOST && event->object != EVENT_OBJECT_DSERVICE)
return;
if (0 == (hostid = select_discovered_host(event)))
return;
sql = zbx_malloc(sql, sql_alloc);
/* make sure host belongs to at least one hostgroup */
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,
"select groupid"
" from hosts_groups"
" where hostid=" ZBX_FS_UI64
" and not",
hostid);
DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "groupid", groupids->values, groupids->values_num);
result = DBselectN(sql, 1);
if (NULL == DBfetch(result))
{
zabbix_log(LOG_LEVEL_WARNING, "cannot remove host \"%s\" from all host groups:"
" it must belong to at least one", zbx_host_string(hostid));
}
else
{
sql_offset = 0;
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,
"delete from hosts_groups"
" where hostid=" ZBX_FS_UI64
" and",
hostid);
DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "groupid", groupids->values, groupids->values_num);
DBexecute("%s", sql);
}
DBfree_result(result);
zbx_free(sql);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
static void DBmodify_field_type_sql(char **sql, size_t *sql_alloc, size_t *sql_offset,
const char *table_name, const ZBX_FIELD *field)
{
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "alter table %s" ZBX_DB_ALTER_COLUMN " ", table_name);
#ifdef HAVE_MYSQL
DBfield_definition_string(sql, sql_alloc, sql_offset, field);
#else
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "%s" ZBX_DB_SET_TYPE " ", field->name);
DBfield_type_string(sql, sql_alloc, sql_offset, field);
#endif
}
static void DBrename_field_sql(char **sql, size_t *sql_alloc, size_t *sql_offset,
const char *table_name, const char *field_name, const ZBX_FIELD *field)
{
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "alter table %s ", table_name);
#ifdef HAVE_MYSQL
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "change column %s ", field_name);
DBfield_definition_string(sql, sql_alloc, sql_offset, field);
#else
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "rename column %s to %s", field_name, field->name);
#endif
}
static void DBset_default_sql(char **sql, size_t *sql_alloc, size_t *sql_offset,
const char *table_name, const ZBX_FIELD *field)
{
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "alter table %s" ZBX_DB_ALTER_COLUMN " ", table_name);
#if defined(HAVE_MYSQL)
DBfield_definition_string(sql, sql_alloc, sql_offset, field);
#elif defined(HAVE_ORACLE)
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "%s default '%s'", field->name, field->default_value);
#else
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "%s set default '%s'", field->name, field->default_value);
#endif
}
static void DBdrop_not_null_sql(char **sql, size_t *sql_alloc, size_t *sql_offset,
const char *table_name, const ZBX_FIELD *field)
{
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "alter table %s" ZBX_DB_ALTER_COLUMN " ", table_name);
#if defined(HAVE_MYSQL)
DBfield_definition_string(sql, sql_alloc, sql_offset, field);
#elif defined(HAVE_ORACLE)
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "%s null", field->name);
#else
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "%s drop not null", field->name);
#endif
}
static void DBrename_index_sql(char **sql, size_t *sql_alloc, size_t *sql_offset, const char *table_name,
const char *old_name, const char *new_name, const char *fields, int unique)
{
#if defined(HAVE_IBM_DB2)
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "rename index %s to %s", old_name, new_name);
#elif defined(HAVE_MYSQL)
DBcreate_index_sql(sql, sql_alloc, sql_offset, table_name, new_name, fields, unique);
zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ";\n");
DBdrop_index_sql(sql, sql_alloc, sql_offset, table_name, old_name);
zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ";\n");
#elif defined(HAVE_ORACLE) || defined(HAVE_POSTGRESQL)
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "alter index %s rename to %s", old_name, new_name);
#endif
}
static void DBfield_type_string(char **sql, size_t *sql_alloc, size_t *sql_offset, const ZBX_FIELD *field)
{
switch (field->type)
{
case ZBX_TYPE_ID:
zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ZBX_TYPE_ID_STR);
break;
case ZBX_TYPE_INT:
zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ZBX_TYPE_INT_STR);
break;
case ZBX_TYPE_CHAR:
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "%s(%hu)", ZBX_TYPE_CHAR_STR, field->length);
break;
case ZBX_TYPE_FLOAT:
zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ZBX_TYPE_FLOAT_STR);
break;
case ZBX_TYPE_UINT:
zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ZBX_TYPE_UINT_STR);
break;
case ZBX_TYPE_SHORTTEXT:
zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ZBX_TYPE_SHORTTEXT_STR);
break;
case ZBX_TYPE_TEXT:
zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ZBX_TYPE_TEXT_STR);
break;
default:
assert(0);
}
}
static void DBfield_definition_string(char **sql, size_t *sql_alloc, size_t *sql_offset, const ZBX_FIELD *field)
{
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "%s ", field->name);
DBfield_type_string(sql, sql_alloc, sql_offset, field);
if (NULL != field->default_value)
{
char *default_value_esc;
#if defined(HAVE_MYSQL)
switch (field->type)
{
case ZBX_TYPE_BLOB:
case ZBX_TYPE_TEXT:
case ZBX_TYPE_SHORTTEXT:
case ZBX_TYPE_LONGTEXT:
/* MySQL: BLOB and TEXT columns cannot be assigned a default value */
break;
default:
#endif
default_value_esc = DBdyn_escape_string(field->default_value);
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, " default '%s'", default_value_esc);
zbx_free(default_value_esc);
#if defined(HAVE_MYSQL)
}
#endif
}
if (0 != (field->flags & ZBX_NOTNULL))
{
#if defined(HAVE_ORACLE)
switch (field->type)
{
case ZBX_TYPE_INT:
case ZBX_TYPE_FLOAT:
case ZBX_TYPE_BLOB:
case ZBX_TYPE_UINT:
case ZBX_TYPE_ID:
zbx_strcpy_alloc(sql, sql_alloc, sql_offset, " not null");
break;
default: /* ZBX_TYPE_CHAR, ZBX_TYPE_TEXT, ZBX_TYPE_SHORTTEXT or ZBX_TYPE_LONGTEXT */
/* nothing to do */;
}
#else
zbx_strcpy_alloc(sql, sql_alloc, sql_offset, " not null");
#endif
}
}
static void DBcreate_table_sql(char **sql, size_t *sql_alloc, size_t *sql_offset, const ZBX_TABLE *table)
{
int i;
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "create table %s (\n", table->table);
for (i = 0; NULL != table->fields[i].name; i++)
{
if (0 != i)
zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ",\n");
DBfield_definition_string(sql, sql_alloc, sql_offset, &table->fields[i]);
}
if ('\0' != *table->recid)
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, ",\nprimary key (%s)", table->recid);
zbx_strcpy_alloc(sql, sql_alloc, sql_offset, "\n)" ZBX_DB_TABLE_OPTIONS);
}
/*********************************************************************************
* *
* Function: db_read_values_by_time *
* *
* Purpose: reads item history data from database *
* *
* Parameters: itemid - [IN] the itemid *
* value_type - [IN] the value type (see ITEM_VALUE_TYPE_* defs) *
* values - [OUT] the item history data values *
* seconds - [IN] the time period to read *
* end_timestamp - [IN] the value timestamp to start reading with *
* *
* Return value: SUCCEED - the history data were read successfully *
* FAIL - otherwise *
* *
* Comments: This function reads all values with timestamps in range: *
* end_timestamp - seconds < <value timestamp> <= end_timestamp *
* *
*********************************************************************************/
static int db_read_values_by_time(zbx_uint64_t itemid, int value_type, zbx_vector_history_record_t *values,
int seconds, int end_timestamp)
{
char *sql = NULL;
size_t sql_alloc = 0, sql_offset = 0;
DB_RESULT result;
DB_ROW row;
zbx_vc_history_table_t *table = &vc_history_tables[value_type];
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,
"select clock,ns,%s"
" from %s"
" where itemid=" ZBX_FS_UI64,
table->fields, table->name, itemid);
if (1 == seconds)
{
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, " and clock=%d", end_timestamp);
}
else
{
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, " and clock>%d and clock<=%d",
end_timestamp - seconds, end_timestamp);
}
result = DBselect("%s", sql);
zbx_free(sql);
if (NULL == result)
goto out;
while (NULL != (row = DBfetch(result)))
{
zbx_history_record_t value;
value.timestamp.sec = atoi(row[0]);
value.timestamp.ns = atoi(row[1]);
table->rtov(&value.value, row + 2);
zbx_vector_history_record_append_ptr(values, &value);
}
DBfree_result(result);
out:
return SUCCEED;
}
static void DBcreate_index_sql(char **sql, size_t *sql_alloc, size_t *sql_offset,
const char *table_name, const char *index_name, const char *fields, int unique)
{
zbx_strcpy_alloc(sql, sql_alloc, sql_offset, "create");
if (0 != unique)
zbx_strcpy_alloc(sql, sql_alloc, sql_offset, " unique");
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, " index %s on %s (%s)", index_name, table_name, fields);
}
static void DBadd_foreign_key_sql(char **sql, size_t *sql_alloc, size_t *sql_offset,
const char *table_name, int id, const ZBX_FIELD *field)
{
zbx_snprintf_alloc(sql, sql_alloc, sql_offset,
"alter table %s add constraint c_%s_%d foreign key (%s) references %s (%s)",
table_name, table_name, id, field->name, field->fk_table, field->fk_field);
if (0 != (field->fk_flags & ZBX_FK_CASCADE_DELETE))
zbx_strcpy_alloc(sql, sql_alloc, sql_offset, " on delete cascade");
}
static char *lld_expression_expand(const char *expression, zbx_vector_ptr_t *functions)
{
const char *__function_name = "lld_expression_expand";
size_t l, r;
int i;
zbx_uint64_t index;
zbx_lld_function_t *function;
char *buffer = NULL;
size_t buffer_alloc = 64, buffer_offset = 0;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() expression:'%s'", __function_name, expression);
buffer = zbx_malloc(buffer, buffer_alloc);
*buffer = '\0';
for (l = 0; '\0' != expression[l]; l++)
{
zbx_chrcpy_alloc(&buffer, &buffer_alloc, &buffer_offset, expression[l]);
if ('{' != expression[l])
continue;
for (r = l + 1; '\0' != expression[r] && '}' != expression[r]; r++)
;
if ('}' != expression[r])
continue;
/* ... > 0 | {1} + ... */
/* l r */
if (SUCCEED != is_uint64_n(expression + l + 1, r - l - 1, &index))
continue;
for (i = 0; i < functions->values_num; i++)
{
function = (zbx_lld_function_t *)functions->values[i];
if (function->index != index)
continue;
zbx_snprintf_alloc(&buffer, &buffer_alloc, &buffer_offset, ZBX_FS_UI64 ":%s(%s)",
function->itemid, function->function, function->parameter);
break;
}
l = r - 1;
}
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():'%s'", __function_name, buffer);
return buffer;
}
static void begin_history_sql(char **sql, size_t *sql_alloc, size_t *sql_offset, const ZBX_TABLE *table)
{
int f;
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "insert into %s (", table->table);
if (0 != (table->flags & ZBX_HISTORY_SYNC))
zbx_strcpy_alloc(sql, sql_alloc, sql_offset, "nodeid,");
for (f = 0; table->fields[f].name != 0; f++)
{
if (0 != (table->flags & ZBX_HISTORY_SYNC) && 0 == (table->fields[f].flags & ZBX_HISTORY_SYNC))
continue;
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "%s,", table->fields[f].name);
}
(*sql_offset)--;
zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ") values ");
}
static int calcitem_parse_expression(DC_ITEM *dc_item, expression_t *exp,
char *error, int max_error_len)
{
const char *__function_name = "calcitem_parse_expression";
char *e, *f, *func = NULL, *params = NULL;
int functionid, exp_alloc = 128, exp_offset = 0, ret;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() expression:'%s'", __function_name, dc_item->params_orig);
assert(dc_item);
assert(exp);
exp->exp = zbx_malloc(exp->exp, exp_alloc);
for (e = dc_item->params_orig; '\0' != *e; e++)
{
if (NULL != strchr(" \t\r\n", *e))
continue;
f = e;
if (FAIL == parse_function(&e, &func, ¶ms))
{
e = f;
calcitem_exp_addchr(&exp->exp, &exp_alloc, &exp_offset, 128, *f);
continue;
}
else
e--;
functionid = calcitem_add_function(exp, func, params);
zabbix_log(LOG_LEVEL_DEBUG, "%s() functionid:%d function:'%s(%s)'",
__function_name, functionid, func, params);
func = NULL;
params = NULL;
zbx_snprintf_alloc(&exp->exp, &exp_alloc, &exp_offset, 16, "{%d}", functionid);
}
calcitem_exp_addchr(&exp->exp, &exp_alloc, &exp_offset, 1, '\0');
zabbix_log(LOG_LEVEL_DEBUG, "%s() expression:'%s'", __function_name, exp->exp);
if (FAIL == (ret = substitute_simple_macros(NULL, NULL, NULL, dc_item, NULL,
&exp->exp, MACRO_TYPE_ITEM_EXPRESSION, error, max_error_len)))
ret = NOTSUPPORTED;
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* Function: log_host_maintenance_update *
* *
* Purpose: log host maintenance changes *
* *
******************************************************************************/
static void log_host_maintenance_update(const zbx_host_maintenance_diff_t* diff)
{
char *msg = NULL;
size_t msg_alloc = 0, msg_offset = 0;
int maintenance_off = 0;
if (0 != (diff->flags & ZBX_FLAG_HOST_MAINTENANCE_UPDATE_MAINTENANCE_STATUS))
{
if (HOST_MAINTENANCE_STATUS_ON == diff->maintenance_status)
{
zbx_snprintf_alloc(&msg, &msg_alloc, &msg_offset, "putting host (" ZBX_FS_UI64 ") into",
diff->hostid);
}
else
{
maintenance_off = 1;
zbx_snprintf_alloc(&msg, &msg_alloc, &msg_offset, "taking host (" ZBX_FS_UI64 ") out of",
diff->hostid);
}
}
else
zbx_snprintf_alloc(&msg, &msg_alloc, &msg_offset, "changing host (" ZBX_FS_UI64 ")", diff->hostid);
zbx_strcpy_alloc(&msg, &msg_alloc, &msg_offset, " maintenance");
if (0 != (diff->flags & ZBX_FLAG_HOST_MAINTENANCE_UPDATE_MAINTENANCEID) && 0 != diff->maintenanceid)
zbx_snprintf_alloc(&msg, &msg_alloc, &msg_offset, "(" ZBX_FS_UI64 ")", diff->maintenanceid);
if (0 != (diff->flags & ZBX_FLAG_HOST_MAINTENANCE_UPDATE_MAINTENANCE_TYPE) && 0 == maintenance_off)
{
const char *desription[] = {"with data collection", "without data collection"};
zbx_snprintf_alloc(&msg, &msg_alloc, &msg_offset, " %s", desription[diff->maintenance_type]);
}
zabbix_log(LOG_LEVEL_DEBUG, "%s", msg);
zbx_free(msg);
}
/******************************************************************************
* *
* Function: str_base64_encode_rfc2047 *
* *
* Purpose: Encode a string into a base64 string as required by rfc2047. *
* Used for encoding e-mail headers. *
* *
* Parameters: src - [IN] a null-terminated UTF-8 string to encode *
* p_base64 - [OUT] a pointer to the encoded string *
* *
* Comments: Based on the patch submitted by *
* Jairo Eduardo Lopez Fuentes Nacarino *
* *
******************************************************************************/
static void str_base64_encode_rfc2047(const char *src, char **p_base64)
{
const char *p0; /* pointer in src to start encoding from */
const char *p1; /* pointer in src: 1st byte of UTF-8 character */
size_t c_len; /* length of UTF-8 character sequence */
size_t p_base64_alloc; /* allocated memory size for subject */
size_t p_base64_offset = 0; /* offset for writing into subject */
assert(src);
assert(NULL == *p_base64); /* do not accept already allocated memory */
p_base64_alloc = ZBX_EMAIL_B64_MAXWORD_RFC2047 + sizeof(ZBX_EMAIL_ENCODED_WORD_SEPARATOR);
*p_base64 = zbx_malloc(NULL, p_base64_alloc);
**p_base64 = '\0';
for (p0 = src; '\0' != *p0; p0 = p1)
{
/* Max length of line is 76 characters (without line separator). */
/* Max length of "encoded-word" is 75 characters (without word separator). */
/* 3 characters are taken by word separator "<CR><LF><Space>" which also includes the line separator. */
/* 12 characters are taken by header "=?UTF-8?B?" and trailer "?=". */
/* So, one "encoded-word" can hold up to 63 characters of Base64-encoded string. */
/* Encoding 45 bytes produces a 61 byte long Base64-encoded string which meets the limit. */
/* Encoding 46 bytes produces a 65 byte long Base64-encoded string which exceeds the limit. */
for (p1 = p0, c_len = 0; '\0' != *p1; p1 += c_len)
{
/* an invalid UTF-8 character or length of a string more than 45 bytes */
if (0 == (c_len = zbx_utf8_char_len(p1)) || 45 < p1 - p0 + c_len)
break;
}
if (0 < p1 - p0)
{
/* 12 characters are taken by header "=?UTF-8?B?" and trailer "?=" plus '\0' */
char b64_buf[ZBX_EMAIL_B64_MAXWORD_RFC2047 - 12 + 1];
str_base64_encode(p0, b64_buf, p1 - p0);
if (0 != p_base64_offset) /* not the first "encoded-word" ? */
{
zbx_strcpy_alloc(p_base64, &p_base64_alloc, &p_base64_offset,
ZBX_EMAIL_ENCODED_WORD_SEPARATOR);
}
zbx_snprintf_alloc(p_base64, &p_base64_alloc, &p_base64_offset, "=?UTF-8?B?%s?=", b64_buf);
}
else
break;
}
}
static size_t WRITEFUNCTION2(void *ptr, size_t size, size_t nmemb, void *userdata)
{
size_t r_size = size * nmemb;
/* first piece of data */
if (NULL == page.data)
{
page.allocated = MAX(8096, r_size);
page.offset = 0;
page.data = zbx_malloc(page.data, page.allocated);
}
zbx_snprintf_alloc(&page.data, &page.allocated, &page.offset, MAX(8096, r_size), "%s", ptr);
return r_size;
}
/******************************************************************************
* *
* Function: tm_process_check_now *
* *
* Purpose: process check now tasks for item rescheduling *
* *
* Return value: The number of successfully processed tasks *
* *
******************************************************************************/
static int tm_process_check_now(zbx_vector_uint64_t *taskids)
{
DB_ROW row;
DB_RESULT result;
int processed_num;
char *sql = NULL;
size_t sql_alloc = 0, sql_offset = 0;
zbx_vector_uint64_t itemids;
zbx_uint64_t itemid;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() tasks_num:%d", __func__, taskids->values_num);
zbx_vector_uint64_create(&itemids);
zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, "select itemid from task_check_now where");
DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "taskid", taskids->values, taskids->values_num);
result = DBselect("%s", sql);
while (NULL != (row = DBfetch(result)))
{
ZBX_STR2UINT64(itemid, row[0]);
zbx_vector_uint64_append(&itemids, itemid);
}
DBfree_result(result);
if (0 != (processed_num = itemids.values_num))
zbx_dc_reschedule_items(&itemids, time(NULL), NULL);
if (0 != taskids->values_num)
{
sql_offset = 0;
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "update task set status=%d where",
ZBX_TM_STATUS_DONE);
DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "taskid", taskids->values, taskids->values_num);
DBexecute("%s", sql);
}
zbx_free(sql);
zbx_vector_uint64_destroy(&itemids);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s() processed:%d", __func__, processed_num);
return processed_num;
}
static void collect_args(char **argv, int argc, char **args, size_t *args_alloc)
{
int i;
size_t args_offset = 0;
if (0 == *args_alloc)
{
*args_alloc = ARGS_START_SIZE;
*args = zbx_malloc(*args, *args_alloc);
}
for (i = 0; i < argc; i++)
zbx_snprintf_alloc(args, args_alloc, &args_offset, "%s ", argv[i]);
if (0 != args_offset)
args_offset--; /* ' ' */
(*args)[args_offset] = '\0';
}
static void make_delete_sql(char **sql, size_t *sql_alloc, size_t *sql_offset,
const ZBX_TABLE *table, zbx_uint64_t *ids, int *ids_num)
{
if (NULL == table)
return;
if (0 == *ids_num)
return;
zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "delete from %s where", table->table);
DBadd_condition_alloc(sql, sql_alloc, sql_offset, table->recid, ids, *ids_num);
zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ";\n");
DBexecute_overflowed_sql(sql, sql_alloc, sql_offset);
*ids_num = 0;
}
static void collect_args(char **argv, int argc, char **args, size_t *args_alloc)
{
int i, args_offset, len;
if (0 == *args_alloc) {
*args_alloc = ARGS_START_SIZE;
*args = zbx_malloc(*args, *args_alloc);
}
args_offset = 0;
for (i = 0; i < argc; i ++ ) {
len = (int)(strlen(argv[i]) + 2/* ' '+'\0' */);
zbx_snprintf_alloc(args, (int *)args_alloc, &args_offset, len, "%s ", argv[i]);
}
if (0 != args_offset)
args_offset--; /* ' ' */
(*args)[args_offset] = '\0';
}
/******************************************************************************
* *
* Function: save_events *
* *
* Purpose: flushes the events into a database *
* *
******************************************************************************/
static void save_events()
{
char *sql = NULL;
size_t sql_alloc = 2 * ZBX_KIBIBYTE, sql_offset = 0, i;
const char *ins_event_sql = "insert into events (eventid,source,object,objectid,clock,ns,value) values ";
sql = zbx_malloc(sql, sql_alloc);
DBbegin_multiple_update(&sql, &sql_alloc, &sql_offset);
#ifdef HAVE_MULTIROW_INSERT
zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, ins_event_sql);
#endif
for (i = 0; i < events_num; i++)
{
if (0 == events[i].eventid)
events[i].eventid = DBget_maxid("events");
#ifndef HAVE_MULTIROW_INSERT
zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, ins_event_sql);
#endif
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,
"(" ZBX_FS_UI64 ",%d,%d," ZBX_FS_UI64 ",%d,%d,%d)" ZBX_ROW_DL,
events[i].eventid, events[i].source, events[i].object, events[i].objectid, events[i].clock,
events[i].ns, events[i].value);
}
#ifdef HAVE_MULTIROW_INSERT
sql_offset--;
zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, ";\n");
#endif
DBend_multiple_update(&sql, &sql_alloc, &sql_offset);
DBexecute("%s", sql);
zbx_free(sql);
}
/******************************************************************************
* *
* Function: DMget_config_data *
* *
* Purpose: get configuration changes to required node *
* *
* Parameters: *
* *
* Return value: SUCCESS - processed successfully *
* FAIL - an error occurred *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
char *DMget_config_data(int nodeid, unsigned char dest_nodetype)
{
const char *__function_name = "DMget_config_data";
char *ptbls = NULL; /* list of processed tables */
size_t ptbls_alloc = ZBX_KIBIBYTE, ptbls_offset = 0;
char *data = NULL;
size_t data_alloc = ZBX_KIBIBYTE, data_offset = 0;
int t;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() node:%d dest_nodetype:%s", __function_name,
nodeid, zbx_nodetype_string(dest_nodetype));
ptbls = zbx_malloc(ptbls, ptbls_alloc);
data = zbx_malloc(data, data_alloc);
*ptbls = '\0';
zbx_snprintf_alloc(&data, &data_alloc, &data_offset, "Data%c%d%c%d",
ZBX_DM_DELIMITER, CONFIG_NODEID, ZBX_DM_DELIMITER, nodeid);
for (t = 0; NULL != tables[t].table; t++)
{
if (0 == (tables[t].flags & ZBX_SYNC))
continue;
DMget_table_data(nodeid, dest_nodetype, &tables[t], &data, &data_alloc, &data_offset,
&ptbls, &ptbls_alloc, &ptbls_offset);
}
zbx_free(ptbls);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
return data;
}
static int zbx_check_user_parameter(const char *param, char *error, int max_error_len)
{
const char suppressed_chars[] = "\\'\"`*?[]{}~$!&;()<>|#@\n", *c;
char *buf = NULL;
size_t buf_alloc = 128, buf_offset = 0;
if (0 != CONFIG_UNSAFE_USER_PARAMETERS)
return SUCCEED;
for (c = suppressed_chars; '\0' != *c; c++)
{
if (NULL == strchr(param, *c))
continue;
buf = zbx_malloc(buf, buf_alloc);
for (c = suppressed_chars; '\0' != *c; c++)
{
if (c != suppressed_chars)
zbx_strcpy_alloc(&buf, &buf_alloc, &buf_offset, ", ");
if (0 != isprint(*c))
zbx_chrcpy_alloc(&buf, &buf_alloc, &buf_offset, *c);
else
zbx_snprintf_alloc(&buf, &buf_alloc, &buf_offset, "0x%02x", *c);
}
zbx_snprintf(error, max_error_len, "special characters \"%s\" are not allowed in the parameters", buf);
zbx_free(buf);
return FAIL;
}
return SUCCEED;
}
/******************************************************************************
* *
* 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_DB_GET_HIST_* *
* 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";
char *sql = NULL;
size_t sql_alloc = 1024, sql_offset = 0;
zbx_uint64_t itemid;
zbx_vector_uint64_t itemids;
DB_RESULT result;
DB_ROW row;
unsigned char value_type;
history_value_t value;
int num = 0, ret = FAIL;
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, param);
memset(&value, 0, sizeof(value));
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 clean;
}
sql = zbx_malloc(sql, sql_alloc);
if (ZBX_DB_GET_HIST_VALUE == item_func)
{
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,
"select value_type,lastvalue"
" from items"
" where lastvalue is not null"
" and value_type in (%d,%d)"
" and",
ITEM_VALUE_TYPE_FLOAT, ITEM_VALUE_TYPE_UINT64);
DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "itemid", itemids.values, itemids.values_num);
result = DBselect("%s", sql);
while (NULL != (row = DBfetch(result)))
{
value_type = (unsigned char)atoi(row[0]);
evaluate_one(item, &value, &num, grp_func, row[1], value_type);
}
DBfree_result(result);
}
else
{
int clock_from;
unsigned int period;
char **h_value;
if (FAIL == is_uint_suffix(param, &period))
{
SET_MSG_RESULT(res, zbx_strdup(NULL, "Invalid fourth parameter"));
goto clean;
}
clock_from = time(NULL) - period;
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,
"select itemid,value_type"
" from items"
" where value_type in (%d,%d)"
" and",
ITEM_VALUE_TYPE_FLOAT, ITEM_VALUE_TYPE_UINT64);
DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "itemid", itemids.values, itemids.values_num);
result = DBselect("%s", sql);
while (NULL != (row = DBfetch(result)))
{
ZBX_STR2UINT64(itemid, row[0]);
value_type = (unsigned char)atoi(row[1]);
h_value = DBget_history(itemid, value_type, item_func, clock_from, 0, NULL, NULL, 0);
if (NULL != h_value[0])
evaluate_one(item, &value, &num, grp_func, h_value[0], value_type);
DBfree_history(h_value);
}
DBfree_result(result);
}
if (0 == num)
{
SET_MSG_RESULT(res, zbx_dsprintf(NULL, "No values for key \"%s\" in group(s) \"%s\"", itemkey, groups));
goto clean;
}
if (ZBX_GRP_FUNC_AVG == grp_func)
{
switch (item->value_type)
{
case ITEM_VALUE_TYPE_FLOAT:
value.dbl = value.dbl / num;
break;
case ITEM_VALUE_TYPE_UINT64:
value.ui64 = value.ui64 / num;
break;
default:
assert(0);
}
}
if (ITEM_VALUE_TYPE_FLOAT == item->value_type)
SET_DBL_RESULT(res, value.dbl);
else
SET_UI64_RESULT(res, value.ui64);
ret = SUCCEED;
clean:
zbx_vector_uint64_destroy(&itemids);
zbx_free(sql);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* Function: aggregate_get_items *
* *
* Purpose: get array of items specified by key for selected groups *
* *
* Parameters: itemids - [OUT] list of item ids *
* groups - [IN] list of comma-separated host groups *
* itemkey - [IN] item key to aggregate *
* *
******************************************************************************/
static void aggregate_get_items(zbx_vector_uint64_t *itemids, const char *groups, const char *itemkey)
{
const char *__function_name = "aggregate_get_items";
char *group, *esc;
DB_RESULT result;
DB_ROW row;
zbx_uint64_t itemid;
char *sql = NULL;
size_t sql_alloc = ZBX_KIBIBYTE, sql_offset = 0;
int num, n;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() groups:'%s' itemkey:'%s'", __function_name, groups, itemkey);
sql = zbx_malloc(sql, sql_alloc);
esc = DBdyn_escape_string(itemkey);
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,
"select distinct i.itemid"
" from items i,hosts h,hosts_groups hg,groups g"
" where i.hostid=h.hostid"
" and h.hostid=hg.hostid"
" and hg.groupid=g.groupid"
" and i.key_='%s'"
" and i.status=%d"
" and h.status=%d",
esc, ITEM_STATUS_ACTIVE, HOST_STATUS_MONITORED);
zbx_free(esc);
num = num_param(groups);
zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, " and g.name in (");
for (n = 1; n <= num; n++)
{
if (NULL == (group = get_param_dyn(groups, n)))
continue;
esc = DBdyn_escape_string(group);
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "'%s'", esc);
if (n != num)
zbx_chrcpy_alloc(&sql, &sql_alloc, &sql_offset, ',');
zbx_free(esc);
zbx_free(group);
}
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, ")" DB_NODE, DBnode_local("h.hostid"));
result = DBselect("%s", sql);
zbx_free(sql);
while (NULL != (row = DBfetch(result)))
{
ZBX_STR2UINT64(itemid, row[0]);
zbx_vector_uint64_append(itemids, itemid);
}
DBfree_result(result);
zbx_vector_uint64_sort(itemids, ZBX_DEFAULT_UINT64_COMPARE_FUNC);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
/******************************************************************************
* *
* Function: save_template_discovery_prototypes *
* *
* Purpose: saves host item prototypes in database *
* *
* Parameters: hostid - [IN] the target host *
* items - [IN] the template items *
* *
******************************************************************************/
void save_template_discovery_prototypes(zbx_uint64_t hostid, zbx_vector_ptr_t *items)
{
typedef struct
{
zbx_uint64_t itemid;
zbx_uint64_t parent_itemid;
}
zbx_proto_t;
DB_RESULT result;
DB_ROW row;
char *sql = NULL;
size_t sql_alloc = 0, sql_offset = 0;
zbx_vector_uint64_t itemids;
zbx_vector_ptr_t prototypes;
zbx_proto_t *proto;
int i;
zbx_db_insert_t db_insert;
zbx_vector_ptr_create(&prototypes);
zbx_vector_uint64_create(&itemids);
for (i = 0; i < items->values_num; i++)
{
zbx_template_item_t *item = items->values[i];
/* process only new prototype items */
if (NULL == item->key || 0 == (ZBX_FLAG_DISCOVERY_PROTOTYPE & item->flags))
continue;
zbx_vector_uint64_append(&itemids, item->itemid);
}
if (0 == itemids.values_num)
goto out;
zbx_vector_uint64_sort(&itemids, ZBX_DEFAULT_UINT64_COMPARE_FUNC);
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,
"select i.itemid,r.itemid"
" from items i,item_discovery id,items r"
" where i.templateid=id.itemid"
" and id.parent_itemid=r.templateid"
" and r.hostid=" ZBX_FS_UI64
" and",
hostid);
DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "i.itemid", itemids.values, itemids.values_num);
result = DBselect("%s", sql);
while (NULL != (row = DBfetch(result)))
{
proto = zbx_malloc(NULL, sizeof(zbx_proto_t));
ZBX_STR2UINT64(proto->itemid, row[0]);
ZBX_STR2UINT64(proto->parent_itemid, row[1]);
zbx_vector_ptr_append(&prototypes, proto);
}
DBfree_result(result);
if (0 == prototypes.values_num)
goto out;
zbx_db_insert_prepare(&db_insert, "item_discovery", "itemdiscoveryid", "itemid",
"parent_itemid", NULL);
for (i = 0; i < prototypes.values_num; i++)
{
proto = prototypes.values[i];
zbx_db_insert_add_values(&db_insert, __UINT64_C(0), proto->itemid, proto->parent_itemid);
}
zbx_db_insert_autoincrement(&db_insert, "itemdiscoveryid");
zbx_db_insert_execute(&db_insert);
zbx_db_insert_clean(&db_insert);
out:
zbx_free(sql);
zbx_vector_uint64_destroy(&itemids);
zbx_vector_ptr_clear_ext(&prototypes, zbx_ptr_free);
zbx_vector_ptr_destroy(&prototypes);
}
/******************************************************************************
* *
* Function: save_template_lld_rules *
* *
* Purpose: saves template lld rule item conditions to the target host in *
* database *
* *
* Parameters: items - [IN] the template items *
* rules - [IN] the ldd rule mapping *
* new_conditions - [IN] the number of new item conditions to *
* be inserted *
* *
******************************************************************************/
static void save_template_lld_rules(zbx_vector_ptr_t *items, zbx_vector_ptr_t *rules, int new_conditions)
{
char *macro_esc, *value_esc;
int i, j, index;
zbx_db_insert_t db_insert;
zbx_lld_rule_map_t *rule;
zbx_lld_rule_condition_t *condition;
char *sql = NULL;
size_t sql_alloc = 0, sql_offset = 0;
zbx_vector_uint64_t item_conditionids;
if (0 == rules->values_num)
return;
zbx_vector_uint64_create(&item_conditionids);
if (0 != new_conditions)
{
zbx_db_insert_prepare(&db_insert, "item_condition", "item_conditionid", "itemid", "operator", "macro",
"value", NULL);
/* insert lld rule conditions for new items */
for (i = 0; i < items->values_num; i++)
{
zbx_template_item_t *item = items->values[i];
if (NULL == item->key)
continue;
if (0 == (ZBX_FLAG_DISCOVERY_RULE & item->flags))
continue;
index = zbx_vector_ptr_bsearch(rules, &item->templateid, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC);
if (FAIL == index)
{
THIS_SHOULD_NEVER_HAPPEN;
continue;
}
rule = rules->values[index];
for (j = 0; j < rule->conditions.values_num; j++)
{
condition = rule->conditions.values[j];
zbx_db_insert_add_values(&db_insert, rule->conditionid++, item->itemid,
(int)condition->operator, condition->macro, condition->value);
}
}
}
DBbegin_multiple_update(&sql, &sql_alloc, &sql_offset);
/* update lld rule conditions for existing items */
for (i = 0; i < rules->values_num; i++)
{
rule = rules->values[i];
/* skip lld rules of new items */
if (0 == rule->itemid)
continue;
index = MIN(rule->conditions.values_num, rule->conditionids.values_num);
/* update intersecting rule conditions */
for (j = 0; j < index; j++)
{
condition = rule->conditions.values[j];
macro_esc = DBdyn_escape_string(condition->macro);
value_esc = DBdyn_escape_string(condition->value);
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "update item_condition"
" set operator=%d,macro='%s',value='%s'"
" where item_conditionid=" ZBX_FS_UI64 ";\n",
(int)condition->operator, macro_esc, value_esc, rule->conditionids.values[j]);
DBexecute_overflowed_sql(&sql, &sql_alloc, &sql_offset);
zbx_free(value_esc);
zbx_free(macro_esc);
}
/* delete removed rule conditions */
for (j = index; j < rule->conditionids.values_num; j++)
zbx_vector_uint64_append(&item_conditionids, rule->conditionids.values[j]);
/* insert new rule conditions */
for (j = index; j < rule->conditions.values_num; j++)
{
condition = rule->conditions.values[j];
zbx_db_insert_add_values(&db_insert, rule->conditionid++, rule->itemid,
(int)condition->operator, condition->macro, condition->value);
}
}
/* delete removed item conditions */
if (0 != item_conditionids.values_num)
{
zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, "delete from item_condition where");
DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "item_conditionid", item_conditionids.values,
item_conditionids.values_num);
zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, ";\n");
}
DBend_multiple_update(&sql, &sql_alloc, &sql_offset);
if (16 < sql_offset)
DBexecute("%s", sql);
if (0 != new_conditions)
{
zbx_db_insert_execute(&db_insert);
zbx_db_insert_clean(&db_insert);
}
zbx_free(sql);
zbx_vector_uint64_destroy(&item_conditionids);
}
