/******************************************************************************
* *
* Function: select hostid of discovered host *
* *
* Purpose: select discovered host *
* *
* Parameters: dhostid - discovered host id *
* *
* Return value: hostid - existing hostid, 0 - if not found *
* *
* Author: Alexei Vladishev *
* *
******************************************************************************/
static zbx_uint64_t select_discovered_host(DB_EVENT *event)
{
const char *__function_name = "select_discovered_host";
DB_RESULT result;
DB_ROW row;
zbx_uint64_t hostid = 0;
char sql[512];
zabbix_log(LOG_LEVEL_DEBUG, "In %s() eventid:" ZBX_FS_UI64,
__function_name, event->eventid);
switch (event->object)
{
case EVENT_OBJECT_DHOST:
zbx_snprintf(sql, sizeof(sql),
"select h.hostid"
" from hosts h,dservices ds"
" where ds.ip=h.ip"
" and ds.dhostid=" ZBX_FS_UI64
DB_NODE
" order by h.hostid",
event->objectid, DBnode_local("h.hostid"));
break;
case EVENT_OBJECT_DSERVICE:
zbx_snprintf(sql, sizeof(sql),
"select h.hostid"
" from hosts h,dservices ds"
" where ds.ip=h.ip"
" and ds.dserviceid=" ZBX_FS_UI64
DB_NODE
" order by h.hostid",
event->objectid, DBnode_local("h.hostid"));
break;
default:
goto exit;
}
result = DBselectN(sql, 1);
if (NULL != (row = DBfetch(result)))
{
ZBX_STR2UINT64(hostid, row[0]);
}
DBfree_result(result);
exit:
zabbix_log(LOG_LEVEL_DEBUG, "End %s():" ZBX_FS_UI64, __function_name, hostid);
return hostid;
}
/******************************************************************************
* *
* Function: run_commands *
* *
* Purpose: run remote commandlist for specific action *
* *
* Parameters: trigger - trigger data *
* action - action data *
* *
* Author: Eugene Grigorjev *
* *
* Comments: commands separated with newline *
* *
******************************************************************************/
void op_run_commands(char *cmd_list)
{
DB_RESULT result;
DB_ROW row;
char *alias, *alias_esc, *command;
int is_group;
assert(cmd_list);
zabbix_log(LOG_LEVEL_DEBUG, "In run_commands()");
while (1 != get_next_command(&cmd_list, &alias, &is_group, &command))
{
if (!alias || *alias == '\0' || !command || *command == '\0')
continue;
if (is_group)
{
alias_esc = DBdyn_escape_string(alias);
result = DBselect("select distinct h.host from hosts_groups hg,hosts h,groups g"
" where hg.hostid=h.hostid and hg.groupid=g.groupid and g.name='%s'" DB_NODE,
alias_esc,
DBnode_local("h.hostid"));
zbx_free(alias_esc);
while (NULL != (row = DBfetch(result)))
run_remote_command(row[0], command);
DBfree_result(result);
}
else
run_remote_command(alias, command);
}
zabbix_log( LOG_LEVEL_DEBUG, "End run_commands()");
}
/******************************************************************************
* *
* Function: get_proxy_id *
* *
* Purpose: *
* *
* Parameters: *
* *
* Return value: SUCCEED - processed successfully *
* FAIL - an error occurred *
* *
* Author: Aleksander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
int get_proxy_id(struct zbx_json_parse *jp, zbx_uint64_t *hostid)
{
DB_RESULT result;
DB_ROW row;
char host[HOST_HOST_LEN_MAX], host_esc[MAX_STRING_LEN];
int res = FAIL;
if (SUCCEED == zbx_json_value_by_name(jp, ZBX_PROTO_TAG_HOST, host, sizeof(host))) {
DBescape_string(host, host_esc, sizeof(host_esc));
result = DBselect("select hostid from hosts where host='%s'"
" and status in (%d)" DB_NODE,
host_esc,
HOST_STATUS_PROXY,
DBnode_local("hostid"));
if (NULL != (row = DBfetch(result)) && FAIL == DBis_null(row[0])) {
*hostid = zbx_atoui64(row[0]);
res = SUCCEED;
} else
zabbix_log(LOG_LEVEL_WARNING, "Unknown proxy \"%s\"",
host);
DBfree_result(result);
} else {
zabbix_log(LOG_LEVEL_WARNING, "Incorrect data. %s",
zbx_json_strerror());
zabbix_syslog("Incorrect data. %s",
zbx_json_strerror());
}
return res;
}
/******************************************************************************
* *
* Function: process_actions *
* *
* Purpose: process all actions that match single event *
* *
* Parameters: event - event to apply actions for *
* *
* Author: Alexei Vladishev *
* *
* Comments: dependencies are checked in a different place *
* *
******************************************************************************/
void process_actions(DB_EVENT *event)
{
const char *__function_name = "process_actions";
DB_RESULT result;
DB_ROW row;
zbx_uint64_t actionid;
unsigned char evaltype;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() eventid:" ZBX_FS_UI64, __function_name, event->eventid);
result = DBselect("select actionid,evaltype"
" from actions"
" where status=%d and eventsource=%d" DB_NODE,
ACTION_STATUS_ACTIVE, event->source, DBnode_local("actionid"));
while (NULL != (row = DBfetch(result)))
{
ZBX_STR2UINT64(actionid, row[0]);
evaltype = (unsigned char)atoi(row[1]);
if (SUCCEED == check_action_conditions(event, actionid, evaltype))
{
DBstart_escalation(actionid, event->source == EVENT_SOURCE_TRIGGERS ? event->objectid : 0, event->eventid);
if (event->source == EVENT_SOURCE_DISCOVERY || event->source == EVENT_SOURCE_AUTO_REGISTRATION)
execute_operations(event, actionid);
}
else if (EVENT_SOURCE_TRIGGERS == event->source)
DBstop_escalation(actionid, event->objectid, event->eventid);
}
DBfree_result(result);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
/******************************************************************************
* *
* Function: get_hostid_by_host *
* *
* Purpose: check for host name and return hostid *
* *
* Parameters: host - host name *
* *
* Return value: SUCCEED - host is found *
* FAIL - an error occured or host not found *
* *
* Author: Aleksander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static int get_hostid_by_host(const char *host, zbx_uint64_t *hostid, char *error)
{
char *host_esc;
DB_RESULT result;
DB_ROW row;
int res = FAIL;
zabbix_log(LOG_LEVEL_DEBUG, "In get_hostid_by_host(host:'%s')", host);
host_esc = DBdyn_escape_string(host);
result = DBselect("select hostid from hosts where host='%s'" DB_NODE,
host_esc,
DBnode_local("hostid"));
if (NULL != (row = DBfetch(result)))
{
*hostid = zbx_atoui64(row[0]);
res = SUCCEED;
}
else
zbx_snprintf(error, MAX_STRING_LEN, "host [%s] not found", host);
DBfree_result(result);
zbx_free(host_esc);
return res;
}
/******************************************************************************
* *
* Function: zabbix_syslog *
* *
* Purpose: save internal warning or error message in item zabbix[log] *
* *
* Parameters: va_list arguments *
* *
* Return value: *
* *
* Author: Alexei Vladishev *
* *
* Comments: do nothing if no zabbix[log] items *
* *
******************************************************************************/
void __zbx_zabbix_syslog(const char *fmt, ...)
{
va_list ap;
char value_str[MAX_STRING_LEN];
DB_ITEM item;
DB_RESULT result;
DB_ROW row;
AGENT_RESULT agent;
time_t now;
zabbix_log(LOG_LEVEL_DEBUG, "In zabbix_log()");
/* This is made to disable writing to database for watchdog */
if(CONFIG_ENABLE_LOG == 0) return;
result = DBselect("select %s where h.hostid=i.hostid and h.status=%d and i.status=%d"
" and h.proxy_hostid=0 and i.key_='%s' and i.value_type=%d" DB_NODE,
ZBX_SQL_ITEM_SELECT,
ITEM_STATUS_ACTIVE,
HOST_STATUS_MONITORED,
SERVER_ZABBIXLOG_KEY,
ITEM_VALUE_TYPE_STR,
DBnode_local("h.hostid"));
now = time(NULL);
while((row=DBfetch(result)))
{
DBget_item_from_db(&item,row);
va_start(ap,fmt);
vsnprintf(value_str,sizeof(value_str),fmt,ap);
value_str[MAX_STRING_LEN-1]=0;
va_end(ap);
init_result(&agent);
SET_STR_RESULT(&agent, strdup(value_str));
process_new_value(&item, &agent, now);
free_result(&agent);
}
DBfree_result(result);
}
static void process_escalations(int now)
{
DB_RESULT result;
DB_ROW row;
DB_ESCALATION escalation;
zabbix_log(LOG_LEVEL_DEBUG, "In process_escalations()");
result = DBselect("select escalationid,actionid,triggerid,eventid,r_eventid,esc_step,status"
" from escalations where status in (%d,%d) and nextcheck<=%d" DB_NODE,
ESCALATION_STATUS_ACTIVE,
ESCALATION_STATUS_RECOVERY,
now,
DBnode_local("escalationid"));
while (NULL != (row = DBfetch(result))) {
memset(&escalation, 0, sizeof(escalation));
ZBX_STR2UINT64(escalation.escalationid, row[0]);
ZBX_STR2UINT64(escalation.actionid, row[1]);
ZBX_STR2UINT64(escalation.triggerid, row[2]);
ZBX_STR2UINT64(escalation.eventid, row[3]);
ZBX_STR2UINT64(escalation.r_eventid, row[4]);
escalation.esc_step = atoi(row[5]);
escalation.status = atoi(row[6]);
escalation.nextcheck = 0;
DBbegin();
execute_escalation(&escalation);
if (escalation.status == ESCALATION_STATUS_COMPLETED)
DBremove_escalation(escalation.escalationid);
else
DBexecute("update escalations set status=%d,esc_step=%d,nextcheck=%d"
" where escalationid=" ZBX_FS_UI64,
escalation.status,
escalation.esc_step,
escalation.nextcheck,
escalation.escalationid);
DBcommit();
}
DBfree_result(result);
}
static int process_value(zbx_uint64_t itemid, AGENT_RESULT *value)
{
const char *__function_name = "process_value";
DB_RESULT result;
DB_ROW row;
int ret;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() itemid:" ZBX_FS_UI64, __function_name, itemid);
result = DBselect(
"select i.value_type"
" from items i,hosts h"
" where h.hostid=i.hostid"
" and h.status=%d"
" and i.status=%d"
" and i.type=%d"
" and i.itemid=" ZBX_FS_UI64
" and (h.maintenance_status=%d or h.maintenance_type=%d)"
DB_NODE,
HOST_STATUS_MONITORED,
ITEM_STATUS_ACTIVE,
ITEM_TYPE_HTTPTEST,
itemid,
HOST_MAINTENANCE_STATUS_OFF, MAINTENANCE_TYPE_NORMAL,
DBnode_local("h.hostid"));
if (NULL != (row = DBfetch(result)))
{
dc_add_history(itemid, (unsigned char)atoi(row[0]), value, time(NULL),
ITEM_STATUS_ACTIVE, NULL, 0, NULL, 0, 0, 0, 0);
ret = SUCCEED;
}
else
ret = FAIL;
DBfree_result(result);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
static void run_remote_command(char* host_name, char* command)
{
int ret = 9;
AGENT_RESULT agent_result;
DC_ITEM item;
DB_RESULT result;
DB_ROW row;
char *p, *host_esc, *param;
#ifdef HAVE_OPENIPMI
int val;
char error[MAX_STRING_LEN];
#endif
assert(host_name);
assert(command);
zabbix_log(LOG_LEVEL_DEBUG, "In run_remote_command(hostname:%s,command:%s)",
host_name,
command);
host_esc = DBdyn_escape_string(host_name);
result = DBselect(
"select hostid,host,useip,ip,dns,port,useipmi,ipmi_ip,ipmi_port,ipmi_authtype,"
"ipmi_privilege,ipmi_username,ipmi_password"
" from hosts"
" where status in (%d)"
" and host='%s'"
DB_NODE,
HOST_STATUS_MONITORED,
host_esc,
DBnode_local("hostid"));
zbx_free(host_esc);
if (NULL != (row = DBfetch(result)))
{
memset(&item, 0, sizeof(item));
ZBX_STR2UINT64(item.host.hostid, row[0]);
zbx_strlcpy(item.host.host, row[1], sizeof(item.host.host));
item.host.useip = (unsigned char)atoi(row[2]);
zbx_strlcpy(item.host.ip, row[3], sizeof(item.host.ip));
zbx_strlcpy(item.host.dns, row[4], sizeof(item.host.dns));
item.host.port = (unsigned short)atoi(row[5]);
p = command;
while (*p == ' ' && *p != '\0')
p++;
#ifdef HAVE_OPENIPMI
if (0 == strncmp(p, "IPMI", 4))
{
if (1 == atoi(row[6]))
{
zbx_strlcpy(item.host.ipmi_ip_orig, row[7], sizeof(item.host.ipmi_ip));
item.host.ipmi_port = (unsigned short)atoi(row[8]);
item.host.ipmi_authtype = atoi(row[9]);
item.host.ipmi_privilege = atoi(row[10]);
zbx_strlcpy(item.host.ipmi_username, row[11], sizeof(item.host.ipmi_username));
zbx_strlcpy(item.host.ipmi_password, row[12], sizeof(item.host.ipmi_password));
}
if (SUCCEED == (ret = parse_ipmi_command(p, item.ipmi_sensor, &val)))
{
item.key = item.ipmi_sensor;
ret = set_ipmi_control_value(&item, val, error, sizeof(error));
}
}
else
{
#endif
param = zbx_dyn_escape_string(p, "\"");
item.key = zbx_dsprintf(NULL, "system.run[\"%s\",\"nowait\"]", param);
zbx_free(param);
init_result(&agent_result);
alarm(CONFIG_TIMEOUT);
ret = get_value_agent(&item, &agent_result);
alarm(0);
free_result(&agent_result);
zbx_free(item.key);
#ifdef HAVE_OPENIPMI
}
#endif
}
DBfree_result(result);
zabbix_log(LOG_LEVEL_DEBUG, "End run_remote_command(result:%d)",
ret);
}
/******************************************************************************
* *
* Function: send_list_of_active_checks_json *
* *
* Purpose: send list of active checks to the host *
* *
* Parameters: sock - open socket of server-agent connection *
* json - request buffer *
* *
* Return value: SUCCEED - list of active checks sent successfully *
* FAIL - an error occurred *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
int send_list_of_active_checks_json(zbx_sock_t *sock, struct zbx_json_parse *jp)
{
const char *__function_name = "send_list_of_active_checks_json";
char host[HOST_HOST_LEN_MAX], *name_esc, params[MAX_STRING_LEN],
pattern[MAX_STRING_LEN], tmp[32],
key_severity[MAX_STRING_LEN], key_logeventid[MAX_STRING_LEN],
ip[INTERFACE_IP_LEN_MAX];
DB_RESULT result;
DB_ROW row;
struct zbx_json json;
int res = FAIL, refresh_unsupported, now;
zbx_uint64_t hostid;
char error[MAX_STRING_LEN], *key = NULL;
DC_ITEM dc_item;
unsigned short port;
char **regexp = NULL;
int regexp_alloc = 0;
int regexp_num = 0, n;
char *sql = NULL;
size_t sql_alloc = 2 * ZBX_KIBIBYTE, sql_offset = 0;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (FAIL == zbx_json_value_by_name(jp, ZBX_PROTO_TAG_HOST, host, sizeof(host)))
{
zbx_snprintf(error, MAX_STRING_LEN, "%s", zbx_json_strerror());
goto error;
}
if (FAIL == zbx_json_value_by_name(jp, ZBX_PROTO_TAG_IP, ip, sizeof(ip)))
strscpy(ip, get_ip_by_socket(sock));
if (FAIL == zbx_json_value_by_name(jp, ZBX_PROTO_TAG_PORT, tmp, sizeof(tmp)))
*tmp = '\0';
if (FAIL == is_ushort(tmp, &port))
port = ZBX_DEFAULT_AGENT_PORT;
if (FAIL == get_hostid_by_host(host, ip, port, &hostid, error))
goto error;
DCconfig_get_config_data(&refresh_unsupported, CONFIG_REFRESH_UNSUPPORTED);
now = time(NULL);
sql = zbx_malloc(sql, sql_alloc);
name_esc = DBdyn_escape_string(host);
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,
"select i.key_,i.delay,i.lastlogsize,i.mtime"
" from items i,hosts h"
" where i.hostid=h.hostid"
" and h.status=%d"
" and i.type=%d"
" and i.flags<>%d"
" and h.hostid=" ZBX_FS_UI64
" and h.proxy_hostid is null",
HOST_STATUS_MONITORED,
ITEM_TYPE_ZABBIX_ACTIVE,
ZBX_FLAG_DISCOVERY_CHILD,
hostid);
zbx_free(name_esc);
zbx_json_init(&json, ZBX_JSON_STAT_BUF_LEN);
zbx_json_addstring(&json, ZBX_PROTO_TAG_RESPONSE, ZBX_PROTO_VALUE_SUCCESS, ZBX_JSON_TYPE_STRING);
zbx_json_addarray(&json, ZBX_PROTO_TAG_DATA);
result = DBselect("%s", sql);
while (NULL != (row = DBfetch(result)))
{
if (FAIL == DCconfig_get_item_by_key(&dc_item, (zbx_uint64_t)0, host, row[0]))
{
zabbix_log(LOG_LEVEL_DEBUG, "%s() Item '%s' was not found in the server cache. Not sending now.", __function_name, row[0]);
continue;
}
if (ITEM_STATUS_NOTSUPPORTED == dc_item.status)
{
if (0 == refresh_unsupported || dc_item.lastclock + refresh_unsupported > now)
{
DCconfig_clean_items(&dc_item, NULL, 1);
continue;
}
}
zabbix_log(LOG_LEVEL_DEBUG, "%s() Item '%s' was successfully found in the server cache. Sending.", __function_name, row[0]);
ZBX_STRDUP(key, row[0]);
substitute_key_macros(&key, NULL, &dc_item, NULL, MACRO_TYPE_ITEM_KEY, NULL, 0);
DCconfig_clean_items(&dc_item, NULL, 1);
zbx_json_addobject(&json, NULL);
zbx_json_addstring(&json, ZBX_PROTO_TAG_KEY, key, ZBX_JSON_TYPE_STRING);
if (0 != strcmp(key, row[0]))
zbx_json_addstring(&json, ZBX_PROTO_TAG_KEY_ORIG, row[0], ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, ZBX_PROTO_TAG_DELAY, row[1], ZBX_JSON_TYPE_INT);
/* The agent expects ALWAYS to have lastlogsize and mtime tags. Removing those would cause older agents to fail. */
zbx_json_addstring(&json, ZBX_PROTO_TAG_LOGLASTSIZE, row[2], ZBX_JSON_TYPE_INT);
zbx_json_addstring(&json, ZBX_PROTO_TAG_MTIME, row[3], ZBX_JSON_TYPE_INT);
zbx_json_close(&json);
/* special processing for log[] and logrt[] items */
do { /* simple try realization */
/* log[filename,pattern,encoding,maxlinespersec] */
/* logrt[filename_format,pattern,encoding,maxlinespersec] */
if (0 != strncmp(key, "log[", 4) && 0 != strncmp(key, "logrt[", 6))
break;
if (2 != parse_command(key, NULL, 0, params, sizeof(params)))
break;
/* dealing with `pattern' parameter */
if (0 == get_param(params, 2, pattern, sizeof(pattern)) &&
*pattern == '@')
add_regexp_name(®exp, ®exp_alloc, ®exp_num, pattern + 1);
} while (0); /* simple try realization */
/* special processing for eventlog[] items */
do { /* simple try realization */
/* eventlog[filename,pattern,severity,source,logeventid,maxlinespersec] */
if (0 != strncmp(key, "eventlog[", 9))
break;
if (2 != parse_command(key, NULL, 0, params, sizeof(params)))
break;
/* dealing with `pattern' parameter */
if (0 == get_param(params, 2, pattern, sizeof(pattern)) &&
*pattern == '@')
add_regexp_name(®exp, ®exp_alloc, ®exp_num, pattern + 1);
/* dealing with `severity' parameter */
if (0 == get_param(params, 3, key_severity, sizeof(key_severity)) &&
*key_severity == '@')
add_regexp_name(®exp, ®exp_alloc, ®exp_num, key_severity + 1);
/* dealing with `logeventid' parameter */
if (0 == get_param(params, 5, key_logeventid, sizeof(key_logeventid)) &&
*key_logeventid == '@')
add_regexp_name(®exp, ®exp_alloc, ®exp_num, key_logeventid + 1);
} while (0); /* simple try realization */
zbx_free(key);
}
zbx_json_close(&json);
DBfree_result(result);
if (0 != regexp_num)
{
zbx_json_addarray(&json, ZBX_PROTO_TAG_REGEXP);
sql_offset = 0;
zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset,
"select r.name,e.expression,e.expression_type,e.exp_delimiter,e.case_sensitive"
" from regexps r,expressions e"
" where r.regexpid=e.regexpid"
" and r.name in (");
for (n = 0; n < regexp_num; n++)
{
name_esc = DBdyn_escape_string(regexp[n]);
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "%s'%s'",
n == 0 ? "" : ",",
name_esc);
zbx_free(name_esc);
zbx_free(regexp[n]);
}
zbx_chrcpy_alloc(&sql, &sql_alloc, &sql_offset, ')');
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, DB_NODE, DBnode_local("r.regexpid"));
result = DBselect("%s", sql);
while (NULL != (row = DBfetch(result)))
{
zbx_json_addobject(&json, NULL);
zbx_json_addstring(&json, "name", row[0], ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, "expression", row[1], ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, "expression_type", row[2], ZBX_JSON_TYPE_INT);
zbx_json_addstring(&json, "exp_delimiter", row[3], ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, "case_sensitive", row[4], ZBX_JSON_TYPE_INT);
zbx_json_close(&json);
}
DBfree_result(result);
}
zbx_free(regexp);
zabbix_log(LOG_LEVEL_DEBUG, "%s() sending [%s]", __function_name, json.buffer);
alarm(CONFIG_TIMEOUT);
if (SUCCEED != zbx_tcp_send(sock, json.buffer))
strscpy(error, zbx_tcp_strerror());
else
res = SUCCEED;
alarm(0);
zbx_json_free(&json);
zbx_free(sql);
goto out;
error:
zabbix_log(LOG_LEVEL_WARNING, "cannot send list of active checks to [%s]: %s", get_ip_by_socket(sock), error);
zbx_json_init(&json, ZBX_JSON_STAT_BUF_LEN);
zbx_json_addstring(&json, ZBX_PROTO_TAG_RESPONSE, ZBX_PROTO_VALUE_FAILED, ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, ZBX_PROTO_TAG_INFO, error, ZBX_JSON_TYPE_STRING);
zabbix_log(LOG_LEVEL_DEBUG, "%s() sending [%s]", __function_name, json.buffer);
res = zbx_tcp_send(sock, json.buffer);
zbx_json_free(&json);
out:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(res));
return res;
}
/******************************************************************************
* *
* Function: main_alerter_loop *
* *
* Purpose: periodically check table alerts and send notifications if needed *
* *
* Author: Alexei Vladishev *
* *
******************************************************************************/
void main_alerter_loop()
{
char error[MAX_STRING_LEN], *error_esc;
int res;
DB_RESULT result;
DB_ROW row;
DB_ALERT alert;
DB_MEDIATYPE mediatype;
zbx_setproctitle("%s [connecting to the database]", get_process_type_string(process_type));
DBconnect(ZBX_DB_CONNECT_NORMAL);
for (;;)
{
zbx_setproctitle("%s [sending alerts]", get_process_type_string(process_type));
result = DBselect("select a.alertid,a.mediatypeid,a.sendto,a.subject,a.message,a.status,mt.mediatypeid"
",mt.type,mt.description,mt.smtp_server,mt.smtp_helo,mt.smtp_email,mt.exec_path"
",mt.gsm_modem,mt.username,mt.passwd,a.retries from alerts a,media_type mt"
" where a.status=%d and a.mediatypeid=mt.mediatypeid and a.alerttype=%d" DB_NODE
" order by a.clock",
ALERT_STATUS_NOT_SENT,
ALERT_TYPE_MESSAGE,
DBnode_local("mt.mediatypeid"));
while (NULL != (row = DBfetch(result)))
{
ZBX_STR2UINT64(alert.alertid, row[0]);
alert.mediatypeid = atoi(row[1]);
alert.sendto = row[2];
alert.subject = row[3];
alert.message = row[4];
alert.status = atoi(row[5]);
ZBX_STR2UINT64(mediatype.mediatypeid, row[6]);
mediatype.type = atoi(row[7]);
mediatype.description = row[8];
mediatype.smtp_server = row[9];
mediatype.smtp_helo = row[10];
mediatype.smtp_email = row[11];
mediatype.exec_path = row[12];
mediatype.gsm_modem = row[13];
mediatype.username = row[14];
mediatype.passwd = row[15];
alert.retries = atoi(row[16]);
*error = '\0';
res = execute_action(&alert, &mediatype, error, sizeof(error));
if (SUCCEED == res)
{
zabbix_log(LOG_LEVEL_DEBUG, "Alert ID [" ZBX_FS_UI64 "] was sent successfully",
alert.alertid);
DBexecute("update alerts set status=%d,error='' where alertid=" ZBX_FS_UI64,
ALERT_STATUS_SENT, alert.alertid);
}
else
{
zabbix_log(LOG_LEVEL_DEBUG, "Error sending alert ID [" ZBX_FS_UI64 "]",
alert.alertid);
zabbix_syslog("Error sending alert ID [" ZBX_FS_UI64 "]",
alert.alertid);
error_esc = DBdyn_escape_string_len(error, ALERT_ERROR_LEN);
alert.retries++;
if (ALERT_MAX_RETRIES > alert.retries)
{
DBexecute("update alerts set retries=%d,error='%s' where alertid=" ZBX_FS_UI64,
alert.retries, error_esc, alert.alertid);
}
else
{
DBexecute("update alerts set status=%d,retries=%d,error='%s' where alertid=" ZBX_FS_UI64,
ALERT_STATUS_FAILED, alert.retries, error_esc, alert.alertid);
}
zbx_free(error_esc);
}
}
DBfree_result(result);
zbx_sleep_loop(CONFIG_SENDER_FREQUENCY);
}
}
/******************************************************************************
* *
* Function: add host if not added already *
* *
* Purpose: add discovered host *
* *
* Parameters: dhostid - discovered host id *
* *
* Return value: hostid - new/existing hostid *
* *
* Author: Alexei Vladishev *
* *
******************************************************************************/
static zbx_uint64_t add_discovered_host(DB_EVENT *event)
{
const char *__function_name = "add_discovered_host";
DB_RESULT result;
DB_RESULT result2;
DB_ROW row;
DB_ROW row2;
zbx_uint64_t hostid = 0, proxy_hostid, host_proxy_hostid;
char host[MAX_STRING_LEN], *host_esc, *ip_esc, *host_unique, *host_unique_esc;
int port;
zbx_uint64_t groupid;
zabbix_log(LOG_LEVEL_DEBUG, "In %s(eventid:" ZBX_FS_UI64 ")",
__function_name, event->eventid);
result = DBselect(
"select discovery_groupid"
" from config"
" where 1=1"
DB_NODE,
DBnode_local("configid"));
if (NULL != (row = DBfetch(result)))
{
ZBX_STR2UINT64(groupid, row[0]);
}
else
{
zabbix_log(LOG_LEVEL_WARNING, "cannot add discovered host: group for discovered hosts is not defined");
return 0;
}
DBfree_result(result);
switch (event->object)
{
case EVENT_OBJECT_DHOST:
result = DBselect(
"select dr.proxy_hostid,ds.ip"
" from drules dr,dchecks dc,dservices ds"
" where dc.druleid=dr.druleid"
" and ds.dcheckid=dc.dcheckid"
" and ds.dhostid=" ZBX_FS_UI64
" order by ds.dserviceid",
event->objectid);
break;
case EVENT_OBJECT_DSERVICE:
result = DBselect(
"select dr.proxy_hostid,ds.ip"
" from drules dr,dchecks dc,dservices ds,dservices ds1"
" where dc.druleid=dr.druleid"
" and ds.dcheckid=dc.dcheckid"
" and ds1.dhostid=ds.dhostid"
" and ds1.dserviceid=" ZBX_FS_UI64
" order by ds.dserviceid",
event->objectid);
break;
case EVENT_OBJECT_ZABBIX_ACTIVE:
result = DBselect("select proxy_hostid,host from autoreg_host"
" where autoreg_hostid=" ZBX_FS_UI64,
event->objectid);
break;
default:
return 0;
}
if (NULL != (row = DBfetch(result)))
{
ZBX_STR2UINT64(proxy_hostid, row[0]);
if (EVENT_OBJECT_ZABBIX_ACTIVE == event->object)
{
char sql[512];
host_esc = DBdyn_escape_string_len(row[1], HOST_HOST_LEN);
zbx_snprintf(sql, sizeof(sql),
"select hostid,proxy_hostid"
" from hosts"
" where host='%s'"
DB_NODE
" order by hostid",
host_esc,
DBnode_local("hostid"));
result2 = DBselectN(sql, 1);
if (NULL == (row2 = DBfetch(result2)))
{
hostid = DBget_maxid("hosts");
DBexecute("insert into hosts (hostid,proxy_hostid,host,useip,dns)"
" values (" ZBX_FS_UI64 "," ZBX_FS_UI64 ",'%s',0,'%s')",
hostid, proxy_hostid, host_esc, host_esc);
}
else
{
ZBX_STR2UINT64(hostid, row2[0]);
ZBX_STR2UINT64(host_proxy_hostid, row2[1]);
if (host_proxy_hostid != proxy_hostid)
{
DBexecute("update hosts"
" set proxy_hostid=" ZBX_FS_UI64
" where hostid=" ZBX_FS_UI64,
proxy_hostid, hostid);
}
}
DBfree_result(result2);
zbx_free(host_esc);
}
else /* EVENT_OBJECT_DHOST, EVENT_OBJECT_DSERVICE */
{
alarm(CONFIG_TIMEOUT);
zbx_gethost_by_ip(row[1], host, sizeof(host));
alarm(0);
host_esc = DBdyn_escape_string_len(host, HOST_HOST_LEN);
ip_esc = DBdyn_escape_string_len(row[1], HOST_IP_LEN);
port = get_discovered_agent_port(event);
result2 = DBselect(
"select hostid,dns,port,proxy_hostid"
" from hosts"
" where ip='%s'"
DB_NODE,
ip_esc,
DBnode_local("hostid"));
if (NULL == (row2 = DBfetch(result2)))
{
hostid = DBget_maxid("hosts");
/* for host uniqueness purposes */
if ('\0' != *host)
{
/* by host name */
make_hostname(host); /* replace not-allowed characters */
host_unique = DBget_unique_hostname_by_sample(host);
}
else
{
/* by ip */
make_hostname(row[1]); /* replace not-allowed characters */
host_unique = DBget_unique_hostname_by_sample(row[1]);
}
host_unique_esc = DBdyn_escape_string(host_unique);
DBexecute("insert into hosts (hostid,proxy_hostid,host,useip,ip,dns,port)"
" values (" ZBX_FS_UI64 "," ZBX_FS_UI64 ",'%s',1,'%s','%s',%d)",
hostid, proxy_hostid, host_unique_esc, ip_esc, host_esc, port);
zbx_free(host_unique);
zbx_free(host_unique_esc);
}
else
{
ZBX_STR2UINT64(hostid, row2[0]);
ZBX_STR2UINT64(host_proxy_hostid, row2[3]);
if (0 != strcmp(host, row2[1]) || host_proxy_hostid != proxy_hostid)
{
DBexecute("update hosts"
" set dns='%s',proxy_hostid=" ZBX_FS_UI64
" where hostid=" ZBX_FS_UI64,
host_esc, proxy_hostid, hostid);
}
}
DBfree_result(result2);
zbx_free(host_esc);
zbx_free(ip_esc);
}
}
DBfree_result(result);
if (0 != hostid)
add_discovered_host_group(hostid, groupid);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
return hostid;
}
/******************************************************************************
* *
* Function: get_values *
* *
* Purpose: retrieve values of metrics from monitored hosts *
* *
* Parameters: *
* *
* Return value: *
* *
* Author: Alexei Vladishev *
* *
* Comments: always SUCCEED *
* *
******************************************************************************/
static int get_values(int now, int *nextcheck)
{
DB_RESULT result;
DB_RESULT result2;
DB_ROW row;
DB_ROW row2;
int delay;
int res;
DB_ITEM item;
AGENT_RESULT agent;
int stop = 0, items = 0;
static char *unreachable_hosts = NULL;
static int unreachable_hosts_alloc = 32;
int unreachable_hosts_offset = 0;
char istatus[16];
zabbix_log( LOG_LEVEL_DEBUG, "In get_values()");
if (0 != CONFIG_DBSYNCER_FORKS)
DCinit_nextchecks();
now = time(NULL);
*nextcheck = FAIL;
if (NULL == unreachable_hosts)
unreachable_hosts = zbx_malloc(unreachable_hosts, unreachable_hosts_alloc);
*unreachable_hosts = '\0';
if (0 != CONFIG_REFRESH_UNSUPPORTED)
zbx_snprintf(istatus, sizeof(istatus), "%d,%d",
ITEM_STATUS_ACTIVE,
ITEM_STATUS_NOTSUPPORTED);
else
zbx_snprintf(istatus, sizeof(istatus), "%d",
ITEM_STATUS_ACTIVE);
switch (poller_type) {
case ZBX_POLLER_TYPE_UNREACHABLE:
result = DBselect("select h.hostid,min(i.itemid) from hosts h,items i"
" where " ZBX_SQL_MOD(h.hostid,%d) "=%d and i.nextcheck<=%d and i.status in (%d)"
" and i.type in (%d,%d,%d,%d,%d) and h.status=%d and h.disable_until<=%d"
" and h.errors_from!=0 and h.hostid=i.hostid and (h.proxy_hostid=0 or i.type in (%d))"
" and i.key_ not in ('%s','%s','%s','%s') and (h.maintenance_status=%d or h.maintenance_type=%d)"
DB_NODE " group by h.hostid",
CONFIG_UNREACHABLE_POLLER_FORKS,
poller_num-1,
now + POLLER_DELAY,
ITEM_STATUS_ACTIVE,
ITEM_TYPE_ZABBIX, ITEM_TYPE_SNMPv1, ITEM_TYPE_SNMPv2c, ITEM_TYPE_SNMPv3, ITEM_TYPE_IPMI,
HOST_STATUS_MONITORED,
now,
ITEM_TYPE_INTERNAL,
SERVER_STATUS_KEY, SERVER_ICMPPING_KEY, SERVER_ICMPPINGSEC_KEY, SERVER_ZABBIXLOG_KEY,
HOST_MAINTENANCE_STATUS_OFF, MAINTENANCE_TYPE_NORMAL,
DBnode_local("h.hostid"));
break;
case ZBX_POLLER_TYPE_IPMI:
result = DBselect("select %s where i.nextcheck<=%d and i.status in (%s)"
" and i.type in (%d) and h.status=%d and h.disable_until<=%d"
" and h.errors_from=0 and h.hostid=i.hostid and (h.proxy_hostid=0 or i.type in (%d))"
" and " ZBX_SQL_MOD(h.hostid,%d) "=%d and i.key_ not in ('%s','%s','%s','%s')"
" and (h.maintenance_status=%d or h.maintenance_type=%d)" DB_NODE " order by i.nextcheck",
ZBX_SQL_ITEM_SELECT,
now + POLLER_DELAY,
istatus,
ITEM_TYPE_IPMI,
HOST_STATUS_MONITORED,
now,
ITEM_TYPE_INTERNAL,
CONFIG_IPMIPOLLER_FORKS,
poller_num-1,
SERVER_STATUS_KEY, SERVER_ICMPPING_KEY, SERVER_ICMPPINGSEC_KEY, SERVER_ZABBIXLOG_KEY,
HOST_MAINTENANCE_STATUS_OFF, MAINTENANCE_TYPE_NORMAL,
DBnode_local("h.hostid"));
break;
default: /* ZBX_POLLER_TYPE_NORMAL */
result = DBselect("select %s where i.nextcheck<=%d and h.hostid=i.hostid and h.status=%d and i.status in (%s)"
" and ((h.disable_until<=%d and h.errors_from=0 and i.type in (%d,%d,%d,%d)) or i.type in (%d,%d,%d,%d,%d))"
" and (h.proxy_hostid=0 or i.type in (%d))"
" and " ZBX_SQL_MOD(i.itemid,%d) "=%d and i.key_ not in ('%s','%s','%s','%s')"
" and (h.maintenance_status=%d or h.maintenance_type=%d)" DB_NODE " order by i.nextcheck",
ZBX_SQL_ITEM_SELECT,
now + POLLER_DELAY,
HOST_STATUS_MONITORED,
istatus,
now,
ITEM_TYPE_ZABBIX, ITEM_TYPE_SNMPv1, ITEM_TYPE_SNMPv2c, ITEM_TYPE_SNMPv3,
ITEM_TYPE_SIMPLE, ITEM_TYPE_INTERNAL, ITEM_TYPE_AGGREGATE, ITEM_TYPE_EXTERNAL, ITEM_TYPE_DB_MONITOR,
ITEM_TYPE_INTERNAL,
CONFIG_POLLER_FORKS,
poller_num-1,
SERVER_STATUS_KEY, SERVER_ICMPPING_KEY, SERVER_ICMPPINGSEC_KEY, SERVER_ZABBIXLOG_KEY,
HOST_MAINTENANCE_STATUS_OFF, MAINTENANCE_TYPE_NORMAL,
DBnode_local("h.hostid"));
}
/* Do not stop when select is made by poller for unreachable hosts */
while((row=DBfetch(result))&&(stop==0 || poller_type == ZBX_POLLER_TYPE_UNREACHABLE))
{
/* This code is just to avoid compilation warining about use of uninitialized result2 */
result2 = result;
/* */
/* Poller for unreachable hosts */
if(poller_type == ZBX_POLLER_TYPE_UNREACHABLE)
{
result2 = DBselect("select %s where h.hostid=i.hostid and h.proxy_hostid=0 and i.itemid=%s" DB_NODE,
ZBX_SQL_ITEM_SELECT,
row[1],
DBnode_local("h.hostid"));
row2 = DBfetch(result2);
if(!row2)
{
DBfree_result(result2);
continue;
}
DBget_item_from_db(&item,row2);
}
else
{
DBget_item_from_db(&item,row);
/* Skip unreachable hosts but do not break the loop. */
if(uint64_in_list(unreachable_hosts,item.hostid) == SUCCEED)
{
zabbix_log( LOG_LEVEL_DEBUG, "Host " ZBX_FS_UI64 " is unreachable. Skipping [%s]",
item.hostid,item.key);
continue;
}
}
if (item.nextcheck > time(NULL))
{
if (*nextcheck == FAIL || (item.nextcheck != 0 && *nextcheck > item.nextcheck))
*nextcheck = item.nextcheck;
if (poller_type == ZBX_POLLER_TYPE_UNREACHABLE)
DBfree_result(result2);
continue;
}
init_result(&agent);
res = get_value(&item, &agent);
now = time(NULL);
if (res == SUCCEED)
{
if (HOST_AVAILABLE_TRUE != item.host_available)
{
DBbegin();
enable_host(&item, now);
stop = 1;
DBcommit();
}
if (item.host_errors_from != 0)
{
DBbegin();
DBexecute("update hosts set errors_from=0 where hostid=" ZBX_FS_UI64,
item.hostid);
stop = 1;
DBcommit();
}
if (0 == CONFIG_DBSYNCER_FORKS)
DBbegin();
switch (zbx_process) {
case ZBX_PROCESS_SERVER:
process_new_value(&item, &agent, now);
break;
case ZBX_PROCESS_PROXY:
proxy_process_new_value(&item, &agent, now);
break;
}
if (0 == CONFIG_DBSYNCER_FORKS)
DBcommit();
if (0 != CONFIG_DBSYNCER_FORKS)
DCadd_nextcheck(&item, now, 0, NULL);
if (poller_type == ZBX_POLLER_TYPE_NORMAL || poller_type == ZBX_POLLER_TYPE_IPMI)
if (*nextcheck == FAIL || (item.nextcheck != 0 && *nextcheck > item.nextcheck))
*nextcheck = item.nextcheck;
}
else if (res == NOTSUPPORTED || res == AGENT_ERROR)
{
if (item.status != ITEM_STATUS_NOTSUPPORTED)
{
zabbix_log(LOG_LEVEL_WARNING, "Parameter [%s] is not supported by agent on host [%s] Old status [%d]",
item.key,
item.host_name,
item.status);
zabbix_syslog("Parameter [%s] is not supported by agent on host [%s]",
item.key,
item.host_name);
}
if (0 == CONFIG_DBSYNCER_FORKS)
{
DBbegin();
DBupdate_item_status_to_notsupported(&item, now, agent.msg);
DBcommit();
}
else
DCadd_nextcheck(&item, now, 0, agent.msg);
if (poller_type == ZBX_POLLER_TYPE_UNREACHABLE)
if (*nextcheck == FAIL || (item.nextcheck != 0 && *nextcheck > item.nextcheck))
*nextcheck = item.nextcheck;
if (HOST_AVAILABLE_TRUE != item.host_available) {
DBbegin();
enable_host(&item, now);
stop = 1;
DBcommit();
}
}
else if (res == NETWORK_ERROR)
{
DBbegin();
/* First error */
if (item.host_errors_from == 0)
{
zabbix_log( LOG_LEVEL_WARNING, "Host [%s]: first network error, wait for %d seconds",
item.host_name,
CONFIG_UNREACHABLE_DELAY);
zabbix_syslog("Host [%s]: first network error, wait for %d seconds",
item.host_name,
CONFIG_UNREACHABLE_DELAY);
DBexecute("update hosts set errors_from=%d,disable_until=%d where hostid=" ZBX_FS_UI64,
now,
now + CONFIG_UNREACHABLE_DELAY,
item.hostid);
item.host_errors_from = now;
delay = MIN(4*item.delay, 300);
zabbix_log(LOG_LEVEL_WARNING, "Parameter [%s] will be checked after %d seconds on host [%s]",
item.key,
delay,
item.host_name);
DBexecute("update items set nextcheck=%d where itemid=" ZBX_FS_UI64,
now + delay,
item.itemid);
}
else
{
if (now - item.host_errors_from > CONFIG_UNREACHABLE_PERIOD)
{
disable_host(&item, now, agent.msg);
}
else
{
/* Still unavailable, but won't change status to UNAVAILABLE yet */
zabbix_log(LOG_LEVEL_WARNING, "Host [%s]: another network error, wait for %d seconds",
item.host_name,
CONFIG_UNREACHABLE_DELAY);
zabbix_syslog("Host [%s]: another network error, wait for %d seconds",
item.host_name,
CONFIG_UNREACHABLE_DELAY);
DBexecute("update hosts set disable_until=%d where hostid=" ZBX_FS_UI64,
now + CONFIG_UNREACHABLE_DELAY,
item.hostid);
}
}
DBcommit();
zbx_snprintf_alloc(&unreachable_hosts, &unreachable_hosts_alloc, &unreachable_hosts_offset, 32,
"%s" ZBX_FS_UI64,
0 == unreachable_hosts_offset ? "" : ",",
item.hostid);
}
else
{
zabbix_log(LOG_LEVEL_CRIT, "Unknown response code returned.");
assert(0==1);
}
items++;
/* Poller for unreachable hosts */
if (poller_type == ZBX_POLLER_TYPE_UNREACHABLE)
{
/* We cannot freeit earlier because items has references to the structure */
DBfree_result(result2);
}
free_result(&agent);
}
DBfree_result(result);
if (0 != CONFIG_DBSYNCER_FORKS)
DCflush_nextchecks();
zabbix_log(LOG_LEVEL_DEBUG, "End get_values()");
return items;
}
/******************************************************************************
* *
* Function: execute_script *
* *
* Purpose: executing command *
* *
* Parameters: *
* *
* Return value: SUCCEED - processed successfully *
* FAIL - an error occurred *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static int execute_script(zbx_uint64_t scriptid, zbx_uint64_t hostid, char **result)
{
char *p, *command, error[MAX_STRING_LEN];
int ret = FAIL;
DC_HOST host;
#ifdef HAVE_OPENIPMI
DB_RESULT db_result;
DB_ROW db_row;
DC_ITEM item;
int val;
#endif
zabbix_log(LOG_LEVEL_DEBUG, "In execute_script() scriptid:" ZBX_FS_UI64
" hostid:" ZBX_FS_UI64, scriptid, hostid);
if (FAIL == DCget_host_by_hostid(&host, hostid))
{
*result = zbx_dsprintf(*result, "NODE %d: Unknown Host ID [" ZBX_FS_UI64 "]",
CONFIG_NODEID, hostid);
return ret;
}
if (NULL == (command = get_command_by_scriptid(scriptid)))
{
*result = zbx_dsprintf(*result, "NODE %d: Unknown Script ID [" ZBX_FS_UI64 "]",
CONFIG_NODEID, scriptid);
return ret;
}
substitute_simple_macros(NULL, NULL, &host, NULL, NULL,
&command, MACRO_TYPE_SCRIPT, NULL, 0);
zabbix_log(LOG_LEVEL_WARNING, "NODE %d: Executing command: '%s'",
CONFIG_NODEID, command);
p = command;
while (*p == ' ' && *p != '\0')
p++;
#ifdef HAVE_OPENIPMI
if (0 == strncmp(p, "IPMI", 4))
{
db_result = DBselect(
"select hostid,host,useip,ip,dns,port,useipmi,ipmi_ip,ipmi_port,ipmi_authtype,"
"ipmi_privilege,ipmi_username,ipmi_password"
" from hosts"
" where hostid=" ZBX_FS_UI64
DB_NODE,
hostid,
DBnode_local("hostid"));
if (NULL != (db_row = DBfetch(db_result)))
{
memset(&item, 0, sizeof(item));
ZBX_STR2UINT64(item.host.hostid, db_row[0]);
zbx_strlcpy(item.host.host, db_row[1], sizeof(item.host.host));
item.host.useip = (unsigned char)atoi(db_row[2]);
zbx_strlcpy(item.host.ip, db_row[3], sizeof(item.host.ip));
zbx_strlcpy(item.host.dns, db_row[4], sizeof(item.host.dns));
item.host.port = (unsigned short)atoi(db_row[5]);
if (1 == atoi(db_row[6]))
{
zbx_strlcpy(item.host.ipmi_ip_orig, db_row[7], sizeof(item.host.ipmi_ip));
item.host.ipmi_port = (unsigned short)atoi(db_row[8]);
item.host.ipmi_authtype = atoi(db_row[9]);
item.host.ipmi_privilege = atoi(db_row[10]);
zbx_strlcpy(item.host.ipmi_username, db_row[11], sizeof(item.host.ipmi_username));
zbx_strlcpy(item.host.ipmi_password, db_row[12], sizeof(item.host.ipmi_password));
}
if (SUCCEED == (ret = parse_ipmi_command(p, item.ipmi_sensor, &val)))
{
if (SUCCEED == (ret = set_ipmi_control_value(&item, val, error, sizeof(error))))
{
*result = zbx_dsprintf(*result, "NODE %d: IPMI command successfully executed",
CONFIG_NODEID);
}
else
{
*result = zbx_dsprintf(*result, "NODE %d: Cannot execute IPMI command: %s",
CONFIG_NODEID, error);
}
}
else
{
*result = zbx_dsprintf(*result, "NODE %d: Cannot parse IPMI command",
CONFIG_NODEID);
}
}
else
{
*result = zbx_dsprintf(*result, "NODE %d: Unknown Host ID [" ZBX_FS_UI64 "]",
CONFIG_NODEID, hostid);
}
DBfree_result(db_result);
}
else
{
#endif /* HAVE_OPENIPMI */
if (SUCCEED != (ret = zbx_execute(p, result, error, sizeof(error), CONFIG_TRAPPER_TIMEOUT)))
*result = zbx_dsprintf(*result, "NODE %d: Cannot execute command: %s", CONFIG_NODEID, error);
#ifdef HAVE_OPENIPMI
}
#endif
zbx_free(command);
return ret;
}
/******************************************************************************
* *
* Function: process_data *
* *
* Purpose: process new item value *
* *
* Parameters: sockfd - descriptor of agent-server socket connection *
* server - server name *
* key - item's key *
* value - new value of server:key *
* lastlogsize - if key=log[*], last size of log file *
* *
* Return value: SUCCEED - new value processed sucesfully *
* FAIL - otherwise *
* *
* Author: Alexei Vladishev *
* *
* Comments: for trapper server process *
* *
******************************************************************************/
static void process_mass_data(zbx_sock_t *sock, zbx_uint64_t proxy_hostid, AGENT_VALUE *values, int value_num,
int *processed, time_t proxy_timediff)
{
AGENT_RESULT agent;
DB_RESULT result;
DB_ROW row;
DB_ITEM item;
char host_esc[MAX_STRING_LEN], key_esc[MAX_STRING_LEN];
static char *sql = NULL;
static int sql_allocated = 65536;
int sql_offset = 0, i;
zabbix_log(LOG_LEVEL_DEBUG, "In process_mass_data()");
if (NULL == sql)
sql = zbx_malloc(sql, sql_allocated);
DCinit_nextchecks();
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 2048,
"select %s where h.hostid=i.hostid and h.proxy_hostid=" ZBX_FS_UI64
" and h.status=%d and i.status in (%d,%d)",
ZBX_SQL_ITEM_SELECT,
proxy_hostid,
HOST_STATUS_MONITORED,
ITEM_STATUS_ACTIVE, ITEM_STATUS_NOTSUPPORTED);
if (proxy_hostid == 0)
{
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 64,
" and i.type in (%d,%d)",
ITEM_TYPE_TRAPPER,
ITEM_TYPE_ZABBIX_ACTIVE);
}
else
{
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 64,
" and i.type in (%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)",
ITEM_TYPE_ZABBIX,
ITEM_TYPE_SNMPv1,
ITEM_TYPE_TRAPPER,
ITEM_TYPE_SIMPLE,
ITEM_TYPE_SNMPv2c,
ITEM_TYPE_SNMPv3,
ITEM_TYPE_ZABBIX_ACTIVE,
ITEM_TYPE_HTTPTEST,
ITEM_TYPE_EXTERNAL,
ITEM_TYPE_IPMI);
}
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 8, " and (");
for (i = 0; i < value_num; i++)
{
DBescape_string(values[i].host_name, host_esc, sizeof(host_esc));
DBescape_string(values[i].key, key_esc, sizeof(key_esc));
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 512,
"(h.host='%s' and i.key_='%s') or ",
host_esc,
key_esc);
}
sql_offset -= 4;
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 128, ")" DB_NODE,
DBnode_local("h.hostid"));
result = DBselect("%s", sql);
while (NULL != (row = DBfetch(result))) {
DBget_item_from_db(&item, row);
if (item.type == ITEM_TYPE_ZABBIX_ACTIVE && FAIL == zbx_tcp_check_security(sock, item.trapper_hosts, 1))
continue;
if (item.maintenance_status == HOST_MAINTENANCE_STATUS_ON && item.maintenance_type == MAINTENANCE_TYPE_NODATA &&
item.maintenance_from <= values[i].clock)
continue;
for (i = 0; i < value_num; i++)
{
if (0 == strcmp(item.host_name, values[i].host_name) && 0 == strcmp(item.key_orig, values[i].key)) {
/* zabbix_log(LOG_LEVEL_DEBUG, "Processing [%s@%s: \"%s\"]",
item.key,
item.host_name,
values[i].value);*/
if (0 == strcmp(values[i].value, "ZBX_NOTSUPPORTED"))
{
zabbix_log(LOG_LEVEL_WARNING, "Active parameter [%s] is not supported by agent on host [%s]",
item.key_orig,
item.host_name);
zabbix_syslog("Active parameter [%s] is not supported by agent on host [%s]",
item.key_orig,
item.host_name);
DCadd_nextcheck(&item, values[i].clock, proxy_timediff, "Not supported by ZABBIX agent");
if (NULL != processed)
(*processed)++;
}
else
{
if (0 == strncmp(item.key, "log[", 4) || 0 == strncmp(item.key, "eventlog[", 9))
{
item.lastlogsize = values[i].lastlogsize;
item.timestamp = values[i].timestamp;
calc_timestamp(values[i].value, &item.timestamp, item.logtimefmt);
item.eventlog_severity = values[i].severity;
item.eventlog_source = values[i].source;
/* zabbix_log(LOG_LEVEL_DEBUG, "Value [%s] Lastlogsize [%s] Timestamp [%s]",
values[i].value,
item.lastlogsize,
item.timestamp);*/
}
init_result(&agent);
if (SUCCEED == set_result_type(&agent, item.value_type, item.data_type, values[i].value))
{
if (0 == CONFIG_DBSYNCER_FORKS)
DBbegin();
switch (zbx_process) {
case ZBX_PROCESS_SERVER:
process_new_value(&item, &agent, values[i].clock);
break;
case ZBX_PROCESS_PROXY:
proxy_process_new_value(&item, &agent, values[i].clock);
break;
}
if (0 == CONFIG_DBSYNCER_FORKS)
DBcommit();
if (NULL != processed)
(*processed)++;
/* only for screen Administration|Queue */
if (item.type != ITEM_TYPE_TRAPPER && item.type != ITEM_TYPE_HTTPTEST &&
item.value_type != ITEM_VALUE_TYPE_LOG &&
0 != strcmp(item.key, SERVER_STATUS_KEY) &&
0 != strcmp(item.key, SERVER_ICMPPING_KEY) &&
0 != strcmp(item.key, SERVER_ICMPPINGSEC_KEY) &&
0 != strcmp(item.key, SERVER_ZABBIXLOG_KEY))
DCadd_nextcheck(&item, values[i].clock, proxy_timediff, NULL);
}
else
{
if (GET_MSG_RESULT(&agent))
zabbix_log(LOG_LEVEL_WARNING, "Item [%s] error: %s",
zbx_host_key_string_by_item(&item),
agent.msg);
}
free_result(&agent);
}
}
}
}
DBfree_result(result);
DCflush_nextchecks();
}
/******************************************************************************
* *
* Function: aggregate_get_items *
* *
* Purpose: get array of items specified by key for selected groups *
* *
* Parameters: ids - result, list of items *
* groups - list of comma-separated host groups *
* itemkey - item key to aggregate *
* *
******************************************************************************/
static void aggregate_get_items(zbx_uint64_t **ids, int *ids_alloc, int *ids_num, const char *groups,
const char *itemkey)
{
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;
sql = zbx_malloc(sql, sql_alloc);
esc = DBdyn_escape_string(itemkey);
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,
"select i.itemid"
" from items i,hosts_groups hg,hosts h,groups g"
" where hg.groupid=g.groupid"
" and i.hostid=h.hostid"
" and hg.hostid=h.hostid"
" 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]);
uint64_array_add(ids, ids_alloc, ids_num, itemid, 64);
}
DBfree_result(result);
}
/******************************************************************************
* *
* Function: main_alerter_loop *
* *
* Purpose: periodically check table alerts and send notifications if needed *
* *
* Parameters: *
* *
* Return value: *
* *
* Author: Alexei Vladishev *
* *
* Comments: never returns *
* *
******************************************************************************/
int main_alerter_loop()
{
char error[MAX_STRING_LEN], *error_esc;
int res, now;
struct sigaction phan;
DB_RESULT result;
DB_ROW row;
DB_ALERT alert;
DB_MEDIATYPE mediatype;
/* phan.sa_handler = child_signal_handler;*/
phan.sa_sigaction = child_signal_handler;
sigemptyset(&phan.sa_mask);
phan.sa_flags = SA_SIGINFO;
sigaction(SIGALRM, &phan, NULL);
zbx_setproctitle("connecting to the database");
DBconnect(ZBX_DB_CONNECT_NORMAL);
for (;;) {
now = time(NULL);
result = DBselect("select a.alertid,a.mediatypeid,a.sendto,a.subject,a.message,a.status,mt.mediatypeid"
",mt.type,mt.description,mt.smtp_server,mt.smtp_helo,mt.smtp_email,mt.exec_path"
",mt.gsm_modem,mt.username,mt.passwd,a.retries from alerts a,media_type mt"
" where a.status=%d and a.mediatypeid=mt.mediatypeid and a.alerttype=%d" DB_NODE
" order by a.clock",
ALERT_STATUS_NOT_SENT,
ALERT_TYPE_MESSAGE,
DBnode_local("mt.mediatypeid"));
while (NULL != (row = DBfetch(result))) {
res = FAIL;
ZBX_STR2UINT64(alert.alertid, row[0]);
alert.mediatypeid = atoi(row[1]);
alert.sendto = row[2];
alert.subject = row[3];
alert.message = row[4];
alert.status = atoi(row[5]);
ZBX_STR2UINT64(mediatype.mediatypeid, row[6]);
mediatype.type = atoi(row[7]);
mediatype.description = row[8];
mediatype.smtp_server = row[9];
mediatype.smtp_helo = row[10];
mediatype.smtp_email = row[11];
mediatype.exec_path = row[12];
mediatype.gsm_modem = row[13];
mediatype.username = row[14];
mediatype.passwd = row[15];
alert.retries = atoi(row[16]);
*error = '\0';
res = execute_action(&alert, &mediatype, error, sizeof(error));
if (res == SUCCEED)
{
zabbix_log( LOG_LEVEL_DEBUG, "Alert ID [" ZBX_FS_UI64 "] was sent successfully",
alert.alertid);
DBexecute("update alerts set status=%d,error='' where alertid=" ZBX_FS_UI64,
ALERT_STATUS_SENT,
alert.alertid);
}
else
{
zabbix_log( LOG_LEVEL_DEBUG, "Error sending alert ID [" ZBX_FS_UI64 "]",
alert.alertid);
zabbix_syslog("Error sending alert ID [" ZBX_FS_UI64 "]",
alert.alertid);
error_esc = DBdyn_escape_string_len(error, ALERT_ERROR_LEN);
alert.retries++;
if(alert.retries < ALERT_MAX_RETRIES)
{
DBexecute("update alerts set retries=%d,error='%s' where alertid=" ZBX_FS_UI64,
alert.retries,
error_esc,
alert.alertid);
}
else
{
DBexecute("update alerts set status=%d,retries=%d,error='%s' where alertid=" ZBX_FS_UI64,
ALERT_STATUS_FAILED,
alert.retries,
error_esc,
alert.alertid);
}
zbx_free(error_esc);
}
}
DBfree_result(result);
zbx_setproctitle("sender [sleeping for %d seconds]",
CONFIG_SENDER_FREQUENCY);
sleep(CONFIG_SENDER_FREQUENCY);
}
/* Never reached */
DBclose();
}
static void process_escalations(int now)
{
const char *__function_name = "process_escalations";
DB_RESULT result;
DB_ROW row;
DB_ESCALATION escalation, last_escalation;
zbx_vector_uint64_t escalationids;
char *sql = NULL;
size_t sql_alloc = ZBX_KIBIBYTE, sql_offset;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
zbx_vector_uint64_create(&escalationids);
sql = zbx_malloc(sql, sql_alloc);
result = DBselect(
"select escalationid,actionid,triggerid,eventid,r_eventid,esc_step,status,nextcheck"
" from escalations"
" where 1=1"
DB_NODE
" order by actionid,triggerid,escalationid",
DBnode_local("escalationid"));
memset(&escalation, 0, sizeof(escalation));
do
{
memset(&last_escalation, 0, sizeof(last_escalation));
if (NULL != (row = DBfetch(result)))
{
ZBX_STR2UINT64(last_escalation.escalationid, row[0]);
ZBX_STR2UINT64(last_escalation.actionid, row[1]);
ZBX_DBROW2UINT64(last_escalation.triggerid, row[2]);
ZBX_DBROW2UINT64(last_escalation.eventid, row[3]);
ZBX_DBROW2UINT64(last_escalation.r_eventid, row[4]);
last_escalation.esc_step = atoi(row[5]);
last_escalation.status = atoi(row[6]);
last_escalation.nextcheck = atoi(row[7]);
/* just delete on the next cycle */
if (0 != last_escalation.r_eventid)
last_escalation.status = ESCALATION_STATUS_COMPLETED;
}
if (0 != escalation.escalationid)
{
unsigned char esc_superseded = 0;
if (ESCALATION_STATUS_COMPLETED == escalation.status)
{
/* delete a recovery record and skip all processing */
zbx_vector_uint64_append(&escalationids, escalation.escalationid);
goto next;
}
if (0 != last_escalation.escalationid)
{
esc_superseded = (escalation.actionid == last_escalation.actionid &&
escalation.triggerid == last_escalation.triggerid);
if (1 == esc_superseded)
{
if (0 != last_escalation.r_eventid)
{
/* recover this escalation */
escalation.r_eventid = last_escalation.r_eventid;
escalation.status = ESCALATION_STATUS_ACTIVE;
}
else if (escalation.nextcheck > now ||
ESCALATION_STATUS_SLEEP == escalation.status)
{
zbx_vector_uint64_append(&escalationids, escalation.escalationid);
goto next;
}
}
}
if (ESCALATION_STATUS_ACTIVE != escalation.status ||
(escalation.nextcheck > now && 0 == escalation.r_eventid))
{
goto next;
}
DBbegin();
if (escalation.nextcheck <= now)
execute_escalation(&escalation);
/* execute recovery */
if (ESCALATION_STATUS_COMPLETED != escalation.status && 0 != escalation.r_eventid)
{
escalation.status = ESCALATION_STATUS_RECOVERY;
execute_escalation(&escalation);
}
else if (1 == esc_superseded)
escalation.status = ESCALATION_STATUS_COMPLETED;
sql_offset = 0;
if (ESCALATION_STATUS_COMPLETED != escalation.status)
{
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,
"update escalations set status=%d", escalation.status);
if (ESCALATION_STATUS_ACTIVE == escalation.status)
{
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, ",esc_step=%d,nextcheck=%d",
escalation.esc_step, escalation.nextcheck);
}
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,
" where escalationid=" ZBX_FS_UI64, escalation.escalationid);
}
else
{
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,
"delete from escalations where escalationid=" ZBX_FS_UI64,
escalation.escalationid);
}
DBexecute("%s", sql);
DBcommit();
}
next:
if (NULL != row)
memcpy(&escalation, &last_escalation, sizeof(escalation));
}
while (NULL != row);
DBfree_result(result);
zbx_free(sql);
/* delete completed escalations */
if (0 != escalationids.values_num)
{
zbx_vector_uint64_sort(&escalationids, ZBX_DEFAULT_UINT64_COMPARE_FUNC);
DBbegin();
DBexecute_multiple_query("delete from escalations where", "escalationid", &escalationids);
DBcommit();
}
zbx_vector_uint64_destroy(&escalationids);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
static int calcitem_evaluate_expression(DC_ITEM *dc_item, expression_t *exp,
char *error, int max_error_len)
{
const char *__function_name = "calcitem_evaluate_expression";
function_t *f = NULL;
char *sql = NULL, *host_esc, *key_esc,
*buf, replace[16];
int sql_alloc = 1024, sql_offset = 0,
i, ret = SUCCEED;
time_t now;
DB_RESULT db_result;
DB_ROW db_row;
DB_ITEM item;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() expression:'%s'", __function_name, exp->exp);
if (0 == exp->functions_num)
return ret;
for (i = 0; i < exp->functions_num; i++)
{
f = &exp->functions[i];
buf = get_param_dyn(f->params, 1); /* for first parameter result is not NULL */
if (SUCCEED != parse_host_key(buf, &f->host, &f->key))
{
zbx_snprintf(error, max_error_len,
"Invalid first parameter in function [%s(%s)]",
f->func, f->params);
ret = NOTSUPPORTED;
}
zbx_free(buf);
if (SUCCEED != ret)
break;
if (NULL == f->host)
f->host = strdup(dc_item->host.host);
remove_param(f->params, 1);
zabbix_log(LOG_LEVEL_DEBUG, "%s() function:'%s:%s.%s(%s)'",
__function_name, f->host, f->key, f->func, f->params);
}
if (SUCCEED != ret)
return ret;
now = time(NULL);
sql = zbx_malloc(sql, sql_alloc);
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, 512,
"select %s"
" where h.hostid=i.hostid"
" and h.status=%d"
" and i.status=%d"
" and (",
ZBX_SQL_ITEM_SELECT,
HOST_STATUS_MONITORED,
ITEM_STATUS_ACTIVE);
for (i = 0; i < exp->functions_num; i++)
{
f = &exp->functions[i];
if (i != 0)
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, 8, " or ");
host_esc = DBdyn_escape_string(f->host);
key_esc = DBdyn_escape_string(f->key);
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,
32 + strlen(host_esc) + strlen(key_esc),
"(h.host='%s' and i.key_='%s')",
host_esc, key_esc);
zbx_free(key_esc);
zbx_free(host_esc);
}
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, 130,
")" DB_NODE,
DBnode_local("h.hostid"));
db_result = DBselect("%s", sql);
zbx_free(sql);
while (NULL != (db_row = DBfetch(db_result)))
{
DBget_item_from_db(&item, db_row);
for (i = 0; i < exp->functions_num; i++)
{
f = &exp->functions[i];
if (0 != strcmp(f->key, item.key_orig))
continue;
if (0 != strcmp(f->host, item.host_name))
continue;
f->found = 1;
f->value = zbx_malloc(f->value, MAX_BUFFER_LEN);
if (SUCCEED != evaluate_function(f->value, &item, f->func, f->params, now))
{
zbx_snprintf(error, max_error_len, "Cannot evaluate function [%s(%s)]",
f->func, f->params);
ret = NOTSUPPORTED;
break;
}
else
f->value = zbx_realloc(f->value, strlen(f->value) + 1);
}
if (SUCCEED != ret)
break;
}
DBfree_result(db_result);
if (SUCCEED != ret)
return ret;
for (i = 0; i < exp->functions_num; i ++)
{
f = &exp->functions[i];
if (0 == f->found)
{
zbx_snprintf(error, max_error_len,
"Cannot evaluate function [%s(%s)]"
": item [%s:%s] not found",
f->func, f->params, f->host, f->key);
ret = NOTSUPPORTED;
break;
}
zbx_snprintf(replace, sizeof(replace), "{%d}", f->functionid);
buf = string_replace(exp->exp, replace, f->value);
zbx_free(exp->exp);
exp->exp = buf;
}
return ret;
}
static int get_dynamic_hostid(DB_EVENT *event, DC_HOST *host, char *error, size_t max_error_len)
{
const char *__function_name = "get_dynamic_hostid";
DB_RESULT result;
DB_ROW row;
char sql[512];
size_t offset;
int ret = SUCCEED;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
offset = zbx_snprintf(sql, sizeof(sql), "select distinct h.hostid,h.host");
#ifdef HAVE_OPENIPMI
offset += zbx_snprintf(sql + offset, sizeof(sql) - offset,
",h.ipmi_authtype,h.ipmi_privilege,h.ipmi_username,h.ipmi_password");
#endif
switch (event->source)
{
case EVENT_SOURCE_TRIGGERS:
zbx_snprintf(sql + offset, sizeof(sql) - offset,
" from functions f,items i,hosts h"
" where f.itemid=i.itemid"
" and i.hostid=h.hostid"
" and h.status=%d"
" and f.triggerid=" ZBX_FS_UI64,
HOST_STATUS_MONITORED, event->objectid);
break;
case EVENT_SOURCE_DISCOVERY:
offset += zbx_snprintf(sql + offset, sizeof(sql) - offset,
" from hosts h,interface i,dservices ds"
" where h.hostid=i.hostid"
" and i.ip=ds.ip"
" and i.useip=1"
" and h.status=%d",
HOST_STATUS_MONITORED);
switch (event->object)
{
case EVENT_OBJECT_DHOST:
zbx_snprintf(sql + offset, sizeof(sql) - offset,
" and ds.dhostid=" ZBX_FS_UI64
DB_NODE,
event->objectid,
DBnode_local("h.hostid"));
break;
case EVENT_OBJECT_DSERVICE:
zbx_snprintf(sql + offset, sizeof(sql) - offset,
" and ds.dserviceid=" ZBX_FS_UI64
DB_NODE,
event->objectid,
DBnode_local("h.hostid"));
break;
}
break;
case EVENT_SOURCE_AUTO_REGISTRATION:
zbx_snprintf(sql + offset, sizeof(sql) - offset,
" from autoreg_host a,hosts h"
" where " ZBX_SQL_NULLCMP("a.proxy_hostid", "h.proxy_hostid")
" and a.host=h.host"
" and h.status=%d"
" and a.autoreg_hostid=" ZBX_FS_UI64
DB_NODE,
HOST_STATUS_MONITORED, event->objectid,
DBnode_local("h.hostid"));
break;
default:
zbx_snprintf(error, max_error_len, "Unsupported event source [%d]", event->source);
return FAIL;
}
host->hostid = 0;
result = DBselect("%s", sql);
while (NULL != (row = DBfetch(result)))
{
if (0 != host->hostid)
{
switch (event->source)
{
case EVENT_SOURCE_TRIGGERS:
zbx_strlcpy(error, "Too many hosts in a trigger expression", max_error_len);
break;
case EVENT_SOURCE_DISCOVERY:
zbx_strlcpy(error, "Too many hosts with same IP addresses", max_error_len);
break;
}
ret = FAIL;
break;
}
ZBX_STR2UINT64(host->hostid, row[0]);
strscpy(host->host, row[1]);
#ifdef HAVE_OPENIPMI
host->ipmi_authtype = (signed char)atoi(row[2]);
host->ipmi_privilege = (unsigned char)atoi(row[3]);
strscpy(host->ipmi_username, row[4]);
strscpy(host->ipmi_password, row[5]);
#endif
}
DBfree_result(result);
if (FAIL == ret)
{
host->hostid = 0;
*host->host = '\0';
}
else if (0 == host->hostid)
{
*host->host = '\0';
zbx_strlcpy(error, "Cannot find a corresponding host", max_error_len);
ret = FAIL;
}
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* Function: get_hostid_by_host *
* *
* Purpose: check for host name and return hostid *
* *
* Parameters: host - [IN] require size 'HOST_HOST_LEN_MAX' *
* *
* Return value: SUCCEED - host is found *
* FAIL - an error occurred or host not found *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static int get_hostid_by_host(const char *host, const char *ip, unsigned short port, zbx_uint64_t *hostid, char *error)
{
const char *__function_name = "get_hostid_by_host";
char *host_esc, dns[INTERFACE_DNS_LEN_MAX];
DB_RESULT result;
DB_ROW row;
int res = FAIL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() host:'%s'", __function_name, host);
if (FAIL == zbx_check_hostname(host))
{
zbx_snprintf(error, MAX_STRING_LEN, "invalid host name [%s]", host);
goto out;
}
host_esc = DBdyn_escape_string(host);
result = DBselect(
"select hostid,status"
" from hosts"
" where host='%s'"
" and status in (%d,%d)"
" and proxy_hostid is null"
DB_NODE,
host_esc,
HOST_STATUS_MONITORED,
HOST_STATUS_NOT_MONITORED,
DBnode_local("hostid"));
if (NULL != (row = DBfetch(result)))
{
if (HOST_STATUS_MONITORED == atoi(row[1]))
{
ZBX_STR2UINT64(*hostid, row[0]);
res = SUCCEED;
}
else
zbx_snprintf(error, MAX_STRING_LEN, "host [%s] not monitored", host);
}
else
{
zbx_snprintf(error, MAX_STRING_LEN, "host [%s] not found", host);
/* remove ::ffff: prefix from IPv4-mapped IPv6 addresses */
if (0 == strncmp("::ffff:", ip, 7) && SUCCEED == is_ip4(ip + 7))
ip += 7;
alarm(CONFIG_TIMEOUT);
zbx_gethost_by_ip(ip, dns, sizeof(dns));
alarm(0);
DBbegin();
if (0 != (daemon_type & ZBX_DAEMON_TYPE_SERVER))
{
DBregister_host(0, host, ip, dns, port, (int)time(NULL));
}
else if (0 != (daemon_type & ZBX_DAEMON_TYPE_PROXY))
{
DBproxy_register_host(host, ip, dns, port);
}
DBcommit();
}
DBfree_result(result);
zbx_free(host_esc);
out:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(res));
return res;
}
/******************************************************************************
* *
* 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: get_hostid_by_host *
* *
* Purpose: check for host name and return hostid *
* *
* Parameters: host - [IN] require size 'HOST_HOST_LEN_MAX' *
* *
* Return value: SUCCEED - host is found *
* FAIL - an error occurred or host not found *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static int get_hostid_by_host(const char *host, zbx_uint64_t *hostid, char *error)
{
char *host_esc;
DB_RESULT result;
DB_ROW row;
int res = FAIL;
zabbix_log(LOG_LEVEL_DEBUG, "In get_hostid_by_host() host:'%s'", host);
if (FAIL == zbx_check_hostname(host))
{
zbx_snprintf(error, MAX_STRING_LEN, "invalid host name [%s]", host);
return res;
}
host_esc = DBdyn_escape_string(host);
result = DBselect(
"select hostid,status"
" from hosts"
" where host='%s'"
" and status in (%d,%d)"
" and proxy_hostid=0"
DB_NODE,
host_esc,
HOST_STATUS_MONITORED,
HOST_STATUS_NOT_MONITORED,
DBnode_local("hostid"));
if (NULL != (row = DBfetch(result)))
{
if (HOST_STATUS_MONITORED == atoi(row[1]))
{
ZBX_STR2UINT64(*hostid, row[0]);
res = SUCCEED;
}
else
zbx_snprintf(error, MAX_STRING_LEN, "host [%s] not monitored", host);
}
else
{
zbx_snprintf(error, MAX_STRING_LEN, "host [%s] not found", host);
DBbegin();
if (0 != (daemon_type & ZBX_DAEMON_TYPE_SERVER))
{
DBregister_host(0, host, (int)time(NULL));
}
else if (0 != (daemon_type & ZBX_DAEMON_TYPE_PROXY))
{
DBproxy_register_host(host);
}
DBcommit();
}
DBfree_result(result);
zbx_free(host_esc);
return res;
}