static char *get_commandline(struct kinfo_proc *proc)
{
int mib[4], i;
size_t sz;
static char *args = NULL;
static int args_alloc = 128;
if (NULL == args)
args = zbx_malloc(args, args_alloc);
mib[0] = CTL_KERN;
mib[1] = KERN_PROC;
mib[2] = KERN_PROC_ARGS;
mib[3] = proc->ZBX_PROC_PID;
retry:
sz = (size_t)args_alloc;
if (-1 == sysctl(mib, 4, args, &sz, NULL, 0))
{
if (errno == ENOMEM) {
args_alloc *= 2;
args = zbx_realloc(args, args_alloc);
goto retry;
}
return NULL;
}
for (i = 0; i < (int)(sz - 1); i++)
if (args[i] == '\0')
args[i] = ' ';
if (sz == 0)
zbx_strlcpy(args, proc->ZBX_PROC_COMM, args_alloc);
return args;
}
static void delete_ipmi_control(zbx_ipmi_host_t *h, ipmi_control_t *control)
{
int i;
size_t sz;
zabbix_log(LOG_LEVEL_DEBUG, "In delete_ipmi_control()");
for (i = 0; i < h->control_count; i++)
if (h->controls[i].control == control)
{
sz = sizeof(zbx_ipmi_control_t);
zabbix_log(LOG_LEVEL_DEBUG, "Control %s@[%s]:%d deleted",
h->controls[i].c_name, h->ip, h->port);
zbx_free(h->controls[i].c_name);
zbx_free(h->controls[i].val);
h->control_count--;
if (h->control_count != i)
memmove(&h->controls[i], &h->controls[i + 1], sz * (h->control_count - i));
h->controls = zbx_realloc(h->controls, sz * h->control_count);
break;
}
}
static void delete_ipmi_control(zbx_ipmi_host_t *h, ipmi_control_t *control)
{
const char *__function_name = "delete_ipmi_control";
int i;
size_t sz;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() phost:%p pcontrol:%p", __function_name, h, control);
for (i = 0; i < h->control_count; i++)
{
if (h->controls[i].control != control)
continue;
sz = sizeof(zbx_ipmi_control_t);
zabbix_log(LOG_LEVEL_DEBUG, "control '%s@[%s]:%d' deleted",
h->controls[i].c_name, h->ip, h->port);
zbx_free(h->controls[i].c_name);
zbx_free(h->controls[i].val);
h->control_count--;
if (h->control_count != i)
memmove(&h->controls[i], &h->controls[i + 1], sz * (h->control_count - i));
h->controls = zbx_realloc(h->controls, sz * h->control_count);
break;
}
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
static int proc_argv(pid_t pid, char ***argv, size_t *argv_alloc, int *argc)
{
size_t sz;
int mib[4], ret;
if (NULL == *argv) {
*argv_alloc = ARGS_START_SIZE;
*argv = zbx_malloc(*argv, *argv_alloc);
}
mib[0] = CTL_KERN;
mib[1] = KERN_PROC_ARGS;
mib[2] = (int)pid;
mib[3] = KERN_PROC_ARGV;
retry:
sz = *argv_alloc;
if (0 != sysctl(mib, 4, *argv, &sz, NULL, 0))
{
if (errno == ENOMEM)
{
*argv_alloc *= 2;
*argv = zbx_realloc(*argv, *argv_alloc);
goto retry;
}
return FAIL;
}
mib[3] = KERN_PROC_NARGV;
sz = sizeof(int);
if (0 != sysctl(mib, 4, argc, &sz, NULL, 0))
return FAIL;
return SUCCEED;
}
/******************************************************************************
* *
* Function: add_event *
* *
* Purpose: add event to an array *
* *
* Parameters: eventid - [IN] event identificator from database *
* source - [IN] event source (EVENT_SOURCE_*) *
* object - [IN] event object (EVENT_OBJECT_*) *
* objectid - [IN] trigger, item ... identificator from database, *
* depends on source and object *
* timespec - [IN] event time *
* value - [IN] event value (TRIGGER_VALUE_*, *
* TRIGGER_STATE_*, ITEM_STATE_* ... depends on *
* source and object) *
* trigger_description - [IN] trigger description *
* trigger_expression - [IN] trigger short expression *
* trigger_priority - [IN] trigger priority *
* trigger_type - [IN] trigger type (TRIGGER_TYPE_*) *
* *
******************************************************************************/
void add_event(zbx_uint64_t eventid, unsigned char source, unsigned char object, zbx_uint64_t objectid,
const zbx_timespec_t *timespec, int value, const char *trigger_description,
const char *trigger_expression, unsigned char trigger_priority, unsigned char trigger_type)
{
if (events_num == events_alloc)
{
events_alloc += 64;
events = zbx_realloc(events, sizeof(DB_EVENT) * events_alloc);
}
events[events_num].eventid = eventid;
events[events_num].source = source;
events[events_num].object = object;
events[events_num].objectid = objectid;
events[events_num].clock = timespec->sec;
events[events_num].ns = timespec->ns;
events[events_num].value = value;
events[events_num].acknowledged = EVENT_NOT_ACKNOWLEDGED;
if (EVENT_SOURCE_TRIGGERS == source)
{
events[events_num].trigger.triggerid = objectid;
events[events_num].trigger.description = zbx_strdup(NULL, trigger_description);
events[events_num].trigger.expression = zbx_strdup(NULL, trigger_expression);
events[events_num].trigger.priority = trigger_priority;
events[events_num].trigger.type = trigger_type;
}
events_num++;
}
static zbx_ipmi_control_t *allocate_ipmi_control(zbx_ipmi_host_t *h, ipmi_control_t *control)
{
size_t sz;
zbx_ipmi_control_t *c;
char *c_name = NULL;
sz = (size_t)ipmi_control_get_id_length(control);
c_name = zbx_malloc(c_name, sz + 1);
ipmi_control_get_id(control, c_name, sz);
zabbix_log(LOG_LEVEL_DEBUG, "In allocate_ipmi_control() %s@[%s]:%d",
c_name, h->ip, h->port);
h->control_count++;
sz = h->control_count * sizeof(zbx_ipmi_control_t);
if (NULL == h->controls)
h->controls = zbx_malloc(h->controls, sz);
else
h->controls = zbx_realloc(h->controls, sz);
c = &h->controls[h->control_count - 1];
memset(c, 0, sizeof(zbx_ipmi_control_t));
c->control = control;
c->c_name = c_name;
c->num_values = ipmi_control_get_num_vals(control);
sz = sizeof(int) * c->num_values;
c->val = zbx_malloc(c->val, sz);
memset(c->val, 0, sz);
return c;
}
/******************************************************************************
* *
* Function: zbx_load_message_file *
* *
* Purpose: load the specified message file, expanding environment variables *
* in the file name if necessary *
* *
* Parameters: szFileName - [IN] the message file name *
* *
* Return value: Handle to the loaded library or NULL otherwise *
* *
******************************************************************************/
static HINSTANCE zbx_load_message_file(const wchar_t *szFileName)
{
wchar_t *dll_name = NULL;
long int sz, len = 0;
HINSTANCE res = NULL;
if (NULL == szFileName)
return NULL;
do
{
if (0 != (sz = len))
dll_name = zbx_realloc(dll_name, sz * sizeof(wchar_t));
len = ExpandEnvironmentStrings(szFileName, dll_name, sz);
}
while (0 != len && sz < len);
if (0 != len)
res = LoadLibraryEx(dll_name, NULL, LOAD_LIBRARY_AS_DATAFILE);
zbx_free(dll_name);
return res;
}
/******************************************************************************
* *
* Function: proc_read_file *
* *
* Purpose: reads whole file into a buffer in a single read operation *
* *
* Parameters: filename - [IN] the file to read *
* buffer - [IN/OUT] the output buffer *
* buffer_alloc - [IN/OUT] the output buffer size *
* *
* Return value: -1 error occurred during reading *
* 0 empty file (shouldn't happen) *
* >0 the number of bytes read *
* *
* Comments: When reading line by line the file might be changed between *
* reads resulting in a possible information loss. To avoid it *
* try reading/expanding the buffer until it fits the whole file. *
* *
******************************************************************************/
static int proc_read_file(const char *filename, char **buffer, int *buffer_alloc)
{
int n, fd, ret = -1;
size_t offset = 0;
if (-1 == (fd = open(filename, O_RDONLY)))
return -1;
while (0 != (n = read(fd, *buffer + offset, *buffer_alloc - offset)))
{
if (-1 == n)
goto out;
offset += n;
if (offset == *buffer_alloc)
{
*buffer_alloc *= 2;
*buffer = zbx_realloc(*buffer, *buffer_alloc);
}
}
ret = offset;
out:
close(fd);
return ret;
}
static void add_pinger_host(ZBX_FPING_HOST **hosts, int *hosts_alloc, int *hosts_count, char *addr)
{
const char *__function_name = "add_pinger_host";
int i;
size_t sz;
ZBX_FPING_HOST *h;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() addr:'%s'", __function_name, addr);
for (i = 0; i < *hosts_count; i ++)
if (0 == strcmp(addr, (*hosts)[i].addr))
return;
(*hosts_count)++;
if (*hosts_alloc < *hosts_count)
{
*hosts_alloc += 4;
sz = *hosts_alloc * sizeof(ZBX_FPING_HOST);
*hosts = zbx_realloc(*hosts, sz);
}
h = &(*hosts)[*hosts_count - 1];
memset(h, 0, sizeof(ZBX_FPING_HOST));
h->addr = addr;
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
static char *proc_argv(pid_t pid)
{
size_t sz = 0;
int mib[4], ret;
int i, len;
static char *argv = NULL;
static size_t argv_alloc = 0;
mib[0] = CTL_KERN;
mib[1] = KERN_PROC_ARGS;
mib[2] = (int)pid;
mib[3] = KERN_PROC_ARGV;
if (0 != sysctl(mib, 4, NULL, &sz, NULL, 0))
return NULL;
if (argv_alloc < sz)
{
argv_alloc = sz;
if (NULL == argv)
argv = zbx_malloc(argv, argv_alloc);
else
argv = zbx_realloc(argv, argv_alloc);
}
sz = argv_alloc;
if (0 != sysctl(mib, 4, argv, &sz, NULL, 0))
return NULL;
for (i = 0; i < (int)(sz - 1); i++ )
if (argv[i] == '\0')
argv[i] = ' ';
return argv;
}
static void cache_del_snmp_index(DC_ITEM *item, char *oid, char *value)
{
const char *__function_name = "cache_del_snmp_index";
int i;
zbx_snmp_index_t s;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() oid:'%s' value:'%s'", __function_name, oid, value);
if (NULL == snmpidx)
goto end;
s.hostid = item->host.hostid;
s.port = item->interface.port;
s.oid = oid;
s.value = value;
if (snmpidx_count > (i = get_snmpidx_nearestindex(&s)) && 0 == zbx_snmp_index_compare(&s, &snmpidx[i]))
{
zbx_free(snmpidx[i].oid);
zbx_free(snmpidx[i].value);
memmove(&snmpidx[i], &snmpidx[i + 1], sizeof(zbx_snmp_index_t) * (snmpidx_count - i - 1));
snmpidx_count--;
}
if (snmpidx_count == snmpidx_alloc - 16)
{
snmpidx_alloc -= 16;
snmpidx = zbx_realloc(snmpidx, snmpidx_alloc * sizeof(zbx_snmp_index_t));
}
end:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
static void delete_ipmi_sensor(zbx_ipmi_host_t *h, ipmi_sensor_t *sensor)
{
int i;
size_t sz;
zabbix_log(LOG_LEVEL_DEBUG, "In delete_ipmi_sensor()");
for (i = 0; i < h->sensor_count; i++)
if (h->sensors[i].sensor == sensor)
{
sz = sizeof(zbx_ipmi_sensor_t);
zabbix_log(LOG_LEVEL_DEBUG, "Sensor %s@[%s]:%d deleted",
h->sensors[i].s_name, h->ip, h->port);
zbx_free(h->sensors[i].s_name);
h->sensor_count--;
if (h->sensor_count != i)
memmove(&h->sensors[i], &h->sensors[i + 1], sz * (h->sensor_count - i));
h->sensors = zbx_realloc(h->sensors, sz * h->sensor_count);
break;
}
}
/******************************************************************************
* *
* Function: proc_get_process_cmdline *
* *
* Purpose: returns process command line *
* *
* Parameters: pid - [IN] the process identifier *
* cmdline - [OUT] the process command line *
* *
* Return value: SUCCEED *
* FAIL *
* *
* Comments: The command line is allocated by this function and must be freed *
* by the caller. *
* *
******************************************************************************/
static int proc_get_process_cmdline(pid_t pid, char **cmdline)
{
char tmp[MAX_STRING_LEN];
int fd, n;
size_t cmdline_alloc = ZBX_KIBIBYTE, cmdline_offset = 0;
zbx_snprintf(tmp, sizeof(tmp), "/proc/%d/cmdline", (int)pid);
if (-1 == (fd = open(tmp, O_RDONLY)))
return FAIL;
*cmdline = zbx_malloc(NULL, cmdline_alloc);
while (0 < (n = read(fd, *cmdline + cmdline_offset, cmdline_alloc - cmdline_offset)))
{
cmdline_offset += n;
if (cmdline_offset == cmdline_alloc)
{
cmdline_alloc *= 2;
*cmdline = zbx_realloc(*cmdline, cmdline_alloc);
}
}
close(fd);
if (0 == cmdline_offset)
zbx_free(*cmdline);
return SUCCEED;
}
static zbx_ipmi_host_t *allocate_ipmi_host(const char *ip, int port, int authtype, int privilege,
const char *username, const char *password)
{
size_t sz;
zbx_ipmi_host_t *h;
zabbix_log(LOG_LEVEL_DEBUG, "In allocate_ipmi_host([%s]:%d)", ip, port);
host_count++;
sz = host_count * sizeof(zbx_ipmi_host_t);
if (NULL == hosts)
hosts = zbx_malloc(hosts, sz);
else
hosts = zbx_realloc(hosts, sz);
h = &hosts[host_count - 1];
memset(h, 0, sizeof(zbx_ipmi_host_t));
h->ip = strdup(ip);
h->port = port;
h->authtype = authtype;
h->privilege = privilege;
h->username = strdup(username);
h->password = strdup(password);
return h;
}
/******************************************************************************
* *
* Function: __zbx_json_realloc *
* *
* Purpose: *
* *
* Parameters: *
* *
* Return value: - *
* *
* Author: Aleksander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static void __zbx_json_realloc(struct zbx_json *j, size_t need)
{
int realloc = 0;
if (j->buffer == NULL) {
if (need > sizeof(j->buf_stat)) {
j->buffer_allocated = need;
j->buffer = zbx_malloc(j->buffer, j->buffer_allocated);
} else {
j->buffer_allocated = sizeof(j->buf_stat);
j->buffer = j->buf_stat;
}
return;
}
while (need > j->buffer_allocated) {
if (0 == j->buffer_allocated)
j->buffer_allocated = 1024;
else
j->buffer_allocated *= 2;
realloc = 1;
}
if (1 == realloc) {
if (j->buffer == j->buf_stat) {
j->buffer = NULL;
j->buffer = zbx_malloc(j->buffer, j->buffer_allocated);
memcpy(j->buffer, j->buf_stat, sizeof(j->buf_stat));
} else
j->buffer = zbx_realloc(j->buffer, j->buffer_allocated);
}
}
static void delete_ipmi_sensor(zbx_ipmi_host_t *h, ipmi_sensor_t *sensor)
{
const char *__function_name = "delete_ipmi_sensor";
char id_str[2 * IPMI_SENSOR_ID_SZ + 1];
int i;
size_t sz;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() phost:%p psensor:%p",
__function_name, h, sensor);
for (i = 0; i < h->sensor_count; i++)
{
if (h->sensors[i].sensor != sensor)
continue;
sz = sizeof(zbx_ipmi_sensor_t);
zabbix_log(LOG_LEVEL_DEBUG, "sensor '%s@[%s]:%d' deleted",
sensor_id_to_str(id_str, sizeof(id_str), h->sensors[i].id, h->sensors[i].id_type,
h->sensors[i].id_sz), h->ip, h->port);
h->sensor_count--;
if (h->sensor_count != i)
memmove(&h->sensors[i], &h->sensors[i + 1], sz * (h->sensor_count - i));
h->sensors = zbx_realloc(h->sensors, sz * h->sensor_count);
break;
}
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
/******************************************************************************
* *
* Function: quote_key_param *
* *
* Purpose: quotes special symbols in item key parameter *
* *
* Parameters: param - [IN/OUT] item key parameter *
* forced - [IN] 1 - enclose parameter in " even if it does not *
* contain any special characters *
* 0 - do nothing if the paramter does not contain *
* any special characters *
* *
******************************************************************************/
void quote_key_param(char **param, int forced)
{
size_t sz_src, sz_dst;
if (0 == forced)
{
if ('"' != **param && NULL == strchr(*param, ',') && NULL == strchr(*param, ']'))
return;
}
sz_dst = zbx_get_escape_string_len(*param, "\"") + 3;
sz_src = strlen(*param);
*param = zbx_realloc(*param, sz_dst);
(*param)[--sz_dst] = '\0';
(*param)[--sz_dst] = '"';
while (0 < sz_src)
{
(*param)[--sz_dst] = (*param)[--sz_src];
if ('"' == (*param)[sz_src])
(*param)[--sz_dst] = '\\';
}
(*param)[--sz_dst] = '"';
}
/******************************************************************************
* *
* Function: register_module *
* *
* Purpose: Add module to the list of loaded modules (dynamic libraries). *
* It skips a module if it is already registered. *
* *
* Parameters: module - library handler *
* *
* Return value: SUCCEED - if module is successfully registered *
* FAIL - if module is already registered *
* *
******************************************************************************/
static int register_module(void *module)
{
const char *__function_name = "register_module";
int i = 0, ret = FAIL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (NULL == modules)
{
modules = zbx_malloc(modules, sizeof(void *));
modules[0] = NULL;
}
while (NULL != modules[i])
{
if (module == modules[i]) /* a module is already registered */
goto out;
i++;
}
modules = zbx_realloc(modules, (i + 2) * sizeof(void *));
modules[i] = module;
modules[i + 1] = NULL;
ret = SUCCEED;
out:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
static zbx_ipmi_sensor_t *allocate_ipmi_sensor(zbx_ipmi_host_t *h, ipmi_sensor_t *sensor)
{
const char *__function_name = "allocate_ipmi_sensor";
size_t sz;
zbx_ipmi_sensor_t *s;
char *s_name = NULL;
sz = (size_t)ipmi_sensor_get_id_length(sensor);
s_name = zbx_malloc(s_name, sz + 1);
ipmi_sensor_get_id(sensor, s_name, sz);
zabbix_log(LOG_LEVEL_DEBUG, "In %s() sensor:'%s@[%s]:%d'", __function_name, s_name, h->ip, h->port);
h->sensor_count++;
sz = h->sensor_count * sizeof(zbx_ipmi_sensor_t);
if (NULL == h->sensors)
h->sensors = zbx_malloc(h->sensors, sz);
else
h->sensors = zbx_realloc(h->sensors, sz);
s = &h->sensors[h->sensor_count - 1];
memset(s, 0, sizeof(zbx_ipmi_sensor_t));
s->sensor = sensor;
s->s_name = s_name;
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%p", __function_name, s);
return s;
}
int NET_TCP_LISTEN(AGENT_REQUEST *request, AGENT_RESULT *result)
{
MIB_TCPTABLE *pTcpTable = NULL;
DWORD dwSize, dwRetVal;
int i, ret = SYSINFO_RET_FAIL;
unsigned short port;
char *port_str;
if (1 < request->nparam)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters."));
return SYSINFO_RET_FAIL;
}
port_str = get_rparam(request, 0);
if (NULL == port_str || SUCCEED != is_ushort(port_str, &port))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid first parameter."));
return SYSINFO_RET_FAIL;
}
dwSize = sizeof(MIB_TCPTABLE);
pTcpTable = (MIB_TCPTABLE *)zbx_malloc(pTcpTable, dwSize);
/* Make an initial call to GetTcpTable to
get the necessary size into the dwSize variable */
if (ERROR_INSUFFICIENT_BUFFER == (dwRetVal = GetTcpTable(pTcpTable, &dwSize, TRUE)))
pTcpTable = (MIB_TCPTABLE *)zbx_realloc(pTcpTable, dwSize);
/* Make a second call to GetTcpTable to get
the actual data we require */
if (NO_ERROR == (dwRetVal = GetTcpTable(pTcpTable, &dwSize, TRUE)))
{
for (i = 0; i < (int)pTcpTable->dwNumEntries; i++)
{
if (MIB_TCP_STATE_LISTEN == pTcpTable->table[i].dwState &&
port == ntohs((u_short)pTcpTable->table[i].dwLocalPort))
{
SET_UI64_RESULT(result, 1);
break;
}
}
ret = SYSINFO_RET_OK;
}
else
{
zabbix_log(LOG_LEVEL_DEBUG, "GetTcpTable failed with error: %s", strerror_from_system(dwRetVal));
SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain system information: %s",
strerror_from_system(dwRetVal)));
goto clean;
}
if (!ISSET_UI64(result))
SET_UI64_RESULT(result, 0);
clean:
zbx_free(pTcpTable);
return ret;
}
static int get_cmdline(FILE *f_cmd, char **line, size_t *line_offset)
{
size_t line_alloc = ZBX_KIBIBYTE, n;
rewind(f_cmd);
*line = zbx_malloc(*line, line_alloc + 2);
*line_offset = 0;
while (0 != (n = fread(*line + *line_offset, 1, line_alloc - *line_offset, f_cmd)))
{
*line_offset += n;
if (0 != feof(f_cmd))
break;
line_alloc *= 2;
*line = zbx_realloc(*line, line_alloc + 2);
}
if (0 == ferror(f_cmd))
{
if (0 == *line_offset || '\0' != (*line)[*line_offset - 1])
(*line)[(*line_offset)++] = '\0';
if (1 == *line_offset || '\0' != (*line)[*line_offset - 2])
(*line)[(*line_offset)++] = '\0';
return SUCCEED;
}
zbx_free(*line);
return FAIL;
}
/******************************************************************************
* *
* Function: DCadd_nextcheck *
* *
* Purpose: add item nextcheck to the array *
* *
******************************************************************************/
void DCadd_nextcheck(zbx_uint64_t itemid, const zbx_timespec_t *ts, const char *error_msg)
{
const char *__function_name = "DCadd_nextcheck";
int i;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (NULL == error_msg)
return;
i = get_nearestindex(nextchecks, sizeof(ZBX_DC_NEXTCHECK), nextcheck_num, itemid);
if (i < nextcheck_num && nextchecks[i].itemid == itemid) /* an item found */
return;
if (nextcheck_alloc == nextcheck_num)
{
nextcheck_alloc += 64;
nextchecks = zbx_realloc(nextchecks, sizeof(ZBX_DC_NEXTCHECK) * nextcheck_alloc);
}
/* insert a new item */
memmove(&nextchecks[i + 1], &nextchecks[i], sizeof(ZBX_DC_NEXTCHECK) * (nextcheck_num - i));
nextchecks[i].itemid = itemid;
nextchecks[i].ts = *ts;
nextchecks[i].error_msg = zbx_strdup(NULL, error_msg);
nextcheck_num++;
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
int NET_TCP_LISTEN(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
{
MIB_TCPTABLE *pTcpTable = NULL;
DWORD dwSize, dwRetVal;
int i, ret = SYSINFO_RET_FAIL;
unsigned short port;
char tmp[8];
assert(result);
init_result(result);
if (num_param(param) > 1)
return SYSINFO_RET_FAIL;
if (0 != get_param(param, 1, tmp, sizeof(tmp)))
return SYSINFO_RET_FAIL;
if (SUCCEED != is_ushort(tmp, &port))
return SYSINFO_RET_FAIL;
dwSize = sizeof(MIB_TCPTABLE);
pTcpTable = (MIB_TCPTABLE *)zbx_malloc(pTcpTable, dwSize);
/* Make an initial call to GetTcpTable to
get the necessary size into the dwSize variable */
if (ERROR_INSUFFICIENT_BUFFER == (dwRetVal = GetTcpTable(pTcpTable, &dwSize, TRUE)))
pTcpTable = (MIB_TCPTABLE *)zbx_realloc(pTcpTable, dwSize);
/* Make a second call to GetTcpTable to get
the actual data we require */
if (NO_ERROR == (dwRetVal = GetTcpTable(pTcpTable, &dwSize, TRUE)))
{
for (i = 0; i < (int)pTcpTable->dwNumEntries; i++)
{
if (MIB_TCP_STATE_LISTEN == pTcpTable->table[i].dwState &&
port == ntohs((u_short)pTcpTable->table[i].dwLocalPort))
{
SET_UI64_RESULT(result, 1);
break;
}
}
ret = SYSINFO_RET_OK;
}
else
{
zabbix_log(LOG_LEVEL_DEBUG, "GetTcpTable failed with error: %s", strerror_from_system(dwRetVal));
goto clean;
}
if (!ISSET_UI64(result))
SET_UI64_RESULT(result, 0);
clean:
zbx_free(pTcpTable);
return ret;
}
/*
* reallocate string buffer if offset >= alloc
*/
static void calcitem_exp_addchr(char **buffer, int *alloc, int *offset, int step, char c)
{
if (*alloc == *offset)
{
*alloc += step;
*buffer = zbx_realloc(*buffer, *alloc);
}
(*buffer)[(*offset)++] = c;
}
static void add_check(const char *key, const char *key_orig, int refresh, zbx_uint64_t lastlogsize, int mtime)
{
const char *__function_name = "add_check";
int i;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() key:'%s' refresh:%d lastlogsize:" ZBX_FS_UI64 " mtime:%d",
__function_name, key, refresh, lastlogsize, mtime);
for (i = 0; NULL != active_metrics[i].key; i++)
{
if (0 != strcmp(active_metrics[i].key_orig, key_orig))
continue;
if (0 != strcmp(active_metrics[i].key, key))
{
zbx_free(active_metrics[i].key);
active_metrics[i].key = strdup(key);
active_metrics[i].lastlogsize = lastlogsize;
active_metrics[i].mtime = mtime;
}
/* replace metric */
if (active_metrics[i].refresh != refresh)
{
active_metrics[i].nextcheck = 0;
active_metrics[i].refresh = refresh;
}
active_metrics[i].state = ITEM_STATE_NORMAL;
goto out;
}
/* add new metric */
active_metrics[i].key = zbx_strdup(NULL, key);
active_metrics[i].key_orig = zbx_strdup(NULL, key_orig);
active_metrics[i].refresh = refresh;
active_metrics[i].nextcheck = 0;
active_metrics[i].state = ITEM_STATE_NORMAL;
active_metrics[i].lastlogsize = lastlogsize;
active_metrics[i].mtime = mtime;
/* can skip existing log[] and eventlog[] data */
active_metrics[i].skip_old_data = active_metrics[i].lastlogsize ? 0 : 1;
/* move to the last metric */
i++;
/* allocate memory for last metric */
active_metrics = zbx_realloc(active_metrics, (i + 1) * sizeof(ZBX_ACTIVE_METRIC));
/* initialize last metric */
active_metrics[i].key = NULL;
out:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
/******************************************************************************
* *
* Function: DCadd_nextcheck *
* *
* Purpose: add item nextcheck to the array *
* *
* Parameters: *
* *
* Return value: *
* *
* Author: Aleksander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
void DCadd_nextcheck(DB_ITEM *item, time_t now, time_t timediff, const char *error_msg)
{
int i;
size_t sz;
zabbix_log(LOG_LEVEL_DEBUG, "In DCadd_nextcheck()");
if (NULL != error_msg)
{
item->status = ITEM_STATUS_NOTSUPPORTED;
item->nextcheck = now;
}
else
item->nextcheck = calculate_item_nextcheck(item->itemid, item->type, item->delay,
item->delay_flex, now - timediff) + timediff;
sz = sizeof(ZBX_DC_NEXTCHECK);
/* item exists? */
for (i = 0; i < nextcheck_num; i ++)
{
if (nextchecks[i].itemid == item->itemid)
{
if (nextchecks[i].clock < item->nextcheck)
{
/* delete item */
memmove(&nextchecks[i], &nextchecks[i + 1], sz * (nextcheck_num - (i + 1)));
nextcheck_num --;
break;
}
else
return;
}
}
if (nextcheck_allocated == nextcheck_num)
{
nextcheck_allocated *= 2;
nextchecks = zbx_realloc(nextchecks, nextcheck_allocated * sz);
}
i = DCget_nextcheck_nearestindex((NULL != error_msg) ? 0 : item->nextcheck, item->itemid);
/* insert new item */
memmove(&nextchecks[i + 1], &nextchecks[i], sz * (nextcheck_num - i));
nextchecks[i].itemid = item->itemid;
nextchecks[i].clock = item->nextcheck;
nextchecks[i].error_msg = (NULL != error_msg) ? strdup(error_msg) : NULL;
nextcheck_num ++;
}
static void add_regexp_name(char ***regexp, int *regexp_alloc, int *regexp_num, const char *regexp_name)
{
int i;
for (i = 0; i < *regexp_num; i++)
if (0 == strcmp((*regexp)[i], regexp_name))
return;
if (i == *regexp_num) {
if (*regexp_num == *regexp_alloc) {
*regexp_alloc += 32;
*regexp = zbx_realloc(*regexp, sizeof(char *) * *regexp_alloc);
}
(*regexp)[(*regexp_num)++] = strdup(regexp_name);
}
}
static int add_activechk_host(const char *host, unsigned short port)
{
int i;
for (i = 0; i < CONFIG_ACTIVE_FORKS; i++)
{
if (0 == strcmp(CONFIG_ACTIVE_ARGS[i].host, host) && CONFIG_ACTIVE_ARGS[i].port == port)
return FAIL;
}
CONFIG_ACTIVE_FORKS++;
CONFIG_ACTIVE_ARGS = zbx_realloc(CONFIG_ACTIVE_ARGS, sizeof(ZBX_THREAD_ACTIVECHK_ARGS) * CONFIG_ACTIVE_FORKS);
CONFIG_ACTIVE_ARGS[CONFIG_ACTIVE_FORKS - 1].host = zbx_strdup(NULL, host);
CONFIG_ACTIVE_ARGS[CONFIG_ACTIVE_FORKS - 1].port = port;
return SUCCEED;
}
static zbx_ipmi_sensor_t *allocate_ipmi_sensor(zbx_ipmi_host_t *h, ipmi_sensor_t *sensor)
{
const char *__function_name = "allocate_ipmi_sensor";
char id_str[2 * IPMI_SENSOR_ID_SZ + 1];
zbx_ipmi_sensor_t *s;
char id[IPMI_SENSOR_ID_SZ];
enum ipmi_str_type_e id_type;
int id_sz, sz;
char full_name[MAX_STRING_LEN];
id_sz = ipmi_sensor_get_id_length(sensor);
memset(id, 0, sizeof(id));
ipmi_sensor_get_id(sensor, id, sizeof(id));
id_type = ipmi_sensor_get_id_type(sensor);
zabbix_log(LOG_LEVEL_DEBUG, "In %s() sensor:'%s@[%s]:%d'", __function_name,
sensor_id_to_str(id_str, sizeof(id_str), id, id_type, id_sz), h->ip, h->port);
h->sensor_count++;
sz = h->sensor_count * sizeof(zbx_ipmi_sensor_t);
if (NULL == h->sensors)
h->sensors = zbx_malloc(h->sensors, sz);
else
h->sensors = zbx_realloc(h->sensors, sz);
s = &h->sensors[h->sensor_count - 1];
s->sensor = sensor;
memcpy(s->id, id, sizeof(id));
s->id_type = id_type;
s->id_sz = id_sz;
memset(&s->value, 0, sizeof(s->value));
s->reading_type = ipmi_sensor_get_event_reading_type(sensor);
s->type = ipmi_sensor_get_sensor_type(sensor);
ipmi_sensor_get_name(s->sensor, full_name, sizeof(full_name));
zabbix_log(LOG_LEVEL_DEBUG, "Added sensor: host:'%s:%d' id_type:%d id_sz:%d id:'%s'"
" reading_type:0x%x ('%s') type:0x%x ('%s') full_name:'%s'", h->ip, h->port,
s->id_type, s->id_sz, sensor_id_to_str(id_str, sizeof(id_str), s->id, s->id_type, s->id_sz),
s->reading_type, ipmi_sensor_get_event_reading_type_string(s->sensor), s->type,
ipmi_sensor_get_sensor_type_string(s->sensor), full_name);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%p", __function_name, s);
return s;
}
static int web_set_regexp(AGENT_RESULT *result, struct web *opt, const char *params, int param_id)
{
char regexp_tmp[WEB_MAX_REGEXP_STRLEN] = {0};
if (get_param(params, param_id, regexp_tmp, WEB_MAX_REGEXP_STRLEN)) {
SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Invalid REGEXP parameter", NULL));
return FAIL;
}
if (strlen(regexp_tmp)) {
opt->regexp = (char **) zbx_realloc(opt->regexp, (opt->regexp_count + 1) * sizeof(char **));
opt->regexp[opt->regexp_count] = zbx_strdup(NULL, regexp_tmp);
opt->regexp_count++;
}
return SUCCEED;
}
