ztatus [discontinued] Status bar for dwm, and simple notification daemon.
	git clone https://noxz.tech/git/ztatus.git
	Log | Files | LICENSE

#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/select.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>

#include "config.h"

#define PNAME "ztatus"

/* functions */
static int  check_proc(struct dirent*);
static int die(const char*, ...);
static void dispatch(void);
static int  get_int(const char*, int*);
static int  get_pid(void);
static void notify(const char*);
static void render_time(char*);
static int  run(void);
static void set_status(const char*);
static void sigint_handler(int);

/* global variables */
static char *last_line;
static int delay_time = 0;
static int running = 0;
static int self_pid = 0;
static int fifofd;

void
sigint_handler(int signum)
{
	running = 0;
}

int
die(const char *format, ...)
{
	va_list args;

	va_start(args, format);
	vfprintf(stderr, format, args);
	va_end(args);

	return 1;
}

int
run(void)
{
	int rv, count, pid;
	fd_set rfds;
	struct timeval tv;
	char *status_line = NULL;

	/* only allow one instance of ztatus */
	if ((pid = get_pid()) != -1)
		return die("error: an instance of %s is already running (PID: %d)\n",
		           PNAME, pid);

	unlink(FIFO_PATH);

	/* setup, or fail */
	if ((mknod(FIFO_PATH, S_IFIFO | 0600, 0)) < 0)
		return die("error: cannot create fifo '%s'\n", FIFO_PATH);
	if ((fifofd = open(FIFO_PATH, O_RDWR | O_NONBLOCK)) < 0)
		return die("error: cannot open fifo '%s'\n", FIFO_PATH);
	if ((status_line = malloc(STATUS_LENGTH)) == NULL)
		return die("error: failed to allocate memory\n", FIFO_PATH);
	if ((last_line = calloc(STATUS_LENGTH, sizeof(char))) == NULL)
		return die("error: failed to allocate memory\n", FIFO_PATH);

	/* handle interrupts and terminations */
	signal(SIGINT, sigint_handler);
	signal(SIGTERM, sigint_handler);

	fprintf(stderr, "%s is running as PID: %d\n", PNAME, self_pid);

	running = 1;
	while (running) {
		count++;

		/* wait for 1 second or fifofd */
		FD_ZERO(&rfds);
		FD_SET(fifofd, &rfds);
		tv.tv_sec = 1;
		tv.tv_usec = 0;

		/* select fifo descriptor, and break on failure */
		if ((rv = select(fifofd + 1, &rfds, NULL, NULL, &tv)) < 0)
			break;

		/* dispatch on fifo read */
		if (FD_ISSET(fifofd, &rfds))
			dispatch();

		/* prevent data printing if it's delayed.
		 * this is so an external signal can borrow the status line
		 * for a short time, determined by the delay_time */
		if (delay_time > 0) {
			delay_time--;
			continue;
		}

		render_time(status_line);
		set_status(status_line);
	}

	/* free up resources when done */
	free(status_line);
	free(last_line);
	if (fifofd >= 0)
		unlink(FIFO_PATH);

	return 0;
}

int
get_pid(void)
{
	const char *path = "/proc";
	DIR *dir;
	struct dirent *e;
	int p = -1;

	/* check all processes */
	if ((dir = opendir(path)) != NULL) {
		while ((e = readdir(dir)) != NULL && (p = check_proc(e)) == -1);
		closedir(dir);
	}

	return p;
}

int
get_int(const char *s, int *i)
{
	const char *c = s;

	*i = 0;
	while (*c) {
		if (*c < 48 || *c >= 58)
			return 0;
		*i = *i * 10 - 48 + *c;
		c++;
	}

	return 1;
}

