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; }