hotplug-dispatch.c

/*
 * Copyright (C) 2021 Daniel Golle <daniel@makrotopia.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 2.1
 * as published by the Free Software Foundation
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#define _GNU_SOURCE

#include <sys/inotify.h>
#include <sys/types.h>

#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <glob.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include <libubox/avl.h>
#include <libubox/avl-cmp.h>
#include <libubox/list.h>
#include <libubox/uloop.h>
#include <libubus.h>

#include "procd.h"
#include "utils/utils.h"

#define HOTPLUG_BASEDIR "/etc/hotplug.d"
#define HOTPLUG_OBJECT_PREFIX "hotplug."

struct ubus_context *ctx;
static struct inotify_watch basedir_watch;

static AVL_TREE(subsystems, avl_strcmp, false, NULL);

extern char **environ;

struct hotplug_subsys {
	struct avl_node node;
	struct ubus_object ubus;
};

struct envlist {
	struct avl_node avl;
	char *env;
};

struct hotplug_process {
	struct ubus_object *ubus;
	char **envp;
	struct uloop_timeout timeout;
	struct uloop_process process;
	glob_t globbuf;
	unsigned int cnt;
	int ret;
};

static void env_free(char **envp)
{
	char **tmp;

	tmp = envp;
	while (*tmp)
		free(*(tmp++));
	free(envp);
}

static void hotplug_free(struct hotplug_process *pc)
{
	env_free(pc->envp);
	globfree(&pc->globbuf);
	free(pc);
}

static void hotplug_done(struct uloop_process *c, int ret)
{
	struct hotplug_process *pc = container_of(c, struct hotplug_process, process);

	pc->ret = ret;

	uloop_timeout_set(&pc->timeout, 50);
}

static void hotplug_exec(struct uloop_timeout *t)
{
	struct hotplug_process *pc = container_of(t, struct hotplug_process, timeout);
	char *script;
	char *exec_argv[4];
	/* we have reached the last entry in the globbuf */
	if (pc->cnt == pc->globbuf.gl_pathc) {
		hotplug_free(pc);
		return;
	}

	if (asprintf(&script, ". /lib/functions.sh\n. %s\n", pc->globbuf.gl_pathv[pc->cnt++]) == -1) {
		pc->ret = ENOMEM;
		return;
	}

	/* prepare for execve() */
	exec_argv[0] = "/bin/sh";
	exec_argv[1] = "-c";
	exec_argv[2] = script;
	exec_argv[3] = NULL;

	/* set callback in uloop_process */
	pc->process.cb = hotplug_done;
	pc->process.pid = fork();
	if (pc->process.pid == 0) {
		/* child */
		patch_stdio("/dev/null");
		execve(exec_argv[0], exec_argv, pc->envp);
		ERROR("Failed to execute script: %m\n");
		exit(EXIT_FAILURE);
	} else if (pc->process.pid < 0) {
		/* fork error */
		free(script);
		hotplug_free(pc);
		return;
	}
	/* parent */
	free(script);
	uloop_process_add(&pc->process);
}

static int avl_envcmp(const void *k1, const void *k2, void *ptr)
{
	const char *tmp;

	tmp = strchr(k1, '=');
	if (!tmp)
		return -1;

	/*
	 * compare the variable name only, ie. limit strncmp to check
	 * only up to and including the '=' sign
	 */
	return strncmp(k1, k2, (tmp - (char *)k1) + 1);
}

/* validate NULL-terminated environment variable name */
static int validate_envvarname(const char *envvarname)
{
	const char *tmp = envvarname;

	/* check for illegal characters in env variable name */
	while (tmp[0] != '\0') {
		if (!((tmp[0] >= 'a' && tmp[0] <= 'z') ||
		      (tmp[0] >= 'A' && tmp[0] <= 'Z') ||
		      (tmp[0] == '_') ||
		      /* allow numbers unless they are at the first character */
		      ((tmp != envvarname) && tmp[0] >= '0' && tmp[0] <= '9')))
			return EINVAL;
		++tmp;
	}

	return 0;
}

enum {
	HOTPLUG_ENV,
	__HOTPLUG_MAX
};

static const struct blobmsg_policy hotplug_policy[__HOTPLUG_MAX] = {
	[HOTPLUG_ENV] = { .name = "env", .type = BLOBMSG_TYPE_ARRAY },
};

