source: code/logger.c

/*
 * Copyright (c) 2009 Michael Shalayeff
 * Copyright (c) 2014 Mike Belopuhov
 * Copyright (c) 2024 Nishi
 * Copyright (c) 2025 Izuru Yakumo
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER IN
 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/uio.h>
#include <errno.h>
#include <limits.h>
#include <netdb.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <syslog.h>
#include <sysexits.h>
#include <time.h>
#include <event.h>
#include <pwd.h>

#include "icb.h"
#include "icbd.h"

void logger_ioerr(struct bufferevent *, short, void *);
void logger_dispatch(struct bufferevent *, void *);
FILE *logger_open(char *);
void logger_tick(void);

struct icbd_logentry {
        char    group[ICB_MAXGRPLEN];
        char    nick[ICB_MAXNICKLEN];
        size_t  length;
};

struct {
        char    group[ICB_MAXGRPLEN];
        FILE    *fp;
} logfiles[10];
int nlogfiles;

int logger_pipe;

char file_ts[sizeof "0000-00"];
char line_ts[sizeof "00:00"];
struct event ev_tick;

extern char logprefix[PATH_MAX/2];
extern int dologging;

int
logger_init(void)
{
        struct bufferevent *bev;
        struct passwd *pw;
        int pipes[2];

        if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, pipes) == -1) {
                syslog(LOG_ERR, "%s: socketpair: %m", __func__);
                exit(EX_OSERR);
        }

        switch (fork()) {
        case -1:
                syslog(LOG_ERR, "%s: fork: %m", __func__);
                exit(EX_OSERR);
        case 0:
                break;

        default:
                close(pipes[1]);
                logger_pipe = pipes[0];
                return (0);
        }

        setproctitle("logger");
        close(pipes[0]);

        if ((pw = getpwnam(ICBD_USER)) == NULL) {
                syslog(LOG_ERR, "%s: No passwd entry for %s", __func__,
                    ICBD_USER);
                exit(EX_NOUSER);
        }
#ifdef __OpenBSD
        if (chroot(pw->pw_dir) < 0) {
                syslog(LOG_ERR, "%s: %s: %m", __func__, pw->pw_dir);
                exit(EX_UNAVAILABLE);
        }

        if (chdir("/") < 0) {
                syslog(LOG_ERR, "%s: chdir: %m", __func__);
                exit(EX_UNAVAILABLE);
        }

        chdir (ICBD_HOME);

        if (setuid(pw->pw_uid) < 0) {
                syslog(LOG_ERR, "%s: %d: %m", __func__, pw->pw_uid);
                exit(EX_NOPERM);
        }
#endif
#ifdef __OpenBSD__
        if (pledge("stdio cpath wpath", NULL) == -1) {
                syslog(LOG_ERR, "%s: pledge", __func__);
                exit(EX_NOPERM);
        }
#endif

        event_init();

        /* event for message processing */
        if ((bev = bufferevent_new(pipes[1], logger_dispatch, NULL,
            logger_ioerr, NULL)) == NULL) {
                syslog(LOG_ERR, "%s: bufferevent_new: %m", __func__);
                exit(EX_UNAVAILABLE);
        }
        if (bufferevent_enable(bev, EV_READ)) {
                syslog(LOG_ERR, "%s: bufferevent_enable: %m", __func__);
                bufferevent_free(bev);
                exit(EX_UNAVAILABLE);
        }

        evtimer_set(&ev_tick, (void (*)(int, short, void *))logger_tick, NULL);
        logger_tick();
        return event_dispatch();
}

void
logger_ioerr(struct bufferevent *bev __attribute__((__unused__)), short what,
    void *arg __attribute__((__unused__)))
{
        const char *cause = NULL;

        if (what & EVBUFFER_TIMEOUT)
                cause = "timeout";
        else if (what & EVBUFFER_EOF)
                cause = "eof";
        else if (what & EVBUFFER_ERROR)
                cause = what & EVBUFFER_READ ? "read" : "write";
        syslog(LOG_ERR, "%s: %s", __func__, cause ? cause : "unknown");
        exit(EX_IOERR);
}

