int SYSTEM_CPU_NUM(AGENT_REQUEST *request, AGENT_RESULT *result) { char *tmp; int online = 0, ncpu; if (1 < request->nparam) return SYSINFO_RET_FAIL; tmp = get_rparam(request, 0); if (NULL == tmp || '\0' == *tmp || 0 == strcmp(tmp, "online")) online = 1; else if (0 != strcmp(tmp, "max")) return SYSINFO_RET_FAIL; if (-1 == (ncpu = get_cpu_num(online))) return SYSINFO_RET_FAIL; SET_UI64_RESULT(result, ncpu); return SYSINFO_RET_OK; }
int SYSTEM_SWAP_OUT(AGENT_REQUEST *request, AGENT_RESULT *result) { int ret; char *tmp, *error; zbx_uint64_t value = 0; if (2 < request->nparam) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters.")); return SYSINFO_RET_FAIL; } tmp = get_rparam(request, 0); if (NULL != tmp && '\0' != *tmp && 0 != strcmp(tmp, "all")) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid first parameter.")); return SYSINFO_RET_FAIL; } tmp = get_rparam(request, 1); if (NULL == tmp || '\0' == *tmp || 0 == strcmp(tmp, "count")) ret = get_swap_io(NULL, NULL, &value, NULL, &error); else if (0 == strcmp(tmp, "pages")) ret = get_swap_io(NULL, NULL, NULL, &value, &error); else { SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid second parameter.")); return SYSINFO_RET_FAIL; } if (SYSINFO_RET_OK == ret) SET_UI64_RESULT(result, value); else SET_MSG_RESULT(result, error); return SYSINFO_RET_OK; }
int KERNEL_MAXPROC(AGENT_REQUEST *request, AGENT_RESULT *result) { #ifdef HAVE_FUNCTION_SYSCTL_KERN_MAXPROC int mib[2]; size_t len; int maxproc; mib[0] = CTL_KERN; mib[1] = KERN_MAXPROC; len = sizeof(maxproc); if (0 != sysctl(mib, 2, &maxproc, &len, NULL, 0)) return SYSINFO_RET_FAIL; SET_UI64_RESULT(result, maxproc); return SYSINFO_RET_OK; #else return SYSINFO_RET_FAIL; #endif }
int NET_IF_COLLISIONS(AGENT_REQUEST *request, AGENT_RESULT *result) { char *if_name, *error; if (1 < request->nparam) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters.")); return SYSINFO_RET_FAIL; } if_name = get_rparam(request, 0); if (SYSINFO_RET_FAIL == get_ifmib_general(if_name, &error)) { SET_MSG_RESULT(result, error); return SYSINFO_RET_FAIL; } SET_UI64_RESULT(result, ifmd.ifmd_data.ifi_collisions); return SYSINFO_RET_OK; }
static int VFS_FS_INODE_FREE(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result) { char mountPoint[MAX_STRING_LEN]; double value = 0; assert(result); init_result(result); if(num_param(param) > 1) return SYSINFO_RET_FAIL; if(get_param(param, 1, mountPoint, MAX_STRING_LEN) != 0) return SYSINFO_RET_FAIL; if(get_fs_inodes_stat(mountPoint, NULL, &value, NULL) != SYSINFO_RET_OK) return SYSINFO_RET_FAIL; SET_UI64_RESULT(result, value); return SYSINFO_RET_OK; }
int SYSTEM_LOCALTIME(AGENT_REQUEST *request, AGENT_RESULT *result) { char *type, buf[32]; long milliseconds; struct tm tm; zbx_timezone_t tz; if (1 < request->nparam) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters.")); return SYSINFO_RET_FAIL; } type = get_rparam(request, 0); if (NULL == type || '\0' == *type || 0 == strcmp(type, "utc")) { SET_UI64_RESULT(result, time(NULL)); } else if (0 == strcmp(type, "local")) { zbx_get_time(&tm, &milliseconds, &tz); zbx_snprintf(buf, sizeof(buf), "%04d-%02d-%02d,%02d:%02d:%02d.%03ld,%01c%02d:%02d", 1900 + tm.tm_year, 1 + tm.tm_mon, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, milliseconds, tz.tz_sign, tz.tz_hour, tz.tz_min); SET_STR_RESULT(result, strdup(buf)); } else { SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid first parameter.")); return SYSINFO_RET_FAIL; } return SYSINFO_RET_OK; }
static int VM_MEMORY_CACHED(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result) { #ifdef HAVE_PROC FILE *f; char *t; char c[MAX_STRING_LEN]; zbx_uint64_t res = 0; if(NULL == (f = fopen("/proc/meminfo","r"))) { return SYSINFO_RET_FAIL; } while(NULL!=fgets(c,MAX_STRING_LEN,f)) { if(strncmp(c,"Cached:",7) == 0) { t=(char *)strtok(c," "); t=(char *)strtok(NULL," "); sscanf(t, ZBX_FS_UI64, &res ); t=(char *)strtok(NULL," "); if(strcasecmp(t,"kb")) res <<= 10; else if(strcasecmp(t, "mb")) res <<= 20; else if(strcasecmp(t, "gb")) res <<= 30; else if(strcasecmp(t, "tb")) res <<= 40; break; } } zbx_fclose(f); SET_UI64_RESULT(result, res); return SYSINFO_RET_OK; #else return SYSINFO_RET_FAIL; #endif }
int SYSTEM_CPU_NUM(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result) { char tmp[16]; int name; long ncpu; if (1 < num_param(param)) return SYSINFO_RET_FAIL; if (0 != get_param(param, 1, tmp, sizeof(tmp)) || '\0' == *tmp || 0 == strcmp(tmp, "online")) name = _SC_NPROCESSORS_ONLN; else if (0 == strcmp(tmp, "max")) name = _SC_NPROCESSORS_CONF; else return SYSINFO_RET_FAIL; if (-1 == (ncpu = sysconf(name))) return SYSINFO_RET_FAIL; SET_UI64_RESULT(result, ncpu); return SYSINFO_RET_OK; }
static int VM_MEMORY_SHARED(AGENT_RESULT *result) { #if defined(HAVE_SYS_VMMETER_VMTOTAL) /* NetBSD 3.1 i386; NetBSD 4.0 i386 */ int mib[] = {CTL_VM, VM_METER}; struct vmtotal v; size_t len; zbx_uint64_t value; len = sizeof(v); if (0 != sysctl(mib, 2, &v, &len, NULL, 0)) return SYSINFO_RET_FAIL; value = (zbx_uint64_t)(v.t_vmshr + v.t_rmshr) * sysconf(_SC_PAGESIZE); SET_UI64_RESULT(result, value); return SYSINFO_RET_OK; #else return SYSINFO_RET_FAIL; #endif /* HAVE_SYS_VMMETER_VMTOTAL */ }
int NET_IF_COLLISIONS(AGENT_REQUEST *request, AGENT_RESULT *result) { char *if_name, *error; net_stat_t ns; if (1 < request->nparam) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters.")); return SYSINFO_RET_FAIL; } if_name = get_rparam(request, 0); if (SYSINFO_RET_FAIL == get_net_stat(if_name, &ns, &error)) { SET_MSG_RESULT(result, error); return SYSINFO_RET_FAIL; } SET_UI64_RESULT(result, ns.colls); return SYSINFO_RET_OK; }
static void update_key_status(zbx_uint64_t hostid, int host_status, time_t now) { const char *__function_name = "update_key_status"; DC_ITEM *items = NULL; int i, num; AGENT_RESULT agent; zabbix_log(LOG_LEVEL_DEBUG, "In %s() hostid:" ZBX_FS_UI64 " status:%d", __function_name, hostid, host_status); num = DCconfig_get_items(hostid, SERVER_STATUS_KEY, &items); for (i = 0; i < num; i++) { init_result(&agent); SET_UI64_RESULT(&agent, host_status); dc_add_history(items[i].itemid, items[i].value_type, &agent, now, 0, NULL, 0, 0, 0, 0); free_result(&agent); } zbx_free(items); }
int SYSTEM_CPU_NUM(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result) { SYSTEM_INFO sysInfo; char mode[128]; assert(result); init_result(result); if(num_param(param) > 1) { return SYSINFO_RET_FAIL; } if(get_param(param, 1, mode, sizeof(mode)) != 0) { mode[0] = '\0'; } if(mode[0] == '\0') { /* default parameter */ zbx_snprintf(mode, sizeof(mode), "online"); } if(0 != strncmp(mode, "online", sizeof(mode))) { return SYSINFO_RET_FAIL; } GetSystemInfo(&sysInfo); SET_UI64_RESULT(result, sysInfo.dwNumberOfProcessors); return SYSINFO_RET_OK; }
int SYSTEM_CPU_NUM(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result) { char mode[128]; int sysinfo_name = -1; long ncpu = 0; if(num_param(param) > 1) { return SYSINFO_RET_FAIL; } if(get_param(param, 1, mode, sizeof(mode)) != 0) { mode[0] = '\0'; } if(mode[0] == '\0') { /* default parameter */ zbx_snprintf(mode, sizeof(mode), "online"); } if(0 == strncmp(mode, "online", sizeof(mode))) { sysinfo_name = _SC_NPROCESSORS_ONLN; } else if(0 == strncmp(mode, "max", sizeof(mode))) { sysinfo_name = _SC_NPROCESSORS_CONF; } if ( -1 == sysinfo_name || (-1 == (ncpu = sysconf(sysinfo_name)) && EINVAL == errno) ) return SYSINFO_RET_FAIL; SET_UI64_RESULT(result, ncpu); return SYSINFO_RET_OK; }
static int vmware_counter_get(const char *stats, const char *instance, zbx_uint64_t counterid, int coeff, AGENT_RESULT *result) { int ret = SYSINFO_RET_FAIL; char xpath[MAX_STRING_LEN], *value; zbx_uint64_t value_ui64; zbx_snprintf(xpath, sizeof(xpath), ZBX_XPATH_LN3("value", "id", "counterId") "[.='" ZBX_FS_UI64 "']/.." ZBX_XPATH_LN("instance") "[.='%s']/../.." ZBX_XPATH_LN("value"), counterid, instance); if (NULL == (value = zbx_xml_read_value(stats, xpath))) return SYSINFO_RET_FAIL; if (SUCCEED == is_uint64(value, &value_ui64)) { SET_UI64_RESULT(result, value_ui64 * coeff); ret = SYSINFO_RET_OK; } zbx_free(value); return ret; }
int SYSTEM_UPTIME(AGENT_REQUEST *request, AGENT_RESULT *result) { #if defined(HAVE_LIBPERFSTAT) perfstat_cpu_total_t ps_cpu_total; if (0 == hertz) { hertz = sysconf(_SC_CLK_TCK); /* make sure we do not divide by 0 */ assert(hertz); } /* AIX 6.1 */ if (-1 == perfstat_cpu_total(NULL, &ps_cpu_total, sizeof(ps_cpu_total), 1)) return SYSINFO_RET_FAIL; SET_UI64_RESULT(result, (zbx_uint64_t)((double)ps_cpu_total.lbolt / hertz)); return SYSINFO_RET_OK; #else return SYSINFO_RET_FAIL; #endif }
static int VM_MEMORY_FREE(AGENT_RESULT *result) { #if defined(HAVE_FUNCTION_SYSCTLBYNAME) /* FreeBSD 6.2 i386; FreeBSD 7.0 i386 */ u_int freepages, pagesize; size_t len; len = sizeof(freepages); if (0 != sysctlbyname("vm.stats.vm.v_free_count", &freepages, &len, NULL, 0)) return SYSINFO_RET_FAIL; len = sizeof(pagesize); if (0 != sysctlbyname("vm.stats.vm.v_page_size", &pagesize, &len, NULL, 0)) return SYSINFO_RET_FAIL; SET_UI64_RESULT(result, (zbx_uint64_t)freepages * pagesize); return SYSINFO_RET_OK; #else return SYSINFO_RET_FAIL; #endif /* HAVE_FUNCTION_SYSCTLBYNAME */ }
static int VM_MEMORY_PROC_MEMINFO(const char *meminfo_entry, AGENT_RESULT *result) { FILE *f; zbx_uint64_t value; int ret = SYSINFO_RET_FAIL; if (NULL == (f = fopen("/proc/meminfo", "r"))) { SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot open /proc/meminfo: %s", zbx_strerror(errno))); return SYSINFO_RET_FAIL; } if (SUCCEED == byte_value_from_proc_file(f, meminfo_entry, NULL, &value)) { SET_UI64_RESULT(result, value); ret = SYSINFO_RET_OK; } else SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain value from /proc/meminfo.")); zbx_fclose(f); return ret; }
int zbx_module_redis_status(AGENT_REQUEST *request, AGENT_RESULT *result) { char *CONFIG_SOURCE_IP = NULL; zbx_sock_t s; char *rs_host, *str_rs_port, *key; unsigned int rs_port; char rs_st_name[MAX_STRING_LEN]; zbx_uint64_t rs_st_value; const char *buf; char *tmp; char *p; int ret = SYSINFO_RET_FAIL; int find = 0; int net_error = 0; if (request->nparam == 3) { rs_host = get_rparam(request, 0); str_rs_port = get_rparam(request, 1); rs_port = atoi(str_rs_port); key = get_rparam(request, 2); } else if (request->nparam == 2) { rs_host = REDIS_DEFAULT_INSTANCE_HOST; str_rs_port = get_rparam(request, 0); rs_port = atoi(str_rs_port); key = get_rparam(request, 1); } else { /* set optional error message */ SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid number of parameters")); return ret; } /* for dev zabbix_log(LOG_LEVEL_INFORMATION, "module [redis], func [zbx_module_redis_status], args:[%s,%d]", rs_host, rs_port); */ if (SUCCEED == zbx_tcp_connect(&s, CONFIG_SOURCE_IP, rs_host, rs_port, 0)) { /* for dev zabbix_log(LOG_LEVEL_INFORMATION, "module [redis], func [zbx_module_redis_status], connect to [%s:%d] successful", rs_host, rs_port); */ if (SUCCEED == zbx_tcp_send_raw(&s, "info\r\nquit\r\n")) { /* for dev zabbix_log(LOG_LEVEL_INFORMATION, "module [redis], func [zbx_module_redis_status], send request successful"); */ while (NULL != (buf = zbx_tcp_recv_line(&s))) { /* for dev zabbix_log(LOG_LEVEL_INFORMATION, "module [redis], func [zbx_module_redis_status], got [%s]", buf); */ if (2 == sscanf(buf, "%[^:]:" ZBX_FS_UI64, rs_st_name, &rs_st_value)) { /* for dev zabbix_log(LOG_LEVEL_INFORMATION, "module [redis], func [zbx_module_redis_status], parse result name :[%s] value:[%d]", rs_st_name, rs_st_value); */ if (0 == strcmp(rs_st_name, key)) { /* for dev zabbix_log(LOG_LEVEL_INFORMATION, "module [redis], func [zbx_module_redis_status], args:[%d,%s] value:[%d]", rs_port, key, rs_st_value); */ find = 1; SET_UI64_RESULT(result, rs_st_value); ret = SYSINFO_RET_OK; break; } } } } else { net_error = 1; zabbix_log(LOG_LEVEL_WARNING, "module [redis], func [zbx_module_redis_status],get redis status error: [%s]", zbx_tcp_strerror()); SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Get redis status error [%s]", zbx_tcp_strerror())); } zbx_tcp_close(&s); } else { net_error = 1; zabbix_log(LOG_LEVEL_WARNING, "module [redis], func [zbx_module_redis_status], connect to redis error: [%s]", zbx_tcp_strerror()); SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Connect to redis error [%s]", zbx_tcp_strerror())); } if (find != 1 && net_error == 0) { zabbix_log(LOG_LEVEL_WARNING, "module [redis], func [zbx_module_redis_status], can't find key: [%s]", key); SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Not supported key [%s]", key)); } return ret; }
int zbx_module_redis_ping(AGENT_REQUEST *request, AGENT_RESULT *result) { char *CONFIG_SOURCE_IP = NULL; zbx_sock_t s; char *rs_host, *str_rs_port; unsigned int rs_port; const char *buf; char rv[MAX_STRING_LEN]; int rs_status = 0; time_t now; char str_time[MAX_STRING_LEN]; char cmd[MAX_STRING_LEN]; char hv[MAX_STRING_LEN]; struct tm *tm = NULL; if (request->nparam == 2) { rs_host = get_rparam(request, 0); str_rs_port = get_rparam(request, 1); rs_port = atoi(str_rs_port); } else if (request->nparam == 1) { rs_host = REDIS_DEFAULT_INSTANCE_HOST; str_rs_port = get_rparam(request, 0); rs_port = atoi(str_rs_port); } else { /* set optional error message */ SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid number of parameters")); return SYSINFO_RET_FAIL; } /* for dev zabbix_log(LOG_LEVEL_INFORMATION, "module [redis], func [zbx_module_redis_ping], args:[%s,%d]", rs_host, rs_port); */ time(&now); tm = localtime(&now); strftime(str_time, MAX_STRING_LEN, "%Y%m%d%H%M%S", tm); /* for dev zabbix_log(LOG_LEVEL_INFORMATION, "module [redis], func [zbx_module_redis_ping], str_time:[%s]", str_time); */ zbx_snprintf(cmd, MAX_STRING_LEN, "set ZBX_PING %s\r\nget ZBX_PING\r\nquit\r\n",str_time); zbx_snprintf(hv, MAX_STRING_LEN, "+OK$%d%s+OK", strlen(str_time), str_time); if (SUCCEED == zbx_tcp_connect(&s, CONFIG_SOURCE_IP, rs_host, rs_port, 0)) { /* for dev zabbix_log(LOG_LEVEL_INFORMATION, "module [redis], func [zbx_module_redis_ping], connect to [%s:%d] successful", rs_host, rs_port); */ if (SUCCEED == zbx_tcp_send_raw(&s, cmd)) { /* for dev zabbix_log(LOG_LEVEL_INFORMATION, "module [redis], func [zbx_module_redis_ping], send request successful"); */ strscpy(rv, ""); while (NULL != (buf = zbx_tcp_recv_line(&s))) { /* for dev zabbix_log(LOG_LEVEL_INFORMATION, "module [redis], func [zbx_module_redis_ping], get [%s]", buf); */ zbx_strlcat(rv, buf, MAX_STRING_LEN); } /* for dev zabbix_log(LOG_LEVEL_INFORMATION, "module [redis], func [zbx_module_redis_ping], all get [%s]", rv); */ if (0 == strcmp(rv, hv)) { /* for dev zabbix_log(LOG_LEVEL_INFORMATION, "module [redis], func [zbx_module_redis_ping], redis instance:[%s:%d] is up", rs_host, rs_port); */ rs_status = 1; } } zbx_tcp_close(&s); } if (rs_status == 1) { SET_UI64_RESULT(result, 1); } else { SET_UI64_RESULT(result, 0); } return SYSINFO_RET_OK; }
int check_service(AGENT_REQUEST *request, const char *default_addr, AGENT_RESULT *result, int perf) { unsigned short port = 0; char *service, *ip_str, ip[MAX_ZBX_DNSNAME_LEN + 1], *port_str; int value_int, ret = SYSINFO_RET_FAIL; double check_time; check_time = zbx_time(); if (3 < request->nparam) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters.")); return SYSINFO_RET_FAIL; } service = get_rparam(request, 0); ip_str = get_rparam(request, 1); port_str = get_rparam(request, 2); if (NULL == service || '\0' == *service) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid first parameter.")); return SYSINFO_RET_FAIL; } if (NULL == ip_str || '\0' == *ip_str) strscpy(ip, default_addr); else strscpy(ip, ip_str); if (NULL != port_str && '\0' != *port_str && SUCCEED != is_ushort(port_str, &port)) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid third parameter.")); return SYSINFO_RET_FAIL; } if (0 == strncmp("net.tcp.service", get_rkey(request), 15)) { if (0 == strcmp(service, "ssh")) { if (NULL == port_str || '\0' == *port_str) port = ZBX_DEFAULT_SSH_PORT; ret = check_ssh(ip, port, CONFIG_TIMEOUT, &value_int); } else if (0 == strcmp(service, "ldap")) { #ifdef HAVE_LDAP if (NULL == port_str || '\0' == *port_str) port = ZBX_DEFAULT_LDAP_PORT; ret = check_ldap(ip, port, CONFIG_TIMEOUT, &value_int); #else SET_MSG_RESULT(result, zbx_strdup(NULL, "Support for LDAP check was not compiled in.")); #endif } else if (0 == strcmp(service, "smtp")) { if (NULL == port_str || '\0' == *port_str) port = ZBX_DEFAULT_SMTP_PORT; ret = tcp_expect(ip, port, CONFIG_TIMEOUT, NULL, validate_smtp, "QUIT\r\n", &value_int); } else if (0 == strcmp(service, "ftp")) { if (NULL == port_str || '\0' == *port_str) port = ZBX_DEFAULT_FTP_PORT; ret = tcp_expect(ip, port, CONFIG_TIMEOUT, NULL, validate_ftp, "QUIT\r\n", &value_int); } else if (0 == strcmp(service, "http")) { if (NULL == port_str || '\0' == *port_str) port = ZBX_DEFAULT_HTTP_PORT; ret = tcp_expect(ip, port, CONFIG_TIMEOUT, NULL, NULL, NULL, &value_int); } else if (0 == strcmp(service, "pop")) { if (NULL == port_str || '\0' == *port_str) port = ZBX_DEFAULT_POP_PORT; ret = tcp_expect(ip, port, CONFIG_TIMEOUT, NULL, validate_pop, "QUIT\r\n", &value_int); } else if (0 == strcmp(service, "nntp")) { if (NULL == port_str || '\0' == *port_str) port = ZBX_DEFAULT_NNTP_PORT; ret = tcp_expect(ip, port, CONFIG_TIMEOUT, NULL, validate_nntp, "QUIT\r\n", &value_int); } else if (0 == strcmp(service, "imap")) { if (NULL == port_str || '\0' == *port_str) port = ZBX_DEFAULT_IMAP_PORT; ret = tcp_expect(ip, port, CONFIG_TIMEOUT, NULL, validate_imap, "a1 LOGOUT\r\n", &value_int); } else if (0 == strcmp(service, "tcp")) { if (NULL == port_str || '\0' == *port_str) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid third parameter.")); return SYSINFO_RET_FAIL; } ret = tcp_expect(ip, port, CONFIG_TIMEOUT, NULL, NULL, NULL, &value_int); } else if (0 == strcmp(service, "https")) { #ifdef HAVE_LIBCURL if (NULL == port_str || '\0' == *port_str) port = ZBX_DEFAULT_HTTPS_PORT; ret = check_https(ip, port, CONFIG_TIMEOUT, &value_int); #else SET_MSG_RESULT(result, zbx_strdup(NULL, "Support for HTTPS check was not compiled in.")); #endif } else if (0 == strcmp(service, "telnet")) { if (NULL == port_str || '\0' == *port_str) port = ZBX_DEFAULT_TELNET_PORT; ret = check_telnet(ip, port, CONFIG_TIMEOUT, &value_int); } else { SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid first parameter.")); return ret; } } else /* net.udp.service */ { if (0 == strcmp(service, "ntp")) { if (NULL == port_str || '\0' == *port_str) port = ZBX_DEFAULT_NTP_PORT; ret = check_ntp(ip, port, CONFIG_TIMEOUT, &value_int); } else { SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid first parameter.")); return ret; } } if (SYSINFO_RET_OK == ret) { if (0 != perf) { if (0 != value_int) { check_time = zbx_time() - check_time; if (ZBX_FLOAT_PRECISION > check_time) check_time = ZBX_FLOAT_PRECISION; SET_DBL_RESULT(result, check_time); } else SET_DBL_RESULT(result, 0.0); } else SET_UI64_RESULT(result, value_int); } return ret; }
int SYSTEM_UPTIME(AGENT_REQUEST *request, AGENT_RESULT *result) { #if defined(HAVE_SYSINFO_UPTIME) struct sysinfo info; if (0 == sysinfo(&info)) { SET_UI64_RESULT(result, info.uptime); return SYSINFO_RET_OK; } else return SYSINFO_RET_FAIL; #elif defined(HAVE_FUNCTION_SYSCTL_KERN_BOOTTIME) int mib[2], now; size_t len; struct timeval uptime; mib[0] = CTL_KERN; mib[1] = KERN_BOOTTIME; len = sizeof(uptime); if (0 != sysctl(mib, 2, &uptime, &len, NULL, 0)) return SYSINFO_RET_FAIL; now = time(NULL); SET_UI64_RESULT(result, now - uptime.tv_sec); return SYSINFO_RET_OK; #elif defined(HAVE_KSTAT_H) /* Solaris */ kstat_ctl_t *kc; kstat_t *kp; kstat_named_t *kn; long hz; long secs; /* open kstat */ kc = kstat_open(); if (0 == kc) return SYSINFO_RET_FAIL; /* read uptime counter */ kp = kstat_lookup(kc, "unix", 0, "system_misc"); if (0 == kp) { kstat_close(kc); return SYSINFO_RET_FAIL; } if (-1 == kstat_read(kc, kp, 0)) { kstat_close(kc); return SYSINFO_RET_FAIL; } kn = (kstat_named_t*)kstat_data_lookup(kp, "clk_intr"); hz = sysconf(_SC_CLK_TCK); /* make sure we do not divide by 0 */ assert(hz); secs = get_kstat_numeric_value(kn) / hz; /* close kstat */ kstat_close(kc); SET_UI64_RESULT(result, secs); return SYSINFO_RET_OK; #else return SYSINFO_RET_FAIL; #endif }
int get_value_ipmi(DC_ITEM *item, AGENT_RESULT *value) { const char *__function_name = "get_value_ipmi"; zbx_ipmi_host_t *h; zbx_ipmi_sensor_t *s; zbx_ipmi_control_t *c = NULL; zabbix_log(LOG_LEVEL_DEBUG, "In %s() key:'%s:%s'", __function_name, item->host.host, item->key_orig); if (NULL == os_hnd) { SET_MSG_RESULT(value, strdup("IPMI handler is not initialised")); return NOTSUPPORTED; } h = init_ipmi_host(item->interface.addr, item->interface.port, item->host.ipmi_authtype, item->host.ipmi_privilege, item->host.ipmi_username, item->host.ipmi_password); if (0 == h->domain_up) { if (NULL != h->err) { SET_MSG_RESULT(value, strdup(h->err)); } return h->ret; } s = get_ipmi_sensor_by_id(h, item->ipmi_sensor); if (NULL == s) c = get_ipmi_control_by_name(h, item->ipmi_sensor); if (NULL == s && NULL == c) { SET_MSG_RESULT(value, zbx_dsprintf(NULL, "sensor or control %s@[%s]:%d does not exist", item->ipmi_sensor, h->ip, h->port)); return NOTSUPPORTED; } if (NULL != s) read_ipmi_sensor(h, s); else read_ipmi_control(h, c); if (h->ret != SUCCEED) { if (NULL != h->err) { SET_MSG_RESULT(value, strdup(h->err)); } return h->ret; } if (NULL != s) { if (IPMI_EVENT_READING_TYPE_THRESHOLD == s->reading_type) SET_DBL_RESULT(value, s->value.threshold); else SET_UI64_RESULT(value, s->value.discrete); } if (NULL != c) SET_DBL_RESULT(value, c->val[0]); zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(h->ret)); return h->ret; }
/****************************************************************************** * * * Function: evaluate_aggregate * * * * Parameters: item - [IN] aggregated item * * grp_func - [IN] one of ZBX_GRP_FUNC_* * * groups - [IN] list of comma-separated host groups * * itemkey - [IN] item key to aggregate * * item_func - [IN] one of ZBX_DB_GET_HIST_* * * param - [IN] item_func parameter (optional) * * * * Return value: SUCCEED - aggregate item evaluated successfully * * FAIL - otherwise * * * ******************************************************************************/ static int evaluate_aggregate(DC_ITEM *item, AGENT_RESULT *res, int grp_func, const char *groups, const char *itemkey, int item_func, const char *param) { const char *__function_name = "evaluate_aggregate"; char *sql = NULL; size_t sql_alloc = 1024, sql_offset = 0; zbx_uint64_t itemid; zbx_vector_uint64_t itemids; DB_RESULT result; DB_ROW row; unsigned char value_type; history_value_t value; int num = 0, ret = FAIL; zabbix_log(LOG_LEVEL_DEBUG, "In %s() grp_func:%d groups:'%s' itemkey:'%s' item_func:%d param:'%s'", __function_name, grp_func, groups, itemkey, item_func, param); memset(&value, 0, sizeof(value)); zbx_vector_uint64_create(&itemids); aggregate_get_items(&itemids, groups, itemkey); if (0 == itemids.values_num) { SET_MSG_RESULT(res, zbx_dsprintf(NULL, "No items for key [%s] in group(s) [%s]", itemkey, groups)); goto clean; } sql = zbx_malloc(sql, sql_alloc); if (ZBX_DB_GET_HIST_VALUE == item_func) { zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "select value_type,lastvalue" " from items" " where lastvalue is not null" " and value_type in (%d,%d)" " and", ITEM_VALUE_TYPE_FLOAT, ITEM_VALUE_TYPE_UINT64); DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "itemid", itemids.values, itemids.values_num); result = DBselect("%s", sql); while (NULL != (row = DBfetch(result))) { value_type = (unsigned char)atoi(row[0]); evaluate_one(item, &value, &num, grp_func, row[1], value_type); } DBfree_result(result); } else { int clock_from; unsigned int period; char **h_value; if (FAIL == is_uint_suffix(param, &period)) { SET_MSG_RESULT(res, zbx_strdup(NULL, "Invalid fourth parameter")); goto clean; } clock_from = time(NULL) - period; zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "select itemid,value_type" " from items" " where value_type in (%d,%d)" " and", ITEM_VALUE_TYPE_FLOAT, ITEM_VALUE_TYPE_UINT64); DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "itemid", itemids.values, itemids.values_num); result = DBselect("%s", sql); while (NULL != (row = DBfetch(result))) { ZBX_STR2UINT64(itemid, row[0]); value_type = (unsigned char)atoi(row[1]); h_value = DBget_history(itemid, value_type, item_func, clock_from, 0, NULL, NULL, 0); if (NULL != h_value[0]) evaluate_one(item, &value, &num, grp_func, h_value[0], value_type); DBfree_history(h_value); } DBfree_result(result); } if (0 == num) { SET_MSG_RESULT(res, zbx_dsprintf(NULL, "No values for key \"%s\" in group(s) \"%s\"", itemkey, groups)); goto clean; } if (ZBX_GRP_FUNC_AVG == grp_func) { switch (item->value_type) { case ITEM_VALUE_TYPE_FLOAT: value.dbl = value.dbl / num; break; case ITEM_VALUE_TYPE_UINT64: value.ui64 = value.ui64 / num; break; default: assert(0); } } if (ITEM_VALUE_TYPE_FLOAT == item->value_type) SET_DBL_RESULT(res, value.dbl); else SET_UI64_RESULT(res, value.ui64); ret = SUCCEED; clean: zbx_vector_uint64_destroy(&itemids); zbx_free(sql); zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret)); return ret; }
static int VM_MEMORY_TOTAL(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result) { #if defined(HAVE_SYS_PSTAT_H) struct pst_static pst; long page; assert(result); init_result(result); if(pstat_getstatic(&pst, sizeof(pst), (size_t)1, 0) == -1) { return SYSINFO_RET_FAIL; } else { /* Get page size */ page = pst.page_size; /* Total physical memory in bytes */ SET_UI64_RESULT(result, (zbx_uint64_t)page*(zbx_uint64_t)pst.physical_memory); return SYSINFO_RET_OK; } #elif defined(HAVE_SYSINFO_TOTALRAM) struct sysinfo info; assert(result); init_result(result); if( 0 == sysinfo(&info)) { #ifdef HAVE_SYSINFO_MEM_UNIT SET_UI64_RESULT(result, (zbx_uint64_t)info.totalram * (zbx_uint64_t)info.mem_unit); #else SET_UI64_RESULT(result, info.totalram); #endif return SYSINFO_RET_OK; } else { return SYSINFO_RET_FAIL; } #elif defined(HAVE_SYS_VMMETER_VMTOTAL) int mib[2],len; struct vmtotal v; assert(result); init_result(result); len=sizeof(struct vmtotal); mib[0]=CTL_VM; mib[1]=VM_METER; sysctl(mib,2,&v,&len,NULL,0); SET_UI64_RESULT(result, v.t_rm<<2); return SYSINFO_RET_OK; #elif defined(HAVE_SYS_SYSCTL_H) static int mib[] = { CTL_HW, HW_PHYSMEM }; size_t len; unsigned int memory; int ret; assert(result); init_result(result); len=sizeof(memory); if(0==sysctl(mib,2,&memory,&len,NULL,0)) { SET_UI64_RESULT(result, memory); ret=SYSINFO_RET_OK; } else { ret=SYSINFO_RET_FAIL; } return ret; #else assert(result); init_result(result); return SYSINFO_RET_FAIL; #endif }
static int VM_MEMORY_FREE(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result) { #if defined(HAVE_SYS_PSTAT_H) struct pst_static pst; struct pst_dynamic dyn; long page; assert(result); init_result(result); if(pstat_getstatic(&pst, sizeof(pst), (size_t)1, 0) == -1) { return SYSINFO_RET_FAIL; } else { /* Get page size */ page = pst.page_size; /* return pst.physical_memory;*/ if (pstat_getdynamic(&dyn, sizeof(dyn), 1, 0) == -1) { return SYSINFO_RET_FAIL; } else { /* cout<<"total virtual memory allocated is " << dyn.psd_vm << " pages, " << dyn.psd_vm * page << " bytes" << endl; cout<<"active virtual memory is " << dyn.psd_avm <<" pages, " << dyn.psd_avm * page << " bytes" << endl; cout<<"total real memory is " << dyn.psd_rm << " pages, " << dyn.psd_rm * page << " bytes" << endl; cout<<"active real memory is " << dyn.psd_arm << " pages, " << dyn.psd_arm * page << " bytes" << endl; cout<<"free memory is " << dyn.psd_free << " pages, " << */ /* Free memory in bytes */ SET_UI64_RESULT(result, (zbx_uint64_t)dyn.psd_free * (zbx_uint64_t)page); return SYSINFO_RET_OK; } } #elif defined(HAVE_SYSINFO_FREERAM) struct sysinfo info; assert(result); init_result(result); if( 0 == sysinfo(&info)) { #ifdef HAVE_SYSINFO_MEM_UNIT SET_UI64_RESULT(result, (zbx_uint64_t)info.freeram * (zbx_uint64_t)info.mem_unit); #else SET_UI64_RESULT(result, info.freeram); #endif return SYSINFO_RET_OK; } else { return SYSINFO_RET_FAIL; } #elif defined(HAVE_SYS_VMMETER_VMTOTAL) int mib[2],len; struct vmtotal v; assert(result); init_result(result); len=sizeof(struct vmtotal); mib[0]=CTL_VM; mib[1]=VM_METER; sysctl(mib,2,&v,&len,NULL,0); SET_UI64_RESULT(result, v.t_free<<2); return SYSINFO_RET_OK; /* OS/X */ #elif defined(HAVE_MACH_HOST_INFO_H) vm_statistics_data_t page_info; vm_size_t pagesize; mach_msg_type_number_t count; kern_return_t kret; int ret; assert(result); init_result(result); pagesize = 0; kret = host_page_size (mach_host_self(), &pagesize); count = HOST_VM_INFO_COUNT; kret = host_statistics (mach_host_self(), HOST_VM_INFO, (host_info_t)&page_info, &count); if (kret == KERN_SUCCESS) { double pw, pa, pi, pf, pu; pw = (double)page_info.wire_count*pagesize; pa = (double)page_info.active_count*pagesize; pi = (double)page_info.inactive_count*pagesize; pf = (double)page_info.free_count*pagesize; pu = pw+pa+pi; SET_UI64_RESULT(result, pf); ret = SYSINFO_RET_OK; } else { ret = SYSINFO_RET_FAIL; } return ret; #else assert(result); init_result(result); return SYSINFO_RET_FAIL; #endif }
int PROFILE (const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result) { /* obtain serial numbers of all disks visible by system */ const char* dev = "/dev/sdd"; char *serial, *serial_res = NULL; DIR* dir; struct dirent* dirent; int len; static char path_buf[1024]; const char* path = "/dev/disk/by-id"; int count = 0; char* res = NULL; /* enumerate all visible block devices */ dir = opendir (path); if (!dir) return SYSINFO_RET_FAIL; while (dirent = readdir (dir)) { if (!strncmp (dirent->d_name, "scsi-", 5) && !strstr (dirent->d_name, "-part")) { snprintf (path_buf, sizeof (path_buf), "%s/%s", path, dirent->d_name); serial = get_hdd_serial (path_buf); if (serial) { count++; if (serial_res) { serial_res = (char*)realloc (serial_res, strlen (serial_res) + 1 + strlen (serial) + 1); strcat (serial_res, " "); strcat (serial_res, serial); free (serial); } else serial_res = serial; } } } closedir (dir); SET_UI64_RESULT(result, count); if (serial_res) { if (res) { res = (char*)realloc (res, strlen (res) + 1 + strlen (serial_res) + 16); strcat (res, "DisksSN: "); strcat (res, serial_res); strcat (res, "\n"); } else { res = (char*)malloc (strlen (serial_res) + 16); snprintf (res, strlen (serial_res) + 16, "DisksSN: %s\n", serial_res); } free (serial_res); } if (res) SET_ERR_RESULT(result, res); return SYSINFO_RET_OK; }
static int vfs_dev_rw(const char *param, AGENT_RESULT *result, int rw) { ZBX_SINGLE_DISKDEVICE_DATA *device; char devname[32], tmp[16]; int type, mode, nparam; zbx_uint64_t dstats[ZBX_DSTAT_MAX]; char *pd; /* pointer to device name without '/dev/' prefix, e.g. 'da0' */ if (3 < (nparam = num_param(param))) /* too many parameters? */ return SYSINFO_RET_FAIL; if (0 != get_param(param, 1, devname, sizeof(devname))) return SYSINFO_RET_FAIL; pd = devname; if ('\0' != *pd) { if (0 == strcmp(pd, "all")) *pd = '\0'; else { /* skip prefix ZBX_DEV_PFX, if present */ if (0 == strncmp(pd, ZBX_DEV_PFX, sizeof(ZBX_DEV_PFX) - 1)) pd += sizeof(ZBX_DEV_PFX) - 1; } } if (0 != get_param(param, 2, tmp, sizeof(tmp))) *tmp = '\0'; if ('\0' == *tmp || 0 == strcmp(tmp, "bps")) /* default parameter */ type = ZBX_DSTAT_TYPE_BPS; else if (0 == strcmp(tmp, "ops")) type = ZBX_DSTAT_TYPE_OPS; else if (0 == strcmp(tmp, "bytes")) type = ZBX_DSTAT_TYPE_BYTE; else if (0 == strcmp(tmp, "operations")) type = ZBX_DSTAT_TYPE_OPER; else return SYSINFO_RET_FAIL; if (type == ZBX_DSTAT_TYPE_BYTE || type == ZBX_DSTAT_TYPE_OPER) { if (nparam > 2) return SYSINFO_RET_FAIL; if (FAIL == get_diskstat(pd, dstats)) return SYSINFO_RET_FAIL; if (ZBX_DSTAT_TYPE_BYTE == type) SET_UI64_RESULT(result, dstats[(ZBX_DEV_READ == rw ? ZBX_DSTAT_R_BYTE : ZBX_DSTAT_W_BYTE)]); else /* ZBX_DSTAT_TYPE_OPER */ SET_UI64_RESULT(result, dstats[(ZBX_DEV_READ == rw ? ZBX_DSTAT_R_OPER : ZBX_DSTAT_W_OPER)]); return SYSINFO_RET_OK; } if (0 != get_param(param, 3, tmp, sizeof(tmp))) *tmp = '\0'; if ('\0' == *tmp || 0 == strcmp(tmp, "avg1")) /* default parameter */ mode = ZBX_AVG1; else if (0 == strcmp(tmp, "avg5")) mode = ZBX_AVG5; else if (0 == strcmp(tmp, "avg15")) mode = ZBX_AVG15; else return SYSINFO_RET_FAIL; if (NULL == collector) { /* CPU statistics collector and (optionally) disk statistics collector is started only when Zabbix */ /* agentd is running as a daemon. When Zabbix agent or agentd is started with "-p" or "-t" parameter */ /* the collectors are not available and keys "vfs.dev.read", "vfs.dev.write" with some parameters */ /* (e.g. sps, ops) are not supported. */ SET_MSG_RESULT(result, strdup("This parameter is available only in daemon mode when collectors are started.")); return SYSINFO_RET_FAIL; } if (NULL == (device = collector_diskdevice_get(pd))) { if (FAIL == get_diskstat(pd, dstats)) /* validate device name */ return SYSINFO_RET_FAIL; if (NULL == (device = collector_diskdevice_add(pd))) return SYSINFO_RET_FAIL; } if (ZBX_DSTAT_TYPE_BPS == type) /* default parameter */ SET_DBL_RESULT(result, (ZBX_DEV_READ == rw ? device->r_bps[mode] : device->w_bps[mode])); else if (ZBX_DSTAT_TYPE_OPS == type) SET_DBL_RESULT(result, (ZBX_DEV_READ == rw ? device->r_ops[mode] : device->w_ops[mode])); return SYSINFO_RET_OK; }
int PROC_NUM(AGENT_REQUEST *request, AGENT_RESULT *result) { char *procname, *proccomm, *param; int zbx_proc_stat, count, i, proc_ok, stat_ok, comm_ok; int proccount = 0; size_t sz; struct passwd *usrinfo; #ifdef KERN_PROC2 int mib[6]; struct kinfo_proc2 *proc = NULL; #else int mib[4]; struct kinfo_proc *proc = NULL; #endif char **argv = NULL, *args = NULL; size_t argv_alloc = 0, args_alloc = 0; int argc; if (4 < request->nparam) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters.")); return SYSINFO_RET_FAIL; } procname = get_rparam(request, 0); param = get_rparam(request, 1); if (NULL != param && '\0' != *param) { errno = 0; if (NULL == (usrinfo = getpwnam(param))) { if (0 == errno) SET_MSG_RESULT(result, zbx_strdup(NULL, "Specified user does not exist.")); else SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain user information: %s", zbx_strerror(errno))); return SYSINFO_RET_FAIL; } } else usrinfo = NULL; param = get_rparam(request, 2); if (NULL == param || '\0' == *param || 0 == strcmp(param, "all")) zbx_proc_stat = ZBX_PROC_STAT_ALL; else if (0 == strcmp(param, "run")) zbx_proc_stat = ZBX_PROC_STAT_RUN; else if (0 == strcmp(param, "sleep")) zbx_proc_stat = ZBX_PROC_STAT_SLEEP; else if (0 == strcmp(param, "zomb")) zbx_proc_stat = ZBX_PROC_STAT_ZOMB; else { SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid third parameter.")); return SYSINFO_RET_FAIL; } proccomm = get_rparam(request, 3); mib[0] = CTL_KERN; if (NULL != usrinfo) { mib[2] = KERN_PROC_UID; mib[3] = usrinfo->pw_uid; } else { mib[2] = KERN_PROC_ALL; mib[3] = 0; } #ifdef KERN_PROC2 mib[1] = KERN_PROC2; mib[4] = sizeof(struct kinfo_proc2); mib[5] = 0; sz = 0; if (0 != sysctl(mib, 6, NULL, &sz, NULL, 0)) { SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain necessary buffer size from system: %s", zbx_strerror(errno))); return SYSINFO_RET_FAIL; } proc = (struct kinfo_proc2 *)zbx_malloc(proc, sz); mib[5] = (int)(sz / sizeof(struct kinfo_proc2)); if (0 != sysctl(mib, 6, proc, &sz, NULL, 0)) { zbx_free(proc); SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain process information: %s", zbx_strerror(errno))); return SYSINFO_RET_FAIL; } count = sz / sizeof(struct kinfo_proc2); #else mib[1] = KERN_PROC; sz = 0; if (0 != sysctl(mib, 4, NULL, &sz, NULL, 0)) { SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain necessary buffer size from system: %s", zbx_strerror(errno))); return SYSINFO_RET_FAIL; } proc = (struct kinfo_proc *)zbx_malloc(proc, sz); if (0 != sysctl(mib, 4, proc, &sz, NULL, 0)) { zbx_free(proc); SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain process information: %s", zbx_strerror(errno))); return SYSINFO_RET_FAIL; } count = sz / sizeof(struct kinfo_proc); #endif for (i = 0; i < count; i++) { proc_ok = 0; stat_ok = 0; comm_ok = 0; if (NULL == procname || '\0' == *procname || 0 == strcmp(procname, proc[i].ZBX_P_COMM)) proc_ok = 1; stat_ok = (zbx_proc_stat == ZBX_PROC_STAT_ALL || (zbx_proc_stat == ZBX_PROC_STAT_RUN && (proc[i].ZBX_P_STAT == SRUN || proc[i].ZBX_P_STAT == SONPROC)) || (zbx_proc_stat == ZBX_PROC_STAT_SLEEP && proc[i].ZBX_P_STAT == SSLEEP) || (zbx_proc_stat == ZBX_PROC_STAT_ZOMB && (proc[i].ZBX_P_STAT == SZOMB || proc[i].ZBX_P_STAT == SDEAD))); if (NULL != proccomm && '\0' != *proccomm) { if (SUCCEED == proc_argv(proc[i].ZBX_P_PID, &argv, &argv_alloc, &argc)) { collect_args(argv, argc, &args, &args_alloc); if (NULL != zbx_regexp_match(args, proccomm, NULL)) comm_ok = 1; } } else comm_ok = 1; if (proc_ok && stat_ok && comm_ok) proccount++; } zbx_free(proc); zbx_free(argv); zbx_free(args); SET_UI64_RESULT(result, proccount); return SYSINFO_RET_OK; }
int PROC_MEM(AGENT_REQUEST *request, AGENT_RESULT *result) { char *procname, *proccomm, *param; int do_task, pagesize, count, i, proc_ok, comm_ok; double value = 0.0, memsize = 0; int proccount = 0; size_t sz; struct passwd *usrinfo; #ifdef KERN_PROC2 int mib[6]; struct kinfo_proc2 *proc = NULL; #else int mib[4]; struct kinfo_proc *proc = NULL; #endif char **argv = NULL, *args = NULL; size_t argv_alloc = 0, args_alloc = 0; int argc; if (4 < request->nparam) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters.")); return SYSINFO_RET_FAIL; } procname = get_rparam(request, 0); param = get_rparam(request, 1); if (NULL != param && '\0' != *param) { errno = 0; if (NULL == (usrinfo = getpwnam(param))) { if (0 == errno) SET_MSG_RESULT(result, zbx_strdup(NULL, "Specified user does not exist.")); else SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain user information: %s", zbx_strerror(errno))); return SYSINFO_RET_FAIL; } } else usrinfo = NULL; param = get_rparam(request, 2); if (NULL == param || '\0' == *param || 0 == strcmp(param, "sum")) do_task = ZBX_DO_SUM; else if (0 == strcmp(param, "avg")) do_task = ZBX_DO_AVG; else if (0 == strcmp(param, "max")) do_task = ZBX_DO_MAX; else if (0 == strcmp(param, "min")) do_task = ZBX_DO_MIN; else { SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid third parameter.")); return SYSINFO_RET_FAIL; } proccomm = get_rparam(request, 3); pagesize = getpagesize(); mib[0] = CTL_KERN; if (NULL != usrinfo) { mib[2] = KERN_PROC_UID; mib[3] = usrinfo->pw_uid; } else { mib[2] = KERN_PROC_ALL; mib[3] = 0; } #ifdef KERN_PROC2 mib[1] = KERN_PROC2; mib[4] = sizeof(struct kinfo_proc2); mib[5] = 0; sz = 0; if (0 != sysctl(mib, 6, NULL, &sz, NULL, 0)) { SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain necessary buffer size from system: %s", zbx_strerror(errno))); return SYSINFO_RET_FAIL; } proc = (struct kinfo_proc2 *)zbx_malloc(proc, sz); mib[5] = (int)(sz / sizeof(struct kinfo_proc2)); if (0 != sysctl(mib, 6, proc, &sz, NULL, 0)) { zbx_free(proc); SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain process information: %s", zbx_strerror(errno))); return SYSINFO_RET_FAIL; } count = sz / sizeof(struct kinfo_proc2); #else mib[1] = KERN_PROC; sz = 0; if (0 != sysctl(mib, 4, NULL, &sz, NULL, 0)) { SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain necessary buffer size from system: %s", zbx_strerror(errno))); return SYSINFO_RET_FAIL; } proc = (struct kinfo_proc *)zbx_malloc(proc, sz); if (0 != sysctl(mib, 4, proc, &sz, NULL, 0)) { zbx_free(proc); SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain process information: %s", zbx_strerror(errno))); return SYSINFO_RET_FAIL; } count = sz / sizeof(struct kinfo_proc); #endif for (i = 0; i < count; i++) { proc_ok = 0; comm_ok = 0; if (NULL == procname || '\0' == *procname || 0 == strcmp(procname, proc[i].ZBX_P_COMM)) proc_ok = 1; if (NULL != proccomm && '\0' != *proccomm) { if (SUCCEED == proc_argv(proc[i].ZBX_P_PID, &argv, &argv_alloc, &argc)) { collect_args(argv, argc, &args, &args_alloc); if (NULL != zbx_regexp_match(args, proccomm, NULL)) comm_ok = 1; } } else comm_ok = 1; if (proc_ok && comm_ok) { value = proc[i].ZBX_P_VM_TSIZE + proc[i].ZBX_P_VM_DSIZE + proc[i].ZBX_P_VM_SSIZE; value *= pagesize; if (0 == proccount++) memsize = value; else { if (ZBX_DO_MAX == do_task) memsize = MAX(memsize, value); else if (ZBX_DO_MIN == do_task) memsize = MIN(memsize, value); else memsize += value; } } } zbx_free(proc); zbx_free(argv); zbx_free(args); if (ZBX_DO_AVG == do_task) SET_DBL_RESULT(result, proccount == 0 ? 0 : memsize/proccount); else SET_UI64_RESULT(result, memsize); return SYSINFO_RET_OK; }
/*int get_value_snmp(double *result,char *result_str,DB_ITEM *item,char *error, int max_error_len)*/ int get_value_snmp(DB_ITEM *item, AGENT_RESULT *value) { #define NEW_APPROACH struct snmp_session session, *ss; struct snmp_pdu *pdu; struct snmp_pdu *response; #ifdef NEW_APPROACH char temp[MAX_STRING_LEN]; #endif oid anOID[MAX_OID_LEN]; size_t anOID_len = MAX_OID_LEN; struct variable_list *vars; int status; char *p, *c; double dbl; unsigned char *ip; char error[MAX_STRING_LEN]; int ret=SUCCEED; zabbix_log( LOG_LEVEL_DEBUG, "In get_value_SNMP()"); init_result(value); /* assert((item->type == ITEM_TYPE_SNMPv1)||(item->type == ITEM_TYPE_SNMPv2c)); */ assert((item->type == ITEM_TYPE_SNMPv1)||(item->type == ITEM_TYPE_SNMPv2c)||(item->type == ITEM_TYPE_SNMPv3)); snmp_sess_init( &session ); /* session.version = version;*/ if(item->type == ITEM_TYPE_SNMPv1) { session.version = SNMP_VERSION_1; } else if(item->type == ITEM_TYPE_SNMPv2c) { session.version = SNMP_VERSION_2c; } else if(item->type == ITEM_TYPE_SNMPv3) { session.version = SNMP_VERSION_3; } else { zbx_snprintf(error,sizeof(error),"Error in get_value_SNMP. Wrong item type [%d]. Must be SNMP.", item->type); zabbix_log( LOG_LEVEL_ERR, "%s", error); SET_MSG_RESULT(value, strdup(error)); return NOTSUPPORTED; } if(item->useip == 1) { #ifdef NEW_APPROACH zbx_snprintf(temp,sizeof(temp),"%s:%d", item->host_ip, item->snmp_port); session.peername = temp; session.remote_port = item->snmp_port; #else session.peername = item->host_ip; session.remote_port = item->snmp_port; #endif } else { #ifdef NEW_APPROACH zbx_snprintf(temp, sizeof(temp), "%s:%d", item->host_dns, item->snmp_port); session.peername = temp; session.remote_port = item->snmp_port; #else session.peername = item->host_dns; session.remote_port = item->snmp_port; #endif } if( (session.version == SNMP_VERSION_1) || (item->type == ITEM_TYPE_SNMPv2c)) { session.community = (u_char *)item->snmp_community; session.community_len = strlen((void *)session.community); zabbix_log( LOG_LEVEL_DEBUG, "SNMP [%s@%s:%d]", session.community, session.peername, session.remote_port); } else if(session.version == SNMP_VERSION_3) { /* set the SNMPv3 user name */ session.securityName = item->snmpv3_securityname; session.securityNameLen = strlen(session.securityName); /* set the security level to authenticated, but not encrypted */ if(item->snmpv3_securitylevel == ITEM_SNMPV3_SECURITYLEVEL_NOAUTHNOPRIV) { session.securityLevel = SNMP_SEC_LEVEL_NOAUTH; } else if(item->snmpv3_securitylevel == ITEM_SNMPV3_SECURITYLEVEL_AUTHNOPRIV) { session.securityLevel = SNMP_SEC_LEVEL_AUTHNOPRIV; /* set the authentication method to MD5 */ session.securityAuthProto = usmHMACMD5AuthProtocol; session.securityAuthProtoLen = USM_AUTH_PROTO_MD5_LEN; session.securityAuthKeyLen = USM_AUTH_KU_LEN; if (generate_Ku(session.securityAuthProto, session.securityAuthProtoLen, (u_char *) item->snmpv3_authpassphrase, strlen(item->snmpv3_authpassphrase), session.securityAuthKey, &session.securityAuthKeyLen) != SNMPERR_SUCCESS) { zbx_snprintf(error,sizeof(error),"Error generating Ku from authentication pass phrase."); zabbix_log( LOG_LEVEL_ERR, "%s", error); SET_MSG_RESULT(value, strdup(error)); return NOTSUPPORTED; } } else if(item->snmpv3_securitylevel == ITEM_SNMPV3_SECURITYLEVEL_AUTHPRIV) { session.securityLevel = SNMP_SEC_LEVEL_AUTHPRIV; /* set the authentication method to MD5 */ session.securityAuthProto = usmHMACMD5AuthProtocol; session.securityAuthProtoLen = USM_AUTH_PROTO_MD5_LEN; session.securityAuthKeyLen = USM_AUTH_KU_LEN; if (generate_Ku(session.securityAuthProto, session.securityAuthProtoLen, (u_char *) item->snmpv3_authpassphrase, strlen(item->snmpv3_authpassphrase), session.securityAuthKey, &session.securityAuthKeyLen) != SNMPERR_SUCCESS) { zbx_snprintf(error,sizeof(error),"Error generating Ku from authentication pass phrase."); zabbix_log( LOG_LEVEL_ERR, "%s", error); SET_MSG_RESULT(value, strdup(error)); return NOTSUPPORTED; } /* set the private method to DES */ session.securityPrivProto = usmDESPrivProtocol; session.securityPrivProtoLen = USM_PRIV_PROTO_DES_LEN; session.securityPrivKeyLen = USM_PRIV_KU_LEN; if (generate_Ku(session.securityAuthProto, session.securityAuthProtoLen, (u_char *) item->snmpv3_privpassphrase, strlen(item->snmpv3_privpassphrase), session.securityPrivKey, &session.securityPrivKeyLen) != SNMPERR_SUCCESS) { zbx_snprintf(error,sizeof(error),"Error generating Ku from priv pass phrase."); zabbix_log( LOG_LEVEL_ERR, "%s", error); SET_MSG_RESULT(value, strdup(error)); return NOTSUPPORTED; } } zabbix_log( LOG_LEVEL_DEBUG, "SNMPv3 [%s@%s:%d]", session.securityName, session.peername, session.remote_port); } else { zbx_snprintf(error,sizeof(error),"Error in get_value_SNMP. Unsupported session.version [%d]", (int)session.version); zabbix_log( LOG_LEVEL_ERR, "%s", error); SET_MSG_RESULT(value, strdup(error)); return NOTSUPPORTED; } zabbix_log( LOG_LEVEL_DEBUG, "OID [%s]", item->snmp_oid); SOCK_STARTUP; ss = snmp_open(&session); if(ss == NULL) { SOCK_CLEANUP; zbx_snprintf(error,sizeof(error),"Error doing snmp_open()"); zabbix_log( LOG_LEVEL_ERR, "%s", error); SET_MSG_RESULT(value, strdup(error)); return NOTSUPPORTED; } zabbix_log( LOG_LEVEL_DEBUG, "In get_value_SNMP() 0.2"); pdu = snmp_pdu_create(SNMP_MSG_GET); /* Changed to snmp_parse_oid */ /* read_objid(item->snmp_oid, anOID, &anOID_len);*/ snmp_parse_oid(item->snmp_oid, anOID, &anOID_len); #if OTHER_METHODS get_node("sysDescr.0", anOID, &anOID_len); read_objid(".1.3.6.1.2.1.1.1.0", anOID, &anOID_len); read_objid("system.sysDescr.0", anOID, &anOID_len); #endif snmp_add_null_var(pdu, anOID, anOID_len); zabbix_log( LOG_LEVEL_DEBUG, "In get_value_SNMP() 0.3"); status = snmp_synch_response(ss, pdu, &response); zabbix_log( LOG_LEVEL_DEBUG, "Status send [%d]", status); zabbix_log( LOG_LEVEL_DEBUG, "In get_value_SNMP() 0.4"); zabbix_log( LOG_LEVEL_DEBUG, "In get_value_SNMP() 1"); if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) { zabbix_log( LOG_LEVEL_DEBUG, "In get_value_SNMP() 2"); /* for(vars = response->variables; vars; vars = vars->next_variable) { print_variable(vars->name, vars->name_length, vars); }*/ for(vars = response->variables; vars; vars = vars->next_variable) { int count=1; zabbix_log( LOG_LEVEL_DEBUG, "AV loop(%d)", vars->type); /* if( (vars->type == ASN_INTEGER) ||*/ if( (vars->type == ASN_UINTEGER)|| (vars->type == ASN_COUNTER) || #ifdef OPAQUE_SPECIAL_TYPES (vars->type == ASN_UNSIGNED64) || #endif (vars->type == ASN_TIMETICKS) || (vars->type == ASN_GAUGE) ) { /* *result=(long)*vars->val.integer;*/ /* * This solves situation when large numbers are stored as negative values * http://sourceforge.net/tracker/index.php?func=detail&aid=700145&group_id=23494&atid=378683 */ /*zbx_snprintf(result_str,sizeof(result_str),"%ld",(long)*vars->val.integer);*/ /* zbx_snprintf(result_str,sizeof(result_str),"%lu",(long)*vars->val.integer);*/ /* Not correct. Returns huge values. */ /* SET_UI64_RESULT(value, (zbx_uint64_t)*vars->val.integer);*/ if (vars->type == ASN_GAUGE && *vars->val.integer >= 4294967294) { SET_UI64_RESULT(value, (unsigned long)0); } else { SET_UI64_RESULT(value, (unsigned long)*vars->val.integer); } zabbix_log( LOG_LEVEL_DEBUG, "OID [%s] Type [%d] UI64[" ZBX_FS_UI64 "]", item->snmp_oid, vars->type, (zbx_uint64_t)*vars->val.integer); zabbix_log( LOG_LEVEL_DEBUG, "OID [%s] Type [%d] ULONG[%lu]", item->snmp_oid, vars->type, (zbx_uint64_t)(unsigned long)*vars->val.integer); } else if(vars->type == ASN_COUNTER64) { /* Incorrect code for 32 bit platforms */ /* SET_UI64_RESULT(value, ((vars->val.counter64->high)<<32)+(vars->val.counter64->low));*/ SET_UI64_RESULT(value, (((zbx_uint64_t)vars->val.counter64->high)<<32)+((zbx_uint64_t)vars->val.counter64->low)); } else if(vars->type == ASN_INTEGER #define ASN_FLOAT (ASN_APPLICATION | 8) #define ASN_DOUBLE (ASN_APPLICATION | 9) #ifdef OPAQUE_SPECIAL_TYPES || (vars->type == ASN_INTEGER64) #endif ) { /* Negative integer values are converted to double */ if(*vars->val.integer<0) { SET_DBL_RESULT(value, (double)*vars->val.integer); } else { SET_UI64_RESULT(value, (zbx_uint64_t)*vars->val.integer); } } #ifdef OPAQUE_SPECIAL_TYPES else if(vars->type == ASN_FLOAT) { SET_DBL_RESULT(value, *vars->val.floatVal); } else if(vars->type == ASN_DOUBLE) { SET_DBL_RESULT(value, *vars->val.doubleVal); } #endif else if(vars->type == ASN_OCTET_STR) { if(item->value_type == ITEM_VALUE_TYPE_FLOAT) { p = malloc(vars->val_len+1); if(p) { memcpy(p, vars->val.string, vars->val_len); p[vars->val_len] = '\0'; dbl = strtod(p, NULL); SET_DBL_RESULT(value, dbl); } else { zbx_snprintf(error,sizeof(error),"Cannot allocate required memory"); zabbix_log( LOG_LEVEL_ERR, "%s", error); SET_MSG_RESULT(value, strdup(error)); } } else if(item->value_type != ITEM_VALUE_TYPE_STR) { zbx_snprintf(error,sizeof(error),"Cannot store SNMP string value (ASN_OCTET_STR) in item having numeric type"); zabbix_log( LOG_LEVEL_ERR, "%s", error); SET_MSG_RESULT(value, strdup(error)); ret = NOTSUPPORTED; } else { zabbix_log( LOG_LEVEL_DEBUG, "ASN_OCTET_STR [%s]", vars->val.string); zabbix_log( LOG_LEVEL_DEBUG, "ASN_OCTET_STR [%d]", vars->val_len); p = malloc(1024); if(p) { memset(p,0,1024); snprint_value(p, 1023, vars->name, vars->name_length, vars); /* Skip STRING: and STRING_HEX: */ c=strchr(p,':'); if(c==NULL) { SET_STR_RESULT(value, strdup(p)); } else { SET_STR_RESULT(value, strdup(c+1)); } zabbix_log( LOG_LEVEL_DEBUG, "ASN_OCTET_STR [%s]", p); free(p); } else { zbx_snprintf(error,MAX_STRING_LEN-1,"Cannot allocate required memory"); zabbix_log( LOG_LEVEL_ERR, "%s", error); SET_MSG_RESULT(value, strdup(error)); } /* p = malloc(vars->val_len+1); if(p) { zabbix_log( LOG_LEVEL_WARNING, "Result [%s] len [%d]",vars->val.string,vars->val_len); memcpy(p, vars->val.string, vars->val_len); p[vars->val_len] = '\0'; SET_STR_RESULT(value, p); } else { zbx_snprintf(error,sizeof(error),"Cannot allocate required memory"); zabbix_log( LOG_LEVEL_ERR, "%s", error); SET_MSG_RESULT(value, strdup(error)); }*/ } } else if(vars->type == ASN_IPADDRESS) { /* ip = vars->val.string; zbx_snprintf(result_str,sizeof(result_str),"%d.%d.%d.%d",ip[0],ip[1],ip[2],ip[3]);*/ /* if(item->type == 0) { ret = NOTSUPPORTED; }*/ if(item->value_type != ITEM_VALUE_TYPE_STR) { zbx_snprintf(error,sizeof(error),"Cannot store SNMP string value (ASN_IPADDRESS) in item having numeric type"); zabbix_log( LOG_LEVEL_ERR, "%s", error); SET_MSG_RESULT(value, strdup(error)); ret = NOTSUPPORTED; } else { p = malloc(MAX_STRING_LEN); if(p) { ip = vars->val.string; zbx_snprintf(p,MAX_STRING_LEN-1,"%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]); SET_STR_RESULT(value, p); } else { zbx_snprintf(error,MAX_STRING_LEN-1,"Cannot allocate required memory"); zabbix_log( LOG_LEVEL_ERR, "%s", error); SET_MSG_RESULT(value, strdup(error)); } } } else { /* count is not really used. Has to be removed */ count++; zbx_snprintf(error,sizeof(error),"OID [%s] value #%d has unknow type [%X]", item->snmp_oid, count, vars->type); zabbix_log( LOG_LEVEL_ERR, "%s", error); SET_MSG_RESULT(value, strdup(error)); ret = NOTSUPPORTED; } } } else { if (status == STAT_SUCCESS) { zabbix_log( LOG_LEVEL_WARNING, "SNMP error in packet. Reason: %s\n", snmp_errstring(response->errstat)); if(response->errstat == SNMP_ERR_NOSUCHNAME) { zbx_snprintf(error,sizeof(error),"SNMP error [%s]", snmp_errstring(response->errstat)); zabbix_log( LOG_LEVEL_ERR, "%s", error); SET_MSG_RESULT(value, strdup(error)); ret=NOTSUPPORTED; } else { zbx_snprintf(error,sizeof(error),"SNMP error [%s]", snmp_errstring(response->errstat)); zabbix_log( LOG_LEVEL_ERR, "%s", error); SET_MSG_RESULT(value, strdup(error)); ret=NOTSUPPORTED; } } else if(status == STAT_TIMEOUT) { zbx_snprintf(error,sizeof(error),"Timeout while connecting to [%s]", session.peername); /* snmp_sess_perror("snmpget", ss);*/ zabbix_log( LOG_LEVEL_ERR, "%s", error); SET_MSG_RESULT(value, strdup(error)); ret = NETWORK_ERROR; } else { zbx_snprintf(error,sizeof(error),"SNMP error [%d]", status); zabbix_log( LOG_LEVEL_ERR, "%s", error); SET_MSG_RESULT(value, strdup(error)); ret=NOTSUPPORTED; } } if (response) { snmp_free_pdu(response); } snmp_close(ss); SOCK_CLEANUP; return ret; }