#2

1 files changed, 694 insertions, 0 deletions

diff --git a/src/core/log.c b/src/core/log.c
new file mode 100644
index 0000000..7812c00
--- /dev/null
+++ b/src/core/log.c
@@ -0,0 +1,694 @@
+#if defined(__linux__)
+#define _DEFAULT_SOURCE
+#endif
+
+#include "hybbx/log.h"
+#if !defined(HYBBX_CLIENT_BUILD)
+#include "hybbx/config.h"
+#endif
+#include "hybbx/limits.h"
+#include "hybbx/util.h"
+
+#include <dirent.h>
+#include <errno.h>
+#include <pthread.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <time.h>
+#include <unistd.h>
+
+#define HYBBX_LOG_LINE_MAX 1024u
+
+/*
+ * Weekly HyBBX file log (replaces stuck month-keyed "daily" open handle).
+ *
+ * Naming: YYYYMMDD-week-hybbx.log
+ *   YYYYMMDD = ISO week start (Monday, local time). One file per 7-day week.
+ *
+ * Cycle (forever):
+ *   Days 1–7  → append to the current week file.
+ *   Day 8     → switch to the new week file (new Monday), then pack every
+ *               closed/legacy packable log under [log] dir into
+ *               logs/arc/<YYYYMMDD>-week-hybbx.tar.bz2 (bzip2) and delete
+ *               those sources only after tar succeeds.
+ *   Pack batches of up to 7 members per archive (oldest first); repeat until
+ *   fewer than 1 packable remain. Legacy daily names (YYYYMMDD-hybbx.log)
+ *   are packable and are swept on day-8 switch (and on startup when ≥7).
+ *
+ * security.log is never packed or deleted here.
+ */
+
+#define HYBBX_LOG_ARC_SUBDIR "arc"
+#define HYBBX_LOG_PACK_BATCH 7
+#define HYBBX_LOG_PACKABLE_MAX 64
+
+static hybbx_log_config_t g_log_config;
+static int g_log_ready;
+static FILE *g_log_file;
+/* ISO-Monday yyyymmdd of the file currently open (0 = none). */
+static int g_log_open_week_yyyymmdd;
+static char g_log_open_name[64];
+static pthread_mutex_t g_log_lock = PTHREAD_MUTEX_INITIALIZER;
+
+static int mkdir_p(const char *path)
+{
+    char buf[HYBBX_PATH_MAX];
+    size_t len;
+    size_t i;
+
+    if (path == NULL || path[0] == '\0') {
+        return -1;
+    }
+
+    hybbx_strlcpy(buf, path, sizeof(buf));
+    len = strlen(buf);
+    while (len > 0 && buf[len - 1] == '/') {
+        buf[--len] = '\0';
+    }
+
+    for (i = 1; i < len; i++) {
+        if (buf[i] != '/') {
+            continue;
+        }
+        buf[i] = '\0';
+        if (buf[0] != '\0' && mkdir(buf, 0755) != 0 && errno != EEXIST) {
+            return -1;
+        }
+        buf[i] = '/';
+    }
+
+    if (mkdir(buf, 0755) != 0 && errno != EEXIST) {
+        return -1;
+    }
+
+    return 0;
+}
+
+void hybbx_log_config_defaults(hybbx_log_config_t *cfg)
+{
+    if (cfg == NULL) {
+        return;
+    }
+
+    cfg->enabled = 1;
+    cfg->dir[0] = '\0';
+    cfg->level = HYBBX_LOG_WARN;
+}
+
+hybbx_log_level_t hybbx_log_parse_level(const char *value)
+{
+    if (value == NULL || value[0] == '\0') {
+        return HYBBX_LOG_WARN;
+    }
+
+    if (strcasecmp(value, "debug") == 0) {
+        return HYBBX_LOG_DEBUG;
+    }
+    if (strcasecmp(value, "stats") == 0) {
+        return HYBBX_LOG_STATS;
+    }
+    if (strcasecmp(value, "info") == 0) {
+        return HYBBX_LOG_INFO;
+    }
+    if (strcasecmp(value, "warn") == 0) {
+        return HYBBX_LOG_WARN;
+    }
+
+    return HYBBX_LOG_WARN;
+}
+
+const char *hybbx_log_level_name(hybbx_log_level_t level)
+{
+    switch (level) {
+    case HYBBX_LOG_DEBUG:
+        return "debug";
+    case HYBBX_LOG_STATS:
+        return "stats";
+    case HYBBX_LOG_INFO:
+        return "info";
+    case HYBBX_LOG_WARN:
+        return "warn";
+    default:
+        return "?";
+    }
+}
+
+int hybbx_log_level_visible(hybbx_log_level_t level)
+{
+    if (!g_log_ready) {
+        return 1;
+    }
+
+    return level >= g_log_config.level;
+}
+
+const hybbx_log_config_t *hybbx_log_config_get(void)
+{
+    return g_log_ready ? &g_log_config : NULL;
+}
+
+int hybbx_log_enabled(void)
+{
+    return g_log_ready && g_log_config.enabled && g_log_file != NULL;
+}
+
+static void log_close_file(void)
+{
+    if (g_log_file != NULL) {
+        fclose(g_log_file);
+        g_log_file = NULL;
+    }
+    g_log_open_week_yyyymmdd = 0;
+    g_log_open_name[0] = '\0';
+}
+
+/* Monday of the ISO week containing @p tm (local wall calendar). */
+static int log_week_start_tm(const struct tm *tm, struct tm *out)
+{
+    time_t t;
+    int from_monday;
+
+    if (tm == NULL || out == NULL) {
+        return -1;
+    }
+
+    *out = *tm;
+    /* tm_wday: 0=Sun … 6=Sat → days since Monday */
+    from_monday = (out->tm_wday + 6) % 7;
+    out->tm_mday -= from_monday;
+    out->tm_hour = 12; /* avoid DST midnight edge when normalizing */
+    out->tm_min = 0;
+    out->tm_sec = 0;
+    out->tm_isdst = -1;
+    t = mktime(out);
+    if (t == (time_t)-1) {
+        return -1;
+    }
+    if (localtime_r(&t, out) == NULL) {
+        return -1;
+    }
+    return 0;
+}
+
+static int log_week_yyyymmdd(const struct tm *tm)
+{
+    struct tm week;
+
+    if (log_week_start_tm(tm, &week) != 0) {
+        return 0;
+    }
+    return (week.tm_year + 1900) * 10000
+         + (week.tm_mon + 1) * 100
+         + week.tm_mday;
+}
+
+static void log_week_basename(int week_yyyymmdd, char *name, size_t name_len)
+{
+    snprintf(name, name_len, "%08d-week-hybbx.log", week_yyyymmdd);
+}
+
+static int log_build_path_for_week(char *out, size_t out_len, int week_yyyymmdd)
+{
+    char name[64];
+
+    log_week_basename(week_yyyymmdd, name, sizeof(name));
+    return hybbx_path_join(out, out_len, g_log_config.dir, name) == HYBBX_OK
+               ? 0
+               : -1;
+}
+
+static int log_is_eight_digits(const char *s)
+{
+    size_t i;
+
+    for (i = 0; i < 8; i++) {
+        if (s[i] < '0' || s[i] > '9') {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+/*
+ * Packable: current-scheme week files, or legacy daily YYYYMMDD-hybbx.log.
+ * Never security.log, arc/, or the active week file.
+ */
+static int log_name_is_packable(const char *name)
+{
+    size_t len;
+
+    if (name == NULL || name[0] == '\0' || name[0] == '.') {
+        return 0;
+    }
+    if (strcmp(name, g_log_open_name) == 0) {
+        return 0;
+    }
+
+    len = strlen(name);
+    if (len == 22 && log_is_eight_digits(name) &&
+        strcmp(name + 8, "-week-hybbx.log") == 0) {
+        return 1;
+    }
+    /* Legacy daily: 20260720-hybbx.log (8 digits + 10). */
+    if (len == 18 && log_is_eight_digits(name) &&
+        strcmp(name + 8, "-hybbx.log") == 0) {
+        return 1;
+    }
+    return 0;
+}
+
+static int log_cmp_names(const void *a, const void *b)
+{
+    return strcmp(*(const char *const *)a, *(const char *const *)b);
+}
+
+static int log_run_tar_bz2(const char *arc_path, char **basenames, int count)
+{
+    pid_t pid;
+    int status;
+    int i;
+    char *argv[HYBBX_LOG_PACKABLE_MAX + 8];
+    int argc = 0;
+
+    if (arc_path == NULL || basenames == NULL || count <= 0 ||
+        count > HYBBX_LOG_PACKABLE_MAX) {
+        return -1;
+    }
+
+    argv[argc++] = "tar";
+    argv[argc++] = "-C";
+    argv[argc++] = (char *)g_log_config.dir;
+    argv[argc++] = "-cjf";
+    argv[argc++] = (char *)arc_path;
+    for (i = 0; i < count; i++) {
+        argv[argc++] = basenames[i];
+    }
+    argv[argc] = NULL;
+
+    pid = fork();
+    if (pid < 0) {
+        return -1;
+    }
+    if (pid == 0) {
+        execvp("tar", argv);
+        _exit(127);
+    }
+
+    if (waitpid(pid, &status, 0) < 0) {
+        return -1;
+    }
+    if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+        return -1;
+    }
+    return 0;
+}
+
+static int log_collect_packable(char namebuf[][64], char **names, int max)
+{
+    DIR *dir;
+    struct dirent *ent;
+    int count = 0;
+
+    dir = opendir(g_log_config.dir);
+    if (dir == NULL) {
+        return 0;
+    }
+
+    while ((ent = readdir(dir)) != NULL && count < max) {
+        if (!log_name_is_packable(ent->d_name)) {
+            continue;
+        }
+        if (strlen(ent->d_name) >= 64) {
+            continue;
+        }
+        hybbx_strlcpy(namebuf[count], ent->d_name, 64);
+        names[count] = namebuf[count];
+        count++;
+    }
+    closedir(dir);
+    return count;
+}
+
+/* Pack up to HYBBX_LOG_PACK_BATCH oldest packable files. Returns packed count. */
+static int log_archive_one_batch(void)
+{
+    char *names[HYBBX_LOG_PACKABLE_MAX];
+    char namebuf[HYBBX_LOG_PACKABLE_MAX][64];
+    int count;
+    int pack_n;
+    int i;
+    char arc_dir[HYBBX_PATH_MAX];
+    char arc_path[HYBBX_PATH_MAX];
+    char arc_name[80];
+    struct stat st;
+
+    count = log_collect_packable(namebuf, names, HYBBX_LOG_PACKABLE_MAX);
+    if (count <= 0) {
+        return 0;
+    }
+
+    qsort(names, (size_t)count, sizeof(names[0]), log_cmp_names);
+    pack_n = count < HYBBX_LOG_PACK_BATCH ? count : HYBBX_LOG_PACK_BATCH;
+
+    if (hybbx_path_join(arc_dir, sizeof(arc_dir), g_log_config.dir,
+                        HYBBX_LOG_ARC_SUBDIR) != HYBBX_OK) {
+        fprintf(stderr, "[log] archive path too long\n");
+        return -1;
+    }
+    if (mkdir_p(arc_dir) != 0) {
+        fprintf(stderr, "[log] cannot create %s\n", arc_dir);
+        return -1;
+    }
+
+    snprintf(arc_name, sizeof(arc_name), "%.8s-week-hybbx.tar.bz2", names[0]);
+    if (hybbx_path_join(arc_path, sizeof(arc_path), arc_dir, arc_name) !=
+        HYBBX_OK) {
+        fprintf(stderr, "[log] archive file path too long\n");
+        return -1;
+    }
+    if (stat(arc_path, &st) == 0) {
+        snprintf(arc_name, sizeof(arc_name),
+                 "%.8s-week-hybbx-%ld.tar.bz2", names[0], (long)time(NULL));
+        if (hybbx_path_join(arc_path, sizeof(arc_path), arc_dir, arc_name) !=
+            HYBBX_OK) {
+            return -1;
+        }
+    }
+
+    if (log_run_tar_bz2(arc_path, names, pack_n) != 0) {
+        fprintf(stderr, "[log] tar.bz2 failed for %s — sources kept\n",
+                arc_path);
+        return -1;
+    }
+
+    for (i = 0; i < pack_n; i++) {
+        char full[HYBBX_PATH_MAX];
+        if (hybbx_path_join(full, sizeof(full), g_log_config.dir, names[i]) !=
+            HYBBX_OK) {
+            continue;
+        }
+        if (unlink(full) != 0) {
+            fprintf(stderr, "[log] cannot remove packed %s\n", full);
+        }
+    }
+
+    fprintf(stderr, "[log] archived %d file(s) → %s\n", pack_n, arc_path);
+    return pack_n;
+}
+
+/*
+ * @p on_week_switch: day-8 path — pack every closed/legacy file (batches of 7).
+ * Otherwise (startup): pack only when ≥7 packable (legacy daily sweep).
+ */
+static void log_archive_packable(int on_week_switch)
+{
+    char *names[HYBBX_LOG_PACKABLE_MAX];
+    char namebuf[HYBBX_LOG_PACKABLE_MAX][64];
+    int count;
+    int guard;
+
+    if (g_log_config.dir[0] == '\0') {
+        return;
+    }
+
+    count = log_collect_packable(namebuf, names, HYBBX_LOG_PACKABLE_MAX);
+    if (count <= 0) {
+        return;
+    }
+    if (!on_week_switch && count < HYBBX_LOG_PACK_BATCH) {
+        return;
+    }
+
+    for (guard = 0; guard < HYBBX_LOG_PACKABLE_MAX; guard++) {
+        int packed = log_archive_one_batch();
+        if (packed <= 0) {
+            break;
+        }
+        count = log_collect_packable(namebuf, names, HYBBX_LOG_PACKABLE_MAX);
+        if (count <= 0) {
+            break;
+        }
+        if (!on_week_switch && count < HYBBX_LOG_PACK_BATCH) {
+            break;
+        }
+    }
+}
+
+hybbx_result_t hybbx_log_current_path(char *out, size_t out_len)
+{
+    time_t now;
+    struct tm tm_buf;
+    struct tm *tm;
+    int week;
+
+    if (out == NULL || out_len == 0) {
+        return HYBBX_ERR_INVALID;
+    }
+
+    out[0] = '\0';
+    if (!g_log_ready || !g_log_config.enabled || g_log_config.dir[0] == '\0') {
+        return HYBBX_ERR_NOT_FOUND;
+    }
+
+    now = time(NULL);
+    tm = localtime_r(&now, &tm_buf);
+    if (tm == NULL) {
+        return HYBBX_ERR_IO;
+    }
+
+    week = log_week_yyyymmdd(tm);
+    if (week == 0 || log_build_path_for_week(out, out_len, week) != 0) {
+        return HYBBX_ERR_IO;
+    }
+
+    return HYBBX_OK;
+}
+
+static int log_open_for_time(const struct tm *tm)
+{
+    char path[HYBBX_PATH_MAX];
+    FILE *fp;
+    int week;
+    int rotated = 0;
+
+    if (tm == NULL) {
+        return -1;
+    }
+
+    week = log_week_yyyymmdd(tm);
+    if (week == 0) {
+        return -1;
+    }
+
+    if (g_log_file != NULL && g_log_open_week_yyyymmdd == week) {
+        return 0;
+    }
+
+    if (g_log_file != NULL) {
+        rotated = 1;
+    }
+
+    log_close_file();
+
+    if (mkdir_p(g_log_config.dir) != 0) {
+        fprintf(stderr, "[log] cannot create directory %s\n", g_log_config.dir);
+        return -1;
+    }
+
+    if (log_build_path_for_week(path, sizeof(path), week) != 0) {
+        fprintf(stderr, "[log] path too long for log file\n");
+        return -1;
+    }
+
+    fp = fopen(path, "a");
+    if (fp == NULL) {
+        fprintf(stderr, "[log] cannot open %s\n", path);
+        return -1;
+    }
+
+    g_log_file = fp;
+    g_log_open_week_yyyymmdd = week;
+    log_week_basename(week, g_log_open_name, sizeof(g_log_open_name));
+
+    /* Day-8 switch packs closed week (+ legacy). Startup sweeps if ≥7. */
+    log_archive_packable(rotated);
+
+    return 0;
+}
+
+static int log_ensure_open(void)
+{
+    time_t now;
+    struct tm tm_buf;
+    struct tm *tm;
+
+    if (!g_log_config.enabled || g_log_config.dir[0] == '\0') {
+        return -1;
+    }
+
+    now = time(NULL);
+    tm = localtime_r(&now, &tm_buf);
+    if (tm == NULL) {
+        return -1;
+    }
+
+    return log_open_for_time(tm);
+}
+
+#if !defined(HYBBX_CLIENT_BUILD)
+void hybbx_log_config_apply(const struct hybbx_config *config)
+{
+    const char *dir_raw;
+    const char *level_raw;
+    hybbx_log_level_t parsed;
+
+    hybbx_log_shutdown();
+    hybbx_log_config_defaults(&g_log_config);
+
+    if (config != NULL) {
+        g_log_config.enabled =
+            hybbx_config_get_bool(config, "log", "enabled", 1);
+        dir_raw = hybbx_config_get(config, "log", "dir", NULL);
+        level_raw = hybbx_config_get(config, "log", "level", "warn");
+
+        parsed = hybbx_log_parse_level(level_raw);
+        if (level_raw != NULL && level_raw[0] != '\0' &&
+            strcmp(level_raw, hybbx_log_level_name(parsed)) != 0 &&
+            strcasecmp(level_raw, hybbx_log_level_name(parsed)) != 0) {
+            fprintf(stderr,
+                    "[log] unknown level '%s' — using warn (debug|stats|info|warn)\n",
+                    level_raw);
+        }
+        g_log_config.level = parsed;
+
+        if (dir_raw != NULL && dir_raw[0] != '\0') {
+            if (hybbx_path_resolve(g_log_config.dir, sizeof(g_log_config.dir),
+                                   dir_raw) != HYBBX_OK) {
+                fprintf(stderr, "[log] invalid dir path\n");
+                g_log_config.enabled = 0;
+            }
+        } else if (g_log_config.enabled) {
+            if (hybbx_path_resolve(g_log_config.dir, sizeof(g_log_config.dir),
+                                   HYBBX_DIR_LOGS) != HYBBX_OK) {
+                fprintf(stderr, "[log] cannot resolve default log directory\n");
+                g_log_config.enabled = 0;
+            }
+        }
+    } else {
+        if (hybbx_path_resolve(g_log_config.dir, sizeof(g_log_config.dir),
+                               HYBBX_DIR_LOGS) != HYBBX_OK) {
+            g_log_config.enabled = 0;
+        }
+    }
+
+    g_log_ready = 1;
+
+    if (g_log_config.enabled) {
+        if (log_ensure_open() != 0) {
+            g_log_config.enabled = 0;
+        }
+    }
+
+    printf("[log] enabled=%s dir=%s level=%s week=%s\n",
+           hybbx_bool_to_string(g_log_config.enabled),
+           g_log_config.dir[0] != '\0' ? g_log_config.dir : "-",
+           hybbx_log_level_name(g_log_config.level),
+           g_log_open_name[0] != '\0' ? g_log_open_name : "-");
+}
+#else
+void hybbx_log_config_apply(const struct hybbx_config *config)
+{
+    (void)config;
+    hybbx_log_config_defaults(&g_log_config);
+    g_log_ready = 1;
+}
+#endif
+
+static void log_write_console(hybbx_log_level_t level, const char *message)
+{
+    FILE *out = (level == HYBBX_LOG_WARN) ? stderr : stdout;
+
+    fputs(message, out);
+    fputc('\n', out);
+    fflush(out);
+}
+
+static void log_write_file(hybbx_log_level_t level, const char *message)
+{
+    char line[HYBBX_LOG_LINE_MAX + 64];
+    time_t now;
+    struct tm tm_buf;
+    struct tm *tm;
+
+    if (!g_log_config.enabled) {
+        return;
+    }
+
+    pthread_mutex_lock(&g_log_lock);
+
+    if (log_ensure_open() != 0) {
+        pthread_mutex_unlock(&g_log_lock);
+        return;
+    }
+
+    now = time(NULL);
+    tm = localtime_r(&now, &tm_buf);
+    if (tm == NULL) {
+        pthread_mutex_unlock(&g_log_lock);
+        return;
+    }
+
+    if (hybbx_time_format_stamp(line, sizeof(line), tm, NULL) != HYBBX_OK) {
+        pthread_mutex_unlock(&g_log_lock);
+        return;
+    }
+
+    {
+        size_t stamp_len = strlen(line);
+        snprintf(line + stamp_len, sizeof(line) - stamp_len,
+                 " [%s] %s\n", hybbx_log_level_name(level), message);
+    }
+
+    fputs(line, g_log_file);
+    fflush(g_log_file);
+
+    pthread_mutex_unlock(&g_log_lock);
+}
+
+void hybbx_log_write(hybbx_log_level_t level, const char *fmt, ...)
+{
+    char message[HYBBX_LOG_LINE_MAX];
+    va_list ap;
+
+    if (fmt == NULL) {
+        return;
+    }
+
+    if (g_log_ready && !hybbx_log_level_visible(level)) {
+        return;
+    }
+
+    va_start(ap, fmt);
+    vsnprintf(message, sizeof(message), fmt, ap);
+    va_end(ap);
+
+    log_write_console(level, message);
+    if (g_log_ready) {
+        log_write_file(level, message);
+    }
+}
+
+void hybbx_log_shutdown(void)
+{
+    pthread_mutex_lock(&g_log_lock);
+    log_close_file();
+    g_log_ready = 0;
+    hybbx_log_config_defaults(&g_log_config);
+    pthread_mutex_unlock(&g_log_lock);
+}