/******************************************************************************
* *
* Function: convert_condition_values *
* *
* Purpose: special processing for "value" field in "conditions" table *
* *
* Parameters: old_id - old id, new_id - new node id *
* *
* Author: Aleksandrs Saveljevs *
* *
* Comments: *
* *
******************************************************************************/
static void convert_condition_values(int old_id, int new_id, const char *rel_table_name, int type)
{
zbx_uint64_t prefix;
const ZBX_TABLE *r_table;
DB_RESULT result;
DB_ROW row;
zbx_uint64_t value;
r_table = DBget_table(rel_table_name);
assert(NULL != r_table);
prefix = (zbx_uint64_t)__UINT64_C(100000000000000) * (zbx_uint64_t)new_id;
if (0 != (r_table->flags & ZBX_SYNC))
prefix += (zbx_uint64_t)__UINT64_C(100000000000) * (zbx_uint64_t)new_id;
result = DBselect("select conditionid,value"
" from conditions"
" where conditiontype=%d",
type);
while (NULL != (row = DBfetch(result)))
{
ZBX_STR2UINT64(value, row[1]);
value += prefix;
DBexecute("update conditions"
" set value='" ZBX_FS_UI64 "'"
" where conditionid=%s",
value, row[0]);
}
DBfree_result(result);
}
/******************************************************************************
* *
* Function: convert_triggers_expression *
* *
* Purpose: convert trigger expressions to new node ID *
* *
* Parameters: old_id - old id, new_id - new node id *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static void convert_triggers_expression(int old_id, int new_id)
{
zbx_uint64_t prefix;
const ZBX_TABLE *r_table;
DB_RESULT result;
DB_ROW row;
char new_expression[MAX_STRING_LEN], *new_expression_esc;
r_table = DBget_table("functions");
assert(NULL != r_table);
prefix = (zbx_uint64_t)__UINT64_C(100000000000000) * (zbx_uint64_t)new_id;
if (0 != (r_table->flags & ZBX_SYNC))
prefix += (zbx_uint64_t)__UINT64_C(100000000000) * (zbx_uint64_t)new_id;
result = DBselect("select expression,triggerid from triggers");
while (NULL != (row = DBfetch(result)))
{
memset(new_expression, 0, sizeof(new_expression));
convert_expression(old_id, new_id, prefix, row[0], new_expression);
new_expression_esc = DBdyn_escape_string_len(new_expression, TRIGGER_EXPRESSION_LEN);
DBexecute("update triggers set expression='%s' where triggerid=%s",
new_expression_esc, row[1]);
zbx_free(new_expression_esc);
}
DBfree_result(result);
}
static int DBpatch_2030065(void)
{
DB_RESULT result;
DB_ROW row;
int local_nodeid = 0;
zbx_uint64_t min, max;
/* 1 - ZBX_NODE_LOCAL */
if (NULL == (result = DBselect("select nodeid from nodes where nodetype=1")))
return FAIL;
if (NULL != (row = DBfetch(result)))
local_nodeid = atoi(row[0]);
DBfree_result(result);
if (0 == local_nodeid)
return SUCCEED;
min = local_nodeid * __UINT64_C(100000000000000);
max = min + __UINT64_C(100000000000000) - 1;
if (ZBX_DB_OK <= DBexecute(
"delete from config where not configid between " ZBX_FS_UI64 " and " ZBX_FS_UI64, min, max))
{
return SUCCEED;
}
return FAIL;
}
/******************************************************************************
* *
* Function: convert_special_field *
* *
* Purpose: special processing for multipurpose fields *
* *
* Parameters: old_id - old id, new_id - new node id *
* *
* Return value: SUCCEED - converted successfully *
* FAIL - an error occurred *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static int convert_special_field(int old_id, int new_id, const char *table_name, const char *field_name, const char *type_field_name,
const char *rel_table_name, int type)
{
zbx_uint64_t prefix;
const ZBX_TABLE *r_table;
if (NULL == (r_table = DBget_table(rel_table_name)))
{
printf("%s.%s FAILED\n", table_name, field_name);
return FAIL;
}
prefix = (zbx_uint64_t)__UINT64_C(100000000000000)*(zbx_uint64_t)new_id;
if (r_table->flags & ZBX_SYNC)
prefix += (zbx_uint64_t)__UINT64_C(100000000000)*(zbx_uint64_t)new_id;
DBexecute("update %s set %s=%s+" ZBX_FS_UI64 " where %s=%d and %s>0",
table_name,
field_name,
field_name,
prefix,
type_field_name,
type,
field_name);
return SUCCEED;
}
/******************************************************************************
* *
* Function: convert_profiles *
* *
* Purpose: convert profiles idx2 and value_id fields to new node ID *
* *
* Parameters: old_id - old id, new_id - new node id *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static void convert_profiles(int old_id, int new_id, const char *field_name)
{
zbx_uint64_t prefix;
prefix = (zbx_uint64_t)__UINT64_C(100000000000000) * (zbx_uint64_t)new_id +
(zbx_uint64_t)__UINT64_C(100000000000) * (zbx_uint64_t)new_id;
DBexecute("update profiles set %s=%s+" ZBX_FS_UI64 " where %s>0",
field_name, field_name, prefix, field_name);
}
/******************************************************************************
* *
* Function: convert_special_field *
* *
* Purpose: special processing for multipurpose fields *
* *
* Parameters: old_id - old id, new_id - new node id *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static void convert_special_field(int old_id, int new_id, const char *table_name,
const char *field_name, const char *type_field_name,
const char *rel_table_name, int type)
{
zbx_uint64_t prefix;
const ZBX_TABLE *r_table;
r_table = DBget_table(rel_table_name);
assert(NULL != r_table);
prefix = (zbx_uint64_t)__UINT64_C(100000000000000) * (zbx_uint64_t)new_id;
if (0 != (r_table->flags & ZBX_SYNC))
prefix += (zbx_uint64_t)__UINT64_C(100000000000) * (zbx_uint64_t)new_id;
DBexecute("update %s set %s=%s+" ZBX_FS_UI64 " where %s=%d and %s>0",
table_name, field_name, field_name, prefix, type_field_name, type, field_name);
}
void zbx_mem_dump_stats(zbx_mem_info_t *info)
{
void *chunk;
int index;
zbx_uint64_t counter, total, total_free = 0;
zbx_uint64_t min_size = __UINT64_C(0xffffffffffffffff), max_size = __UINT64_C(0);
LOCK_INFO;
zabbix_log(LOG_LEVEL_DEBUG, "=== memory statistics for %s ===", info->mem_descr);
for (index = 0; index < MEM_BUCKET_COUNT; index++)
{
counter = 0;
chunk = info->buckets[index];
while (NULL != chunk)
{
counter++;
min_size = MIN(min_size, CHUNK_SIZE(chunk));
max_size = MAX(max_size, CHUNK_SIZE(chunk));
chunk = mem_get_next_chunk(chunk);
}
if (counter > 0)
{
total_free += counter;
zabbix_log(LOG_LEVEL_DEBUG, "free chunks of size %2s %3d bytes: %8d",
index == MEM_BUCKET_COUNT - 1 ? ">=" : "",
MEM_MIN_BUCKET_SIZE + 8 * index, counter);
}
}
zabbix_log(LOG_LEVEL_DEBUG, "min chunk size: %10u bytes", min_size);
zabbix_log(LOG_LEVEL_DEBUG, "max chunk size: %10u bytes", max_size);
total = (info->total_size - info->used_size - info->free_size) / (2 * MEM_SIZE_FIELD) + 1;
zabbix_log(LOG_LEVEL_DEBUG, "memory of total size %u bytes fragmented into %d chunks", info->total_size, total);
zabbix_log(LOG_LEVEL_DEBUG, "of those, %10u bytes are in %8d free chunks", info->free_size, total_free);
zabbix_log(LOG_LEVEL_DEBUG, "of those, %10u bytes are in %8d used chunks", info->used_size, total - total_free);
zabbix_log(LOG_LEVEL_DEBUG, "================================");
UNLOCK_INFO;
}
int get_diskstat(const char *devname, zbx_uint64_t *dstat)
{
FILE *f;
char tmp[MAX_STRING_LEN], name[MAX_STRING_LEN], dev_path[MAX_STRING_LEN];
int i, ret = FAIL, dev_exists = FAIL;
zbx_uint64_t ds[ZBX_DSTAT_MAX], rdev_major, rdev_minor;
zbx_stat_t dev_st;
int found = 0;
for (i = 0; i < ZBX_DSTAT_MAX; i++)
dstat[i] = (zbx_uint64_t)__UINT64_C(0);
if (NULL != devname && '\0' != *devname && 0 != strcmp(devname, "all"))
{
*dev_path = '\0';
if (0 != strncmp(devname, ZBX_DEV_PFX, ZBX_CONST_STRLEN(ZBX_DEV_PFX)))
strscpy(dev_path, ZBX_DEV_PFX);
strscat(dev_path, devname);
if (zbx_stat(dev_path, &dev_st) == 0)
dev_exists = SUCCEED;
}
if (NULL == (f = fopen(INFO_FILE_NAME, "r")))
return FAIL;
while (NULL != fgets(tmp, sizeof(tmp), f))
{
PARSE(tmp);
if (NULL != devname && '\0' != *devname && 0 != strcmp(devname, "all"))
{
if (0 != strcmp(name, devname))
{
if (SUCCEED != dev_exists
|| major(dev_st.st_rdev) != rdev_major
|| minor(dev_st.st_rdev) != rdev_minor)
continue;
}
else
found = 1;
}
dstat[ZBX_DSTAT_R_OPER] += ds[ZBX_DSTAT_R_OPER];
dstat[ZBX_DSTAT_R_SECT] += ds[ZBX_DSTAT_R_SECT];
dstat[ZBX_DSTAT_W_OPER] += ds[ZBX_DSTAT_W_OPER];
dstat[ZBX_DSTAT_W_SECT] += ds[ZBX_DSTAT_W_SECT];
ret = SUCCEED;
if (1 == found)
break;
}
zbx_fclose(f);
return ret;
}
uint64_t easy_hash_code(const void *key, int len, unsigned int seed)
{
const uint64_t m = __UINT64_C(0xc6a4a7935bd1e995);
const int r = 47;
uint64_t h = seed ^ (len * m);
const uint64_t *data = (const uint64_t *)key;
const uint64_t *end = data + (len / 8);
while(data != end) {
uint64_t k = *data++;
k *= m;
k ^= k >> r;
k *= m;
h ^= k;
h *= m;
}
const unsigned char *data2 = (const unsigned char *)data;
switch(len & 7) {
case 7:
h ^= (uint64_t)(data2[6]) << 48;
case 6:
h ^= (uint64_t)(data2[5]) << 40;
case 5:
h ^= (uint64_t)(data2[4]) << 32;
case 4:
h ^= (uint64_t)(data2[3]) << 24;
case 3:
h ^= (uint64_t)(data2[2]) << 16;
case 2:
h ^= (uint64_t)(data2[1]) << 8;
case 1:
h ^= (uint64_t)(data2[0]);
h *= m;
};
h ^= h >> r;
h *= m;
h ^= h >> r;
return h;
}
/**
* Check if the string is unsigned integer within the specified range and
* optionally store it into value parameter
*
* @param
* str - [IN] string to check
* @param n
* [IN] string length or MAX_UINT64_LEN
* @param value
* - [OUT] a pointer to output buffer where the converted value is to be written
* (optional, can be NULL)
* @param size
* [IN] size of the output buffer (optional)
* @param min
* [IN] the minimum acceptable value
* @param max
* [IN] the maximum acceptable value
*
* @return
* SUCCEED - the string is unsigned integer
* FAIL - the string is not a number or its value is outside the specified
* range
*
*/
int is_uint_n_range(const char *str, size_t n, void *value, size_t size,
uint64_t min, uint64_t max)
{
const uint64_t max_uint64 = ~(uint64_t)__UINT64_C(0);
uint64_t value_uint64 = 0, c;
unsigned short value_offset;
int len = 0;
if ('\0' == *str || 0 == n || sizeof(uint64_t) < size
|| (0 == size && NULL != value)) {
return FAIL;
}
while ('\0' != *str && 0 < n--) {
if (0 == isdigit(*str))
return FAIL; /* not a digit */
c = (uint64_t)(unsigned char)(*str - '0');
if (20 <= ++len && (max_uint64 - c) / 10 < value_uint64)
return FAIL; /* maximum value exceeded */
value_uint64 = value_uint64 * 10 + c;
str++;
}
if (min > value_uint64 || value_uint64 > max)
return FAIL;
if (NULL != value) {
/* On little endian architecture the output value will be stored
starting from the first bytes of 'value' buffer while on big endian
architecture it will be stored starting from the last bytes. We handle
it by storing the offset in the most significant byte of short value
and then use the first byte as source offset. */
value_offset = (unsigned short)((sizeof(uint64_t) - size) << 8);
memcpy(value,
(unsigned char *)&value_uint64 + *((unsigned char *)&value_offset),
size);
}
return SUCCEED;
}
/******************************************************************************
* *
* Function: db_update_event_suppress_data *
* *
* Purpose: create/update event suppress data to reflect latest maintenance *
* changes in cache *
* *
* Parameters: suppressed_num - [OUT] the number of suppressed events *
* *
******************************************************************************/
static void db_update_event_suppress_data(int *suppressed_num)
{
zbx_vector_ptr_t event_queries, event_data;
*suppressed_num = 0;
zbx_vector_ptr_create(&event_queries);
zbx_vector_ptr_create(&event_data);
db_get_query_events(&event_queries, &event_data);
if (0 != event_queries.values_num)
{
zbx_db_insert_t db_insert;
char *sql = NULL;
size_t sql_alloc = 0, sql_offset = 0;
int i, j, k;
zbx_event_suppress_query_t *query;
zbx_event_suppress_data_t *data;
zbx_vector_uint64_pair_t del_event_maintenances;
zbx_vector_uint64_t maintenanceids;
zbx_uint64_pair_t pair;
zbx_vector_uint64_create(&maintenanceids);
zbx_vector_uint64_pair_create(&del_event_maintenances);
db_get_query_functions(&event_queries);
db_get_query_tags(&event_queries);
zbx_dc_get_running_maintenanceids(&maintenanceids);
DBbegin();
if (0 != maintenanceids.values_num && SUCCEED == zbx_db_lock_maintenanceids(&maintenanceids))
zbx_dc_get_event_maintenances(&event_queries, &maintenanceids);
zbx_db_insert_prepare(&db_insert, "event_suppress", "event_suppressid", "eventid", "maintenanceid",
"suppress_until", NULL);
DBbegin_multiple_update(&sql, &sql_alloc, &sql_offset);
for (i = 0; i < event_queries.values_num; i++)
{
query = (zbx_event_suppress_query_t *)event_queries.values[i];
zbx_vector_uint64_pair_sort(&query->maintenances, ZBX_DEFAULT_UINT64_COMPARE_FUNC);
k = 0;
if (FAIL != (j = zbx_vector_ptr_bsearch(&event_data, &query->eventid,
ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC)))
{
data = (zbx_event_suppress_data_t *)event_data.values[j];
zbx_vector_uint64_pair_sort(&data->maintenances, ZBX_DEFAULT_UINT64_COMPARE_FUNC);
j = 0;
while (j < data->maintenances.values_num && k < query->maintenances.values_num)
{
if (data->maintenances.values[j].first < query->maintenances.values[k].first)
{
pair.first = query->eventid;
pair.second = data->maintenances.values[j].first;
zbx_vector_uint64_pair_append(&del_event_maintenances, pair);
j++;
continue;
}
if (data->maintenances.values[j].first > query->maintenances.values[k].first)
{
if (0 == query->r_eventid)
{
zbx_db_insert_add_values(&db_insert, __UINT64_C(0),
query->eventid,
query->maintenances.values[k].first,
(int)query->maintenances.values[k].second);
(*suppressed_num)++;
}
k++;
continue;
}
if (data->maintenances.values[j].second != query->maintenances.values[k].second)
{
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,
"update event_suppress"
" set suppress_until=%d"
" where eventid=" ZBX_FS_UI64
" and maintenanceid=" ZBX_FS_UI64 ";\n",
(int)query->maintenances.values[k].second,
query->eventid,
query->maintenances.values[k].first);
if (FAIL == DBexecute_overflowed_sql(&sql, &sql_alloc, &sql_offset))
goto cleanup;
}
j++;
k++;
}
for (;j < data->maintenances.values_num; j++)
{
pair.first = query->eventid;
pair.second = data->maintenances.values[j].first;
zbx_vector_uint64_pair_append(&del_event_maintenances, pair);
}
}
if (0 == query->r_eventid)
{
for (;k < query->maintenances.values_num; k++)
{
zbx_db_insert_add_values(&db_insert, __UINT64_C(0), query->eventid,
query->maintenances.values[k].first,
(int)query->maintenances.values[k].second);
(*suppressed_num)++;
}
}
}
for (i = 0; i < del_event_maintenances.values_num; i++)
{
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,
"delete from event_suppress"
" where eventid=" ZBX_FS_UI64
" and maintenanceid=" ZBX_FS_UI64 ";\n",
del_event_maintenances.values[i].first,
del_event_maintenances.values[i].second);
if (FAIL == DBexecute_overflowed_sql(&sql, &sql_alloc, &sql_offset))
goto cleanup;
}
DBend_multiple_update(&sql, &sql_alloc, &sql_offset);
if (16 < sql_offset)
{
if (ZBX_DB_OK > DBexecute("%s", sql))
goto cleanup;
}
zbx_db_insert_autoincrement(&db_insert, "event_suppressid");
zbx_db_insert_execute(&db_insert);
cleanup:
DBcommit();
zbx_db_insert_clean(&db_insert);
zbx_free(sql);
zbx_vector_uint64_pair_destroy(&del_event_maintenances);
zbx_vector_uint64_destroy(&maintenanceids);
}
zbx_vector_ptr_clear_ext(&event_data, (zbx_clean_func_t)event_suppress_data_free);
zbx_vector_ptr_destroy(&event_data);
zbx_vector_ptr_clear_ext(&event_queries, (zbx_clean_func_t)zbx_event_suppress_query_free);
zbx_vector_ptr_destroy(&event_queries);
}
/******************************************************************************
* *
* Function: zbx_load_config *
* *
* Purpose: parse config file and update configuration parameters *
* *
* Parameters: *
* *
* Return value: *
* *
* Author: Alexei Vladishev *
* *
* Comments: will terminate process if parsing fails *
* *
******************************************************************************/
static void zbx_load_config()
{
static struct cfg_line cfg[] =
{
/* PARAMETER, VAR, TYPE,
MANDATORY, MIN, MAX */
{"StartDBSyncers", &CONFIG_HISTSYNCER_FORKS, TYPE_INT,
PARM_OPT, 1, 100},
{"StartDiscoverers", &CONFIG_DISCOVERER_FORKS, TYPE_INT,
PARM_OPT, 0, 250},
{"StartHTTPPollers", &CONFIG_HTTPPOLLER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"StartPingers", &CONFIG_PINGER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"StartPollers", &CONFIG_POLLER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"StartPollersUnreachable", &CONFIG_UNREACHABLE_POLLER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"StartIPMIPollers", &CONFIG_IPMIPOLLER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"StartTimers", &CONFIG_TIMER_FORKS, TYPE_INT,
PARM_OPT, 1, 1000},
{"StartTrappers", &CONFIG_TRAPPER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"StartJavaPollers", &CONFIG_JAVAPOLLER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"JavaGateway", &CONFIG_JAVA_GATEWAY, TYPE_STRING,
PARM_OPT, 0, 0},
{"JavaGatewayPort", &CONFIG_JAVA_GATEWAY_PORT, TYPE_INT,
PARM_OPT, 1024, 32767},
{"SNMPTrapperFile", &CONFIG_SNMPTRAP_FILE, TYPE_STRING,
PARM_OPT, 0, 0},
{"StartSNMPTrapper", &CONFIG_SNMPTRAPPER_FORKS, TYPE_INT,
PARM_OPT, 0, 1},
{"CacheSize", &CONFIG_CONF_CACHE_SIZE, TYPE_UINT64,
PARM_OPT, 128 * ZBX_KIBIBYTE, __UINT64_C(8) * ZBX_GIBIBYTE},
{"HistoryCacheSize", &CONFIG_HISTORY_CACHE_SIZE, TYPE_UINT64,
PARM_OPT, 128 * ZBX_KIBIBYTE, __UINT64_C(2) * ZBX_GIBIBYTE},
{"TrendCacheSize", &CONFIG_TRENDS_CACHE_SIZE, TYPE_UINT64,
PARM_OPT, 128 * ZBX_KIBIBYTE, __UINT64_C(2) * ZBX_GIBIBYTE},
{"HistoryTextCacheSize", &CONFIG_TEXT_CACHE_SIZE, TYPE_UINT64,
PARM_OPT, 128 * ZBX_KIBIBYTE, __UINT64_C(2) * ZBX_GIBIBYTE},
{"ValueCacheSize", &CONFIG_VALUE_CACHE_SIZE, TYPE_UINT64,
PARM_OPT, 0, __UINT64_C(64) * ZBX_GIBIBYTE},
{"CacheUpdateFrequency", &CONFIG_CONFSYNCER_FREQUENCY, TYPE_INT,
PARM_OPT, 1, SEC_PER_HOUR},
{"HousekeepingFrequency", &CONFIG_HOUSEKEEPING_FREQUENCY, TYPE_INT,
PARM_OPT, 1, 24},
{"MaxHousekeeperDelete", &CONFIG_MAX_HOUSEKEEPER_DELETE, TYPE_INT,
PARM_OPT, 0, 1000000},
{"SenderFrequency", &CONFIG_SENDER_FREQUENCY, TYPE_INT,
PARM_OPT, 5, SEC_PER_HOUR},
{"TmpDir", &CONFIG_TMPDIR, TYPE_STRING,
PARM_OPT, 0, 0},
{"FpingLocation", &CONFIG_FPING_LOCATION, TYPE_STRING,
PARM_OPT, 0, 0},
#ifdef HAVE_IPV6
{"Fping6Location", &CONFIG_FPING6_LOCATION, TYPE_STRING,
PARM_OPT, 0, 0},
#endif
{"Timeout", &CONFIG_TIMEOUT, TYPE_INT,
PARM_OPT, 1, 30},
{"TrapperTimeout", &CONFIG_TRAPPER_TIMEOUT, TYPE_INT,
PARM_OPT, 1, 300},
{"UnreachablePeriod", &CONFIG_UNREACHABLE_PERIOD, TYPE_INT,
PARM_OPT, 1, SEC_PER_HOUR},
{"UnreachableDelay", &CONFIG_UNREACHABLE_DELAY, TYPE_INT,
PARM_OPT, 1, SEC_PER_HOUR},
{"UnavailableDelay", &CONFIG_UNAVAILABLE_DELAY, TYPE_INT,
PARM_OPT, 1, SEC_PER_HOUR},
{"ListenIP", &CONFIG_LISTEN_IP, TYPE_STRING_LIST,
PARM_OPT, 0, 0},
{"ListenPort", &CONFIG_LISTEN_PORT, TYPE_INT,
PARM_OPT, 1024, 32767},
{"SourceIP", &CONFIG_SOURCE_IP, TYPE_STRING,
PARM_OPT, 0, 0},
{"DebugLevel", &CONFIG_LOG_LEVEL, TYPE_INT,
PARM_OPT, 0, 4},
{"PidFile", &CONFIG_PID_FILE, TYPE_STRING,
PARM_OPT, 0, 0},
{"LogFile", &CONFIG_LOG_FILE, TYPE_STRING,
PARM_OPT, 0, 0},
{"LogFileSize", &CONFIG_LOG_FILE_SIZE, TYPE_INT,
PARM_OPT, 0, 1024},
{"AlertScriptsPath", &CONFIG_ALERT_SCRIPTS_PATH, TYPE_STRING,
PARM_OPT, 0, 0},
{"ExternalScripts", &CONFIG_EXTERNALSCRIPTS, TYPE_STRING,
PARM_OPT, 0, 0},
{"DBHost", &CONFIG_DBHOST, TYPE_STRING,
PARM_OPT, 0, 0},
{"DBName", &CONFIG_DBNAME, TYPE_STRING,
PARM_MAND, 0, 0},
{"DBSchema", &CONFIG_DBSCHEMA, TYPE_STRING,
PARM_OPT, 0, 0},
{"DBUser", &CONFIG_DBUSER, TYPE_STRING,
PARM_OPT, 0, 0},
{"DBPassword", &CONFIG_DBPASSWORD, TYPE_STRING,
PARM_OPT, 0, 0},
{"DBSocket", &CONFIG_DBSOCKET, TYPE_STRING,
PARM_OPT, 0, 0},
{"DBPort", &CONFIG_DBPORT, TYPE_INT,
PARM_OPT, 1024, 65535},
{"NodeID", &CONFIG_NODEID, TYPE_INT,
PARM_OPT, 0, 999},
{"NodeNoEvents", &CONFIG_NODE_NOEVENTS, TYPE_INT,
PARM_OPT, 0, 1},
{"NodeNoHistory", &CONFIG_NODE_NOHISTORY, TYPE_INT,
PARM_OPT, 0, 1},
{"SSHKeyLocation", &CONFIG_SSH_KEY_LOCATION, TYPE_STRING,
PARM_OPT, 0, 0},
{"LogSlowQueries", &CONFIG_LOG_SLOW_QUERIES, TYPE_INT,
PARM_OPT, 0, 3600000},
{"StartProxyPollers", &CONFIG_PROXYPOLLER_FORKS, TYPE_INT,
PARM_OPT, 0, 250},
{"ProxyConfigFrequency", &CONFIG_PROXYCONFIG_FREQUENCY, TYPE_INT,
PARM_OPT, 1, SEC_PER_WEEK},
{"ProxyDataFrequency", &CONFIG_PROXYDATA_FREQUENCY, TYPE_INT,
PARM_OPT, 1, SEC_PER_HOUR},
{"AllowRoot", &CONFIG_ALLOW_ROOT, TYPE_INT,
PARM_OPT, 0, 1},
{"LoadModulePath", &CONFIG_LOAD_MODULE_PATH, TYPE_STRING,
PARM_OPT, 0, 0},
{"LoadModule", &CONFIG_LOAD_MODULE, TYPE_MULTISTRING,
PARM_OPT, 0, 0},
{"StartVMwareCollectors", &CONFIG_VMWARE_FORKS, TYPE_INT,
PARM_OPT, 0, 250},
{"VMwareFrequency", &CONFIG_VMWARE_FREQUENCY, TYPE_INT,
PARM_OPT, 10, SEC_PER_DAY},
{"VMwareCacheSize", &CONFIG_VMWARE_CACHE_SIZE, TYPE_UINT64,
PARM_OPT, 256 * ZBX_KIBIBYTE, __UINT64_C(2) * ZBX_GIBIBYTE},
{"EnableSNMPBulkRequests", &CONFIG_SNMP_BULK_REQUESTS, TYPE_INT,
PARM_OPT, 0, 1},
{NULL}
};
/* initialize multistrings */
zbx_strarr_init(&CONFIG_LOAD_MODULE);
parse_cfg_file(CONFIG_FILE, cfg, ZBX_CFG_FILE_REQUIRED, ZBX_CFG_STRICT);
zbx_set_defaults();
zbx_validate_config();
}
/******************************************************************************
* *
* 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: calculate_checksums *
* *
* Purpose: calculate check sums of configuration data *
* *
* Parameters: *
* *
* Return value: SUCCESS - calculated succesfully *
* FAIL - an error occured *
* *
* Author: Alexei Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static int calculate_checksums()
{
char *sql = NULL;
int sql_allocated, sql_offset;
int i = 0;
int j;
DB_RESULT result;
DB_RESULT result2;
DB_ROW row;
DB_ROW row2;
int nodeid;
int now;
zabbix_log( LOG_LEVEL_DEBUG, "In calculate_checksums");
DBexecute("delete from node_cksum where cksumtype=%d",
NODE_CKSUM_TYPE_NEW);
/* Select all nodes */
result =DBselect("select nodeid from nodes");
while((row=DBfetch(result)))
{
sql_allocated=64*1024;
sql_offset=0;
sql=zbx_malloc(sql, sql_allocated);
now = time(NULL);
nodeid = atoi(row[0]);
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 128,
"select 'table ','field ',itemid, '012345678901234' from items where 1=0\n");
for(i=0; tables[i].table!=0; i++)
{
/* zabbix_log( LOG_LEVEL_WARNING, "In calculate_checksums2 [%s]", tables[i].table ); */
/* Do not sync some of tables */
if( (tables[i].flags & ZBX_SYNC) ==0) continue;
#ifdef HAVE_MYSQL
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 4096,
"union all select '%s','%s',%s,md5(concat(",
tables[i].table,
tables[i].recid,
tables[i].recid);
#else
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 4096,
"union all select '%s','%s',%s,md5(",
tables[i].table,
tables[i].recid,
tables[i].recid);
#endif
j=0;
while(tables[i].fields[j].name != 0)
{
if( (tables[i].fields[j].flags & ZBX_SYNC) ==0)
{
j++;
continue;
}
#ifdef HAVE_MYSQL
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 128, "coalesce(%s,'1234567890'),",
tables[i].fields[j].name);
#else
if(tables[i].fields[j].type == ZBX_TYPE_BLOB) /* postgresql is not work: coalesce(blob,'1234567890')||coalesce(varchar,'1234567890') */
{
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 128, "md5(coalesce(%s,'1234567890'))||",
tables[i].fields[j].name);
}
else
{
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 128, "coalesce(%s,'1234567890')||",
tables[i].fields[j].name);
}
#endif
j++;
}
#ifdef HAVE_MYSQL
if(j>0) sql_offset--; /* Remove last */
#else
if(j>0) sql_offset-=2; /* Remove last */
#endif
/* select table,recid,md5(fields) from table union all ... */
#ifdef HAVE_MYSQL
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 4096,
")) from %s where %s>=" ZBX_FS_UI64 " and %s<=" ZBX_FS_UI64 "\n",
tables[i].table,
tables[i].recid,
(zbx_uint64_t)__UINT64_C(100000000000000)*(zbx_uint64_t)nodeid,
tables[i].recid,
(zbx_uint64_t)__UINT64_C(100000000000000)*(zbx_uint64_t)nodeid+__UINT64_C(99999999999999));
#else
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 4096,
") from %s where %s>=" ZBX_FS_UI64 " and %s<=" ZBX_FS_UI64 "\n",
tables[i].table,
tables[i].recid,
(zbx_uint64_t)__UINT64_C(100000000000000)*(zbx_uint64_t)nodeid,
tables[i].recid,
(zbx_uint64_t)__UINT64_C(100000000000000)*(zbx_uint64_t)nodeid+__UINT64_C(99999999999999));
#endif
}
/* zabbix_log( LOG_LEVEL_WARNING, "SQL DUMP [%s]", sql);*/
result2 =DBselect("%s",sql);
/* zabbix_log( LOG_LEVEL_WARNING, "Selected records in %d seconds", time(NULL)-now);*/
now = time(NULL);
i=0;
while((row2=DBfetch(result2)))
{
DBexecute("insert into node_cksum (cksumid,nodeid,tablename,fieldname,recordid,cksumtype,cksum) "\
"values (" ZBX_FS_UI64 ",%d,'%s','%s',%s,%d,'%s')",
/* DBget_nextid("node_cksum","cksumid"),*/
DBget_maxid("node_cksum","cksumid"),
nodeid,
row2[0],
row2[1],
row2[2],
NODE_CKSUM_TYPE_NEW,
row2[3]);
i++;
}
DBfree_result(result2);
zbx_free(sql);
}
DBfree_result(result);
return SUCCEED;
}
/******************************************************************************
* *
* Function: save_template_item_applications *
* *
* Purpose: saves new item applications links in database *
* *
* Parameters: items - [IN] the template items *
* *
******************************************************************************/
void save_template_item_applications(zbx_vector_ptr_t *items)
{
typedef struct
{
zbx_uint64_t itemid;
zbx_uint64_t applicationid;
}
zbx_itemapp_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 itemapps;
zbx_itemapp_t *itemapp;
int i;
zbx_db_insert_t db_insert;
zbx_vector_ptr_create(&itemapps);
zbx_vector_uint64_create(&itemids);
for (i = 0; i < items->values_num; i++)
{
zbx_template_item_t *item = items->values[i];
zbx_vector_uint64_append(&itemids, item->itemid);
}
zbx_vector_uint64_sort(&itemids, ZBX_DEFAULT_UINT64_COMPARE_FUNC);
zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset,
"select hi.itemid,ha.applicationid"
" from items_applications tia"
" join items hi on hi.templateid=tia.itemid"
" and");
DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "hi.itemid", itemids.values, itemids.values_num);
zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset,
" join application_template hat on hat.templateid=tia.applicationid"
" join applications ha on ha.applicationid=hat.applicationid"
" and ha.hostid=hi.hostid"
" left join items_applications hia on hia.applicationid=ha.applicationid"
" and hia.itemid=hi.itemid"
" where hia.itemappid is null");
result = DBselect("%s", sql);
while (NULL != (row = DBfetch(result)))
{
itemapp = zbx_malloc(NULL, sizeof(zbx_itemapp_t));
ZBX_STR2UINT64(itemapp->itemid, row[0]);
ZBX_STR2UINT64(itemapp->applicationid, row[1]);
zbx_vector_ptr_append(&itemapps, itemapp);
}
DBfree_result(result);
if (0 == itemapps.values_num)
goto out;
zbx_db_insert_prepare(&db_insert, "items_applications", "itemappid", "itemid", "applicationid", NULL);
for (i = 0; i < itemapps.values_num; i++)
{
itemapp = itemapps.values[i];
zbx_db_insert_add_values(&db_insert, __UINT64_C(0), itemapp->itemid, itemapp->applicationid);
}
zbx_db_insert_autoincrement(&db_insert, "itemappid");
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(&itemapps, zbx_ptr_free);
zbx_vector_ptr_destroy(&itemapps);
}
int get_diskstat(const char *devname, zbx_uint64_t *dstat)
{
int i;
struct devstat *ds = NULL;
int ret = FAIL;
char dev[DEVSTAT_NAME_LEN + 10];
const char *pd; /* pointer to device name without '/dev/' prefix, e.g. 'da0' */
assert(devname);
for (i = 0; i < ZBX_DSTAT_MAX; i++)
dstat[i] = (zbx_uint64_t)__UINT64_C(0);
if (NULL == si)
{
si = (struct statinfo *)zbx_malloc(si, sizeof(struct statinfo));
si->dinfo = (struct devinfo *)zbx_malloc(NULL, sizeof(struct devinfo));
memset(si->dinfo, 0, sizeof(struct devinfo));
}
pd = devname;
/* skip prefix ZBX_DEV_PFX, if present */
if ('\0' != *devname && 0 == strncmp(pd, ZBX_DEV_PFX, sizeof(ZBX_DEV_PFX) - 1))
pd += sizeof(ZBX_DEV_PFX) - 1;
#if DEVSTAT_USER_API_VER >= 5
if (-1 == devstat_getdevs(NULL, si))
#else
if (-1 == getdevs(si))
#endif
return FAIL;
for (i = 0; i < si->dinfo->numdevs; i++)
{
ds = &si->dinfo->devices[i];
/* empty '*devname' string means adding statistics for all disks together */
if ('\0' != *devname)
{
zbx_snprintf(dev, sizeof(dev), "%s%d", ds->device_name, ds->unit_number);
if (0 != strcmp(dev, pd))
continue;
}
#if DEVSTAT_USER_API_VER >= 5
dstat[ZBX_DSTAT_R_OPER] += (zbx_uint64_t)ds->operations[DEVSTAT_READ];
dstat[ZBX_DSTAT_W_OPER] += (zbx_uint64_t)ds->operations[DEVSTAT_WRITE];
dstat[ZBX_DSTAT_R_BYTE] += (zbx_uint64_t)ds->bytes[DEVSTAT_READ];
dstat[ZBX_DSTAT_W_BYTE] += (zbx_uint64_t)ds->bytes[DEVSTAT_WRITE];
#else
dstat[ZBX_DSTAT_R_OPER] += (zbx_uint64_t)ds->num_reads;
dstat[ZBX_DSTAT_W_OPER] += (zbx_uint64_t)ds->num_writes;
dstat[ZBX_DSTAT_R_BYTE] += (zbx_uint64_t)ds->bytes_read;
dstat[ZBX_DSTAT_W_BYTE] += (zbx_uint64_t)ds->bytes_written;
#endif
ret = SUCCEED;
if ('\0' != *devname)
break;
}
return ret;
}
/******************************************************************************
* *
* Function: zbx_load_config *
* *
* Purpose: parse config file and update configuration parameters *
* *
* Parameters: *
* *
* Return value: *
* *
* Author: Alexei Vladishev *
* *
* Comments: will terminate process if parsing fails *
* *
******************************************************************************/
static void zbx_load_config(ZBX_TASK_EX *task)
{
static struct cfg_line cfg[] =
{
/* PARAMETER, VAR, TYPE,
MANDATORY, MIN, MAX */
{"StartDBSyncers", &CONFIG_HISTSYNCER_FORKS, TYPE_INT,
PARM_OPT, 1, 100},
{"StartDiscoverers", &CONFIG_DISCOVERER_FORKS, TYPE_INT,
PARM_OPT, 0, 250},
{"StartHTTPPollers", &CONFIG_HTTPPOLLER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"StartPingers", &CONFIG_PINGER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"StartPollers", &CONFIG_POLLER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"StartPollersUnreachable", &CONFIG_UNREACHABLE_POLLER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"StartIPMIPollers", &CONFIG_IPMIPOLLER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"StartTimers", &CONFIG_TIMER_FORKS, TYPE_INT,
PARM_OPT, 1, 1000},
{"StartTrappers", &CONFIG_TRAPPER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"StartJavaPollers", &CONFIG_JAVAPOLLER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"StartEscalators", &CONFIG_ESCALATOR_FORKS, TYPE_INT,
PARM_OPT, 1, 100},
{"JavaGateway", &CONFIG_JAVA_GATEWAY, TYPE_STRING,
PARM_OPT, 0, 0},
{"JavaGatewayPort", &CONFIG_JAVA_GATEWAY_PORT, TYPE_INT,
PARM_OPT, 1024, 32767},
{"SNMPTrapperFile", &CONFIG_SNMPTRAP_FILE, TYPE_STRING,
PARM_OPT, 0, 0},
{"StartSNMPTrapper", &CONFIG_SNMPTRAPPER_FORKS, TYPE_INT,
PARM_OPT, 0, 1},
{"CacheSize", &CONFIG_CONF_CACHE_SIZE, TYPE_UINT64,
PARM_OPT, 128 * ZBX_KIBIBYTE, __UINT64_C(8) * ZBX_GIBIBYTE},
{"HistoryCacheSize", &CONFIG_HISTORY_CACHE_SIZE, TYPE_UINT64,
PARM_OPT, 128 * ZBX_KIBIBYTE, __UINT64_C(2) * ZBX_GIBIBYTE},
{"HistoryIndexCacheSize", &CONFIG_HISTORY_INDEX_CACHE_SIZE, TYPE_UINT64,
PARM_OPT, 128 * ZBX_KIBIBYTE, __UINT64_C(2) * ZBX_GIBIBYTE},
{"TrendCacheSize", &CONFIG_TRENDS_CACHE_SIZE, TYPE_UINT64,
PARM_OPT, 128 * ZBX_KIBIBYTE, __UINT64_C(2) * ZBX_GIBIBYTE},
{"ValueCacheSize", &CONFIG_VALUE_CACHE_SIZE, TYPE_UINT64,
PARM_OPT, 0, __UINT64_C(64) * ZBX_GIBIBYTE},
{"CacheUpdateFrequency", &CONFIG_CONFSYNCER_FREQUENCY, TYPE_INT,
PARM_OPT, 1, SEC_PER_HOUR},
{"HousekeepingFrequency", &CONFIG_HOUSEKEEPING_FREQUENCY, TYPE_INT,
PARM_OPT, 0, 24},
{"MaxHousekeeperDelete", &CONFIG_MAX_HOUSEKEEPER_DELETE, TYPE_INT,
PARM_OPT, 0, 1000000},
{"TmpDir", &CONFIG_TMPDIR, TYPE_STRING,
PARM_OPT, 0, 0},
{"FpingLocation", &CONFIG_FPING_LOCATION, TYPE_STRING,
PARM_OPT, 0, 0},
{"Fping6Location", &CONFIG_FPING6_LOCATION, TYPE_STRING,
PARM_OPT, 0, 0},
{"Timeout", &CONFIG_TIMEOUT, TYPE_INT,
PARM_OPT, 1, 30},
{"TrapperTimeout", &CONFIG_TRAPPER_TIMEOUT, TYPE_INT,
PARM_OPT, 1, 300},
{"UnreachablePeriod", &CONFIG_UNREACHABLE_PERIOD, TYPE_INT,
PARM_OPT, 1, SEC_PER_HOUR},
{"UnreachableDelay", &CONFIG_UNREACHABLE_DELAY, TYPE_INT,
PARM_OPT, 1, SEC_PER_HOUR},
{"UnavailableDelay", &CONFIG_UNAVAILABLE_DELAY, TYPE_INT,
PARM_OPT, 1, SEC_PER_HOUR},
{"ListenIP", &CONFIG_LISTEN_IP, TYPE_STRING_LIST,
PARM_OPT, 0, 0},
{"ListenPort", &CONFIG_LISTEN_PORT, TYPE_INT,
PARM_OPT, 1024, 32767},
{"SourceIP", &CONFIG_SOURCE_IP, TYPE_STRING,
PARM_OPT, 0, 0},
{"DebugLevel", &CONFIG_LOG_LEVEL, TYPE_INT,
PARM_OPT, 0, 5},
{"PidFile", &CONFIG_PID_FILE, TYPE_STRING,
PARM_OPT, 0, 0},
{"LogType", &CONFIG_LOG_TYPE_STR, TYPE_STRING,
PARM_OPT, 0, 0},
{"LogFile", &CONFIG_LOG_FILE, TYPE_STRING,
PARM_OPT, 0, 0},
{"LogFileSize", &CONFIG_LOG_FILE_SIZE, TYPE_INT,
PARM_OPT, 0, 1024},
{"AlertScriptsPath", &CONFIG_ALERT_SCRIPTS_PATH, TYPE_STRING,
PARM_OPT, 0, 0},
{"ExternalScripts", &CONFIG_EXTERNALSCRIPTS, TYPE_STRING,
PARM_OPT, 0, 0},
{"DBHost", &CONFIG_DBHOST, TYPE_STRING,
PARM_OPT, 0, 0},
{"DBName", &CONFIG_DBNAME, TYPE_STRING,
PARM_MAND, 0, 0},
{"DBSchema", &CONFIG_DBSCHEMA, TYPE_STRING,
PARM_OPT, 0, 0},
{"DBUser", &CONFIG_DBUSER, TYPE_STRING,
PARM_OPT, 0, 0},
{"DBPassword", &CONFIG_DBPASSWORD, TYPE_STRING,
PARM_OPT, 0, 0},
{"DBSocket", &CONFIG_DBSOCKET, TYPE_STRING,
PARM_OPT, 0, 0},
{"DBPort", &CONFIG_DBPORT, TYPE_INT,
PARM_OPT, 1024, 65535},
{"SSHKeyLocation", &CONFIG_SSH_KEY_LOCATION, TYPE_STRING,
PARM_OPT, 0, 0},
{"LogSlowQueries", &CONFIG_LOG_SLOW_QUERIES, TYPE_INT,
PARM_OPT, 0, 3600000},
{"StartProxyPollers", &CONFIG_PROXYPOLLER_FORKS, TYPE_INT,
PARM_OPT, 0, 250},
{"ProxyConfigFrequency", &CONFIG_PROXYCONFIG_FREQUENCY, TYPE_INT,
PARM_OPT, 1, SEC_PER_WEEK},
{"ProxyDataFrequency", &CONFIG_PROXYDATA_FREQUENCY, TYPE_INT,
PARM_OPT, 1, SEC_PER_HOUR},
{"LoadModulePath", &CONFIG_LOAD_MODULE_PATH, TYPE_STRING,
PARM_OPT, 0, 0},
{"LoadModule", &CONFIG_LOAD_MODULE, TYPE_MULTISTRING,
PARM_OPT, 0, 0},
{"StartVMwareCollectors", &CONFIG_VMWARE_FORKS, TYPE_INT,
PARM_OPT, 0, 250},
{"VMwareFrequency", &CONFIG_VMWARE_FREQUENCY, TYPE_INT,
PARM_OPT, 10, SEC_PER_DAY},
{"VMwarePerfFrequency", &CONFIG_VMWARE_PERF_FREQUENCY, TYPE_INT,
PARM_OPT, 10, SEC_PER_DAY},
{"VMwareCacheSize", &CONFIG_VMWARE_CACHE_SIZE, TYPE_UINT64,
PARM_OPT, 256 * ZBX_KIBIBYTE, __UINT64_C(2) * ZBX_GIBIBYTE},
{"VMwareTimeout", &CONFIG_VMWARE_TIMEOUT, TYPE_INT,
PARM_OPT, 1, 300},
{"AllowRoot", &CONFIG_ALLOW_ROOT, TYPE_INT,
PARM_OPT, 0, 1},
{"User", &CONFIG_USER, TYPE_STRING,
PARM_OPT, 0, 0},
{"SSLCALocation", &CONFIG_SSL_CA_LOCATION, TYPE_STRING,
PARM_OPT, 0, 0},
{"SSLCertLocation", &CONFIG_SSL_CERT_LOCATION, TYPE_STRING,
PARM_OPT, 0, 0},
{"SSLKeyLocation", &CONFIG_SSL_KEY_LOCATION, TYPE_STRING,
PARM_OPT, 0, 0},
{"TLSCAFile", &CONFIG_TLS_CA_FILE, TYPE_STRING,
PARM_OPT, 0, 0},
{"TLSCRLFile", &CONFIG_TLS_CRL_FILE, TYPE_STRING,
PARM_OPT, 0, 0},
{"TLSCertFile", &CONFIG_TLS_CERT_FILE, TYPE_STRING,
PARM_OPT, 0, 0},
{"TLSKeyFile", &CONFIG_TLS_KEY_FILE, TYPE_STRING,
PARM_OPT, 0, 0},
{"SocketDir", &CONFIG_SOCKET_PATH, TYPE_STRING,
PARM_OPT, 0, 0},
{"StartAlerters", &CONFIG_ALERTER_FORKS, TYPE_INT,
PARM_OPT, 1, 100},
{"StartPreprocessors", &CONFIG_PREPROCESSOR_FORKS, TYPE_INT,
PARM_OPT, 1, 1000},
{"HistoryStorageURL", &CONFIG_HISTORY_STORAGE_URL, TYPE_STRING,
PARM_OPT, 0, 0},
{"HistoryStorageTypes", &CONFIG_HISTORY_STORAGE_OPTS, TYPE_STRING_LIST,
PARM_OPT, 0, 0},
{"HistoryStorageDateIndex", &CONFIG_HISTORY_STORAGE_PIPELINES, TYPE_INT,
PARM_OPT, 0, 1},
{"ExportDir", &CONFIG_EXPORT_DIR, TYPE_STRING,
PARM_OPT, 0, 0},
{"ExportFileSize", &CONFIG_EXPORT_FILE_SIZE, TYPE_UINT64,
PARM_OPT, ZBX_MEBIBYTE, ZBX_GIBIBYTE},
{"StartLLDProcessors", &CONFIG_LLDWORKER_FORKS, TYPE_INT,
PARM_OPT, 1, 100},
{"StatsAllowedIP", &CONFIG_STATS_ALLOWED_IP, TYPE_STRING_LIST,
PARM_OPT, 0, 0},
{NULL}
};
/* initialize multistrings */
zbx_strarr_init(&CONFIG_LOAD_MODULE);
parse_cfg_file(CONFIG_FILE, cfg, ZBX_CFG_FILE_REQUIRED, ZBX_CFG_STRICT);
zbx_set_defaults();
CONFIG_LOG_TYPE = zbx_get_log_type(CONFIG_LOG_TYPE_STR);
zbx_validate_config(task);
#if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL)
zbx_tls_validate_config();
#endif
}
/******************************************************************************
* *
* Function: change_nodeid *
* *
* Purpose: convert database data to new node ID *
* *
* Parameters: old_id - old id, new_id - new node id *
* *
* Return value: SUCCEED - converted successfully *
* FAIL - an error occurred *
* *
* Author: Alexei Vladishev *
* *
******************************************************************************/
int change_nodeid(int old_id, int new_id)
{
struct conv_t
{
const char *rel;
int type;
};
struct special_conv_t
{
const char *table_name, *field_name, *type_field_name;
struct conv_t convs[32];
};
struct special_conv_t special_convs[] =
{
{"sysmaps_elements", "elementid", "elementtype",
{
{"hosts", SYSMAP_ELEMENT_TYPE_HOST},
{"sysmaps", SYSMAP_ELEMENT_TYPE_MAP},
{"triggers", SYSMAP_ELEMENT_TYPE_TRIGGER},
{"groups", SYSMAP_ELEMENT_TYPE_HOST_GROUP},
{"images", SYSMAP_ELEMENT_TYPE_IMAGE},
{NULL}
}
},
{"events", "objectid", "object",
{
{"triggers", EVENT_OBJECT_TRIGGER},
{"dhosts", EVENT_OBJECT_DHOST},
{"dservices", EVENT_OBJECT_DSERVICE},
{NULL}
}
},
{"ids", "nextid", NULL,
{
{NULL}
}
},
{"node_cksum", "recordid", NULL,
{
{NULL}
}
},
{"screens_items", "resourceid", "resourcetype",
{
{"graphs", SCREEN_RESOURCE_GRAPH},
{"items", SCREEN_RESOURCE_SIMPLE_GRAPH},
{"sysmaps", SCREEN_RESOURCE_MAP},
{"items", SCREEN_RESOURCE_PLAIN_TEXT},
{"groups", SCREEN_RESOURCE_HOSTS_INFO},
{"screens", SCREEN_RESOURCE_SCREEN},
{"groups", SCREEN_RESOURCE_TRIGGERS_OVERVIEW},
{"groups", SCREEN_RESOURCE_DATA_OVERVIEW},
{"groups", SCREEN_RESOURCE_HOSTGROUP_TRIGGERS},
{"hosts", SCREEN_RESOURCE_HOST_TRIGGERS},
{NULL}
}
},
{"auditlog", "resourceid", "resourcetype",
{
{"users", AUDIT_RESOURCE_USER},
/* {"", AUDIT_RESOURCE_ZABBIX},*/
{"config", AUDIT_RESOURCE_ZABBIX_CONFIG},
{"media_type", AUDIT_RESOURCE_MEDIA_TYPE},
{"hosts", AUDIT_RESOURCE_HOST},
{"actions", AUDIT_RESOURCE_ACTION},
{"graphs", AUDIT_RESOURCE_GRAPH},
{"graphs_items", AUDIT_RESOURCE_GRAPH_ELEMENT},
/* {"", AUDIT_RESOURCE_ESCALATION},
{"", AUDIT_RESOURCE_ESCALATION_RULE},
{"", AUDIT_RESOURCE_AUTOREGISTRATION},*/
{"usrgrp", AUDIT_RESOURCE_USER_GROUP},
{"applications", AUDIT_RESOURCE_APPLICATION},
{"triggers", AUDIT_RESOURCE_TRIGGER},
{"groups", AUDIT_RESOURCE_HOST_GROUP},
{"items", AUDIT_RESOURCE_ITEM},
{"images", AUDIT_RESOURCE_IMAGE},
{"valuemaps", AUDIT_RESOURCE_VALUE_MAP},
{"services", AUDIT_RESOURCE_IT_SERVICE},
{"sysmaps", AUDIT_RESOURCE_MAP},
{"screens", AUDIT_RESOURCE_SCREEN},
/* {"nodes", AUDIT_RESOURCE_NODE},*/
/* {"", AUDIT_RESOURCE_SCENARIO},*/
{"drules", AUDIT_RESOURCE_DISCOVERY_RULE},
{"slideshows", AUDIT_RESOURCE_SLIDESHOW},
{"scripts", AUDIT_RESOURCE_SCRIPT},
/* {"", AUDIT_RESOURCE_PROXY},*/
{"maintenances", AUDIT_RESOURCE_MAINTENANCE},
{"regexps", AUDIT_RESOURCE_REGEXP},
{NULL}
}
},
{NULL}
};
struct conv_t condition_convs[] =
{
{"groups", CONDITION_TYPE_HOST_GROUP},
{"hosts", CONDITION_TYPE_HOST},
{"hosts", CONDITION_TYPE_HOST_TEMPLATE},
{"hosts", CONDITION_TYPE_PROXY},
{"triggers", CONDITION_TYPE_TRIGGER},
{"dchecks", CONDITION_TYPE_DCHECK},
{"drules", CONDITION_TYPE_DRULE},
{NULL},
};
int i, j, s, t, ret = FAIL;
zbx_uint64_t prefix;
const ZBX_TABLE *r_table;
if (0 != old_id)
{
printf("Conversion from non-zero node ID is not supported.\n");
return ret;
}
if (1 > new_id || new_id > 999)
{
printf("Node ID must be in range of 1-999.\n");
return ret;
}
zabbix_set_log_level(LOG_LEVEL_WARNING);
DBconnect(ZBX_DB_CONNECT_EXIT);
DBbegin();
printf("Dropping foreign keys ");
fflush(stdout);
for (i = 0; NULL != db_schema_fkeys_drop[i]; i++)
{
DBexecute("%s", db_schema_fkeys_drop[i]);
printf(".");
fflush(stdout);
}
printf(" done.\nConverting tables ");
fflush(stdout);
for (i = 0; NULL != tables[i].table; i++)
{
printf(".");
fflush(stdout);
for (j = 0; NULL != tables[i].fields[j].name; j++)
{
for (s = 0; NULL != special_convs[s].table_name; s++)
{
if (0 == strcmp(special_convs[s].table_name, tables[i].table) &&
0 == strcmp(special_convs[s].field_name, tables[i].fields[j].name))
{
break;
}
}
if (NULL != special_convs[s].table_name)
{
for (t = 0; NULL != special_convs[s].convs[t].rel; t++)
{
convert_special_field(old_id, new_id, special_convs[s].table_name,
special_convs[s].field_name, special_convs[s].type_field_name,
special_convs[s].convs[t].rel, special_convs[s].convs[t].type);
}
continue;
}
if (ZBX_TYPE_ID != tables[i].fields[j].type)
continue;
/* primary key */
if (0 == strcmp(tables[i].fields[j].name, tables[i].recid))
{
prefix = (zbx_uint64_t)__UINT64_C(100000000000000) * (zbx_uint64_t)new_id;
if (0 != (tables[i].flags & ZBX_SYNC))
prefix += (zbx_uint64_t)__UINT64_C(100000000000) * (zbx_uint64_t)new_id;
}
/* relations */
else if (NULL != tables[i].fields[j].fk_table)
{
r_table = DBget_table(tables[i].fields[j].fk_table);
assert(NULL != r_table);
prefix = (zbx_uint64_t)__UINT64_C(100000000000000)*(zbx_uint64_t)new_id;
if (0 != (r_table->flags & ZBX_SYNC))
prefix += (zbx_uint64_t)__UINT64_C(100000000000)*(zbx_uint64_t)new_id;
}
/* special processing for table 'profiles' */
else if (0 == strcmp("profiles", tables[i].table))
{
convert_profiles(old_id, new_id, tables[i].fields[j].name);
continue;
}
else
assert(0);
DBexecute("update %s set %s=%s+" ZBX_FS_UI64 " where %s>0",
tables[i].table,
tables[i].fields[j].name,
tables[i].fields[j].name,
prefix,
tables[i].fields[j].name);
}
}
/* special processing for trigger expressions */
convert_triggers_expression(old_id, new_id);
/* special processing for condition values */
for (i = 0; NULL != condition_convs[i].rel; i++)
convert_condition_values(old_id, new_id, condition_convs[i].rel, condition_convs[i].type);
DBexecute("insert into nodes (nodeid,name,ip,nodetype) values (%d,'Local node','127.0.0.1',1)", new_id);
DBexecute("delete from ids where nodeid=0");
if (SUCCEED != (ret = DBtxn_status()))
goto error;
printf(" done.\nCreating foreign keys ");
fflush(stdout);
for (i = 0; NULL != db_schema_fkeys[i]; i++)
{
DBexecute("%s", db_schema_fkeys[i]);
printf(".");
fflush(stdout);
}
ret = DBtxn_status();
error:
DBcommit();
DBclose();
if (SUCCEED != ret)
printf("Conversion failed.\n");
else
printf(" done.\nConversion completed successfully.\n");
return ret;
}
static int dm_rename_slave_data(const char *table_name, const char *key_name, const char *field_name,
int field_length)
{
DB_RESULT result;
DB_ROW row;
int local_nodeid = 0, nodeid, globalmacro;
zbx_uint64_t id, min, max;
char *name = NULL, *name_esc;
size_t name_alloc = 0, name_offset;
/* 1 - ZBX_NODE_LOCAL */
if (NULL == (result = DBselect("select nodeid from nodes where nodetype=1")))
return FAIL;
if (NULL != (row = DBfetch(result)))
local_nodeid = atoi(row[0]);
DBfree_result(result);
if (0 == local_nodeid)
return SUCCEED;
globalmacro = (0 == strcmp(table_name, "globalmacro"));
min = local_nodeid * __UINT64_C(100000000000000);
max = min + __UINT64_C(100000000000000) - 1;
if (NULL == (result = DBselect(
"select %s,%s"
" from %s"
" where not %s between " ZBX_FS_UI64 " and " ZBX_FS_UI64
" order by %s",
key_name, field_name, table_name, key_name, min, max, key_name)))
{
return FAIL;
}
while (NULL != (row = DBfetch(result)))
{
ZBX_STR2UINT64(id, row[0]);
nodeid = (int)(id / __UINT64_C(100000000000000));
name_offset = 0;
if (0 == globalmacro)
zbx_snprintf_alloc(&name, &name_alloc, &name_offset, "N%d_%s", nodeid, row[1]);
else
zbx_snprintf_alloc(&name, &name_alloc, &name_offset, "{$N%d_%s", nodeid, row[1] + 2);
name_esc = DBdyn_escape_string_len(name, field_length);
if (ZBX_DB_OK > DBexecute("update %s set %s='%s' where %s=" ZBX_FS_UI64,
table_name, field_name, name_esc, key_name, id))
{
zbx_free(name_esc);
break;
}
zbx_free(name_esc);
}
DBfree_result(result);
zbx_free(name);
return SUCCEED;
}
static void *__mem_malloc(zbx_mem_info_t *info, zbx_uint64_t size)
{
int index;
void *chunk;
zbx_uint64_t chunk_size;
size = mem_proper_alloc_size(size);
/* try to find an appropriate chunk in special buckets */
index = mem_bucket_by_size(size);
while (index < MEM_BUCKET_COUNT - 1 && NULL == info->buckets[index])
index++;
chunk = info->buckets[index];
if (index == MEM_BUCKET_COUNT - 1)
{
/* otherwise, find a chunk big enough according to first-fit strategy */
int counter = 0;
zbx_uint64_t skip_min = __UINT64_C(0xffffffffffffffff), skip_max = __UINT64_C(0);
while (NULL != chunk && CHUNK_SIZE(chunk) < size)
{
counter++;
skip_min = MIN(skip_min, CHUNK_SIZE(chunk));
skip_max = MAX(skip_max, CHUNK_SIZE(chunk));
chunk = mem_get_next_chunk(chunk);
}
/* don't log errors if malloc can return null in low memory situations */
if (0 == info->allow_oom)
{
if (NULL == chunk)
zabbix_log(LOG_LEVEL_CRIT, "__mem_malloc: skipped %d asked %u skip_min %u skip_max %u",
counter, size, skip_min, skip_max);
else if (counter >= 100)
zabbix_log(LOG_LEVEL_DEBUG, "__mem_malloc: skipped %d asked %u skip_min %u skip_max %u size %u",
counter, size, skip_min, skip_max, CHUNK_SIZE(chunk));
}
}
if (NULL == chunk)
return NULL;
chunk_size = CHUNK_SIZE(chunk);
mem_unlink_chunk(info, chunk);
/* either use the full chunk or split it */
if (chunk_size < size + 2 * MEM_SIZE_FIELD + MEM_MIN_ALLOC)
{
info->used_size += chunk_size;
info->free_size -= chunk_size;
mem_set_used_chunk_size(chunk, chunk_size);
}
else
{
void *new_chunk;
zbx_uint64_t new_chunk_size;
new_chunk = chunk + MEM_SIZE_FIELD + size + MEM_SIZE_FIELD;
new_chunk_size = chunk_size - size - 2 * MEM_SIZE_FIELD;
mem_set_chunk_size(new_chunk, new_chunk_size);
mem_link_chunk(info, new_chunk);
info->used_size += size;
info->free_size -= chunk_size;
info->free_size += new_chunk_size;
mem_set_used_chunk_size(chunk, size);
}
return chunk;
}
/******************************************************************************
* *
* Function: zbx_load_config *
* *
* Purpose: parse config file and update configuration parameters *
* *
* Author: Alexei Vladishev *
* *
* Comments: will terminate process if parsing fails *
* *
******************************************************************************/
static void zbx_load_config(void)
{
static struct cfg_line cfg[] =
{
/* PARAMETER, VAR, TYPE,
MANDATORY, MIN, MAX */
{"ProxyMode", &CONFIG_PROXYMODE, TYPE_INT,
PARM_OPT, ZBX_PROXYMODE_ACTIVE, ZBX_PROXYMODE_PASSIVE},
{"Server", &CONFIG_SERVER, TYPE_STRING,
PARM_OPT, 0, 0},
{"ServerPort", &CONFIG_SERVER_PORT, TYPE_INT,
PARM_OPT, 1024, 32767},
{"Hostname", &CONFIG_HOSTNAME, TYPE_STRING,
PARM_OPT, 0, 0},
{"HostnameItem", &CONFIG_HOSTNAME_ITEM, TYPE_STRING,
PARM_OPT, 0, 0},
{"StartDBSyncers", &CONFIG_HISTSYNCER_FORKS, TYPE_INT,
PARM_OPT, 1, 100},
{"StartDiscoverers", &CONFIG_DISCOVERER_FORKS, TYPE_INT,
PARM_OPT, 0, 250},
{"StartHTTPPollers", &CONFIG_HTTPPOLLER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"StartPingers", &CONFIG_PINGER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"StartPollers", &CONFIG_POLLER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"StartPollersUnreachable", &CONFIG_UNREACHABLE_POLLER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"StartIPMIPollers", &CONFIG_IPMIPOLLER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"StartTrappers", &CONFIG_TRAPPER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"StartJavaPollers", &CONFIG_JAVAPOLLER_FORKS, TYPE_INT,
PARM_OPT, 0, 1000},
{"JavaGateway", &CONFIG_JAVA_GATEWAY, TYPE_STRING,
PARM_OPT, 0, 0},
{"JavaGatewayPort", &CONFIG_JAVA_GATEWAY_PORT, TYPE_INT,
PARM_OPT, 1024, 32767},
{"SNMPTrapperFile", &CONFIG_SNMPTRAP_FILE, TYPE_STRING,
PARM_OPT, 0, 0},
{"StartSNMPTrapper", &CONFIG_SNMPTRAPPER_FORKS, TYPE_INT,
PARM_OPT, 0, 1},
{"CacheSize", &CONFIG_CONF_CACHE_SIZE, TYPE_UINT64,
PARM_OPT, 128 * ZBX_KIBIBYTE, __UINT64_C(8) * ZBX_GIBIBYTE},
{"HistoryCacheSize", &CONFIG_HISTORY_CACHE_SIZE, TYPE_UINT64,
PARM_OPT, 128 * ZBX_KIBIBYTE, __UINT64_C(2) * ZBX_GIBIBYTE},
{"HistoryTextCacheSize", &CONFIG_TEXT_CACHE_SIZE, TYPE_UINT64,
PARM_OPT, 128 * ZBX_KIBIBYTE, __UINT64_C(2) * ZBX_GIBIBYTE},
{"HousekeepingFrequency", &CONFIG_HOUSEKEEPING_FREQUENCY, TYPE_INT,
PARM_OPT, 1, 24},
{"ProxyLocalBuffer", &CONFIG_PROXY_LOCAL_BUFFER, TYPE_INT,
PARM_OPT, 0, 720},
{"ProxyOfflineBuffer", &CONFIG_PROXY_OFFLINE_BUFFER, TYPE_INT,
PARM_OPT, 1, 720},
{"HeartbeatFrequency", &CONFIG_HEARTBEAT_FREQUENCY, TYPE_INT,
PARM_OPT, 0, SEC_PER_HOUR},
{"ConfigFrequency", &CONFIG_PROXYCONFIG_FREQUENCY, TYPE_INT,
PARM_OPT, 1, SEC_PER_WEEK},
{"DataSenderFrequency", &CONFIG_PROXYDATA_FREQUENCY, TYPE_INT,
PARM_OPT, 1, SEC_PER_HOUR},
{"TmpDir", &CONFIG_TMPDIR, TYPE_STRING,
PARM_OPT, 0, 0},
{"FpingLocation", &CONFIG_FPING_LOCATION, TYPE_STRING,
PARM_OPT, 0, 0},
#ifdef HAVE_IPV6
{"Fping6Location", &CONFIG_FPING6_LOCATION, TYPE_STRING,
PARM_OPT, 0, 0},
#endif
{"Timeout", &CONFIG_TIMEOUT, TYPE_INT,
PARM_OPT, 1, 30},
{"TrapperTimeout", &CONFIG_TRAPPER_TIMEOUT, TYPE_INT,
PARM_OPT, 1, 300},
{"UnreachablePeriod", &CONFIG_UNREACHABLE_PERIOD, TYPE_INT,
PARM_OPT, 1, SEC_PER_HOUR},
{"UnreachableDelay", &CONFIG_UNREACHABLE_DELAY, TYPE_INT,
PARM_OPT, 1, SEC_PER_HOUR},
{"UnavailableDelay", &CONFIG_UNAVAILABLE_DELAY, TYPE_INT,
PARM_OPT, 1, SEC_PER_HOUR},
{"ListenIP", &CONFIG_LISTEN_IP, TYPE_STRING_LIST,
PARM_OPT, 0, 0},
{"ListenPort", &CONFIG_LISTEN_PORT, TYPE_INT,
PARM_OPT, 1024, 32767},
{"SourceIP", &CONFIG_SOURCE_IP, TYPE_STRING,
PARM_OPT, 0, 0},
{"DebugLevel", &CONFIG_LOG_LEVEL, TYPE_INT,
PARM_OPT, 0, 4},
{"PidFile", &CONFIG_PID_FILE, TYPE_STRING,
PARM_OPT, 0, 0},
{"LogFile", &CONFIG_LOG_FILE, TYPE_STRING,
PARM_OPT, 0, 0},
{"LogFileSize", &CONFIG_LOG_FILE_SIZE, TYPE_INT,
PARM_OPT, 0, 1024},
{"ExternalScripts", &CONFIG_EXTERNALSCRIPTS, TYPE_STRING,
PARM_OPT, 0, 0},
{"DBHost", &CONFIG_DBHOST, TYPE_STRING,
PARM_OPT, 0, 0},
{"DBName", &CONFIG_DBNAME, TYPE_STRING,
PARM_MAND, 0, 0},
{"DBSchema", &CONFIG_DBSCHEMA, TYPE_STRING,
PARM_OPT, 0, 0},
{"DBUser", &CONFIG_DBUSER, TYPE_STRING,
PARM_OPT, 0, 0},
{"DBPassword", &CONFIG_DBPASSWORD, TYPE_STRING,
PARM_OPT, 0, 0},
{"DBSocket", &CONFIG_DBSOCKET, TYPE_STRING,
PARM_OPT, 0, 0},
{"DBPort", &CONFIG_DBPORT, TYPE_INT,
PARM_OPT, 1024, 65535},
{"SSHKeyLocation", &CONFIG_SSH_KEY_LOCATION, TYPE_STRING,
PARM_OPT, 0, 0},
{"LogSlowQueries", &CONFIG_LOG_SLOW_QUERIES, TYPE_INT,
PARM_OPT, 0, 3600000},
{"LoadModulePath", &CONFIG_LOAD_MODULE_PATH, TYPE_STRING,
PARM_OPT, 0, 0},
{"LoadModule", &CONFIG_LOAD_MODULE, TYPE_MULTISTRING,
PARM_OPT, 0, 0},
{"StartVMwareCollectors", &CONFIG_VMWARE_FORKS, TYPE_INT,
PARM_OPT, 0, 250},
{"VMwareFrequency", &CONFIG_VMWARE_FREQUENCY, TYPE_INT,
PARM_OPT, 10, SEC_PER_DAY},
{"VMwarePerfFrequency", &CONFIG_VMWARE_PERF_FREQUENCY, TYPE_INT,
PARM_OPT, 10, SEC_PER_DAY},
{"VMwareCacheSize", &CONFIG_VMWARE_CACHE_SIZE, TYPE_UINT64,
PARM_OPT, 256 * ZBX_KIBIBYTE, __UINT64_C(2) * ZBX_GIBIBYTE},
{"VMwareTimeout", &CONFIG_VMWARE_TIMEOUT, TYPE_INT,
PARM_OPT, 1, 300},
{"AllowRoot", &CONFIG_ALLOW_ROOT, TYPE_INT,
PARM_OPT, 0, 1},
{"User", &CONFIG_USER, TYPE_STRING,
PARM_OPT, 0, 0},
#ifdef HAVE_LIBCURL
{"SSLCALocation", &CONFIG_SSL_CA_LOCATION, TYPE_STRING,
PARM_OPT, 0, 0},
{"SSLCertLocation", &CONFIG_SSL_CERT_LOCATION, TYPE_STRING,
PARM_OPT, 0, 0},
{"SSLKeyLocation", &CONFIG_SSL_KEY_LOCATION, TYPE_STRING,
PARM_OPT, 0, 0},
#endif
{NULL}
};
/* initialize multistrings */
zbx_strarr_init(&CONFIG_LOAD_MODULE);
parse_cfg_file(CONFIG_FILE, cfg, ZBX_CFG_FILE_REQUIRED, ZBX_CFG_STRICT);
zbx_set_defaults();
zbx_validate_config();
}
