wmsl

wmsl.c (6737B)

#include <X11/Xlib.h>

#include <bits/time.h>
#include <sys/poll.h>
#include <sys/wait.h>
#include <unistd.h>
#include <err.h>
#include <errno.h>
#include <signal.h>
#include <time.h>
#include <math.h>
#include <string.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>

#define OUTPUTMAX  2048

struct block {
	struct block *next;
	const char *command;
	bool ready;
	int id, sleep;
	time_t sleep_left;
	char output[OUTPUTMAX];
};

static const char *usage = "Usage: wmsl [-C FILE] [-h] [-v]\n";
static const char *pid_file = "/tmp/wmsl.pid";
static pid_t pid;

static char status_text[OUTPUTMAX];
static size_t status_len;

static Display *dpy;
static Window root;

static char config[1024];

static struct block *blocks;

static char *delim;
static char *prefix;
static char *suffix;

static void
update_status(const char *str)
{
	XStoreName(dpy, root, str);
	XFlush(dpy);
}

static void
sigexit(int sig)
{
	update_status("");
	exit(128 + sig);
}

static time_t
now_ms(void)
{
	struct timespec now;

	if (clock_gettime(CLOCK_REALTIME, &now))
		err(1, "clock_gettime REALTIME");

	return now.tv_sec * 1000L + now.tv_nsec / 1000000L;
}

static void
sighandler(int sig, siginfo_t *info, void *context)
{
	struct block *block;
	int block_id;

	block_id = info->si_value.sival_int;
	if (!block_id || info->si_pid == pid) return;

	for (block = blocks; block; block = block->next) {
		if (block->id == block_id) {
			block->ready = true;
			break;
		}
	}
}

static void
concat_status(const char *text)
{
	size_t len = strlen(text);
	if (status_len + len + 1 > OUTPUTMAX)
		len = OUTPUTMAX - status_len - 1;
	memcpy(&status_text[status_len], text, len);
	status_len += len;
	if (status_len == OUTPUTMAX)
		strcpy(&status_text[status_len - 4], "...");
	status_text[status_len] = '\0';
}

static int
run_block(const char *cmd, pid_t *pid)
{
	int out[2];

	if (pipe(out) == -1)
		err(1, "pipe");

	*pid = fork();
	if (*pid < 0) err(1, "fork");

	if (*pid) {
		close(out[1]);
	} else {
		close(0);
		dup2(out[1], 1);
		close(out[0]);
		close(out[1]);
		execl("/bin/sh", "sh", "-c", cmd, NULL);
		abort();
	}

	return out[0];
}

static void
read_block(int fd, char *buf, size_t size)
{
	time_t start_ms, end_ms;
	struct pollfd pollfd;
	ssize_t nread;
	char *tok;

	pollfd.fd = fd;
	pollfd.events = POLLIN;

	start_ms = now_ms();
	end_ms = start_ms + 1000; /* 1 second timeout */

	*buf = '\0';
	while (end_ms > start_ms) {
		if (poll(&pollfd, 1, (int) (end_ms - start_ms)) <= 0)
			break;
		start_ms = now_ms();

		if (!(pollfd.revents & POLLIN))
			continue;

		nread = read(fd, buf, size);
		if (nread <= 0) break;

		tok = memchr(buf, '\n', (size_t) nread);
		if (tok) *tok = '\0';

		buf += nread;
		size -= (size_t) nread;

		if (tok) break;
	}
}

static void
update_blocks(void)
{
	struct block *block;
	char buf[OUTPUTMAX];
	pid_t child;
	bool update;
	int fd;

	status_text[0] = '\0';
	status_len = 0;

	concat_status(prefix);

	update = false;
	for (block = blocks; block; block = block->next) {
		if (block->ready || block->sleep && block->sleep_left <= 50) {
			block->sleep_left = block->sleep * 1000;
			block->ready = false;

			fd = run_block(block->command, &child);

			read_block(fd, buf, sizeof(buf)-1);
			if (strcmp(buf, block->output)) {
				strncpy(block->output, buf, OUTPUTMAX);
				update = true;
			}

			close(fd);
			kill(child, SIGKILL);
			waitpid(child, NULL, 0);
		}

		if (*block->output) {
			if (status_len > 0)
				concat_status(delim);
			concat_status(block->output);
		}
	}
	if (!update) return;

	concat_status(suffix);

	update_status(status_text);
}

