bus.c

/* See LICENSE file for copyright and license details. */
#include "bus.h"

#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <grp.h>
#include <pwd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "arg.h"



/**
 * Statement wrapper that goes to `fail` on failure
 */
#define t(inst) do { if ((inst) == -1) goto fail; } while (0)



/**
 * The name of the process
 */
char *argv0;

/**
 * The command to spawn when a message is received
 */
static const char *command;



/**
 * Spawn a command because a message has been received
 * 
 * @param   message    The received message
 * @param   user_data  Not used
 * @return             1 (continue listening) on success, -1 on error
 */
static int
spawn_continue(const char *message, void *user_data)
{
	pid_t pid;
	if (!message)
		return 1;
	if ((pid = fork()))
		return pid == -1 ? -1 : 1;
	setenv("msg", message, 1);
	execlp("sh", "sh", "-c", command, NULL);
	perror(argv0);
	exit(1);
	(void) user_data;
}


/**
 * Spawn a command because a message has been received
 * 
 * @param   message    The received message
 * @param   user_data  Not used
 * @return             0 (stop listening) on success, -1 on error, or 1 if `message` is `NULL`
 */
static int
spawn_break(const char *message, void *user_data)
{
	pid_t pid;
	if (!message)
		return 1;
	if ((pid = fork()))
		return pid == -1 ? -1 : 0;
	setenv("msg", message, 1);
	execlp("sh", "sh", "-c", command, NULL);
	perror(argv0);
	exit(1);
	(void) user_data;
}


/**
 * Parse a permission string
 * 
 * @param   str     The permission string
 * @param   andnot  Output paramter for the mask of bits to remove (before applying `*or`)
 * @param   or      Output paramter for the mask of bits to apply
 * @return          0 on success, -1 on error
 */
static int
parse_mode(const char *str, mode_t *andnot, mode_t *or)
{
#define U S_IRWXU
#define G S_IRWXG
#define O S_IRWXO
	const char *s = str;
	int numerical = 1;
	mode_t mode = 0;
	char op = '=';
	mode_t bits;

	*andnot = 0;
	*or = 0;

	if (!*s)
		return errno = 0, -1;

	for (s = str; *s; s++) {
		if (('0' > *s) || (*s > '7')) {
			numerical = 0;
			break;
		} else {
			mode = (mode << 3) | (*s & 15);
		}
	}

	if (numerical) {
		*andnot = U | G | O;
		*or = mode;
		*or &= U | G | O;
		*or = (*or & U) ? (*or | U) : (*or & (mode_t)~U);
		*or = (*or & G) ? (*or | G) : (*or & (mode_t)~G);
		*or = (*or & O) ? (*or | O) : (*or & (mode_t)~O);
		return 0;
	}

	for (s = str; *s; s++) {
		if (strchr("+-=", *s)) {
			op = *s;
		} else if (strchr("ugo", *s)) {
			if (*s == 'u')
				bits = U;
			else if (*s == 'g')
				bits = G;
			else
				bits = O;
			if (op == '+') {
				*andnot |= bits;
				*or |= bits;
			}
			else if (op == '-') {
				*andnot |= bits;
				*or &= ~bits;
			}
			else if (op == '=') {
				*andnot |= U | G | O;
				*or |= bits;
			}
		} else {
			return errno = 0, -1;
		}
	}

	return 0;
}


/**
 * Parse a user name/identifier string
 * 
 * @param   str  The user's name or identifier
 * @param   uid  Output parameter for the user's identifier
 * @return       0 on success, -1 on error
 */
static int
parse_uid(const char *str, uid_t *uid)
{
	const char *s = str;
	int numerical = 1;
	uid_t rc = 0;
	struct passwd *pwd;

	if (!*s || (*s == ':'))
		return errno = 0, -1;

	for (s = str; *s; s++) {
		if (('0' > *s) || (*s > '9')) {
			numerical = 0;
			break;
		}
	}

	if (numerical) {
		for (s = str; *s; s++)
			rc = (rc * 10) + (*s & 15);
		*uid = rc;
		return 0;
	}

	pwd = getpwnam(str);
	if (!pwd) {
		return -1;
	}
	*uid = pwd->pw_uid;
	return 0;
}


/**
 * Parse a group name/identifier string
 * 
 * @param   str  The group's name or identifier
 * @param   gid  Output parameter for the group's identifier
 * @return       0 on success, -1 on error
 */
static int
parse_gid(const char *str, gid_t *gid)
{
	const char *s = str;
	int numerical = 1;
	gid_t rc = 0;
	struct group *grp;

	if (!*s || strchr(s, ':'))
		return errno = 0, -1;

	for (s = str; *s; s++) {
		if (('0' > *s) || (*s > '9')) {
			numerical = 0;
			break;
		}
	}

	if (numerical) {
		for (s = str; *s; s++)
			rc = (rc * 10) + (*s & 15);
		*gid = rc;
		return 0;
	}

	grp = getgrnam(str);
	if (!grp)
		return -1;
	*gid = grp->gr_gid;
	return 0;
}