static int hotplug_call(struct ubus_context *ctx, struct ubus_object *obj,
			struct ubus_request_data *req, const char *method,
			struct blob_attr *msg)
{
	const char *subsys = &obj->name[strlen(HOTPLUG_OBJECT_PREFIX)];
	struct blob_attr *tb[__HOTPLUG_MAX], *cur;
	AVL_TREE(env, avl_envcmp, false, NULL);
	struct envlist *envle, *p;
	int rem;
	char **envp, *globstr, *tmp, **tmpenv;
	size_t envz = 0;
	struct hotplug_process *pc;
	bool async = true;
	int err = UBUS_STATUS_UNKNOWN_ERROR;

	blobmsg_parse(hotplug_policy, __HOTPLUG_MAX, tb, blobmsg_data(msg), blobmsg_len(msg));

	if (!tb[HOTPLUG_ENV])
		return UBUS_STATUS_INVALID_ARGUMENT;

	tmpenv = environ;

	/* first adding existing environment to avl_tree */
	while (*tmpenv) {
		envle = calloc(1, sizeof(struct envlist));
		if (!envle)
			goto err_envle;

		envle->env = strdup(*tmpenv);
		if (!envle->env) {
			free(envle);
			goto err_envle;
		}
		envle->avl.key = envle->env;
		if (avl_insert(&env, &envle->avl) == -1) {
			free(envle->env);
			free(envle);
			goto err_envle;
		}

		++tmpenv;
	}

	/* then adding additional variables from ubus call */
	blobmsg_for_each_attr(cur, tb[HOTPLUG_ENV], rem) {
		char *enve = blobmsg_get_string(cur);
		if (!enve)
			continue;

		if (!strncmp(enve, "LD_", 3))
			continue;

		if (!strncmp(enve, "PATH=", 5))
			continue;

		if (strlen(enve) < 3)
			continue;

		if (!(tmp = strchr(enve, '=')))
			continue;

		*tmp = '\0';
		if (validate_envvarname(enve))
			continue;
		*tmp = '=';

		if (!strcmp(enve, "ASYNC=0"))
			async = false;

		envle = calloc(1, sizeof(struct envlist));
		if (!envle)
			goto err_envle;

		envle->env = strdup(enve);
		if (!envle->env) {
			free(envle);
			goto err_envle;
		}
		envle->avl.key = envle->env;
		if (avl_insert(&env, &envle->avl)) {
			/* do not override existing env values, just skip */
			free((void*)envle->env);
			free(envle);
		}
	}

	/* synchronous calls are unsupported for now */
	if (!async) {
		err = UBUS_STATUS_NOT_SUPPORTED;
		goto err_envle;
	}

	/* allocating new environment */
	avl_for_each_element(&env, envle, avl)
		++envz;

	envp = calloc(envz + 1, sizeof(char *));
	if (!envp)
		goto err_envle;

	/* populating new environment */
	envz = 0;
	avl_for_each_element_safe(&env, envle, avl, p) {
		envp[envz++] = envle->env;
		avl_delete(&env, &envle->avl);
		free(envle);
	}

	pc = calloc(1, sizeof(struct hotplug_process));
	if (!pc) {
		env_free(envp);
		return UBUS_STATUS_UNKNOWN_ERROR;
	}
	pc->timeout.cb = hotplug_exec;
	pc->envp = envp;
	pc->cnt = 0;
	pc->ubus = obj;

	/* glob'ing for hotplug scripts */
	if (asprintf(&globstr, "%s/%s/*", HOTPLUG_BASEDIR, subsys) == -1) {
		hotplug_free(pc);
		return UBUS_STATUS_UNKNOWN_ERROR;
	}

	if (glob(globstr, GLOB_DOOFFS, NULL, &pc->globbuf)) {
		free(globstr);
		hotplug_free(pc);
		return UBUS_STATUS_OK;
	}

	free(globstr);

	/* asynchronous call to hotplug_exec() */
	uloop_timeout_set(&pc->timeout, 50);

	return UBUS_STATUS_OK;

err_envle:
	avl_for_each_element_safe(&env, envle, avl, p) {
		if (envle->env)
			free(envle->env);

		avl_delete(&env, &envle->avl);
		free(envle);
	}

	return err;
}

static const struct ubus_method hotplug_methods[] = {
	UBUS_METHOD("call", hotplug_call, hotplug_policy),
};