int
check_proc(struct dirent *e)
{
	char *base_p = NULL;
	char *comm_p = NULL;
	char *cmdline_p = NULL;
	char comm[7] = {0};
	char cmdline[64] = {0};
	FILE *fptr = NULL;
	struct stat sb;
	int i, l;
	int pid;
	int state = 0;

	if (get_int(e->d_name, &pid) == 0 || pid == self_pid)
		state = -1;

	if (state == 0) {
		base_p = malloc(strlen(e->d_name) + 7);
		strcpy(base_p, "/proc/");
		strcat(base_p, e->d_name);
		if (stat(base_p, &sb) != 0 || !S_ISDIR(sb.st_mode))
			state = -1;
	}

	if (state == 0) {
		comm_p = malloc(strlen(base_p) + 6);
		strcpy(comm_p, base_p);
		strcat(comm_p, "/comm");
		if (stat(comm_p, &sb) != 0 || !S_ISREG(sb.st_mode))
			state = -1;
	}

	if (state == 0) {
		cmdline_p = malloc(strlen(base_p) + 9);
		strcpy(cmdline_p, base_p);
		strcat(cmdline_p, "/cmdline");
		if (stat(cmdline_p, &sb) != 0 || !S_ISREG(sb.st_mode))
			state = -1;
	}

	if (state == 0) {
		fptr = fopen(comm_p, "rb");
		for (i = 0, l = sizeof(comm); i < l; i++)
			comm[i] = fgetc(fptr);
		fclose(fptr);
		if (comm[6] != '\n') {
			state = -1;
		} else {
			comm[6] = '\0';
			if (strcmp(comm, PNAME) != 0)
				state = -1;
		}
	}

	if (state == 0) {
		fptr = fopen(cmdline_p, "rb");
		fread(cmdline, sizeof(cmdline), 1, fptr);
		l = ftell(fptr);
		fclose(fptr);
		if (strchr(cmdline, '/') != NULL)
			memmove(cmdline,
			        strrchr(cmdline, '/') + 1,
			        strlen(strrchr(cmdline, '/') + 1)
			);
		if (strcmp(cmdline, PNAME) == 0)
			return pid;
	}

	if (base_p != NULL)
		free(base_p);
	if (comm_p != NULL)
		free(comm_p);
	if (cmdline_p != NULL)
		free(cmdline_p);

	return -1;
}

void
render_time(char *str)
{
	int z, y, era, time_val;
	unsigned doe, yoe, doy, mp, d, m;
	char *tmp = malloc(32);
	time_t currentTime = time(NULL);
	struct tm *localTime;

	localTime = localtime(&currentTime);
	time_val = currentTime + localTime->tm_gmtoff;

	z = time_val / 86400 + 719468;
	era = (z >= 0 ? z : z - 146096) / 146097;
	doe = (unsigned)(z - era * 146097);
	yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
	y = (int)yoe + era * 400;
	doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
	mp = (5 * doy + 2) / 153;
	d = doy - (153 * mp + 2) / 5 + 1;
	m = mp + (mp < 10 ? 3 : -9);
	y += (m <= 2);

	snprintf(tmp, 32, FORMAT_TIME
		,y ,m ,d
		,(time_val / 3600) % 24
		,(time_val / 60) % 60
	);
	strcpy(str, tmp);
	free(tmp);
}

void
set_status(const char *line) {
	if (strcmp(line, last_line))
		puts(line);
	strcpy(last_line, line);
}

void
dispatch(void)
{
	char buf[BUFSIZ];
	char *line, *next;
	ssize_t n;

	if ((n = read(fifofd, buf, sizeof(buf) - 1)) == -1)
		return;

	buf[n] = '\0';
	line = buf;

	/* read each line as a single notification,
	 * which means that only that last line will be seen */
	while (line) {
		next = strchr(line, '\n');
		if (next)
			*next = '\0';
		notify(line);
		if (next)
			*next = '\n';
		line = next ? next + 1 : NULL;
	}

	/* make sure fifo is empty */
	while (errno != EWOULDBLOCK)
		read(fifofd, buf, sizeof(buf) - 1);
}

void
notify(const char* input)
{
	char *status_line = NULL;

	if ((status_line = malloc(STATUS_LENGTH)) == NULL)
		return;

	delay_time = (int)(DELAY_INTERVAL);

	snprintf(status_line, STATUS_LENGTH, FORMAT_NOTIFY, input);
	set_status(status_line);
	free(status_line);
}

int
main(int argc, char *argv[])
{
	char *s;
	self_pid = getpid();

	if ((s = strrchr(argv[0], '/')) == NULL)
		s = argv[0];
	else
		s++;

	if (strcmp(s, PNAME) != 0)
		return die("error: program must run as '%s'\n", PNAME);

	return run();
}