int NET_UDP_LISTEN(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result) { FILE *f = NULL; char tmp[MAX_STRING_LEN], pattern[64]; unsigned short port; zbx_uint64_t listen = 0; int ret = SYSINFO_RET_FAIL; if (num_param(param) > 1) return ret; if (0 != get_param(param, 1, tmp, sizeof(tmp))) return ret; if (SUCCEED != is_ushort(tmp, &port)) return ret; if (NULL != (f = fopen("/proc/net/udp", "r"))) { zbx_snprintf(pattern, sizeof(pattern), "%04X 00000000:0000 07", (unsigned int)port); while (NULL != fgets(tmp, sizeof(tmp), f)) { if (NULL != strstr(tmp, pattern)) { listen = 1; break; } } zbx_fclose(f); ret = SYSINFO_RET_OK; } if (0 == listen && NULL != (f = fopen("/proc/net/udp6", "r"))) { zbx_snprintf(pattern, sizeof(pattern), "%04X 00000000000000000000000000000000:0000 07", (unsigned int)port); while (NULL != fgets(tmp, sizeof(tmp), f)) { if (NULL != strstr(tmp, pattern)) { listen = 1; break; } } zbx_fclose(f); ret = SYSINFO_RET_OK; } SET_UI64_RESULT(result, listen); return ret; }
int get_bio_stat(int type, zbx_uint64_t *res) { int ret = SYSINFO_RET_FAIL; char line[MAX_STRING_LEN]; zbx_uint64_t pages_in; FILE *f; if((f = fopen(BIO_STAT,"r")) != NULL) { while(fgets(line,MAX_STRING_LEN,f) != NULL) { if(sscanf(line,"page " ZBX_FS_UI64 " " ZBX_FS_UI64, &pages_in, res) == 2) { if (type == BIO_IN) *res = pages_in; ret = SYSINFO_RET_OK; break; } } zbx_fclose(f); if (ret == SYSINFO_RET_OK) return ret; } if ((f = fopen(BIO_VMSTAT,"r")) != NULL) { while(fgets(line,MAX_STRING_LEN,f) != NULL) { if (type == BIO_IN && sscanf(line,"pgpgin " ZBX_FS_UI64, res) == 1) { ret = SYSINFO_RET_OK; break; } if (type == BIO_OUT && sscanf(line,"pgpgout " ZBX_FS_UI64, res) == 1) { ret = SYSINFO_RET_OK; break; } } zbx_fclose(f); } return ret; }
static int VM_MEMORY_CACHED(AGENT_RESULT *result) { FILE *f; zbx_uint64_t value; int res; 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 (FAIL == (res = byte_value_from_proc_file(f, "Cached:", NULL, &value))) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot obtain the value of Cached from /proc/meminfo.")); goto close; } if (NOTSUPPORTED == res) value = 0; close: zbx_fclose(f); SET_UI64_RESULT(result, value); return SYSINFO_RET_OK; }
int SYSTEM_CPU_INTR(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result) { int ret = SYSINFO_RET_FAIL; char line[MAX_STRING_LEN]; zbx_uint64_t value = 0; FILE *f; if (NULL == (f = fopen("/proc/stat", "r"))) return SYSINFO_RET_FAIL; while (NULL != fgets(line, sizeof(line), f)) { if (0 != strncmp(line, "intr", 4)) continue; if (1 != sscanf(line, "%*s " ZBX_FS_UI64, &value)) continue; SET_UI64_RESULT(result, value); ret = SYSINFO_RET_OK; break; } zbx_fclose(f); return ret; }
/****************************************************************************** * * * Comments: Translate device name to the one used internally by kernel. The * * translation is done based on minor and major device numbers * * listed in INFO_FILE_NAME . If the names differ it is usually an * * LVM device which is listed in kernel device mapper. * * * ******************************************************************************/ static int get_kernel_devname(const char *devname, char *kernel_devname, size_t max_kernel_devname_len) { FILE *f; char tmp[MAX_STRING_LEN], name[MAX_STRING_LEN], dev_path[MAX_STRING_LEN]; int ret = FAIL; zbx_uint64_t ds[ZBX_DSTAT_MAX], rdev_major, rdev_minor; zbx_stat_t dev_st; if ('\0' == *devname) return ret; *dev_path = '\0'; if (0 != strncmp(devname, ZBX_DEV_PFX, ZBX_CONST_STRLEN(ZBX_DEV_PFX))) strscpy(dev_path, ZBX_DEV_PFX); strscat(dev_path, devname); if (zbx_stat(dev_path, &dev_st) < 0 || NULL == (f = fopen(INFO_FILE_NAME, "r"))) return ret; while (NULL != fgets(tmp, sizeof(tmp), f)) { PARSE(tmp); if (major(dev_st.st_rdev) != rdev_major || minor(dev_st.st_rdev) != rdev_minor) continue; zbx_strlcpy(kernel_devname, name, max_kernel_devname_len); ret = SUCCEED; break; } zbx_fclose(f); return ret; }
static int get_disk_stat(const char *interface, struct disk_stat_s *result) { int ret = SYSINFO_RET_FAIL; char line[MAX_STRING_LEN]; char name[MAX_STRING_LEN]; FILE *f; assert(result); if(NULL != (f = fopen(INFO_FILE_NAME,"r") )) { while(fgets(line,MAX_STRING_LEN,f) != NULL) { PARSE(line); if(strncmp(name, interface, MAX_STRING_LEN) == 0) { ret = SYSINFO_RET_OK; break; } } zbx_fclose(f); } if(ret != SYSINFO_RET_OK) { memset(result, 0, sizeof(struct disk_stat_s)); } return ret; }
int SYSTEM_CPU_SWITCHES(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result) { int ret = SYSINFO_RET_FAIL; char line[MAX_STRING_LEN], name[32]; zbx_uint64_t value = 0; FILE *f; if (NULL == (f = fopen("/proc/stat", "r"))) return SYSINFO_RET_FAIL; while (NULL != fgets(line, sizeof(line), f)) { if (2 != sscanf(line, "%s " ZBX_FS_UI64, name, &value)) continue; if (0 == strcmp(name, "ctxt")) { SET_UI64_RESULT(result, value); ret = SYSINFO_RET_OK; break; } } zbx_fclose(f); return ret; }
int SYSTEM_CPU_INTR(AGENT_REQUEST *request, AGENT_RESULT *result) { int ret = SYSINFO_RET_FAIL; char line[MAX_STRING_LEN]; zbx_uint64_t value = 0; FILE *f; if (NULL == (f = fopen("/proc/stat", "r"))) { SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot open /proc/stat: %s", zbx_strerror(errno))); return SYSINFO_RET_FAIL; } while (NULL != fgets(line, sizeof(line), f)) { if (0 != strncmp(line, "intr", 4)) continue; if (1 != sscanf(line, "%*s " ZBX_FS_UI64, &value)) continue; SET_UI64_RESULT(result, value); ret = SYSINFO_RET_OK; break; } zbx_fclose(f); if (SYSINFO_RET_FAIL == ret) SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot find a line with \"intr\" in /proc/stat.")); return ret; }
void drop_pid_file(const char *pidfile) { #ifdef HAVE_FCNTL_H struct flock fl; fl.l_type = F_UNLCK; /* tell it to unlock the region */ fl.l_whence = SEEK_SET; /* SEEK_SET, SEEK_CUR, SEEK_END */ fl.l_start = 0; /* Offset from l_whence */ fl.l_len = 0; /* length, 0 = to EOF */ fl.l_pid = zbx_get_thread_id(); /* our PID */ #endif /* HAVE_FCNTL_H */ /* unlock file */ #ifdef HAVE_FCNTL_H if(-1 != fdpid) fcntl(fdpid, F_SETLK, &fl); #else if(-1 != fdpid) flock(fdpid, LOCK_UN); #endif /* HAVE_FCNTL_H */ /* close pid file */ zbx_fclose(fpid); if(-1 == unlink(pidfile)) { zabbix_log( LOG_LEVEL_DEBUG, "Cannot remove PID file [%s] [%s]", pidfile, strerror(errno)); } }
int SYSTEM_SW_OS(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result) { char type[8], line[MAX_STRING_LEN]; int ret = SYSINFO_RET_FAIL; FILE *f = NULL; if (1 < num_param(param)) return ret; if (0 != get_param(param, 1, type, sizeof(type))) *type = '\0'; if ('\0' == *type || 0 == strcmp(type, "full")) f = fopen(SW_OS_FULL, "r"); else if (0 == strcmp(type, "short")) f = fopen(SW_OS_SHORT, "r"); else if (0 == strcmp(type, "name")) f = fopen(SW_OS_NAME, "r"); if (NULL == f) return ret; if (NULL != fgets(line, sizeof(line), f)) { ret = SYSINFO_RET_OK; zbx_rtrim(line, ZBX_WHITESPACE); SET_STR_RESULT(result, zbx_strdup(NULL, line)); } zbx_fclose(f); return ret; }
int SYSTEM_BOOTTIME(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result) { FILE *f; char buf[MAX_STRING_LEN]; int ret = SYSINFO_RET_FAIL; unsigned long value; if (NULL == (f = fopen("/proc/stat", "r"))) return ret; /* find boot time entry "btime [boot time]" */ while (NULL != fgets(buf, MAX_STRING_LEN, f)) { if (1 == sscanf(buf, "btime %lu", &value)) { SET_UI64_RESULT(result, value); ret = SYSINFO_RET_OK; break; } } zbx_fclose(f); return ret; }
static int get_net_stat(const char *if_name, net_stat_t *result, char **error) { int ret = SYSINFO_RET_FAIL; char line[MAX_STRING_LEN], name[MAX_STRING_LEN], *p; FILE *f; if (NULL == if_name || '\0' == *if_name) { *error = zbx_strdup(NULL, "Network interface name cannot be empty."); return SYSINFO_RET_FAIL; } if (NULL == (f = fopen("/proc/net/dev", "r"))) { *error = zbx_dsprintf(NULL, "Cannot open /proc/net/dev: %s", zbx_strerror(errno)); return SYSINFO_RET_FAIL; } while (NULL != fgets(line, sizeof(line), f)) { if (NULL == (p = strstr(line, ":"))) continue; *p = '\t'; if (10 == sscanf(line, "%s\t" ZBX_FS_UI64 "\t" ZBX_FS_UI64 "\t" ZBX_FS_UI64 "\t" ZBX_FS_UI64 "\t%*s\t%*s\t%*s\t%*s\t" ZBX_FS_UI64 "\t" ZBX_FS_UI64 "\t" ZBX_FS_UI64 "\t" ZBX_FS_UI64 "\t%*s\t" ZBX_FS_UI64 "\t%*s\t%*s\n", name, &result->ibytes, /* bytes */ &result->ipackets, /* packets */ &result->ierr, /* errs */ &result->idrop, /* drop */ &result->obytes, /* bytes */ &result->opackets, /* packets */ &result->oerr, /* errs */ &result->odrop, /* drop */ &result->colls)) /* icolls */ { if (0 == strcmp(name, if_name)) { ret = SYSINFO_RET_OK; break; } } } zbx_fclose(f); if (SYSINFO_RET_FAIL == ret) { *error = zbx_strdup(NULL, "Cannot find information for this network interface in /proc/net/dev."); return SYSINFO_RET_FAIL; } return SYSINFO_RET_OK; }
int get_diskstat(const char *devname, zbx_uint64_t *dstat) { FILE *f; char tmp[MAX_STRING_LEN], name[MAX_STRING_LEN], dev_path[MAX_STRING_LEN]; int i, ret = FAIL, dev_exists = FAIL; zbx_uint64_t ds[ZBX_DSTAT_MAX], rdev_major, rdev_minor; zbx_stat_t dev_st; int found = 0; for (i = 0; i < ZBX_DSTAT_MAX; i++) dstat[i] = (zbx_uint64_t)__UINT64_C(0); if (NULL != devname && '\0' != *devname && 0 != strcmp(devname, "all")) { *dev_path = '\0'; if (0 != strncmp(devname, ZBX_DEV_PFX, ZBX_CONST_STRLEN(ZBX_DEV_PFX))) strscpy(dev_path, ZBX_DEV_PFX); strscat(dev_path, devname); if (zbx_stat(dev_path, &dev_st) == 0) dev_exists = SUCCEED; } if (NULL == (f = fopen(INFO_FILE_NAME, "r"))) return FAIL; while (NULL != fgets(tmp, sizeof(tmp), f)) { PARSE(tmp); if (NULL != devname && '\0' != *devname && 0 != strcmp(devname, "all")) { if (0 != strcmp(name, devname)) { if (SUCCEED != dev_exists || major(dev_st.st_rdev) != rdev_major || minor(dev_st.st_rdev) != rdev_minor) continue; } else found = 1; } dstat[ZBX_DSTAT_R_OPER] += ds[ZBX_DSTAT_R_OPER]; dstat[ZBX_DSTAT_R_SECT] += ds[ZBX_DSTAT_R_SECT]; dstat[ZBX_DSTAT_W_OPER] += ds[ZBX_DSTAT_W_OPER]; dstat[ZBX_DSTAT_W_SECT] += ds[ZBX_DSTAT_W_SECT]; ret = SUCCEED; if (1 == found) break; } zbx_fclose(f); return ret; }
int getPROC(char *file, int lineno, int fieldno, unsigned flags, AGENT_RESULT *result) { #ifdef HAVE_PROC FILE *f; char *t; char c[MAX_STRING_LEN]; int i; double value = 0; assert(result); init_result(result); if(NULL == (f = fopen(file,"r"))) { return SYSINFO_RET_FAIL; } for(i=1; i<=lineno; i++) { if(NULL == fgets(c,MAX_STRING_LEN,f)) { zbx_fclose(f); return SYSINFO_RET_FAIL; } } t=(char *)strtok(c," "); for(i=2; i<=fieldno; i++) { t=(char *)strtok(NULL," "); } zbx_fclose(f); sscanf(t, "%lf", &value); SET_DBL_RESULT(result, value); return SYSINFO_RET_OK; #else return SYSINFO_RET_FAIL; #endif /* HAVE_PROC */ }
static int get_sensor(const char *name, unsigned flags, AGENT_RESULT *result) { DIR *dir; struct dirent *entries; struct stat buf; char filename[MAX_STRING_LEN]; char line[MAX_STRING_LEN]; double d1,d2,d3; FILE *f; assert(result); init_result(result); dir=opendir("/proc/sys/dev/sensors"); if(NULL == dir) { return SYSINFO_RET_FAIL; } while((entries=readdir(dir))!=NULL) { strscpy(filename,"/proc/sys/dev/sensors/"); zbx_strlcat(filename,entries->d_name,MAX_STRING_LEN); zbx_strlcat(filename,name,MAX_STRING_LEN); if(stat(filename,&buf)==0) { if( NULL == (f = fopen(filename,"r") )) { continue; } fgets(line,MAX_STRING_LEN,f); zbx_fclose(f); if(sscanf(line,"%lf\t%lf\t%lf\n",&d1, &d2, &d3) == 3) { closedir(dir); SET_DBL_RESULT(result, d3); return SYSINFO_RET_OK; } else { closedir(dir); return SYSINFO_RET_FAIL; } } } closedir(dir); return SYSINFO_RET_FAIL; }
static int get_total_memory(zbx_uint64_t *total_memory) { FILE *f; int ret = FAIL; if (NULL != (f = fopen("/proc/meminfo", "r"))) { ret = byte_value_from_proc_file(f, "MemTotal:", NULL, total_memory); zbx_fclose(f); } return ret; }
static int VM_MEMORY_CACHED(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result) { #if defined(HAVE_LIBPERFSTAT) /* AIX 6.1 */ perfstat_memory_total_t m; zbx_uint64_t value; if (-1 == perfstat_memory_total(NULL, &m, sizeof(m), 1)) return SYSINFO_RET_FAIL; value = (zbx_uint64_t)m.numperm; /* number of frames used for files (in 4KB pages) */ value <<= 12; SET_UI64_RESULT(result, value); return SYSINFO_RET_OK; #elif defined(HAVE_PROC) FILE *f = NULL; 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 VFS_FS_DISCOVERY(AGENT_REQUEST *request, AGENT_RESULT *result) { int ret = SYSINFO_RET_FAIL; char line[MAX_STRING_LEN], *p, *mpoint, *mtype; FILE *f; struct zbx_json j; zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN); zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA); if (NULL != (f = fopen("/proc/mounts", "r"))) { while (NULL != fgets(line, sizeof(line), f)) { if (NULL == (p = strchr(line, ' '))) continue; mpoint = ++p; if (NULL == (p = strchr(mpoint, ' '))) continue; *p = '\0'; mtype = ++p; if (NULL == (p = strchr(mtype, ' '))) continue; *p = '\0'; zbx_json_addobject(&j, NULL); zbx_json_addstring(&j, "{#FSNAME}", mpoint, ZBX_JSON_TYPE_STRING); zbx_json_addstring(&j, "{#FSTYPE}", mtype, ZBX_JSON_TYPE_STRING); zbx_json_close(&j); } zbx_fclose(f); ret = SYSINFO_RET_OK; } zbx_json_close(&j); SET_STR_RESULT(result, zbx_strdup(NULL, j.buffer)); zbx_json_free(&j); return ret; }
static void count_sensor(int do_task, const char *filename, double *aggr, int *cnt) { FILE *f; char line[MAX_STRING_LEN]; double value; if (NULL == (f = fopen(filename, "r"))) return; if (NULL == fgets(line, sizeof(line), f)) { zbx_fclose(f); return; } zbx_fclose(f); if (1 == sscanf(line, "%*f\t%*f\t%lf\n", &value)) { (*cnt)++; switch (do_task) { case DO_ONE: *aggr = value; break; case DO_AVG: *aggr += value; break; case DO_MAX: *aggr = (1 == *cnt ? value : MAX(*aggr, value)); break; case DO_MIN: *aggr = (1 == *cnt ? value : MIN(*aggr, value)); break; } } }
static int VM_MEMORY_AVAILABLE(AGENT_RESULT *result) { FILE *f; zbx_uint64_t value; struct sysinfo info; int res, ret = SYSINFO_RET_FAIL; /* try MemAvailable (present since Linux 3.14), falling back to a calculation based on sysinfo() and Cached */ 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 (FAIL == (res = byte_value_from_proc_file(f, "MemAvailable:", "Cached:", &value))) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot obtain the value of MemAvailable from /proc/meminfo.")); goto close; } if (SUCCEED == res) { SET_UI64_RESULT(result, value); ret = SYSINFO_RET_OK; goto close; } if (FAIL == (res = byte_value_from_proc_file(f, "Cached:", NULL, &value))) { SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot obtain the value of Cached from /proc/meminfo.")); goto close; } if (NOTSUPPORTED == res) value = 0; if (0 != sysinfo(&info)) { SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain system information: %s", zbx_strerror(errno))); goto close; } SET_UI64_RESULT(result, (zbx_uint64_t)(info.freeram + info.bufferram) * info.mem_unit + value); ret = SYSINFO_RET_OK; close: zbx_fclose(f); return ret; }
int TCP_LISTEN(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result) { #ifdef HAVE_PROC FILE *f = NULL; char c[MAX_STRING_LEN]; char porthex[MAX_STRING_LEN]; char pattern[MAX_STRING_LEN]; int ret = SYSINFO_RET_FAIL; assert(result); init_result(result); if(num_param(param) > 1) { return SYSINFO_RET_FAIL; } if(get_param(param, 1, porthex, MAX_STRING_LEN) != 0) { return SYSINFO_RET_FAIL; } strscpy(pattern,porthex); zbx_strlcat(pattern," 00000000:0000 0A", MAX_STRING_LEN); if(NULL == (f = fopen("/proc/net/tcp","r"))) { return SYSINFO_RET_FAIL; } while (NULL != fgets(c,MAX_STRING_LEN,f)) { if(NULL != strstr(c,pattern)) { SET_UI64_RESULT(result, 1); ret = SYSINFO_RET_OK; break; } } zbx_fclose(f); SET_UI64_RESULT(result, 0); return ret; #else return SYSINFO_RET_FAIL; #endif }
static int get_net_stat(const char *if_name, net_stat_t *result) { int ret = SYSINFO_RET_FAIL; char line[MAX_STRING_LEN], name[MAX_STRING_LEN], *p; FILE *f; assert(result); if (NULL != (f = fopen("/proc/net/dev", "r"))) { while (NULL != fgets(line, sizeof(line), f)) { if (NULL == (p = strstr(line, ":"))) continue; *p = '\t'; if (10 == sscanf(line, "%s\t" ZBX_FS_UI64 "\t" ZBX_FS_UI64 "\t" ZBX_FS_UI64 "\t" ZBX_FS_UI64 "\t%*s\t%*s\t%*s\t%*s\t" ZBX_FS_UI64 "\t" ZBX_FS_UI64 "\t" ZBX_FS_UI64 "\t" ZBX_FS_UI64 "\t%*s\t" ZBX_FS_UI64 "\t%*s\t%*s\n", name, &(result->ibytes), /* bytes */ &(result->ipackets), /* packets */ &(result->ierr), /* errs */ &(result->idrop), /* drop */ &(result->obytes), /* bytes */ &(result->opackets), /* packets*/ &(result->oerr), /* errs */ &(result->odrop), /* drop */ &(result->colls))) /* icolls */ { if (0 == strcmp(name, if_name)) { ret = SYSINFO_RET_OK; break; } } } zbx_fclose(f); } if (ret != SYSINFO_RET_OK) memset(result, 0, sizeof(net_stat_t)); return ret; }
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; assert(result); init_result(result); 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 assert(result); init_result(result); return SYSINFO_RET_FAIL; #endif }
int read_pid_file(const char *pidfile, pid_t *pid, char *error, size_t max_error_len) { int ret = FAIL; FILE *fpid; if (NULL == (fpid = fopen(pidfile, "r"))) { zbx_snprintf(error, max_error_len, "cannot open PID file [%s]: %s", pidfile, zbx_strerror(errno)); return ret; } if (1 == fscanf(fpid, "%d", (int *)pid)) ret = SUCCEED; zbx_fclose(fpid); return ret; }
static int read_uint64_from_procfs(const char *path, zbx_uint64_t *value) { int ret = SYSINFO_RET_FAIL; char line[MAX_STRING_LEN]; FILE *f; if (NULL != (f = fopen(path, "r"))) { if (NULL != fgets(line, sizeof(line), f)) { if (1 == sscanf(line, ZBX_FS_UI64 "\n", value)) ret = SYSINFO_RET_OK; } zbx_fclose(f); } return ret; }
void drop_pid_file(const char *pidfile) { struct flock fl; fl.l_type = F_UNLCK; fl.l_whence = SEEK_SET; fl.l_start = 0; fl.l_len = 0; fl.l_pid = zbx_get_thread_id(); /* unlock file */ if (-1 != fdpid) fcntl(fdpid, F_SETLK, &fl); /* close pid file */ zbx_fclose(fpid); unlink(pidfile); }
int NET_IF_DISCOVERY(AGENT_REQUEST *request, AGENT_RESULT *result) { char line[MAX_STRING_LEN], *p; FILE *f; struct zbx_json j; if (NULL == (f = fopen("/proc/net/dev", "r"))) { SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot open /proc/net/dev: %s", zbx_strerror(errno))); return SYSINFO_RET_FAIL; } zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN); zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA); while (NULL != fgets(line, sizeof(line), f)) { if (NULL == (p = strstr(line, ":"))) continue; *p = '\0'; /* trim left spaces */ for (p = line; ' ' == *p && '\0' != *p; p++) ; zbx_json_addobject(&j, NULL); zbx_json_addstring(&j, "{#IFNAME}", p, ZBX_JSON_TYPE_STRING); zbx_json_close(&j); } zbx_fclose(f); zbx_json_close(&j); SET_STR_RESULT(result, strdup(j.buffer)); zbx_json_free(&j); return SYSINFO_RET_OK; }
int NET_IF_DISCOVERY(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result) { int ret = SYSINFO_RET_FAIL; char line[MAX_STRING_LEN], *p; FILE *f; struct zbx_json j; zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN); zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA); if (NULL != (f = fopen("/proc/net/dev", "r"))) { while (NULL != fgets(line, sizeof(line), f)) { if (NULL == (p = strstr(line, ":"))) continue; *p = '\0'; /* trim left spaces */ for (p = line; ' ' == *p && '\0' != *p; p++) ; zbx_json_addobject(&j, NULL); zbx_json_addstring(&j, "{#IFNAME}", p, ZBX_JSON_TYPE_STRING); zbx_json_close(&j); } zbx_fclose(f); ret = SYSINFO_RET_OK; } zbx_json_close(&j); SET_STR_RESULT(result, strdup(j.buffer)); zbx_json_free(&j); return ret; }
/****************************************************************************** * * * Function: zbx_module_docker_up * * * * Purpose: check if container is running * * * * Return value: 1 - is running, 0 - is not running * * * ******************************************************************************/ int zbx_module_docker_up(AGENT_REQUEST *request, AGENT_RESULT *result) { zabbix_log(LOG_LEVEL_DEBUG, "In zbx_module_docker_up()"); char *container, *metric; int ret = SYSINFO_RET_FAIL; if (1 != request->nparam) { zabbix_log(LOG_LEVEL_ERR, "Invalid number of parameters: %d", request->nparam); SET_MSG_RESULT(result, strdup("Invalid number of parameters.")); return SYSINFO_RET_FAIL; } if (stat_dir == NULL) { zabbix_log(LOG_LEVEL_DEBUG, "docker.up check is not available at the moment - no stat directory."); SET_MSG_RESULT(result, zbx_strdup(NULL, "docker.up check is not available at the moment - no stat directory.")); return SYSINFO_RET_OK; } container = get_rparam(request, 0); char *stat_file = "/cpuacct.stat"; char *cgroup = "cpuacct/"; size_t filename_size = strlen(base_dir) + strlen(cgroup) + strlen(container) + strlen(stat_dir) + strlen(stat_file) + 2; char *filename = malloc(filename_size); zbx_strlcpy(filename, base_dir, filename_size); zbx_strlcat(filename, cgroup, filename_size); zbx_strlcat(filename, stat_dir, filename_size); zbx_strlcat(filename, container, filename_size); zbx_strlcat(filename, stat_file, filename_size); zabbix_log(LOG_LEVEL_DEBUG, "Metric source file: %s", filename); FILE *file; if (NULL == (file = fopen(filename, "r"))) { zabbix_log(LOG_LEVEL_DEBUG, "Can't open docker container metric file: '%s', container doesn't run", filename); SET_DBL_RESULT(result, 0); return SYSINFO_RET_OK; } zbx_fclose(file); zabbix_log(LOG_LEVEL_DEBUG, "Can open docker container metric file: '%s', container is running", filename); SET_DBL_RESULT(result, 1); return SYSINFO_RET_OK; }
int VFS_FS_DISCOVERY(AGENT_REQUEST *request, AGENT_RESULT *result) { int ret = SYSINFO_RET_FAIL; struct mnttab mt; FILE *f; struct zbx_json j; zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN); zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA); /* opening the mounted filesystems file */ if (NULL != (f = fopen("/etc/mnttab", "r"))) { /* fill mnttab structure from file */ while (-1 != getmntent(f, &mt)) { zbx_json_addobject(&j, NULL); zbx_json_addstring(&j, "{#FSNAME}", mt.mnt_mountp, ZBX_JSON_TYPE_STRING); zbx_json_addstring(&j, "{#FSTYPE}", mt.mnt_fstype, ZBX_JSON_TYPE_STRING); zbx_json_close(&j); } zbx_fclose(f); ret = SYSINFO_RET_OK; } zbx_json_close(&j); SET_STR_RESULT(result, zbx_strdup(NULL, j.buffer)); zbx_json_free(&j); return ret; }