/**
 * Parse a ownership string
 * 
 * @param   str  The ownership string
 * @param   uid  Output parameter for the owner, `NULL` if `str` only contains the group
 * @param   gid  Output parameter for the group, `NULL` if `str` only contains the owner
 * @return       0 on success, -1 on error
 */
static int
parse_owner(char *str, uid_t *uid, gid_t *gid)
{
	int r = 0;
	char* group;

	if (!uid)
		return parse_gid(str, gid);
	if (!gid)
		return parse_uid(str, uid);

	group = strchr(str, ':');
	*group++ = 0;

	r = parse_gid(group, gid);
	if (r)
		return r;
	return parse_uid(str, uid);
}



/**
 * Main function of the command line interface for the bus system
 * 
 * @param   argc  The number of elements in `argv`
 * @param   argv  The command. Valid commands:
 *                  <argv0> create [-x] [--] [<path>]             # create a bus
 *                  <argv0> remove [--] <path>                    # remove a bus
 *                  <argv0> listen [--] <path> <command>          # listen for new messages
 *                  <argv0> wait [--] <path> <command>            # listen for one new message
 *                  <argv0> broadcast [-n] [--] <path> <message>  # broadcast a message
 *                  <argv0> chmod [--] <mode> <path>              # change permissions
 *                  <argv0> chown [--] <owner>[:<group>] <path>   # change ownership
 *                  <argv0> chgrp [--] <group> <path>             # change group
 *                <command> will be spawned with $arg set to the message
 * @return        0 on sucess, 1 on error, 2 on invalid command
 */
int
main(int argc, char *argv[])
{
	int xflag = 0;
	int nflag = 0;
	bus_t bus;
	char *file;
	struct stat attr;
	uid_t uid;
	gid_t gid;
	mode_t mode_andnot, mode_or;

	/* Parse arguments. */
	ARGBEGIN {
	case 'x':
		xflag = 1;
		break;
	case 'n':
		nflag = 1;
		break;
	default:
		return 2;
	} ARGEND;

	/* Check options. */
	if (xflag && strcmp(argv[0], "create") && (argc != 2))
		return 2;
	if (nflag && strcmp(argv[0], "broadcast") && (argc != 3))
		return 2;

	/* Create a new bus with selected name. */
	if ((argc == 2) && !strcmp(argv[0], "create")) {
		t(bus_create(argv[1], xflag * BUS_EXCL, NULL));

	/* Create a new bus with random name. */
	} else if ((argc == 1) && !strcmp(argv[0], "create")) {
		t(bus_create(NULL, 0, &file));
		printf("%s\n", file);
		free(file);

	/* Remove a bus. */
	} else if ((argc == 2) && !strcmp(argv[0], "remove")) {
		t(bus_unlink(argv[1]));

	/* Listen on a bus in a loop. */
	} else if ((argc == 3) && !strcmp(argv[0], "listen")) {
		command = argv[2];
		t(bus_open(&bus, argv[1], BUS_RDONLY));
		t(bus_read(&bus, spawn_continue, NULL));
		t(bus_close(&bus));

	/* Listen on a bus for one message. */
	} else if ((argc == 3) && !strcmp(argv[0], "wait")) {
		command = argv[2];
		t(bus_open(&bus, argv[1], BUS_RDONLY));
		t(bus_read(&bus, spawn_break, NULL));
		t(bus_close(&bus));

	/* Broadcast a message on a bus. */
	} else if ((argc == 3) && !strcmp(argv[0], "broadcast")) {
		t(bus_open(&bus, argv[1], BUS_WRONLY));
		t(bus_write(&bus, argv[2], nflag * BUS_NOWAIT));
		t(bus_close(&bus));

	/* Change permissions. */
	} else if ((argc == 3) && !strcmp(argv[0], "chmod")) {
		t(parse_mode(argv[1], &mode_andnot, &mode_or));
		t(stat(argv[2], &attr));
		attr.st_mode &= ~mode_andnot;
		attr.st_mode |= mode_or;
		t(bus_chmod(argv[2], attr.st_mode));

	/* Change ownership. */
	} else if ((argc == 3) && !strcmp(argv[0], "chown")) {
		if (strchr(argv[1], ':')) {
			t(parse_owner(argv[1], &uid, &gid));
			t(bus_chown(argv[2], uid, gid));
		} else {
			t(parse_owner(argv[1], &uid, NULL));
			t(stat(argv[2], &attr));
			t(bus_chown(argv[2], uid, attr.st_gid));
		}

	/* Change group. */
	} else if ((argc == 3) && !strcmp(argv[0], "chgrp")) {
		t(parse_owner(argv[1], NULL, &gid));
		t(stat(argv[2], &attr));
		t(bus_chown(argv[2], attr.st_uid, gid));

	} else
		return 2;

	return 0;

fail:
	if (!errno)
		return 2;
	perror(argv0);
	return 1;
}