static void
sleep_next(void)
{
	struct block *block;
	time_t min_sleep;
	time_t start_ms;
	time_t stop_ms;

	min_sleep = 0;
	for (block = blocks; block; block = block->next) {
		if (block->ready || block->sleep && block->sleep_left <= 0)
			return;
		if (!min_sleep || block->sleep && block->sleep_left < min_sleep)
			min_sleep = block->sleep_left;
	}

	start_ms = now_ms();
	poll(NULL, 0, (int) min_sleep);
	stop_ms = now_ms();

	for (block = blocks; block; block = block->next) {
		if (block->sleep) {
			block->sleep_left -= (stop_ms - start_ms);
		}
	}
}

static void
read_config(void)
{
	struct block **block;
	char line[256], *tok;
	FILE *file;

	file = fopen(config, "r");
	if (!file) err(1, "fopen '%s'", config);

	block = &blocks;
	while (fgets(line, 256, file)) {
		if (*line == '#' || strspn(line, " \n\v\t") == strlen(line))
			continue;
		if ((tok = strchr(line, '\n')))
			*tok = '\0';
		if (!strncmp(line, "delim=", 6)) {
			delim = strdup(line + 6);
		} else if (!strncmp(line, "prefix=", 7)) {
			prefix = strdup(line + 7);
		} else if (!strncmp(line, "suffix=", 7)) {
			suffix = strdup(line + 7);
		} else if (!strncmp(line, "block=", 6)) {
			if (block != &blocks || *block)
				block = &(*block)->next;
			*block = malloc(sizeof(struct block));
			(*block)->command = strdup(line + 6);
			(*block)->id = 0;
			(*block)->sleep_left = 0;
			(*block)->sleep = 0;
			(*block)->ready = true;
			(*block)->next = NULL;
		} else if (!strncmp(line, "block-id=", 9)) {
			if (!*block) errx(1, "missing block=");
			(*block)->id = atoi(line + 9);
		} else if (!strncmp(line, "block-sleep=", 12)) {
			if (!*block) errx(1, "missing block=");
			(*block)->sleep = atoi(line + 12);
		} else {
			errx(1, "invalid config");
		}
	}

	if (!suffix) suffix = " ";
	if (!prefix) prefix = "";
	if (!delim) delim = " | ";

	fclose(file);
}

int
main(int argc, const char **argv)
{
	const char **arg;
	struct sigaction sa;
	const char *home;
	int screen;
	FILE *file;

	if (argc <= 0) return 1; 

	for (arg = argv + 1; *arg; arg++) {
		if ((*arg)[0] != '-')
			errx(1, "invalid arg: %s", *arg);
		switch ((*arg)[1]) {
		case 'C':
			strncpy(config, *++arg, sizeof(config));
			break;
		case 'h':
			fputs(usage, stdout);
			return 0;
		default:
			fputs(usage, stderr);
			return 1;
		}
	}

	if (!*config) {
		home = getenv("HOME");
		if (!home) errx(1, "not config");
		snprintf(config, sizeof(config),
			"%s/.config/wmsl/wmslrc", home);
	}

	read_config();

	/* get root window */
	dpy = XOpenDisplay(NULL);
	if (!dpy) errx(1, "XOpenDisplay root window");
	screen = DefaultScreen(dpy);
	root = RootWindow(dpy, screen);

	/* save pid */
	pid = getpid();
	file = fopen(pid_file, "w+");
	if (!file) err(1, "fopen '%s'", pid_file);
	fprintf(file, "%i", pid);
	fclose(file);

	/* setup signal handlers & cleanup */
	sigemptyset(&sa.sa_mask);
	sa.sa_handler = NULL;
	sa.sa_sigaction = sighandler;
	sa.sa_flags = SA_RESTART | SA_SIGINFO;
	if (sigaction(SIGUSR1, &sa, NULL))
		err(1, "sigaction");
	signal(SIGINT, sigexit);
	signal(SIGTERM, sigexit);

	while (1) {
		sleep_next();
		update_blocks();
	}
}