/******************************************************************************
* *
* Function: register_host *
* *
* Purpose: register host if one does not exist *
* *
* Parameters: host ip address *
* *
* Return value: dhostid or 0 if we didn't add host *
* *
* Author: Alexei Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static void register_host(DB_DHOST *host,DB_DCHECK *check, zbx_uint64_t druleid, char *ip)
{
DB_RESULT result;
DB_ROW row;
char hostname[MAX_STRING_LEN], hostname_esc[MAX_STRING_LEN];
assert(host);
assert(check);
assert(ip);
zabbix_log(LOG_LEVEL_DEBUG, "In register_host(ip:%s)",
ip);
host->dhostid=0;
result = DBselect("select dhostid,druleid,ip,status,lastup,lastdown from dhosts where ip='%s'", ip);
row=DBfetch(result);
if(!row || DBis_null(row[0])==SUCCEED)
{
/* Add host only if service is up */
if(check->status == DOBJECT_STATUS_UP)
{
alarm(CONFIG_TIMEOUT);
zbx_gethost_by_ip(ip, hostname, sizeof(hostname));
alarm(0);
if (hostname[0] != '\0')
DBescape_string(hostname, hostname_esc, sizeof(hostname_esc));
else
hostname_esc[0] = '\0';
zabbix_log(LOG_LEVEL_DEBUG, "New host discovered at %s (%s)",
ip, hostname);
host->dhostid = DBget_maxid("dhosts","dhostid");
DBexecute("insert into dhosts (dhostid, druleid, dns, ip) values (" ZBX_FS_UI64 "," ZBX_FS_UI64 ", '%s','%s')",
host->dhostid,
druleid,
hostname_esc,
ip);
host->druleid = druleid;
strscpy(host->ip,ip);
host->status = 0;
host->lastup = 0;
host->lastdown = 0;
}
}
else
{
zabbix_log(LOG_LEVEL_DEBUG, "Host is already in database");
ZBX_STR2UINT64(host->dhostid,row[0]);
ZBX_STR2UINT64(host->druleid,row[1]);
strscpy(host->ip, row[2]);
host->status = atoi(row[3]);
host->lastup = atoi(row[4]);
host->lastdown = atoi(row[5]);
}
DBfree_result(result);
zabbix_log(LOG_LEVEL_DEBUG, "End register_host()");
}
/******************************************************************************
* *
* 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: update_dservice *
* *
* Purpose: update descovered service details *
* *
* Parameters: *
* *
* Return value: *
* *
* Author: Alexei Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static void update_dservice(DB_DSERVICE *service)
{
char key_esc[MAX_STRING_LEN];
assert(service);
DBescape_string(service->key_, key_esc, sizeof(key_esc)-1);
DBexecute("update dservices set dhostid=" ZBX_FS_UI64 ",type=%d,port=%d,status=%d,lastup=%d,lastdown=%d,key_='%s' where dserviceid=" ZBX_FS_UI64,
service->dhostid,
service->type,
service->port,
service->status,
service->lastup,
service->lastdown,
key_esc,
service->dserviceid);
}
/******************************************************************************
* *
* Function: register_service *
* *
* Purpose: register service if one does not exist *
* *
* Parameters: host ip address *
* *
* Return value: *
* *
* Author: Alexei Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static void register_service(DB_DSERVICE *service,DB_DRULE *rule,DB_DCHECK *check,zbx_uint64_t dhostid,char *ip,int port)
{
DB_RESULT result;
DB_ROW row;
char value_esc[MAX_STRING_LEN];
char key_esc[MAX_STRING_LEN];
assert(service);
assert(rule);
assert(check);
assert(ip);
zabbix_log(LOG_LEVEL_DEBUG, "In register_service(ip:%s,port:%d)",
ip,
port);
DBescape_string(check->key_, key_esc, sizeof(key_esc)-1);
result = DBselect("select dserviceid,dhostid,type,port,status,lastup,lastdown,value,key_ from dservices where dhostid=" ZBX_FS_UI64 " and type=%d and port=%d and key_='%s'",
dhostid,
check->type,
port,
key_esc);
row=DBfetch(result);
if(!row || DBis_null(row[0])==SUCCEED)
{
/* Add host only if service is up */
if(check->status == DOBJECT_STATUS_UP)
{
zabbix_log(LOG_LEVEL_DEBUG, "New service discovered on port %d", port);
service->dserviceid = DBget_maxid("dservices","dserviceid");
service->dhostid = dhostid;
service->type = check->type;
service->port = port;
service->status = DOBJECT_STATUS_UP;
service->lastup = 0;
service->lastdown = 0;
strscpy(service->value, check->value);
strscpy(service->key_, check->key_);
DBescape_string(service->value, value_esc, sizeof(value_esc)-1);
DBescape_string(service->key_, key_esc, sizeof(key_esc)-1);
DBexecute("insert into dservices (dhostid,dserviceid,type,port,status,value,key_) values (" ZBX_FS_UI64 "," ZBX_FS_UI64 ",%d,%d,%d,'%s','%s')",
service->dhostid,
service->dserviceid,
check->type,
service->port,
service->status,
value_esc,
key_esc);
}
}
else
{
zabbix_log(LOG_LEVEL_DEBUG, "Service is already in database");
ZBX_STR2UINT64(service->dserviceid, row[0]);
ZBX_STR2UINT64(service->dhostid, row[1]);
service->type = atoi(row[2]);
service->port = atoi(row[3]);
service->status = atoi(row[4]);
service->lastup = atoi(row[5]);
service->lastdown = atoi(row[6]);
strscpy(service->value,row[7]);
strscpy(service->key_,row[8]);
}
DBfree_result(result);
zabbix_log(LOG_LEVEL_DEBUG, "End register_service()");
}
/******************************************************************************
* *
* 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();
}
