1437 lines
52 KiB
C
1437 lines
52 KiB
C
/* hbc_mini.c — HeartBeat Client, single-file C port of hbc_mini.py
|
|
*
|
|
* Build: cc -O2 -o hbc_mini hbc_mini.c -lz -lpthread -lm
|
|
* Requires: zlib, pthreads, POSIX
|
|
* Supported: Linux, FreeBSD, NetBSD, DragonFly BSD
|
|
*
|
|
* Drop on any host and run: ./hbc_mini <hbd-host>
|
|
* Config: ~/.hbc.json (same keys as Python version)
|
|
*/
|
|
|
|
#ifdef __linux__
|
|
# define _GNU_SOURCE
|
|
# define _POSIX_C_SOURCE 200809L
|
|
#endif
|
|
|
|
#include <arpa/inet.h>
|
|
#include <netinet/in.h>
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <math.h>
|
|
#include <netdb.h>
|
|
#include <pthread.h>
|
|
#include <signal.h>
|
|
#include <stdarg.h>
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/select.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/time.h>
|
|
#include <sys/types.h>
|
|
#include <sys/utsname.h>
|
|
#include <sys/wait.h>
|
|
#include <syslog.h>
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
#include <zlib.h>
|
|
|
|
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__)
|
|
# include <sys/sysctl.h>
|
|
# include <net/if.h>
|
|
# include <net/if_dl.h>
|
|
# include <ifaddrs.h>
|
|
#endif
|
|
#if defined(__NetBSD__)
|
|
# include <uvm/uvm_extern.h>
|
|
#endif
|
|
|
|
/* version updated by scripts/bumpminor.sh */
|
|
#define HBC_VERSION "5.2.4"
|
|
#define DEFAULT_PORT 50003
|
|
#define DEFAULT_INTERVAL 10
|
|
#define MAX_HOSTS 8
|
|
#define MAX_KV 64
|
|
#define MAX_KEY 128
|
|
#define MAX_VAL 4096
|
|
#define PROTO_BUF_SIZE 65536
|
|
#define MAX_PING_HOSTS 32
|
|
#define MAX_NAGIOS_CMDS 32
|
|
#define MAX_DISK_MOUNTS 32
|
|
#define MAX_NET_SKIP 16
|
|
|
|
/* ============================================================
|
|
* Logging
|
|
* ============================================================ */
|
|
|
|
static bool g_use_syslog = false;
|
|
static int g_log_level = 3; /* 0=debug 1=info 2=warn 3=error */
|
|
|
|
#define LL_DEBUG 0
|
|
#define LL_INFO 1
|
|
#define LL_WARN 2
|
|
#define LL_ERROR 3
|
|
|
|
static void hbc_log(int level, const char *fmt, ...) {
|
|
if (level < g_log_level) return;
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
if (g_use_syslog) {
|
|
int pri = LOG_ERR;
|
|
if (level == LL_DEBUG) pri = LOG_DEBUG;
|
|
else if (level == LL_INFO) pri = LOG_INFO;
|
|
else if (level == LL_WARN) pri = LOG_WARNING;
|
|
vsyslog(pri, fmt, ap);
|
|
} else {
|
|
const char *ln[] = {"DEBUG","INFO","WARN","ERROR"};
|
|
time_t t = time(NULL);
|
|
struct tm tm; localtime_r(&t, &tm);
|
|
char ts[32]; strftime(ts, sizeof(ts), "%Y-%m-%d %H:%M:%S", &tm);
|
|
fprintf(stderr, "%s hbc %s: ", ts, ln[level]);
|
|
vfprintf(stderr, fmt, ap);
|
|
fputc('\n', stderr);
|
|
}
|
|
va_end(ap);
|
|
}
|
|
|
|
#define LOGD(fmt, ...) hbc_log(LL_DEBUG, fmt, ##__VA_ARGS__)
|
|
#define LOGI(fmt, ...) hbc_log(LL_INFO, fmt, ##__VA_ARGS__)
|
|
#define LOGW(fmt, ...) hbc_log(LL_WARN, fmt, ##__VA_ARGS__)
|
|
#define LOGE(fmt, ...) hbc_log(LL_ERROR, fmt, ##__VA_ARGS__)
|
|
|
|
/* ============================================================
|
|
* Key-Value dict (protocol messages)
|
|
* ============================================================ */
|
|
|
|
typedef struct { char key[MAX_KEY]; char val[MAX_VAL]; } kv_t;
|
|
typedef struct { kv_t pairs[MAX_KV]; int count; } kvdict_t;
|
|
|
|
static void kv_clear(kvdict_t *d) { d->count = 0; }
|
|
|
|
static bool kv_set(kvdict_t *d, const char *key, const char *val) {
|
|
if (d->count >= MAX_KV) return false;
|
|
snprintf(d->pairs[d->count].key, MAX_KEY, "%s", key);
|
|
snprintf(d->pairs[d->count].val, MAX_VAL, "%s", val);
|
|
d->count++;
|
|
return true;
|
|
}
|
|
|
|
static bool kv_set_int(kvdict_t *d, const char *key, long long v) {
|
|
char buf[32]; snprintf(buf, sizeof(buf), "%lld", v);
|
|
return kv_set(d, key, buf);
|
|
}
|
|
|
|
static bool kv_set_ull(kvdict_t *d, const char *key, unsigned long long v) {
|
|
char buf[32]; snprintf(buf, sizeof(buf), "%llu", v);
|
|
return kv_set(d, key, buf);
|
|
}
|
|
|
|
static bool kv_set_dbl(kvdict_t *d, const char *key, double v) {
|
|
char buf[32];
|
|
if (isinf(v)) snprintf(buf, sizeof(buf), "inf");
|
|
else snprintf(buf, sizeof(buf), "%.5f", v);
|
|
return kv_set(d, key, buf);
|
|
}
|
|
|
|
static const char *kv_get(const kvdict_t *d, const char *key) {
|
|
for (int i = 0; i < d->count; i++)
|
|
if (strcmp(d->pairs[i].key, key) == 0)
|
|
return d->pairs[i].val;
|
|
return NULL;
|
|
}
|
|
|
|
/* ============================================================
|
|
* Protocol codec (mirrors hbd/common/proto.py)
|
|
* ============================================================ */
|
|
|
|
/* Build wire bytes: !MSG: + zlib-compressed key=val;key=val;... */
|
|
static int proto_encode(const char *msg_id, const kvdict_t *d,
|
|
uint8_t *out, size_t cap) {
|
|
/* Build payload */
|
|
char *payload = malloc(PROTO_BUF_SIZE);
|
|
if (!payload) return -1;
|
|
int plen = 0;
|
|
for (int i = 0; i < d->count; i++) {
|
|
if (i > 0 && plen < PROTO_BUF_SIZE - 1) payload[plen++] = ';';
|
|
plen += snprintf(payload + plen, PROTO_BUF_SIZE - plen,
|
|
"%s=%s", d->pairs[i].key, d->pairs[i].val);
|
|
if (plen >= PROTO_BUF_SIZE) { plen = PROTO_BUF_SIZE - 1; break; }
|
|
}
|
|
/* Compress */
|
|
uLongf clen = compressBound(plen);
|
|
uint8_t *cbuf = malloc(clen);
|
|
if (!cbuf) { free(payload); return -1; }
|
|
if (compress2(cbuf, &clen, (uint8_t *)payload, plen, 6) != Z_OK) {
|
|
free(payload); free(cbuf); return -1;
|
|
}
|
|
free(payload);
|
|
/* Header: !XXX: (5 bytes) */
|
|
if ((size_t)(5 + clen) > cap) { free(cbuf); return -1; }
|
|
out[0] = '!';
|
|
memcpy(out + 1, msg_id, 3);
|
|
out[4] = ':';
|
|
memcpy(out + 5, cbuf, clen);
|
|
free(cbuf);
|
|
return 5 + (int)clen;
|
|
}
|
|
|
|
/* Parse wire bytes into kvdict */
|
|
static bool proto_decode(const uint8_t *data, int dlen, kvdict_t *out) {
|
|
kv_clear(out);
|
|
if (dlen < 5 || data[0] != '!') return false;
|
|
char id[4] = {0};
|
|
memcpy(id, data + 1, 3);
|
|
kv_set(out, "ID", id);
|
|
uint8_t *payload = malloc(PROTO_BUF_SIZE);
|
|
if (!payload) return false;
|
|
uLongf plen = PROTO_BUF_SIZE - 1;
|
|
if (uncompress(payload, &plen, data + 5, dlen - 5) != Z_OK) {
|
|
free(payload); return false;
|
|
}
|
|
payload[plen] = '\0';
|
|
char *p = (char *)payload;
|
|
while (*p) {
|
|
char *semi = strchr(p, ';');
|
|
if (semi) *semi = '\0';
|
|
char *eq = strchr(p, '=');
|
|
if (eq) {
|
|
*eq = '\0';
|
|
char *kp = p; while (*kp == ' ') kp++;
|
|
char *vp = eq+1; while (*vp == ' ') vp++;
|
|
kv_set(out, kp, vp);
|
|
}
|
|
if (semi) p = semi + 1; else break;
|
|
}
|
|
free(payload);
|
|
return true;
|
|
}
|
|
|
|
/* ============================================================
|
|
* Minimal JSON parser (for config file)
|
|
* ============================================================ */
|
|
|
|
typedef enum { JT_NULL,JT_BOOL,JT_INT,JT_FLOAT,JT_STRING,JT_ARRAY,JT_OBJECT } jtype_t;
|
|
|
|
typedef struct jval jval_t;
|
|
struct jval {
|
|
jtype_t type;
|
|
union {
|
|
bool b;
|
|
long long i;
|
|
double f;
|
|
char *s;
|
|
struct { char **keys; jval_t **vals; int count, cap; } obj;
|
|
struct { jval_t **items; int count, cap; } arr;
|
|
};
|
|
};
|
|
|
|
static void jval_free(jval_t *v) {
|
|
if (!v) return;
|
|
if (v->type == JT_STRING) { free(v->s); }
|
|
else if (v->type == JT_OBJECT) {
|
|
for (int i = 0; i < v->obj.count; i++) { free(v->obj.keys[i]); jval_free(v->obj.vals[i]); }
|
|
free(v->obj.keys); free(v->obj.vals);
|
|
} else if (v->type == JT_ARRAY) {
|
|
for (int i = 0; i < v->arr.count; i++) jval_free(v->arr.items[i]);
|
|
free(v->arr.items);
|
|
}
|
|
free(v);
|
|
}
|
|
|
|
static const char *jskip(const char *p) {
|
|
while (*p && isspace((unsigned char)*p)) p++;
|
|
return p;
|
|
}
|
|
|
|
static const char *jparse_value(const char *p, jval_t **out);
|
|
|
|
static const char *jparse_string(const char *p, char **out) {
|
|
if (*p != '"') return NULL;
|
|
p++;
|
|
char buf[4096]; int n = 0;
|
|
while (*p && *p != '"') {
|
|
if (*p == '\\') {
|
|
p++;
|
|
switch (*p) {
|
|
case '"': buf[n++]='"'; break; case '\\': buf[n++]='\\'; break;
|
|
case 'n': buf[n++]='\n'; break; case 'r': buf[n++]='\r'; break;
|
|
case 't': buf[n++]='\t'; break; default: buf[n++]=*p; break;
|
|
}
|
|
} else { buf[n++] = *p; }
|
|
p++;
|
|
if (n >= (int)sizeof(buf)-1) break;
|
|
}
|
|
buf[n] = '\0';
|
|
if (*p == '"') p++;
|
|
*out = strdup(buf);
|
|
return p;
|
|
}
|
|
|
|
static const char *jparse_object(const char *p, jval_t **out) {
|
|
if (*p != '{') return NULL;
|
|
p++;
|
|
jval_t *v = calloc(1, sizeof(jval_t)); v->type = JT_OBJECT;
|
|
p = jskip(p);
|
|
while (*p && *p != '}') {
|
|
p = jskip(p);
|
|
char *key = NULL;
|
|
p = jparse_string(p, &key);
|
|
if (!p) break;
|
|
p = jskip(p); if (*p == ':') p++;
|
|
p = jskip(p);
|
|
jval_t *val = NULL;
|
|
p = jparse_value(p, &val);
|
|
if (key && val) {
|
|
if (v->obj.count >= v->obj.cap) {
|
|
v->obj.cap = v->obj.cap ? v->obj.cap*2 : 4;
|
|
v->obj.keys = realloc(v->obj.keys, v->obj.cap * sizeof(char*));
|
|
v->obj.vals = realloc(v->obj.vals, v->obj.cap * sizeof(jval_t*));
|
|
}
|
|
v->obj.keys[v->obj.count] = key;
|
|
v->obj.vals[v->obj.count] = val;
|
|
v->obj.count++;
|
|
} else { free(key); jval_free(val); }
|
|
p = jskip(p); if (*p == ',') p++;
|
|
p = jskip(p);
|
|
}
|
|
if (*p == '}') p++;
|
|
*out = v; return p;
|
|
}
|
|
|
|
static const char *jparse_array(const char *p, jval_t **out) {
|
|
if (*p != '[') return NULL;
|
|
p++;
|
|
jval_t *v = calloc(1, sizeof(jval_t)); v->type = JT_ARRAY;
|
|
p = jskip(p);
|
|
while (*p && *p != ']') {
|
|
jval_t *item = NULL;
|
|
p = jparse_value(jskip(p), &item);
|
|
if (item) {
|
|
if (v->arr.count >= v->arr.cap) {
|
|
v->arr.cap = v->arr.cap ? v->arr.cap*2 : 4;
|
|
v->arr.items = realloc(v->arr.items, v->arr.cap * sizeof(jval_t*));
|
|
}
|
|
v->arr.items[v->arr.count++] = item;
|
|
}
|
|
p = jskip(p); if (*p == ',') p++;
|
|
}
|
|
if (*p == ']') p++;
|
|
*out = v; return p;
|
|
}
|
|
|
|
static const char *jparse_value(const char *p, jval_t **out) {
|
|
p = jskip(p);
|
|
if (!*p) { *out = NULL; return p; }
|
|
if (*p == '{') return jparse_object(p, out);
|
|
if (*p == '[') return jparse_array(p, out);
|
|
if (*p == '"') {
|
|
char *s = NULL; p = jparse_string(p, &s);
|
|
jval_t *v = calloc(1, sizeof(jval_t)); v->type = JT_STRING; v->s = s;
|
|
*out = v; return p;
|
|
}
|
|
if (strncmp(p,"true",4)==0) { jval_t *v=calloc(1,sizeof(jval_t)); v->type=JT_BOOL; v->b=true; *out=v; return p+4; }
|
|
if (strncmp(p,"false",5)==0) { jval_t *v=calloc(1,sizeof(jval_t)); v->type=JT_BOOL; v->b=false; *out=v; return p+5; }
|
|
if (strncmp(p,"null",4)==0) { jval_t *v=calloc(1,sizeof(jval_t)); v->type=JT_NULL; *out=v; return p+4; }
|
|
if (isdigit((unsigned char)*p) || *p == '-') {
|
|
char *e1, *e2;
|
|
long long iv = strtoll(p, &e1, 10);
|
|
double fv = strtod(p, &e2);
|
|
if (e2 > e1) {
|
|
jval_t *v=calloc(1,sizeof(jval_t)); v->type=JT_FLOAT; v->f=fv; *out=v; return e2;
|
|
} else {
|
|
jval_t *v=calloc(1,sizeof(jval_t)); v->type=JT_INT; v->i=iv; *out=v; return e1;
|
|
}
|
|
}
|
|
*out = NULL; return p + 1;
|
|
}
|
|
|
|
static jval_t *json_parse(const char *src) {
|
|
jval_t *v = NULL; jparse_value(src, &v); return v;
|
|
}
|
|
|
|
static jval_t *jget(const jval_t *obj, const char *key) {
|
|
if (!obj || obj->type != JT_OBJECT) return NULL;
|
|
for (int i = 0; i < obj->obj.count; i++)
|
|
if (strcmp(obj->obj.keys[i], key) == 0) return obj->obj.vals[i];
|
|
return NULL;
|
|
}
|
|
|
|
static long long jint(const jval_t *v, long long def) {
|
|
if (!v) return def;
|
|
if (v->type==JT_INT) return v->i;
|
|
if (v->type==JT_FLOAT) return (long long)v->f;
|
|
if (v->type==JT_BOOL) return v->b ? 1 : 0;
|
|
return def;
|
|
}
|
|
static const char *jstr(const jval_t *v, const char *def) {
|
|
return (!v || v->type!=JT_STRING) ? def : v->s;
|
|
}
|
|
|
|
/* ============================================================
|
|
* Config
|
|
* ============================================================ */
|
|
|
|
typedef struct {
|
|
int hb_port, interval;
|
|
char owner[256];
|
|
|
|
char ping_hosts[MAX_PING_HOSTS][256];
|
|
int ping_host_count, ping_interval, ping_count, ping_timeout;
|
|
|
|
struct { char name[64]; char cmd[512]; } nagios[MAX_NAGIOS_CMDS];
|
|
int nagios_count, nagios_interval, nagios_timeout;
|
|
|
|
int cpu_interval, mem_interval, disk_interval, net_interval;
|
|
|
|
char disk_mounts[MAX_DISK_MOUNTS][256];
|
|
int disk_mount_count;
|
|
|
|
char net_skip[MAX_NET_SKIP][64];
|
|
int net_skip_count;
|
|
} config_t;
|
|
|
|
static void config_defaults(config_t *c) {
|
|
memset(c, 0, sizeof(*c));
|
|
c->hb_port = DEFAULT_PORT;
|
|
c->interval = DEFAULT_INTERVAL;
|
|
c->ping_interval = 60; c->ping_count = 3; c->ping_timeout = 5;
|
|
c->nagios_interval = 300; c->nagios_timeout = 30;
|
|
c->cpu_interval = 300;
|
|
c->mem_interval = 300;
|
|
c->disk_interval = 300;
|
|
c->net_interval = 300;
|
|
snprintf(c->net_skip[0], 64, "lo");
|
|
c->net_skip_count = 1;
|
|
}
|
|
|
|
static void config_load(config_t *cfg, const char *path) {
|
|
config_defaults(cfg);
|
|
char fpath[512];
|
|
if (!path) {
|
|
const char *home = getenv("HOME");
|
|
snprintf(fpath, sizeof(fpath), "%s/.hbc.json", home ? home : "");
|
|
path = fpath;
|
|
}
|
|
FILE *f = fopen(path, "r");
|
|
if (!f) return;
|
|
fseek(f, 0, SEEK_END); long sz = ftell(f); fseek(f, 0, SEEK_SET);
|
|
char *buf = malloc(sz + 1);
|
|
if (!buf) { fclose(f); return; }
|
|
size_t _nr = fread(buf, 1, sz, f); buf[_nr] = '\0'; fclose(f);
|
|
jval_t *root = json_parse(buf); free(buf);
|
|
if (!root || root->type != JT_OBJECT) { LOGW("cannot parse %s", path); jval_free(root); return; }
|
|
|
|
jval_t *v;
|
|
if ((v = jget(root, "hb_port"))) cfg->hb_port = jint(v, cfg->hb_port);
|
|
if ((v = jget(root, "interval"))) cfg->interval = jint(v, cfg->interval);
|
|
if ((v = jget(root, "owner"))) snprintf(cfg->owner, sizeof(cfg->owner), "%s", jstr(v, ""));
|
|
|
|
jval_t *plugins = jget(root, "plugins");
|
|
|
|
/* ping_monitor */
|
|
jval_t *pm = plugins ? jget(plugins,"ping_monitor") : jget(root,"ping_monitor");
|
|
if (pm && pm->type == JT_OBJECT) {
|
|
if ((v=jget(pm,"interval"))) cfg->ping_interval = jint(v, cfg->ping_interval);
|
|
if ((v=jget(pm,"count"))) cfg->ping_count = jint(v, cfg->ping_count);
|
|
if ((v=jget(pm,"timeout"))) cfg->ping_timeout = jint(v, cfg->ping_timeout);
|
|
jval_t *h = jget(pm, "hosts");
|
|
if (h && h->type == JT_ARRAY) {
|
|
for (int i = 0; i < h->arr.count && cfg->ping_host_count < MAX_PING_HOSTS; i++) {
|
|
const char *s = jstr(h->arr.items[i], NULL);
|
|
if (s) snprintf(cfg->ping_hosts[cfg->ping_host_count++], 256, "%s", s);
|
|
}
|
|
} else if (h && h->type == JT_OBJECT) {
|
|
for (int i = 0; i < h->obj.count && cfg->ping_host_count < MAX_PING_HOSTS; i++)
|
|
snprintf(cfg->ping_hosts[cfg->ping_host_count++], 256, "%s", h->obj.keys[i]);
|
|
}
|
|
}
|
|
|
|
/* nagios_runner */
|
|
jval_t *nr = plugins ? jget(plugins,"nagios_runner") : jget(root,"nagios_runner");
|
|
if (nr && nr->type == JT_OBJECT) {
|
|
if ((v=jget(nr,"interval"))) cfg->nagios_interval = jint(v, cfg->nagios_interval);
|
|
if ((v=jget(nr,"timeout"))) cfg->nagios_timeout = jint(v, cfg->nagios_timeout);
|
|
jval_t *cmds = jget(nr, "commands");
|
|
if (cmds && cmds->type == JT_ARRAY) {
|
|
for (int i = 0; i < cmds->arr.count && cfg->nagios_count < MAX_NAGIOS_CMDS; i++) {
|
|
jval_t *c = cmds->arr.items[i];
|
|
if (!c || c->type != JT_OBJECT) continue;
|
|
jval_t *n = jget(c,"name"), *cmd = jget(c,"command");
|
|
if (n && cmd) {
|
|
int idx = cfg->nagios_count++;
|
|
snprintf(cfg->nagios[idx].name, 64, "%s", jstr(n, ""));
|
|
snprintf(cfg->nagios[idx].cmd, 512, "%s", jstr(cmd, ""));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* cpu/memory/disk/network */
|
|
jval_t *cpu = plugins ? jget(plugins,"cpu_monitor") : jget(root,"cpu_monitor");
|
|
if (cpu && (v=jget(cpu,"interval"))) cfg->cpu_interval = jint(v, cfg->cpu_interval);
|
|
|
|
jval_t *mem = plugins ? jget(plugins,"memory_monitor") : jget(root,"memory_monitor");
|
|
if (mem && (v=jget(mem,"interval"))) cfg->mem_interval = jint(v, cfg->mem_interval);
|
|
|
|
jval_t *disk = plugins ? jget(plugins,"disk_monitor") : jget(root,"disk_monitor");
|
|
if (disk && disk->type == JT_OBJECT) {
|
|
if ((v=jget(disk,"interval"))) cfg->disk_interval = jint(v, cfg->disk_interval);
|
|
jval_t *m = jget(disk,"mounts");
|
|
if (m && m->type == JT_ARRAY)
|
|
for (int i = 0; i < m->arr.count && cfg->disk_mount_count < MAX_DISK_MOUNTS; i++) {
|
|
const char *s = jstr(m->arr.items[i], NULL);
|
|
if (s) snprintf(cfg->disk_mounts[cfg->disk_mount_count++], 256, "%s", s);
|
|
}
|
|
}
|
|
|
|
jval_t *net = plugins ? jget(plugins,"network_monitor") : jget(root,"network_monitor");
|
|
if (net && net->type == JT_OBJECT) {
|
|
if ((v=jget(net,"interval"))) cfg->net_interval = jint(v, cfg->net_interval);
|
|
jval_t *sk = jget(net,"skip_interfaces");
|
|
if (sk && sk->type == JT_ARRAY) {
|
|
cfg->net_skip_count = 0;
|
|
for (int i = 0; i < sk->arr.count && cfg->net_skip_count < MAX_NET_SKIP; i++) {
|
|
const char *s = jstr(sk->arr.items[i], NULL);
|
|
if (s) snprintf(cfg->net_skip[cfg->net_skip_count++], 64, "%s", s);
|
|
}
|
|
}
|
|
}
|
|
|
|
LOGI("loaded config from %s", path);
|
|
jval_free(root);
|
|
}
|
|
|
|
/* ============================================================
|
|
* UDP connection
|
|
* ============================================================ */
|
|
|
|
typedef struct {
|
|
int conn_id;
|
|
char addr[INET6_ADDRSTRLEN];
|
|
int port, af, sockfd;
|
|
char name[256];
|
|
long long ack_count;
|
|
double last_send, rtt;
|
|
volatile bool request_info;
|
|
pthread_mutex_t mu;
|
|
} conn_t;
|
|
|
|
static double now_ts(void) {
|
|
struct timespec ts;
|
|
clock_gettime(CLOCK_REALTIME, &ts);
|
|
return ts.tv_sec + ts.tv_nsec * 1e-9;
|
|
}
|
|
|
|
static bool conn_open(conn_t *c) {
|
|
c->sockfd = socket(c->af, SOCK_DGRAM, 0);
|
|
if (c->sockfd < 0) { LOGE("socket: %s", strerror(errno)); return false; }
|
|
int fl = fcntl(c->sockfd, F_GETFL, 0);
|
|
fcntl(c->sockfd, F_SETFL, fl | O_NONBLOCK);
|
|
pthread_mutex_init(&c->mu, NULL);
|
|
return true;
|
|
}
|
|
|
|
static void conn_close(conn_t *c) {
|
|
if (c->sockfd >= 0) { close(c->sockfd); c->sockfd = -1; }
|
|
}
|
|
|
|
static int conn_send(conn_t *c, const char *msg_id, kvdict_t *d) {
|
|
kv_set(d, "name", c->name);
|
|
char buf[32];
|
|
snprintf(buf, sizeof(buf), "%d", c->conn_id); kv_set(d, "id", buf);
|
|
snprintf(buf, sizeof(buf), "%.3f", now_ts()); kv_set(d, "time", buf);
|
|
|
|
uint8_t wire[PROTO_BUF_SIZE];
|
|
int wlen = proto_encode(msg_id, d, wire, sizeof(wire));
|
|
if (wlen < 0) { LOGW("proto_encode failed"); return -1; }
|
|
|
|
struct sockaddr_storage sa; socklen_t salen = 0;
|
|
memset(&sa, 0, sizeof(sa));
|
|
if (c->af == AF_INET) {
|
|
struct sockaddr_in *s4 = (struct sockaddr_in *)&sa;
|
|
s4->sin_family = AF_INET;
|
|
s4->sin_port = htons(c->port);
|
|
inet_pton(AF_INET, c->addr, &s4->sin_addr);
|
|
salen = sizeof(*s4);
|
|
} else {
|
|
struct sockaddr_in6 *s6 = (struct sockaddr_in6 *)&sa;
|
|
s6->sin6_family = AF_INET6;
|
|
s6->sin6_port = htons(c->port);
|
|
inet_pton(AF_INET6, c->addr, &s6->sin6_addr);
|
|
salen = sizeof(*s6);
|
|
}
|
|
|
|
pthread_mutex_lock(&c->mu);
|
|
c->last_send = now_ts();
|
|
ssize_t sent = sendto(c->sockfd, wire, wlen, 0, (struct sockaddr *)&sa, salen);
|
|
pthread_mutex_unlock(&c->mu);
|
|
return (sent == wlen) ? 0 : -1;
|
|
}
|
|
|
|
static void conn_recv(conn_t *c) {
|
|
uint8_t buf[PROTO_BUF_SIZE];
|
|
struct sockaddr_storage sa; socklen_t sl = sizeof(sa);
|
|
ssize_t n = recvfrom(c->sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&sa, &sl);
|
|
if (n <= 0) return;
|
|
|
|
kvdict_t msg;
|
|
if (!proto_decode(buf, (int)n, &msg)) return;
|
|
const char *id = kv_get(&msg, "ID");
|
|
if (!id) return;
|
|
|
|
if (strcmp(id, "ACK") == 0) {
|
|
c->rtt = (now_ts() - c->last_send) * 1000.0;
|
|
c->ack_count++;
|
|
const char *ru = kv_get(&msg, "request_update");
|
|
if (ru && strcmp(ru,"1") == 0) c->request_info = true;
|
|
LOGD("ACK rtt=%.1fms", c->rtt);
|
|
} else if (strcmp(id, "CMD") == 0) {
|
|
const char *cmd = kv_get(&msg, "cmd");
|
|
if (cmd) {
|
|
LOGI("CMD: %s", cmd);
|
|
char out[4096] = "";
|
|
FILE *p = popen(cmd, "r");
|
|
if (p) { size_t _r = fread(out, 1, sizeof(out)-1, p); (void)_r; pclose(p); }
|
|
kvdict_t rep; kv_clear(&rep);
|
|
kv_set(&rep, "service", "command");
|
|
kv_set(&rep, "msg", out[0] ? out : "OK");
|
|
conn_send(c, "HTB", &rep);
|
|
}
|
|
} else if (strcmp(id, "UPD") == 0) {
|
|
LOGI("UPD: update requested (not implemented in C version)");
|
|
}
|
|
}
|
|
|
|
/* ============================================================
|
|
* Global state
|
|
* ============================================================ */
|
|
|
|
static volatile bool g_running = true;
|
|
static volatile bool g_restart = false;
|
|
static conn_t g_conns[MAX_HOSTS];
|
|
static int g_nconns = 0;
|
|
|
|
static void sig_handler(int sig) {
|
|
if (sig == SIGHUP) g_restart = true;
|
|
g_running = false;
|
|
}
|
|
|
|
/* ============================================================
|
|
* Plugin: os_info
|
|
* ============================================================ */
|
|
|
|
static void plugin_os_info(conn_t *c, const config_t *cfg) {
|
|
kvdict_t d; kv_clear(&d);
|
|
kv_set(&d, "plugin", "os_info");
|
|
struct utsname u;
|
|
if (uname(&u) == 0) {
|
|
kv_set(&d, "system", u.sysname);
|
|
kv_set(&d, "node", u.nodename);
|
|
kv_set(&d, "release", u.release);
|
|
kv_set(&d, "machine", u.machine);
|
|
}
|
|
kv_set(&d, "hbc_version", HBC_VERSION);
|
|
kv_set(&d, "hbc_type", "mini-c");
|
|
if (cfg->owner[0]) kv_set(&d, "owner", cfg->owner);
|
|
|
|
#ifdef __linux__
|
|
{
|
|
FILE *f = fopen("/etc/os-release", "r");
|
|
if (!f) f = fopen("/etc/lsb-release", "r");
|
|
if (f) {
|
|
char line[512];
|
|
while (fgets(line, sizeof(line), f)) {
|
|
char *eq = strchr(line, '=');
|
|
if (!eq || line[0] == '#') continue;
|
|
*eq = '\0';
|
|
char *val = eq + 1;
|
|
int vl = strlen(val);
|
|
while (vl > 0 && (val[vl-1]=='\n'||val[vl-1]=='\r'||val[vl-1]=='"'||val[vl-1]=='\'')) val[--vl]='\0';
|
|
if (*val == '"' || *val == '\'') val++;
|
|
if (strcmp(line,"PRETTY_NAME")==0) kv_set(&d, "distro_pretty_name", val);
|
|
else if (strcmp(line,"NAME")==0) kv_set(&d, "distro_name", val);
|
|
else if (strcmp(line,"VERSION_ID")==0) kv_set(&d, "distro_version_id", val);
|
|
else if (strcmp(line,"ID")==0) kv_set(&d, "distro_id", val);
|
|
}
|
|
fclose(f);
|
|
}
|
|
}
|
|
#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__)
|
|
{
|
|
char osver[128] = ""; size_t len = sizeof(osver);
|
|
sysctlbyname("kern.osrelease", osver, &len, NULL, 0);
|
|
if (osver[0]) kv_set(&d, "distro_version_id", osver);
|
|
}
|
|
#endif
|
|
conn_send(c, "PLG", &d);
|
|
LOGI("sent os_info");
|
|
}
|
|
|
|
/* ============================================================
|
|
* Plugin: cpu_monitor
|
|
* Linux: /proc/stat (user nice sys idle iowait irq softirq steal)
|
|
* BSD: sysctl kern.cp_time (CP_USER CP_NICE CP_SYS CP_INTR CP_IDLE)
|
|
* ============================================================ */
|
|
|
|
typedef struct {
|
|
long long user, sys, idle, iowait, total;
|
|
} cpu_sample_t;
|
|
|
|
#ifdef __linux__
|
|
|
|
static bool read_cpu_sample(cpu_sample_t *s) {
|
|
FILE *f = fopen("/proc/stat", "r");
|
|
if (!f) return false;
|
|
char line[256]; bool ok = false;
|
|
while (fgets(line, sizeof(line), f)) {
|
|
if (strncmp(line, "cpu ", 4) != 0) continue;
|
|
long long u=0, ni=0, sy=0, id=0, iow=0, irq=0, sirq=0;
|
|
int n = sscanf(line+4, "%lld %lld %lld %lld %lld %lld %lld",
|
|
&u, &ni, &sy, &id, &iow, &irq, &sirq);
|
|
if (n < 4) break;
|
|
s->user = u + ni;
|
|
s->sys = sy + irq + sirq;
|
|
s->idle = id;
|
|
s->iowait = (n >= 5) ? iow : 0;
|
|
s->total = u + ni + sy + id + iow + irq + sirq;
|
|
ok = true; break;
|
|
}
|
|
fclose(f); return ok;
|
|
}
|
|
|
|
static void read_cpu_extras(kvdict_t *d) {
|
|
FILE *fi = fopen("/proc/cpuinfo", "r");
|
|
if (fi) {
|
|
char ln[256]; int cores = 0;
|
|
while (fgets(ln, sizeof(ln), fi)) if (strncmp(ln,"processor",9)==0) cores++;
|
|
fclose(fi);
|
|
if (cores > 0) kv_set_int(d, "cpu_core_count", cores);
|
|
}
|
|
fi = fopen("/proc/uptime", "r");
|
|
if (fi) {
|
|
double up = 0;
|
|
if (fscanf(fi, "%lf", &up) == 1) kv_set_int(d, "uptime_seconds", (long long)up);
|
|
fclose(fi);
|
|
}
|
|
}
|
|
|
|
#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__)
|
|
|
|
static bool read_cpu_sample(cpu_sample_t *s) {
|
|
/* kern.cp_time: CP_USER(0) CP_NICE(1) CP_SYS(2) CP_INTR(3) CP_IDLE(4) */
|
|
unsigned long cp[5] = {0};
|
|
size_t len = sizeof(cp);
|
|
if (sysctlbyname("kern.cp_time", cp, &len, NULL, 0) != 0) return false;
|
|
s->user = (long long)cp[0] + (long long)cp[1];
|
|
s->sys = (long long)cp[2] + (long long)cp[3]; /* SYS + INTR */
|
|
s->idle = (long long)cp[4];
|
|
s->iowait = 0;
|
|
s->total = s->user + (long long)cp[2] + (long long)cp[3] + s->idle;
|
|
return true;
|
|
}
|
|
|
|
static void read_cpu_extras(kvdict_t *d) {
|
|
int ncpu = 0; size_t len = sizeof(ncpu);
|
|
if (sysctlbyname("hw.ncpu", &ncpu, &len, NULL, 0) == 0 && ncpu > 0)
|
|
kv_set_int(d, "cpu_core_count", ncpu);
|
|
struct timeval bt; len = sizeof(bt);
|
|
if (sysctlbyname("kern.boottime", &bt, &len, NULL, 0) == 0)
|
|
kv_set_int(d, "uptime_seconds", (long long)(time(NULL) - bt.tv_sec));
|
|
}
|
|
|
|
#endif /* platform cpu */
|
|
|
|
static cpu_sample_t g_cpu_prev;
|
|
static bool g_cpu_have_prev = false;
|
|
|
|
static void plugin_cpu_monitor(conn_t *c, const config_t *cfg) {
|
|
(void)cfg;
|
|
cpu_sample_t t1, t2;
|
|
if (!g_cpu_have_prev) {
|
|
if (!read_cpu_sample(&t1)) return;
|
|
sleep(1);
|
|
if (!read_cpu_sample(&t2)) return;
|
|
} else {
|
|
t1 = g_cpu_prev;
|
|
if (!read_cpu_sample(&t2)) return;
|
|
}
|
|
g_cpu_prev = t2; g_cpu_have_prev = true;
|
|
|
|
long long idle_delta = (t2.idle + t2.iowait) - (t1.idle + t1.iowait);
|
|
long long total_delta = t2.total - t1.total;
|
|
if (total_delta == 0) return;
|
|
|
|
kvdict_t d; kv_clear(&d);
|
|
kv_set(&d, "plugin", "cpu_monitor");
|
|
kv_set_dbl(&d, "cpu_percent", round(100.0*(1.0-(double)idle_delta/total_delta)*10)/10.0);
|
|
kv_set_dbl(&d, "cpu_user", round(100.0*(t2.user - t1.user) / total_delta*10)/10.0);
|
|
kv_set_dbl(&d, "cpu_system", round(100.0*(t2.sys - t1.sys) / total_delta*10)/10.0);
|
|
kv_set_dbl(&d, "cpu_idle", round(100.0*(t2.idle - t1.idle) / total_delta*10)/10.0);
|
|
if (t2.iowait || t1.iowait)
|
|
kv_set_dbl(&d, "cpu_iowait", round(100.0*(t2.iowait - t1.iowait) / total_delta*10)/10.0);
|
|
double la[3];
|
|
if (getloadavg(la, 3) == 3) {
|
|
kv_set_dbl(&d, "load_1min", round(la[0]*100)/100.0);
|
|
kv_set_dbl(&d, "load_5min", round(la[1]*100)/100.0);
|
|
kv_set_dbl(&d, "load_15min", round(la[2]*100)/100.0);
|
|
}
|
|
read_cpu_extras(&d);
|
|
kv_set_dbl(&d, "_timestamp", now_ts());
|
|
conn_send(c, "PLG", &d);
|
|
LOGD("sent cpu_monitor");
|
|
}
|
|
|
|
/* ============================================================
|
|
* Plugin: memory_monitor
|
|
* Linux: /proc/meminfo
|
|
* FreeBSD: sysctl vm.stats.vm.*
|
|
* NetBSD: sysctl vm.uvmexp (struct uvmexp_sysctl)
|
|
* ============================================================ */
|
|
|
|
/* emit the common kvdict fields and send */
|
|
static void mem_send(conn_t *c,
|
|
long long tot, long long used, long long av, long long fr,
|
|
long long act, long long ina, long long cac, long long buf,
|
|
long long stot, long long sused) {
|
|
kvdict_t d; kv_clear(&d);
|
|
kv_set(&d, "plugin", "memory_monitor");
|
|
kv_set_ull(&d, "memory_total", (unsigned long long)tot);
|
|
kv_set_ull(&d, "memory_used", (unsigned long long)used);
|
|
kv_set_ull(&d, "memory_available", (unsigned long long)av);
|
|
kv_set_ull(&d, "memory_free", (unsigned long long)fr);
|
|
char pct[32];
|
|
snprintf(pct, sizeof(pct), "%.1f", tot ? 100.0*used/tot : 0.0);
|
|
kv_set(&d, "memory_percent", pct);
|
|
if (buf) kv_set_ull(&d, "memory_buffers", (unsigned long long)buf);
|
|
if (cac) kv_set_ull(&d, "memory_cached", (unsigned long long)cac);
|
|
if (act) kv_set_ull(&d, "memory_active", (unsigned long long)act);
|
|
if (ina) kv_set_ull(&d, "memory_inactive", (unsigned long long)ina);
|
|
if (stot > 0) {
|
|
long long sfr = stot - sused;
|
|
kv_set_ull(&d, "swap_total", (unsigned long long)stot);
|
|
kv_set_ull(&d, "swap_used", (unsigned long long)sused);
|
|
kv_set_ull(&d, "swap_free", (unsigned long long)sfr);
|
|
snprintf(pct, sizeof(pct), "%.1f", 100.0*sused/stot);
|
|
kv_set(&d, "swap_percent", pct);
|
|
}
|
|
kv_set_dbl(&d, "_timestamp", now_ts());
|
|
conn_send(c, "PLG", &d);
|
|
LOGD("sent memory_monitor");
|
|
}
|
|
|
|
#ifdef __linux__
|
|
|
|
static void plugin_memory_monitor(conn_t *c, const config_t *cfg) {
|
|
(void)cfg;
|
|
FILE *f = fopen("/proc/meminfo", "r");
|
|
if (!f) return;
|
|
long long tot=0, fr=0, av=0, buf=0, cac=0, act=0, ina=0, stot=0, sfr=0;
|
|
char line[256];
|
|
while (fgets(line, sizeof(line), f)) {
|
|
long long v; char key[64];
|
|
if (sscanf(line, "%63s %lld", key, &v) != 2) continue;
|
|
int kl = strlen(key); if (key[kl-1]==':') key[kl-1]='\0';
|
|
if (!strcmp(key,"MemTotal")) tot=v;
|
|
else if (!strcmp(key,"MemFree")) fr=v;
|
|
else if (!strcmp(key,"MemAvailable")) av=v;
|
|
else if (!strcmp(key,"Buffers")) buf=v;
|
|
else if (!strcmp(key,"Cached")) cac=v;
|
|
else if (!strcmp(key,"Active")) act=v;
|
|
else if (!strcmp(key,"Inactive")) ina=v;
|
|
else if (!strcmp(key,"SwapTotal")) stot=v;
|
|
else if (!strcmp(key,"SwapFree")) sfr=v;
|
|
}
|
|
fclose(f);
|
|
if (!tot) return;
|
|
if (!av) av = fr;
|
|
|
|
/* ZFS ARC is reclaimable memory not counted in MemAvailable */
|
|
long long arc_kb = 0;
|
|
FILE *arc = fopen("/proc/spl/kstat/zfs/arcstats", "r");
|
|
if (arc) {
|
|
char ak[64]; long long av2; int at;
|
|
while (fscanf(arc, "%63s %d %lld\n", ak, &at, &av2) == 3)
|
|
if (!strcmp(ak,"size")) { arc_kb = av2/1024; break; }
|
|
fclose(arc);
|
|
}
|
|
av = (av + arc_kb < tot) ? av + arc_kb : tot;
|
|
long long used = tot - av;
|
|
/* values from /proc/meminfo are in kB */
|
|
mem_send(c, tot*1024, used*1024, av*1024, fr*1024,
|
|
act*1024, ina*1024, cac*1024, buf*1024,
|
|
stot*1024, (stot-sfr)*1024);
|
|
}
|
|
|
|
#elif defined(__FreeBSD__) || defined(__DragonFly__)
|
|
|
|
static void plugin_memory_monitor(conn_t *c, const config_t *cfg) {
|
|
(void)cfg;
|
|
long ps = getpagesize();
|
|
|
|
unsigned long physmem = 0; size_t len = sizeof(physmem);
|
|
sysctlbyname("hw.physmem", &physmem, &len, NULL, 0);
|
|
if (!physmem) return;
|
|
|
|
unsigned int v_free=0, v_inactive=0, v_active=0, v_cache=0;
|
|
len = sizeof(v_free); sysctlbyname("vm.stats.vm.v_free_count", &v_free, &len, NULL, 0);
|
|
len = sizeof(v_inactive); sysctlbyname("vm.stats.vm.v_inactive_count", &v_inactive, &len, NULL, 0);
|
|
len = sizeof(v_active); sysctlbyname("vm.stats.vm.v_active_count", &v_active, &len, NULL, 0);
|
|
len = sizeof(v_cache); sysctlbyname("vm.stats.vm.v_cache_count", &v_cache, &len, NULL, 0);
|
|
|
|
long long tot = (long long)physmem;
|
|
long long fr = (long long)v_free * ps;
|
|
long long act = (long long)v_active * ps;
|
|
long long ina = (long long)v_inactive * ps;
|
|
long long cac = (long long)v_cache * ps;
|
|
long long av = fr + ina + cac; if (av > tot) av = tot;
|
|
long long used = tot - av;
|
|
mem_send(c, tot, used, av, fr, act, ina, cac, 0, 0, 0);
|
|
}
|
|
|
|
#elif defined(__NetBSD__)
|
|
|
|
static void plugin_memory_monitor(conn_t *c, const config_t *cfg) {
|
|
(void)cfg;
|
|
struct uvmexp_sysctl uvm;
|
|
size_t len = sizeof(uvm);
|
|
int mib[2] = {CTL_VM, VM_UVMEXP2};
|
|
if (sysctl(mib, 2, &uvm, &len, NULL, 0) != 0) return;
|
|
|
|
long long ps = uvm.pagesize;
|
|
long long tot = (long long)uvm.npages * ps;
|
|
long long fr = (long long)uvm.free * ps;
|
|
long long act = (long long)uvm.active * ps;
|
|
long long ina = (long long)uvm.inactive * ps;
|
|
long long av = fr + ina; if (av > tot) av = tot;
|
|
long long used = tot - av;
|
|
long long stot = (long long)uvm.swpages * ps;
|
|
long long sinuse = (long long)uvm.swpginuse * ps;
|
|
mem_send(c, tot, used, av, fr, act, ina, 0, 0, stot, sinuse);
|
|
}
|
|
|
|
#endif /* platform memory */
|
|
|
|
/* ============================================================
|
|
* Plugin: disk_monitor (df -P)
|
|
* ============================================================ */
|
|
|
|
static void plugin_disk_monitor(conn_t *c, const config_t *cfg) {
|
|
FILE *f = popen("df -P", "r");
|
|
if (!f) return;
|
|
|
|
char *json = malloc(MAX_VAL); if (!json) { pclose(f); return; }
|
|
int jlen = 0; bool first = true;
|
|
json[jlen++] = '{';
|
|
|
|
char line[512];
|
|
if (!fgets(line, sizeof(line), f)) { pclose(f); free(json); return; } /* skip header */
|
|
while (fgets(line, sizeof(line), f)) {
|
|
char fs[256], mount[256], pcts[16];
|
|
long long tk, uk, ak; int pct;
|
|
if (sscanf(line, "%255s %lld %lld %lld %15s %255s", fs, &tk, &uk, &ak, pcts, mount) != 6) continue;
|
|
pct = atoi(pcts);
|
|
if (cfg->disk_mount_count > 0) {
|
|
bool found = false;
|
|
for (int i = 0; i < cfg->disk_mount_count; i++)
|
|
if (!strcmp(cfg->disk_mounts[i], mount)) { found=true; break; }
|
|
if (!found) continue;
|
|
}
|
|
/* JSON-escape the mount point */
|
|
char esc[512]; int ei = 0;
|
|
for (int i = 0; mount[i] && ei < (int)sizeof(esc)-2; i++) {
|
|
if (mount[i]=='"'||mount[i]=='\\') esc[ei++]='\\';
|
|
esc[ei++] = mount[i];
|
|
}
|
|
esc[ei] = '\0';
|
|
char entry[512];
|
|
int el = snprintf(entry, sizeof(entry),
|
|
"%s\"%s\":{\"total\":%lld,\"used\":%lld,\"free\":%lld,\"percent\":%d}",
|
|
first ? "" : ",", esc, tk*1024, uk*1024, ak*1024, pct);
|
|
if (jlen + el < MAX_VAL - 2) { memcpy(json+jlen, entry, el); jlen+=el; first=false; }
|
|
}
|
|
pclose(f);
|
|
json[jlen++] = '}'; json[jlen] = '\0';
|
|
if (first) { free(json); return; }
|
|
|
|
kvdict_t d; kv_clear(&d);
|
|
kv_set(&d, "plugin", "disk_monitor");
|
|
char *jval = malloc(MAX_VAL + 1);
|
|
if (jval) { snprintf(jval, MAX_VAL, "@%s", json); kv_set(&d, "partitions", jval); free(jval); }
|
|
kv_set_dbl(&d, "_timestamp", now_ts());
|
|
conn_send(c, "PLG", &d);
|
|
free(json);
|
|
LOGD("sent disk_monitor");
|
|
}
|
|
|
|
/* ============================================================
|
|
* Plugin: network_monitor
|
|
* Linux: /proc/net/dev
|
|
* BSD: getifaddrs() + struct if_data (AF_LINK)
|
|
* ============================================================ */
|
|
|
|
typedef struct { char iface[64]; unsigned long long rx, tx; } net_stat_t;
|
|
static net_stat_t g_net_prev[64];
|
|
static int g_net_prev_n = 0;
|
|
static double g_net_prev_ts = 0;
|
|
|
|
#ifdef __linux__
|
|
|
|
static int read_net_stats(net_stat_t *out, int max) {
|
|
FILE *f = fopen("/proc/net/dev", "r");
|
|
if (!f) return 0;
|
|
char line[512]; int n = 0;
|
|
if (!fgets(line, sizeof(line), f)) { fclose(f); return 0; } /* header 1 */
|
|
if (!fgets(line, sizeof(line), f)) { fclose(f); return 0; } /* header 2 */
|
|
while (fgets(line, sizeof(line), f) && n < max) {
|
|
char *col = strchr(line, ':');
|
|
if (!col) continue;
|
|
*col = '\0';
|
|
char *iface = line; while (*iface==' ') iface++;
|
|
unsigned long long rx, tx, dummy;
|
|
if (sscanf(col+1, "%llu %llu %llu %llu %llu %llu %llu %llu %llu",
|
|
&rx,&dummy,&dummy,&dummy,&dummy,&dummy,&dummy,&dummy,&tx) == 9) {
|
|
snprintf(out[n].iface, 64, "%.*s", 63, iface);
|
|
out[n].rx = rx; out[n].tx = tx; n++;
|
|
}
|
|
}
|
|
fclose(f); return n;
|
|
}
|
|
|
|
#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__)
|
|
|
|
static int read_net_stats(net_stat_t *out, int max) {
|
|
struct ifaddrs *ifap;
|
|
if (getifaddrs(&ifap) != 0) return 0;
|
|
int n = 0;
|
|
for (struct ifaddrs *ifa = ifap; ifa && n < max; ifa = ifa->ifa_next) {
|
|
if (!ifa->ifa_addr || ifa->ifa_addr->sa_family != AF_LINK) continue;
|
|
struct if_data *ifd = (struct if_data *)ifa->ifa_data;
|
|
if (!ifd) continue;
|
|
snprintf(out[n].iface, 64, "%.*s", 63, ifa->ifa_name);
|
|
out[n].rx = (unsigned long long)ifd->ifi_ibytes;
|
|
out[n].tx = (unsigned long long)ifd->ifi_obytes;
|
|
n++;
|
|
}
|
|
freeifaddrs(ifap);
|
|
return n;
|
|
}
|
|
|
|
#endif /* platform network */
|
|
|
|
static void plugin_network_monitor(conn_t *c, const config_t *cfg) {
|
|
net_stat_t curr[64];
|
|
int cn = read_net_stats(curr, 64);
|
|
double now = now_ts();
|
|
|
|
if (g_net_prev_n == 0) {
|
|
memcpy(g_net_prev, curr, cn * sizeof(net_stat_t));
|
|
g_net_prev_n = cn; g_net_prev_ts = now;
|
|
return;
|
|
}
|
|
double dt = now - g_net_prev_ts;
|
|
if (dt <= 0) return;
|
|
|
|
char *json = malloc(MAX_VAL); if (!json) return;
|
|
int jlen = 0; bool first = true;
|
|
json[jlen++] = '{';
|
|
|
|
for (int i = 0; i < cn; i++) {
|
|
bool skip = false;
|
|
for (int s = 0; s < cfg->net_skip_count; s++)
|
|
if (!strcmp(cfg->net_skip[s], curr[i].iface)) { skip=true; break; }
|
|
if (skip) continue;
|
|
net_stat_t *prev = NULL;
|
|
for (int j = 0; j < g_net_prev_n; j++)
|
|
if (!strcmp(g_net_prev[j].iface, curr[i].iface)) { prev=&g_net_prev[j]; break; }
|
|
if (!prev) continue;
|
|
long long rd = (long long)(curr[i].rx - prev->rx);
|
|
long long td = (long long)(curr[i].tx - prev->tx);
|
|
char entry[256];
|
|
int el = snprintf(entry, sizeof(entry),
|
|
"%s\"%s\":{\"bytes_recv\":%llu,\"bytes_sent\":%llu"
|
|
",\"bytes_recv_delta\":%lld,\"bytes_sent_delta\":%lld}",
|
|
first?"":"," , curr[i].iface, curr[i].rx, curr[i].tx, rd, td);
|
|
if (jlen + el < MAX_VAL - 2) { memcpy(json+jlen, entry, el); jlen+=el; first=false; }
|
|
}
|
|
json[jlen++] = '}'; json[jlen] = '\0';
|
|
memcpy(g_net_prev, curr, cn * sizeof(net_stat_t));
|
|
g_net_prev_n = cn; g_net_prev_ts = now;
|
|
if (first) { free(json); return; }
|
|
|
|
kvdict_t d; kv_clear(&d);
|
|
kv_set(&d, "plugin", "network_monitor");
|
|
char *jval = malloc(MAX_VAL + 1);
|
|
if (jval) { snprintf(jval, MAX_VAL, "@%s", json); kv_set(&d, "interfaces", jval); free(jval); }
|
|
kv_set_dbl(&d, "_timestamp", now_ts());
|
|
conn_send(c, "PLG", &d);
|
|
free(json);
|
|
LOGD("sent network_monitor");
|
|
}
|
|
|
|
/* ============================================================
|
|
* Plugin: ping_monitor
|
|
* ============================================================ */
|
|
|
|
static bool do_ping(const char *host, int count, int timeout,
|
|
double *rmin, double *ravg, double *rmax, double *loss) {
|
|
*rmin = *ravg = *rmax = 1.0/0.0; /* inf */
|
|
*loss = 100.0;
|
|
char cmd[512];
|
|
snprintf(cmd, sizeof(cmd), "ping -c %d -W %d %s 2>/dev/null", count, timeout, host);
|
|
FILE *f = popen(cmd, "r");
|
|
if (!f) return false;
|
|
char line[512]; bool got = false;
|
|
while (fgets(line, sizeof(line), f)) {
|
|
char *p = strstr(line, "% packet loss");
|
|
if (p) {
|
|
while (p > line && (isdigit((unsigned char)*(p-1)) || *(p-1)=='.')) p--;
|
|
*loss = atof(p);
|
|
}
|
|
p = strstr(line, "min/avg/max");
|
|
if (p) {
|
|
p = strchr(p, '=');
|
|
if (p) { sscanf(p+1, " %lf/%lf/%lf", rmin, ravg, rmax); got=true; }
|
|
}
|
|
}
|
|
pclose(f); return got;
|
|
}
|
|
|
|
static void plugin_ping_monitor(conn_t *c, const config_t *cfg) {
|
|
if (!cfg->ping_host_count) return;
|
|
kvdict_t d; kv_clear(&d);
|
|
kv_set(&d, "plugin", "ping_monitor");
|
|
for (int i = 0; i < cfg->ping_host_count; i++) {
|
|
double rmin, ravg, rmax, loss;
|
|
bool ok = do_ping(cfg->ping_hosts[i], cfg->ping_count, cfg->ping_timeout,
|
|
&rmin, &ravg, &rmax, &loss);
|
|
char key[300];
|
|
snprintf(key, sizeof(key), "%s", cfg->ping_hosts[i]);
|
|
for (char *p = key; *p; p++) if (!isalnum((unsigned char)*p) && *p!='_') *p='_';
|
|
char kb[512];
|
|
if (ok) {
|
|
snprintf(kb,sizeof(kb),"%s_rtt_min",key); kv_set_dbl(&d,kb,rmin);
|
|
snprintf(kb,sizeof(kb),"%s_rtt_avg",key); kv_set_dbl(&d,kb,ravg);
|
|
snprintf(kb,sizeof(kb),"%s_rtt_max",key); kv_set_dbl(&d,kb,rmax);
|
|
snprintf(kb,sizeof(kb),"%s_loss",key); kv_set_dbl(&d,kb,loss);
|
|
} else {
|
|
snprintf(kb,sizeof(kb),"%s_rtt_min",key); kv_set(&d,kb,"inf");
|
|
snprintf(kb,sizeof(kb),"%s_rtt_avg",key); kv_set(&d,kb,"inf");
|
|
snprintf(kb,sizeof(kb),"%s_rtt_max",key); kv_set(&d,kb,"inf");
|
|
snprintf(kb,sizeof(kb),"%s_loss",key); kv_set_dbl(&d,kb,100.0);
|
|
}
|
|
}
|
|
kv_set_dbl(&d, "_timestamp", now_ts());
|
|
conn_send(c, "PLG", &d);
|
|
LOGD("sent ping_monitor");
|
|
}
|
|
|
|
/* ============================================================
|
|
* Plugin: nagios_runner
|
|
* ============================================================ */
|
|
|
|
static const char *nagios_status_str(int rc) {
|
|
switch (rc) { case 0:return"OK"; case 1:return"WARNING"; case 2:return"CRITICAL"; default:return"UNKNOWN"; }
|
|
}
|
|
|
|
static void parse_perfdata(const char *output, kvdict_t *d, const char *prefix) {
|
|
const char *pipe = strchr(output, '|');
|
|
if (!pipe) return;
|
|
const char *p = pipe + 1;
|
|
while (*p) {
|
|
while (*p==' ') p++;
|
|
if (!*p) break;
|
|
char label[128]; int li = 0;
|
|
if (*p == '\'') {
|
|
p++;
|
|
while (*p && *p != '\'') label[li++] = *p++;
|
|
if (*p == '\'') p++;
|
|
} else {
|
|
while (*p && *p != '=') label[li++] = *p++;
|
|
}
|
|
label[li] = '\0';
|
|
if (*p != '=') { while (*p && *p!=' ') p++; continue; }
|
|
p++;
|
|
char val[64]; int vi = 0;
|
|
while (*p && (isdigit((unsigned char)*p) || *p=='.' || *p=='-')) val[vi++] = *p++;
|
|
val[vi] = '\0';
|
|
char uom[16]; int ui = 0;
|
|
while (*p && *p!=';' && *p!=' ') uom[ui++] = *p++;
|
|
uom[ui] = '\0';
|
|
char key[256];
|
|
snprintf(key, sizeof(key), "%s_%s", prefix, label); kv_set(d, key, val);
|
|
if (uom[0]) { snprintf(key,sizeof(key),"%s_%s_uom",prefix,label); kv_set(d,key,uom); }
|
|
for (int n=0; n<4 && *p==';'; n++) { p++; while (*p && *p!=';' && *p!=' ') p++; }
|
|
while (*p==' ') p++;
|
|
}
|
|
}
|
|
|
|
static void plugin_nagios_runner(conn_t *c, const config_t *cfg) {
|
|
if (!cfg->nagios_count) return;
|
|
kvdict_t d; kv_clear(&d);
|
|
kv_set(&d, "plugin", "nagios_runner");
|
|
for (int i = 0; i < cfg->nagios_count; i++) {
|
|
const char *name = cfg->nagios[i].name;
|
|
char output[4096] = ""; int rc = 3;
|
|
FILE *f = popen(cfg->nagios[i].cmd, "r");
|
|
if (f) {
|
|
size_t _nr = fread(output, 1, sizeof(output)-1, f); (void)_nr;
|
|
int ret = pclose(f);
|
|
rc = WIFEXITED(ret) ? WEXITSTATUS(ret) : 3;
|
|
if (rc < 0 || rc > 3) rc = 3;
|
|
}
|
|
char *nl = strchr(output, '\n'); if (nl) *nl = '\0';
|
|
char msg[512]; char *pipe = strchr(output,'|');
|
|
if (pipe) snprintf(msg, sizeof(msg), "%.*s", (int)(pipe-output), output);
|
|
else snprintf(msg, sizeof(msg), "%s", output);
|
|
char key[128];
|
|
snprintf(key,sizeof(key),"%s_status",name); kv_set(&d,key,nagios_status_str(rc));
|
|
snprintf(key,sizeof(key),"%s_status_code",name); kv_set_int(&d,key,rc);
|
|
snprintf(key,sizeof(key),"%s_output",name); kv_set(&d,key,msg);
|
|
parse_perfdata(output, &d, name);
|
|
}
|
|
kv_set_dbl(&d, "_timestamp", now_ts());
|
|
conn_send(c, "PLG", &d);
|
|
LOGD("sent nagios_runner");
|
|
}
|
|
|
|
/* ============================================================
|
|
* Monitor thread: all periodic plugins in one thread
|
|
* ============================================================ */
|
|
|
|
typedef struct { conn_t *conn; const config_t *cfg; } thread_ctx_t;
|
|
|
|
static void *monitor_thread(void *arg) {
|
|
thread_ctx_t *ctx = arg;
|
|
conn_t *conn = ctx->conn;
|
|
const config_t *cfg = ctx->cfg;
|
|
|
|
time_t next_cpu = time(NULL);
|
|
time_t next_mem = time(NULL);
|
|
time_t next_disk = time(NULL);
|
|
time_t next_net = time(NULL);
|
|
time_t next_ping = time(NULL);
|
|
time_t next_nagios = time(NULL);
|
|
|
|
/* Prime network baseline */
|
|
plugin_network_monitor(conn, cfg);
|
|
|
|
while (g_running) {
|
|
time_t now = time(NULL);
|
|
if (now >= next_cpu) { plugin_cpu_monitor(conn, cfg); next_cpu = now + cfg->cpu_interval; }
|
|
if (now >= next_mem) { plugin_memory_monitor(conn, cfg); next_mem = now + cfg->mem_interval; }
|
|
if (now >= next_disk) { plugin_disk_monitor(conn, cfg); next_disk = now + cfg->disk_interval; }
|
|
if (now >= next_net) { plugin_network_monitor(conn, cfg); next_net = now + cfg->net_interval; }
|
|
if (cfg->ping_host_count && now >= next_ping) {
|
|
plugin_ping_monitor(conn, cfg); next_ping = now + cfg->ping_interval;
|
|
}
|
|
if (cfg->nagios_count && now >= next_nagios) {
|
|
plugin_nagios_runner(conn, cfg); next_nagios = now + cfg->nagios_interval;
|
|
}
|
|
sleep(1);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/* ============================================================
|
|
* Daemonize
|
|
* ============================================================ */
|
|
|
|
static void daemonize(void) {
|
|
for (int n = 0; n < 2; n++) {
|
|
pid_t pid = fork();
|
|
if (pid < 0) { perror("fork"); exit(1); }
|
|
if (pid > 0) exit(0);
|
|
if (n == 0) { setsid(); if (chdir("/")) {}; umask(0); }
|
|
}
|
|
int fd;
|
|
fd = open("/dev/zero", O_RDONLY); if (fd>=0) { dup2(fd,0); close(fd); }
|
|
fd = open("/dev/null", O_WRONLY); if (fd>=0) { dup2(fd,1); close(fd); }
|
|
fd = open("/dev/null", O_WRONLY); if (fd>=0) { dup2(fd,2); close(fd); }
|
|
}
|
|
|
|
/* ============================================================
|
|
* CLI
|
|
* ============================================================ */
|
|
|
|
static void usage(const char *prog) {
|
|
fprintf(stderr,
|
|
"Usage: %s [options] host [host...]\n"
|
|
" -b Send boot message\n"
|
|
" -c FILE Config file (JSON)\n"
|
|
" -m MSG Send one-shot message\n"
|
|
" -n NAME Override hostname\n"
|
|
" -4 Use IPv4 only\n"
|
|
" -6 Use IPv6 only\n"
|
|
" -d Daemonize\n"
|
|
" -v Verbose (info)\n"
|
|
" -x Debug\n"
|
|
" -h Help\n", prog);
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
bool do_boot = false;
|
|
bool do_daemon = false;
|
|
const char *cfgpath = NULL;
|
|
const char *message = NULL;
|
|
const char *nameov = NULL;
|
|
int af_filter = 0;
|
|
|
|
int opt;
|
|
while ((opt = getopt(argc, argv, "bc:m:n:dvxh46")) != -1) {
|
|
switch (opt) {
|
|
case 'b': do_boot = true; break;
|
|
case 'c': cfgpath = optarg; break;
|
|
case 'm': message = optarg; break;
|
|
case 'n': nameov = optarg; break;
|
|
case 'd': do_daemon = true; break;
|
|
case 'v': g_log_level = LL_INFO; break;
|
|
case 'x': g_log_level = LL_DEBUG; break;
|
|
case '4': af_filter = AF_INET; break;
|
|
case '6': af_filter = AF_INET6; break;
|
|
case 'h': usage(argv[0]); return 0;
|
|
default: usage(argv[0]); return 1;
|
|
}
|
|
}
|
|
if (optind >= argc) { fprintf(stderr,"error: host required\n"); usage(argv[0]); return 1; }
|
|
|
|
const char *hosts[MAX_HOSTS]; int nhost = 0;
|
|
for (int i = optind; i < argc && nhost < MAX_HOSTS; i++) hosts[nhost++] = argv[i];
|
|
|
|
config_t cfg;
|
|
config_load(&cfg, cfgpath);
|
|
|
|
if (do_daemon) {
|
|
daemonize();
|
|
g_use_syslog = true;
|
|
openlog("hbc", LOG_PID, LOG_DAEMON);
|
|
}
|
|
|
|
char iam[256];
|
|
if (nameov) {
|
|
snprintf(iam, sizeof(iam), "%s", nameov);
|
|
} else {
|
|
gethostname(iam, sizeof(iam));
|
|
char *dot = strchr(iam, '.'); if (dot) *dot = '\0';
|
|
}
|
|
|
|
struct sigaction sa = {0};
|
|
sa.sa_handler = sig_handler;
|
|
sigaction(SIGTERM, &sa, NULL);
|
|
sigaction(SIGINT, &sa, NULL);
|
|
sigaction(SIGHUP, &sa, NULL);
|
|
|
|
int conn_id = 1;
|
|
int retry_delay = 5;
|
|
while (g_running && !g_nconns) {
|
|
for (int i = 0; i < nhost; i++) {
|
|
struct addrinfo hints = {0}, *res = NULL;
|
|
hints.ai_socktype = SOCK_DGRAM;
|
|
hints.ai_protocol = IPPROTO_UDP;
|
|
hints.ai_family = af_filter;
|
|
char ps[16]; snprintf(ps, sizeof(ps), "%d", cfg.hb_port);
|
|
if (getaddrinfo(hosts[i], ps, &hints, &res) != 0) {
|
|
LOGW("cannot resolve %s — retrying in %ds", hosts[i], retry_delay);
|
|
continue;
|
|
}
|
|
for (struct addrinfo *ai = res; ai && g_nconns < MAX_HOSTS; ai = ai->ai_next) {
|
|
conn_t *c = &g_conns[g_nconns];
|
|
memset(c, 0, sizeof(*c));
|
|
c->conn_id = conn_id++; c->port = cfg.hb_port;
|
|
c->af = ai->ai_family; c->sockfd = -1;
|
|
snprintf(c->name, sizeof(c->name), "%s", iam);
|
|
void *addr = (ai->ai_family == AF_INET)
|
|
? (void *)&((struct sockaddr_in *)ai->ai_addr)->sin_addr
|
|
: (void *)&((struct sockaddr_in6 *)ai->ai_addr)->sin6_addr;
|
|
inet_ntop(ai->ai_family, addr, c->addr, sizeof(c->addr));
|
|
if (conn_open(c)) { g_nconns++; LOGI("connected to %s", c->addr); }
|
|
}
|
|
freeaddrinfo(res);
|
|
}
|
|
if (!g_nconns) {
|
|
sleep(retry_delay);
|
|
if (retry_delay < 60) retry_delay *= 2;
|
|
}
|
|
}
|
|
if (!g_nconns) return 1;
|
|
|
|
conn_t *primary = &g_conns[0];
|
|
LOGI("hbc_mini-c %s on %s -> %s port=%d interval=%ds",
|
|
HBC_VERSION, iam, hosts[0], cfg.hb_port, cfg.interval);
|
|
|
|
/* Boot / one-shot message */
|
|
bool send_shutdown = false;
|
|
if (do_boot || message) {
|
|
kvdict_t bm; kv_clear(&bm);
|
|
kv_set_int(&bm, "acks", 0);
|
|
if (do_boot) { kv_set_int(&bm,"boot",1); send_shutdown=true; }
|
|
if (message) { kv_set(&bm,"service","service"); kv_set(&bm,"msg",message); }
|
|
conn_send(primary, "HTB", &bm);
|
|
if (message && !do_daemon) {
|
|
usleep(300000);
|
|
for (int i=0;i<g_nconns;i++) conn_close(&g_conns[i]);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* Info plugins at startup */
|
|
plugin_os_info(primary, &cfg);
|
|
|
|
/* Monitor thread */
|
|
thread_ctx_t tctx = {primary, &cfg};
|
|
pthread_t tid;
|
|
pthread_create(&tid, NULL, monitor_thread, &tctx);
|
|
|
|
/* Main heartbeat + receive loop */
|
|
time_t last_hb = 0;
|
|
while (g_running) {
|
|
time_t now = time(NULL);
|
|
if (now - last_hb >= cfg.interval) {
|
|
for (int i = 0; i < g_nconns; i++) {
|
|
kvdict_t hb; kv_clear(&hb);
|
|
kv_set_int(&hb, "acks", g_conns[i].ack_count);
|
|
kv_set_dbl(&hb, "rtt", g_conns[i].rtt);
|
|
kv_set_int(&hb, "interval", cfg.interval);
|
|
conn_send(&g_conns[i], "HTB", &hb);
|
|
}
|
|
last_hb = now;
|
|
}
|
|
|
|
fd_set rset; FD_ZERO(&rset); int maxfd = -1;
|
|
for (int i = 0; i < g_nconns; i++) {
|
|
if (g_conns[i].sockfd >= 0) { FD_SET(g_conns[i].sockfd,&rset); if(g_conns[i].sockfd>maxfd) maxfd=g_conns[i].sockfd; }
|
|
}
|
|
if (maxfd >= 0) {
|
|
struct timeval tv = {1, 0};
|
|
if (select(maxfd+1, &rset, NULL, NULL, &tv) > 0)
|
|
for (int i = 0; i < g_nconns; i++)
|
|
if (g_conns[i].sockfd>=0 && FD_ISSET(g_conns[i].sockfd,&rset))
|
|
conn_recv(&g_conns[i]);
|
|
} else { sleep(1); }
|
|
|
|
if (primary->request_info) {
|
|
primary->request_info = false;
|
|
LOGI("refreshing info plugins on server request");
|
|
plugin_os_info(primary, &cfg);
|
|
}
|
|
}
|
|
|
|
pthread_cancel(tid);
|
|
pthread_join(tid, NULL);
|
|
|
|
if (send_shutdown) {
|
|
kvdict_t sh; kv_clear(&sh);
|
|
kv_set_int(&sh, "shutdown", 1);
|
|
kv_set_int(&sh, "acks", primary->ack_count);
|
|
conn_send(primary, "HTB", &sh);
|
|
usleep(300000);
|
|
}
|
|
for (int i = 0; i < g_nconns; i++) conn_close(&g_conns[i]);
|
|
if (g_use_syslog) closelog();
|
|
if (g_restart) { LOGI("restarting..."); execv(argv[0], argv); }
|
|
return 0;
|
|
}
|