void
logger_dispatch(struct bufferevent *bev, void *arg __attribute__((unused)))
{
        struct icbd_logentry *e;
        static char buf[sizeof *e + ICB_MSGSIZE];
        static size_t nread = 0;
        FILE *fp = NULL;
        size_t res;
        char *m;
        int i;

        e = (struct icbd_logentry *)buf;
        m = buf + sizeof *e;

        while (EVBUFFER_LENGTH(EVBUFFER_INPUT(bev)) > 0) {
                if (nread == 0) {
                        bzero(e, sizeof *e);
                        /* read the log entry header */
                        res = bufferevent_read(bev, &buf[0], sizeof *e);
                        nread += res;
                        if (nread < sizeof *e)
                                return;
                }
                /* see if we got the whole header */
                if (nread < sizeof *e) {
                        /* finish reading */
                        res = bufferevent_read(bev, &buf[nread],
                            sizeof *e - nread);
                        nread += res;
                        if (nread < sizeof *e)
                                return;
                }
                if (e->length >= ICB_MSGSIZE) {
                        syslog(LOG_ERR, "%s: message too big: %lu", __func__,
                            e->length);
                        exit(EX_DATAERR);
                }
                /* fetch the message */
                res = bufferevent_read(bev, &buf[nread],
                    e->length - (nread - sizeof *e));
                nread += res;
                if (nread - sizeof *e < e->length)
                        return;
#ifdef DEBUG
                {
                        printf("logger read %lu\n", nread - sizeof *e);
                        for (i = 0; i < (int)(nread - sizeof *e); i++)
                                printf(" %02x", (unsigned char)m[i]);
                        printf("\n");
                }
#endif
                /* terminate the buffer */
                m[MIN(nread - sizeof *e, ICB_MSGSIZE - 1)] = '\0';
                /* find the appropriate log file */
                for (i = 0; i < nlogfiles; i++)
                        if (strcmp(logfiles[i].group, e->group) == 0)
                                fp = logfiles[i].fp;
                if (!fp && (fp = logger_open(e->group)) == NULL)
                        return;
                if (strlen(e->nick) == 0)
                        fprintf(fp, "[%s] %s\n", line_ts, m);
                else
                        fprintf(fp, "[%s] <%s> %s\n", line_ts, e->nick, m);
                /* get ready for the next message */
                nread = 0;
        }
}

FILE *
logger_open(char *group)
{
        char path[PATH_MAX];
        FILE *fp = NULL;

        /* make sure not to overflow the logfiles table */
        if (nlogfiles == nitems(logfiles)) {
                syslog(LOG_NOTICE, "%s: logfiles table is full", __func__);
                return (NULL);
        }
        snprintf(path, sizeof path, "%s/%s", logprefix, group);
        if (mkdir(path, 0755) < 0 && errno != EEXIST) {
                syslog(LOG_ERR, "%s: %s: %m", __func__, group);
                return (NULL);
        }
        snprintf(path, sizeof path, "%s/%s/%s", logprefix, group, file_ts);
        if ((fp = fopen(path, "a")) == NULL) {
                syslog(LOG_ERR, "%s: %s: %m", __func__, path);
                return (NULL);
        }
        setvbuf(fp, NULL, _IOLBF, 0);
        if (verbose)
                syslog(LOG_NOTICE, "%s: %s", __func__, path);
        strlcpy(logfiles[nlogfiles].group, group, ICB_MAXGRPLEN);
        logfiles[nlogfiles++].fp = fp;
        return (fp);
}

void
logger(char *group, char *nick, char *what)
{
        struct icbd_logentry e;
        struct iovec iov[2];
        const char *defgrp = "1";

        if (!dologging)
                return;

        if (strcmp(group, defgrp) == 0)
                return;

        strlcpy(e.group, group, ICB_MAXGRPLEN);
        strlcpy(e.nick, nick, ICB_MAXNICKLEN);
        e.length = strlen(what) + 1;

        iov[0].iov_base = &e;
        iov[0].iov_len = sizeof e;

        iov[1].iov_base = what;
        iov[1].iov_len = e.length;

        if (writev(logger_pipe, iov, 2) == -1)
                syslog(LOG_ERR, "%s: %m", __func__);
}

void
logger_tick(void)
{
        static int last_mon = -1, last_mday = -1;
        struct timeval tv = { 60, 0 };
        char buf[128];
        struct tm *tm;
        time_t t;
        int i;

        time(&t);
        tm = gmtime(&t);
        if (last_mon != tm->tm_mon) {
                snprintf(file_ts, sizeof file_ts, "%04d-%02d",
                    tm->tm_year + 1900, tm->tm_mon + 1);
                last_mon = tm->tm_mon;
                /* rotate log files */
                for (i = 0; i < nlogfiles; i++) {
                        fclose(logfiles[i].fp);
                        logfiles[i].fp = NULL;
                }
                nlogfiles = 0;
        }
        if (tm->tm_mday != last_mday) {
                strftime(buf, sizeof(buf),
                    "Today is %a %b %e %Y %H:%M %Z (%z)", tm);
                for (i = 0; i < nlogfiles; i++)
                        fprintf(logfiles[i].fp, "%s\n", buf);
                last_mday = tm->tm_mday;
        }
        snprintf(line_ts, sizeof line_ts, "%02d:%02d", tm->tm_hour,
            tm->tm_min);
        if (evtimer_add(&ev_tick, &tv) < 0) {
                syslog(LOG_ERR, "%s: evtimer_add: %m", __func__);
                exit(EX_UNAVAILABLE);
        }
}