lenstatus.c

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <stdbool.h>
#include <stdint.h>
#include <sys/wait.h>
#ifndef NO_X
#include <X11/Xlib.h>
#endif

typedef void (*cfunc_t)(char *, int *);

union func {
    char *const *cmd;
    cfunc_t func;
};

struct segment {
    int interval;
    int sig;
    const char *prefix;
    bool iscmd;
    union func f;
};

#include "config.h"

#define LEN(x) (sizeof(x) / sizeof(x[0]))

int delimlen;

#ifndef NO_X
Display *dpy;
Window root;
#endif

char bufs[LEN(segs)][64];
char *self;
int lens[LEN(segs)];
char out[2][256];
int outlen[2];

void format() {
    int len = 0, pflen;
    for (int i = 0; i < LEN(segs); i++) {
        pflen = segs[i].prefix ? strlen(segs[i].prefix) : 0;
        if (len + pflen >= 255)
            goto end;
        memcpy(out[0] + len, segs[i].prefix, pflen);
        len += pflen;

        for (int j = 0; j < lens[i]; j++) {
            if (len == 255)
                goto end;
            if (bufs[i][j] == '\n')
                break;
            out[0][len++] = bufs[i][j];
        }

        if (len + delimlen >= 255 || i + 1 == LEN(segs))
            goto end;
        memcpy(out[0] + len, delim, delimlen);
        len += delimlen;
    }
end:
    outlen[0] = len;
}

void execcmd(int seg) {
    int fds[2];

    if (pipe(fds) != 0)
        return;

    if (fork() != 0) {
	wait(NULL);
        lens[seg] = read(fds[0], bufs[seg], 64);
	close(fds[0]);
	close(fds[1]);
        return;
    }

    dup2(fds[1], STDOUT_FILENO);

    execvp(segs[seg].f.cmd[0], segs[seg].f.cmd);
    close(fds[0]);
    close(fds[1]);
}

void execute(int seg) {
    if (segs[seg].iscmd) {
        execcmd(seg);
    } else {
        segs[seg].f.func(bufs[seg], lens + seg);
    }
}

void update(int seg) {
    execute(seg);
    format();
}

void writebuf(void) {
    if (outlen[0] == outlen[1]) {
        if (memcmp(out[0], out[1], outlen[0]) == 0)
            return;
    }
    memcpy(out[1], out[0], outlen[0]);
    outlen[1] = outlen[0];
#ifndef NO_X
    out[0][outlen[0]] = '\0';
    XStoreName(dpy, root, out[0]);
    XFlush(dpy);
#else
    printf("%.*s\n", outlen[0], out[0]);
#endif
}

void sighandler(int sig) {
    if (sig == SIGHUP) {
        fprintf(stderr, "restarting...\n");
        exit(execvp(self, (char *const[]){self, NULL}));
    }

    sig = sig - SIGRTMIN;
    for (int i = 0; i < LEN(segs); i++)
        if (segs[i].sig == sig)
            update(i);
    writebuf();
}

void setup(void) {
    struct sigaction sa = {{0}, .sa_handler = sighandler};
#ifndef NO_X
    dpy = XOpenDisplay(NULL);
    if (dpy == NULL) {
        fprintf(stderr, "error opening x\n");
        exit(1);
    }
    root = DefaultRootWindow(dpy);
#endif

    sigaction(SIGHUP, &sa, NULL);

    for (int i = 0; i < LEN(segs); i++) {
        if (segs[i].sig)
            sigaction(SIGRTMIN + segs[i].sig, &sa, NULL);
        execute(i);
    }
    format();
    writebuf();
}

void process(uint64_t t) {
    for (int i = 0; i < LEN(segs); i++) {
        if (segs[i].interval && t % segs[i].interval == 0) {
            update(i);
            writebuf();
        }
    }
}

int main(int argc, char *argv[]) {
    uint64_t i = 0;
    struct timespec t, orig = {1, 0};
    self = argv[0];
    delimlen = strlen(delim);

    setup();

    t = orig;
    while (1) {
        if (nanosleep(&t, &t) == -1)
            continue;

        process(i);

        i++;
        t = orig;
    }

#ifndef NO_X
    XCloseDisplay(dpy);
#endif
}