#2

1 files changed, 497 insertions, 0 deletions

diff --git a/src/core/monitor.c b/src/core/monitor.c
new file mode 100644
index 0000000..0b6d0c5
--- /dev/null
+++ b/src/core/monitor.c
@@ -0,0 +1,497 @@
+#if defined(__linux__)
+#define _DEFAULT_SOURCE
+#endif
+
+#include "hybbx/monitor.h"
+#include "hybbx/auth.h"
+#include "hybbx/config.h"
+#include "hybbx/log.h"
+#include "hybbx/security.h"
+#include "hybbx/service.h"
+#include "hybbx/session.h"
+#include "hybbx/util.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#define MONITOR_LINE_MAX 512u
+#define MONITOR_READ_CHUNK 4096u
+
+typedef struct monitor_tail {
+    char path[HYBBX_PATH_MAX];
+    off_t offset;
+    int active;
+    char carry[MONITOR_LINE_MAX];
+    size_t carry_len;
+} monitor_tail_t;
+
+static hybbx_monitor_config_t g_mon_cfg;
+static int g_mon_ready;
+static monitor_tail_t g_tail_hybbx;
+static monitor_tail_t g_tail_security;
+static int g_any_monitor_active;
+
+void hybbx_monitor_config_defaults(hybbx_monitor_config_t *cfg)
+{
+    if (cfg == NULL) {
+        return;
+    }
+
+    memset(cfg, 0, sizeof(*cfg));
+    cfg->enabled = 1;
+    cfg->follow_hybbx = 1;
+    cfg->follow_security = 1;
+    cfg->invisible_sysop = 0;
+    cfg->invite_timeout_sec = 20u;
+}
+
+static void monitor_parse_allow(hybbx_monitor_config_t *cfg, const char *raw)
+{
+    char buf[HYBBX_CONFIG_VALUE_MAX];
+    char *p;
+    char *comma;
+
+    cfg->allow_count = 0;
+    if (raw == NULL || raw[0] == '\0') {
+        return;
+    }
+
+    hybbx_strlcpy(buf, raw, sizeof(buf));
+    p = buf;
+    while (p != NULL && *p != '\0' &&
+           cfg->allow_count < HYBBX_MONITOR_ALLOW_MAX) {
+        char *tok = p;
+        comma = strchr(p, ',');
+        if (comma != NULL) {
+            *comma = '\0';
+            p = comma + 1;
+        } else {
+            p = NULL;
+        }
+        while (*tok == ' ' || *tok == '\t') {
+            tok++;
+        }
+        if (*tok == '\0') {
+            continue;
+        }
+        {
+            char *end = tok + strlen(tok);
+            while (end > tok && (end[-1] == ' ' || end[-1] == '\t')) {
+                *--end = '\0';
+            }
+        }
+        if (tok[0] == '\0') {
+            continue;
+        }
+        hybbx_strlcpy(cfg->allow[cfg->allow_count], tok,
+                      sizeof(cfg->allow[cfg->allow_count]));
+        cfg->allow_count++;
+    }
+}
+
+void hybbx_monitor_config_apply(const struct hybbx_config *config)
+{
+    const char *allow_raw;
+
+    hybbx_monitor_shutdown();
+    hybbx_monitor_config_defaults(&g_mon_cfg);
+
+    if (config != NULL) {
+        g_mon_cfg.enabled =
+            hybbx_config_get_bool(config, "monitor", "enabled", 1);
+        g_mon_cfg.follow_hybbx =
+            hybbx_config_get_bool(config, "monitor", "follow_hybbx", 1);
+        g_mon_cfg.follow_security =
+            hybbx_config_get_bool(config, "monitor", "follow_security", 1);
+        /* Prefer hyphen key; accept underscore alias. */
+        if (hybbx_config_get(config, "monitor", "invisible-sysop", NULL) !=
+            NULL) {
+            g_mon_cfg.invisible_sysop = hybbx_config_get_bool(
+                config, "monitor", "invisible-sysop", 0);
+        } else {
+            g_mon_cfg.invisible_sysop = hybbx_config_get_bool(
+                config, "monitor", "invisible_sysop", 0);
+        }
+        g_mon_cfg.invite_timeout_sec = hybbx_config_get_uint(
+            config, "monitor", "invite_timeout_sec", 20u, 5u, 300u);
+        allow_raw = hybbx_config_get(config, "monitor", "allow", NULL);
+        monitor_parse_allow(&g_mon_cfg, allow_raw);
+    }
+
+    g_mon_ready = 1;
+    hybbx_log_info("[monitor] enabled=%s follow_hybbx=%s follow_security=%s "
+                   "invisible-sysop=%s invite_timeout_sec=%u allow=%u",
+                   g_mon_cfg.enabled ? "yes" : "no",
+                   g_mon_cfg.follow_hybbx ? "yes" : "no",
+                   g_mon_cfg.follow_security ? "yes" : "no",
+                   g_mon_cfg.invisible_sysop ? "yes" : "no",
+                   g_mon_cfg.invite_timeout_sec,
+                   g_mon_cfg.allow_count);
+}
+
+const hybbx_monitor_config_t *hybbx_monitor_config_get(void)
+{
+    return g_mon_ready ? &g_mon_cfg : NULL;
+}
+
+int hybbx_monitor_enabled(void)
+{
+    return g_mon_ready && g_mon_cfg.enabled;
+}
+
+int hybbx_monitor_invisible_sysop(void)
+{
+    return g_mon_ready && g_mon_cfg.invisible_sysop;
+}
+
+int hybbx_monitor_user_allowed(const char *username)
+{
+    unsigned i;
+
+    if (!g_mon_ready || username == NULL || username[0] == '\0') {
+        return 0;
+    }
+
+    for (i = 0; i < g_mon_cfg.allow_count; i++) {
+        if (strcasecmp(g_mon_cfg.allow[i], username) == 0) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+int hybbx_monitor_session_may_use(const struct hybbx_session *session)
+{
+    const char *user;
+
+    if (!hybbx_monitor_enabled() || session == NULL) {
+        return 0;
+    }
+
+    if (hybbx_user_level_is_sysop(hybbx_session_user_level(session))) {
+        return 1;
+    }
+
+    user = hybbx_session_username(session);
+    return hybbx_monitor_user_allowed(user);
+}
+
+typedef struct mon_count_ctx {
+    unsigned count;
+} mon_count_ctx_t;
+
+static void mon_count_visitor(hybbx_session_t *session, void *userdata)
+{
+    mon_count_ctx_t *ctx = (mon_count_ctx_t *)userdata;
+
+    if (session != NULL && hybbx_monitor_is_active(session)) {
+        ctx->count++;
+    }
+}
+
+static void monitor_refresh_active_flag(hybbx_service_t *service)
+{
+    mon_count_ctx_t ctx;
+
+    ctx.count = 0;
+    if (service != NULL) {
+        hybbx_service_visit_sessions(service, mon_count_visitor, &ctx);
+    }
+    g_any_monitor_active = ctx.count > 0;
+}
+
+static void monitor_tail_seek_end(monitor_tail_t *tail, const char *path)
+{
+    struct stat st;
+
+    tail->path[0] = '\0';
+    tail->offset = 0;
+    tail->active = 0;
+
+    if (path == NULL || path[0] == '\0') {
+        return;
+    }
+
+    hybbx_strlcpy(tail->path, path, sizeof(tail->path));
+    if (stat(tail->path, &st) != 0) {
+        return;
+    }
+
+    tail->offset = st.st_size;
+    tail->active = 1;
+}
+
+static void monitor_reset_tails(void)
+{
+    char path[HYBBX_PATH_MAX];
+
+    memset(&g_tail_hybbx, 0, sizeof(g_tail_hybbx));
+    memset(&g_tail_security, 0, sizeof(g_tail_security));
+
+    if (g_mon_cfg.follow_hybbx &&
+        hybbx_log_current_path(path, sizeof(path)) == HYBBX_OK) {
+        monitor_tail_seek_end(&g_tail_hybbx, path);
+    }
+    if (g_mon_cfg.follow_security &&
+        hybbx_security_log_current_path(path, sizeof(path)) == HYBBX_OK) {
+        monitor_tail_seek_end(&g_tail_security, path);
+    }
+}
+
+hybbx_result_t hybbx_monitor_set_active(hybbx_session_t *session, int on)
+{
+    hybbx_service_t *service;
+
+    if (session == NULL) {
+        return HYBBX_ERR_INVALID;
+    }
+
+    if (!hybbx_monitor_enabled()) {
+        hybbx_session_write_line(session, "Monitor is disabled in config.");
+        return HYBBX_ERR_DENIED;
+    }
+
+    hybbx_session_set_monitor_active(session, on ? 1 : 0);
+    service = hybbx_session_service(session);
+    monitor_refresh_active_flag(service);
+
+    if (on) {
+        /* Fresh follow from current EOF — no backlog. */
+        monitor_reset_tails();
+        hybbx_session_write_line(session, "Monitor on.");
+        if (hybbx_user_level_is_sysop(hybbx_session_user_level(session))) {
+            if (hybbx_monitor_invisible_sysop()) {
+                hybbx_session_write_line(session,
+                    "Sysop: hidden from /who (/monitor invisible-sysop=yes).");
+            } else {
+                hybbx_session_write_line(session,
+                    "Sysop: hidden from /who and /online while monitor is on.");
+            }
+        }
+    } else {
+        hybbx_session_write_line(session, "Monitor off.");
+        monitor_refresh_active_flag(service);
+        if (!g_any_monitor_active) {
+            memset(&g_tail_hybbx, 0, sizeof(g_tail_hybbx));
+            memset(&g_tail_security, 0, sizeof(g_tail_security));
+        }
+    }
+
+    return HYBBX_OK;
+}
+
+int hybbx_monitor_is_active(const hybbx_session_t *session)
+{
+    return hybbx_session_monitor_active(session);
+}
+
+typedef struct mon_bcast_ctx {
+    const char *line;
+    hybbx_session_t *skip;
+} mon_bcast_ctx_t;
+
+static void mon_bcast_visitor(hybbx_session_t *session, void *userdata)
+{
+    mon_bcast_ctx_t *ctx = (mon_bcast_ctx_t *)userdata;
+    char out[MONITOR_LINE_MAX + 16];
+
+    if (session == NULL || ctx == NULL || ctx->line == NULL) {
+        return;
+    }
+    if (session == ctx->skip) {
+        return;
+    }
+    if (!hybbx_monitor_is_active(session)) {
+        return;
+    }
+
+    snprintf(out, sizeof(out), "[monitor] %s", ctx->line);
+    hybbx_session_write_line(session, out);
+}
+
+void hybbx_monitor_broadcast(hybbx_service_t *service, const char *line)
+{
+    mon_bcast_ctx_t ctx;
+
+    if (service == NULL || line == NULL || line[0] == '\0') {
+        return;
+    }
+
+    ctx.line = line;
+    ctx.skip = NULL;
+    hybbx_service_visit_sessions(service, mon_bcast_visitor, &ctx);
+}
+
+void hybbx_monitor_event(hybbx_service_t *service,
+                         const char *username,
+                         const char *plugin,
+                         const char *detail)
+{
+    char line[MONITOR_LINE_MAX];
+    const char *user = (username != NULL && username[0] != '\0') ? username : "?";
+    const char *plug = (plugin != NULL && plugin[0] != '\0') ? plugin : "?";
+
+    if (service == NULL || !g_any_monitor_active) {
+        /* Still compute flag lazily */
+        monitor_refresh_active_flag(service);
+        if (!g_any_monitor_active) {
+            return;
+        }
+    }
+
+    if (detail != NULL && detail[0] != '\0') {
+        snprintf(line, sizeof(line), "%s@%s %s", user, plug, detail);
+    } else {
+        snprintf(line, sizeof(line), "%s@%s", user, plug);
+    }
+
+    hybbx_monitor_broadcast(service, line);
+}
+
+static void monitor_push_raw_line(hybbx_service_t *service, const char *tag,
+                                  const char *text)
+{
+    char line[MONITOR_LINE_MAX];
+
+    if (text == NULL) {
+        return;
+    }
+    while (*text == '\r' || *text == '\n') {
+        text++;
+    }
+    if (*text == '\0') {
+        return;
+    }
+
+    snprintf(line, sizeof(line), "%s %s", tag, text);
+    hybbx_monitor_broadcast(service, line);
+}
+
+static void monitor_tail_read(hybbx_service_t *service, monitor_tail_t *tail,
+                              const char *tag)
+{
+    FILE *fp;
+    struct stat st;
+    char chunk[MONITOR_READ_CHUNK];
+    size_t n;
+    char *p;
+    char *nl;
+
+    if (tail == NULL || !tail->active || tail->path[0] == '\0') {
+        return;
+    }
+
+    if (stat(tail->path, &st) != 0) {
+        return;
+    }
+
+    if (st.st_size < tail->offset) {
+        /* Truncated / rotated — follow from start of new content. */
+        tail->offset = 0;
+        tail->carry_len = 0;
+    }
+
+    if (st.st_size == tail->offset) {
+        return;
+    }
+
+    fp = fopen(tail->path, "r");
+    if (fp == NULL) {
+        return;
+    }
+
+    if (fseeko(fp, tail->offset, SEEK_SET) != 0) {
+        fclose(fp);
+        return;
+    }
+
+    while ((n = fread(chunk, 1, sizeof(chunk) - 1, fp)) > 0) {
+        chunk[n] = '\0';
+        p = chunk;
+        while (*p != '\0') {
+            nl = strchr(p, '\n');
+            if (nl == NULL) {
+                size_t left = strlen(p);
+                if (tail->carry_len + left >= sizeof(tail->carry)) {
+                    tail->carry_len = 0;
+                }
+                memcpy(tail->carry + tail->carry_len, p, left);
+                tail->carry_len += left;
+                tail->carry[tail->carry_len] = '\0';
+                break;
+            }
+            *nl = '\0';
+            if (tail->carry_len > 0) {
+                size_t room = sizeof(tail->carry) - 1u - tail->carry_len;
+                size_t take = strlen(p);
+                if (take > room) {
+                    take = room;
+                }
+                memcpy(tail->carry + tail->carry_len, p, take);
+                tail->carry_len += take;
+                tail->carry[tail->carry_len] = '\0';
+                monitor_push_raw_line(service, tag, tail->carry);
+                tail->carry_len = 0;
+            } else {
+                monitor_push_raw_line(service, tag, p);
+            }
+            p = nl + 1;
+        }
+        tail->offset = ftello(fp);
+    }
+
+    fclose(fp);
+
+    /* Refresh path if weekly rotate changed hybbx log name. */
+    if (tail == &g_tail_hybbx) {
+        char path[HYBBX_PATH_MAX];
+        if (hybbx_log_current_path(path, sizeof(path)) == HYBBX_OK &&
+            strcmp(path, tail->path) != 0) {
+            monitor_tail_seek_end(tail, path);
+        }
+    }
+}
+
+void hybbx_monitor_tick(hybbx_service_t *service)
+{
+    if (!g_mon_ready || !g_mon_cfg.enabled || service == NULL) {
+        return;
+    }
+
+    monitor_refresh_active_flag(service);
+    if (!g_any_monitor_active) {
+        return;
+    }
+
+    if (!g_tail_hybbx.active && g_mon_cfg.follow_hybbx) {
+        char path[HYBBX_PATH_MAX];
+        if (hybbx_log_current_path(path, sizeof(path)) == HYBBX_OK) {
+            monitor_tail_seek_end(&g_tail_hybbx, path);
+        }
+    }
+    if (!g_tail_security.active && g_mon_cfg.follow_security) {
+        char path[HYBBX_PATH_MAX];
+        if (hybbx_security_log_current_path(path, sizeof(path)) == HYBBX_OK) {
+            monitor_tail_seek_end(&g_tail_security, path);
+        }
+    }
+
+    if (g_mon_cfg.follow_hybbx) {
+        monitor_tail_read(service, &g_tail_hybbx, "hybbx:");
+    }
+    if (g_mon_cfg.follow_security) {
+        monitor_tail_read(service, &g_tail_security, "security:");
+    }
+}
+
+void hybbx_monitor_shutdown(void)
+{
+    memset(&g_mon_cfg, 0, sizeof(g_mon_cfg));
+    memset(&g_tail_hybbx, 0, sizeof(g_tail_hybbx));
+    memset(&g_tail_security, 0, sizeof(g_tail_security));
+    g_mon_ready = 0;
+    g_any_monitor_active = 0;
+}