static struct ubus_object_type hotplug_object_type =
	UBUS_OBJECT_TYPE("hotplug", hotplug_methods);

static void add_subsystem(const char *name)
{
	struct hotplug_subsys *nh;
	char *name_buf;

	nh = avl_find_element(&subsystems, name, nh, node);
	if (nh)
		return;

	nh = calloc_a(sizeof(struct hotplug_subsys),
		&name_buf, sizeof(HOTPLUG_OBJECT_PREFIX) + 1 + strlen(name));
	if (!nh)
		return;

	nh->ubus.name = name_buf;
	name_buf += sprintf(name_buf, "%s", HOTPLUG_OBJECT_PREFIX);
	nh->node.key = strcpy(name_buf, name);

	nh->ubus.type = &hotplug_object_type;
	nh->ubus.methods = hotplug_object_type.methods;
	nh->ubus.n_methods = hotplug_object_type.n_methods;
	ubus_add_object(ctx, &nh->ubus);
	avl_insert(&subsystems, &nh->node);
}

static void free_subsystem(struct hotplug_subsys *h)
{
	ubus_remove_object(ctx, &h->ubus);
	free(h);
}

static void remove_all_subsystems(void)
{
	struct hotplug_subsys *n, *h;

	/* find match subsystem object by name or any if not given */
	avl_remove_all_elements(&subsystems, h, node, n)
		free_subsystem(h);
}

static void remove_subsystem(char *name)
{
	struct hotplug_subsys *h;

	if (!strcmp(name, "button"))
		return;

	h = avl_find_element(&subsystems, name, h, node);
	if (!h)
		return;

	avl_delete(&subsystems, &h->node);
	free_subsystem(h);
}

static int init_subsystems(void)
{
	DIR *dir;
	struct dirent *dirent;
	struct stat st;

	add_subsystem("button");

	dir = opendir(HOTPLUG_BASEDIR);
	if (dir == NULL)
		return ENOENT;

	while ((dirent = readdir(dir))) {
		/* skip everything but directories */
		if (dirent->d_type == DT_UNKNOWN) {
			if ((fstatat(dirfd(dir), dirent->d_name, &st, AT_SYMLINK_NOFOLLOW) == -1)
			    || !S_ISDIR(st.st_mode))
				continue;
		} else if (dirent->d_type != DT_DIR)
			continue;

		/* skip '.' and '..' as well as hidden files */
		if (dirent->d_name[0] == '.')
			continue;

		add_subsystem(dirent->d_name);
	}
	closedir(dir);

	return 0;
}

static void basedir_event(struct inotify_watch *w, struct inotify_event *in)
{
	/* skip everything but directories */
	if (!(in->mask & IN_ISDIR))
		return;

	if (in->len < 1)
		return;

	/* skip hidden files */
	if (in->name[0] == '.')
		return;

	/* add/remove subsystem objects */
	if (in->mask & (IN_CREATE | IN_MOVED_TO))
		add_subsystem(in->name);
	else if (in->mask & (IN_DELETE | IN_MOVED_FROM))
		remove_subsystem(in->name);
}

void hotplug_ubus_event(struct blob_attr *data)
{
	static const struct blobmsg_policy policy =
		{ "SUBSYSTEM", BLOBMSG_TYPE_STRING };
	struct hotplug_subsys *h;
	struct blob_attr *attr;
	const char *subsys;

	blobmsg_parse_attr(&policy, 1, &attr, data);
	if (!attr)
		return;

	subsys = blobmsg_get_string(attr);
	h = avl_find_element(&subsystems, subsys, h, node);
	if (!h)
		return;

	ubus_notify(ctx, &h->ubus, "event", data, -1);
}

void ubus_init_hotplug(struct ubus_context *newctx)
{
	ctx = newctx;
	remove_all_subsystems();
	if (init_subsystems()) {
		printf("failed to initialize hotplug subsystems from %s\n", HOTPLUG_BASEDIR);
		return;
	}
	if (inotify_watch_open(&basedir_watch, basedir_event) ||
	    inotify_watch_add(&basedir_watch, HOTPLUG_BASEDIR,
			      IN_CREATE | IN_MOVED_TO | IN_DELETE |
			      IN_MOVED_FROM | IN_ONLYDIR) == -1)
		printf("failed to initialize inotify handler for %s\n", HOTPLUG_BASEDIR);
}