hotplug-dispatch.c

   1 /*
   2  * Copyright (C) 2021 Daniel Golle <daniel@makrotopia.org>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU Lesser General Public License version 2.1
   6  * as published by the Free Software Foundation
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #define _GNU_SOURCE
  15
  16 #include <sys/inotify.h>
  17 #include <sys/types.h>
  18
  19 #include <assert.h>
  20 #include <dirent.h>
  21 #include <errno.h>
  22 #include <glob.h>
  23 #include <limits.h>
  24 #include <stdbool.h>
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29
  30 #include <libubox/avl.h>
  31 #include <libubox/avl-cmp.h>
  32 #include <libubox/list.h>
  33 #include <libubox/uloop.h>
  34 #include <libubus.h>
  35
  36 #include "procd.h"
  37
  38 #define HOTPLUG_BASEDIR "/etc/hotplug.d"
  39 #define HOTPLUG_OBJECT_PREFIX "hotplug."
  40
  41 #define INOTIFY_SZ (sizeof(struct inotify_event) + PATH_MAX + 1)
  42
  43 struct ubus_context *ctx;
  44 static char *inotify_buffer;
  45 static struct uloop_fd fd_inotify_read;
  46
  47 static LIST_HEAD(subsystems);
  48
  49 extern char **environ;
  50
  51 struct hotplug_subsys {
  52         struct list_head list;
  53         struct ubus_object ubus;
  54 };
  55
  56 struct envlist {
  57         struct avl_node avl;
  58         char *env;
  59 };
  60
  61 struct hotplug_process {
  62         struct ubus_object *ubus;
  63         char **envp;
  64         struct uloop_timeout timeout;
  65         struct uloop_process process;
  66         glob_t globbuf;
  67         unsigned int cnt;
  68         int ret;
  69 };
  70
  71 static void env_free(char **envp)
  72 {
  73         char **tmp;
  74
  75         tmp = envp;
  76         while (*tmp)
  77                 free(*(tmp++));
  78         free(envp);
  79 }
  80
  81 static void hotplug_free(struct hotplug_process *pc)
  82 {
  83         env_free(pc->envp);
  84         globfree(&pc->globbuf);
  85         free(pc);
  86 }
  87
  88 static void hotplug_done(struct uloop_process *c, int ret)
  89 {
  90         struct hotplug_process *pc = container_of(c, struct hotplug_process, process);
  91
  92         pc->ret = ret;
  93
  94         uloop_timeout_set(&pc->timeout, 50);
  95 }
  96
  97 static void hotplug_exec(struct uloop_timeout *t)
  98 {
  99         struct hotplug_process *pc = container_of(t, struct hotplug_process, timeout);
 100         char *script;
 101         char *exec_argv[4];
 102         /* we have reached the last entry in the globbuf */
 103         if (pc->cnt == pc->globbuf.gl_pathc) {
 104                 hotplug_free(pc);
 105                 return;
 106         }
 107
 108         asprintf(&script, ". /lib/functions.sh\n. %s\n", pc->globbuf.gl_pathv[pc->cnt++]);
 109         /* prepare for execve() */
 110         exec_argv[0] = "/bin/sh";
 111         exec_argv[1] = "-c";
 112         exec_argv[2] = script;
 113         exec_argv[3] = NULL;
 114
 115         /* set callback in uloop_process */
 116         pc->process.cb = hotplug_done;
 117         pc->process.pid = fork();
 118         if (pc->process.pid == 0) {
 119                 /* child */
 120                 exit(execve(exec_argv[0], exec_argv, pc->envp));
 121         } else if (pc->process.pid < 0) {
 122                 /* fork error */
 123                 hotplug_free(pc);
 124                 return;
 125         }
 126         /* parent */
 127         free(script);
 128         uloop_process_add(&pc->process);
 129 }
 130
 131 static int avl_envcmp(const void *k1, const void *k2, void *ptr)
 132 {
 133         const char *tmp;
 134
 135         tmp = strchr(k1, '=');
 136         if (!tmp)
 137                 return -1;
 138
 139         /*
 140          * compare the variable name only, ie. limit strncmp to check
 141          * only up to and including the '=' sign
 142          */
 143         return strncmp(k1, k2, (tmp - (char *)k1) + 1);
 144 }
 145
 146 /* validate NULL-terminated environment variable name */
 147 static int validate_envvarname(const char *envvarname)
 148 {
 149         const char *tmp = envvarname;
 150
 151         /* check for illegal characters in env variable name */
 152         while (tmp[0] != '\0') {
 153                 if (!((tmp[0] >= 'a' && tmp[0] <= 'z') ||
 154                       (tmp[0] >= 'A' && tmp[0] <= 'Z') ||
 155                       (tmp[0] == '_') ||
 156                       /* allow numbers unless they are at the first character */
 157                       ((tmp != envvarname) && tmp[0] >= '0' && tmp[0] <= '9')))
 158                         return EINVAL;
 159                 ++tmp;
 160         }
 161
 162         return 0;
 163 }
 164
 165 enum {
 166         HOTPLUG_ENV,
 167         __HOTPLUG_MAX
 168 };
 169
 170 static const struct blobmsg_policy hotplug_policy[__HOTPLUG_MAX] = {
 171         [HOTPLUG_ENV] = { .name = "env", .type = BLOBMSG_TYPE_ARRAY },
 172 };
 173
 174 static int hotplug_call(struct ubus_context *ctx, struct ubus_object *obj,
 175                         struct ubus_request_data *req, const char *method,
 176                         struct blob_attr *msg)
 177 {
 178         const char *subsys = &obj->name[strlen(HOTPLUG_OBJECT_PREFIX)];
 179         struct blob_attr *tb[__HOTPLUG_MAX], *cur;
 180         AVL_TREE(env, avl_envcmp, false, NULL);
 181         struct envlist *envle, *p;
 182         int rem;
 183         char **envp, *globstr, *tmp, **tmpenv;
 184         size_t envz = 0;
 185         struct hotplug_process *pc;
 186         bool async = true;
 187
 188         blobmsg_parse(hotplug_policy, __HOTPLUG_MAX, tb, blobmsg_data(msg), blobmsg_len(msg));
 189
 190         if (!tb[HOTPLUG_ENV])
 191                 return UBUS_STATUS_INVALID_ARGUMENT;
 192
 193         tmpenv = environ;
 194
 195         /* first adding existing environment to avl_tree */
 196         while (*tmpenv) {
 197                 envle = calloc(1, sizeof(struct envlist));
 198                 assert(envle != NULL);
 199                 envle->env = strdup(*tmpenv);
 200                 envle->avl.key = envle->env;
 201                 avl_insert(&env, &envle->avl);
 202                 ++tmpenv;
 203         }
 204
 205         /* then adding additional variables from ubus call */
 206         blobmsg_for_each_attr(cur, tb[HOTPLUG_ENV], rem) {
 207                 char *enve = blobmsg_get_string(cur);
 208                 if (!enve)
 209                         continue;
 210
 211                 if (!strncmp(enve, "LD_", 3))
 212                         continue;
 213
 214                 if (!strcmp(enve, "PATH"))
 215                         continue;
 216
 217                 if (strlen(enve) < 3)
 218                         continue;
 219
 220                 if (!(tmp = strchr(enve, '=')))
 221                         continue;
 222
 223                 *tmp = '\0';
 224                 if (validate_envvarname(enve))
 225                         continue;
 226                 *tmp = '=';
 227
 228                 if (!strlen(++tmp))
 229                         continue;
 230
 231                 if (!strcmp(enve, "ASYNC=0"))
 232                         async = false;
 233
 234                 envle = calloc(1, sizeof(struct envlist));
 235                 assert(envle != NULL);
 236                 envle->env = strdup(enve);
 237                 envle->avl.key = envle->env;
 238                 if (avl_insert(&env, &envle->avl)) {
 239                         free((void*)envle->env);
 240                         free(envle);
 241                 }
 242                 ++tmpenv;
 243         }
 244
 245         /* allocating new environment */
 246         avl_for_each_element(&env, envle, avl)
 247                 ++envz;
 248
 249         envp = calloc(envz + 1, sizeof(char *));
 250         assert(envp != NULL);
 251
 252         /* populating new environment */
 253         envz = 0;
 254         avl_for_each_element_safe(&env, envle, avl, p) {
 255                 envp[envz++] = envle->env;
 256                 avl_delete(&env, &envle->avl);
 257                 free(envle);
 258         }
 259
 260         /* glob'ing for hotplug scripts */
 261         if (asprintf(&globstr, "%s/%s/*", HOTPLUG_BASEDIR, subsys) == -1) {
 262                 env_free(envp);
 263                 return UBUS_STATUS_UNKNOWN_ERROR;
 264         }
 265
 266         /* synchronous calls are unsupported for now */
 267         if (!async) {
 268                 env_free(envp);
 269                 return UBUS_STATUS_NOT_SUPPORTED;
 270         }
 271
 272         pc = calloc(1, sizeof(struct hotplug_process));
 273         assert(pc != NULL);
 274         pc->timeout.cb = hotplug_exec;
 275         pc->envp = envp;
 276         pc->cnt = 0;
 277         pc->ubus = obj;
 278
 279         if (glob(globstr, GLOB_DOOFFS, NULL, &pc->globbuf)) {
 280                 free(globstr);
 281                 hotplug_free(pc);
 282                 return UBUS_STATUS_OK;
 283         }
 284
 285         free(globstr);
 286
 287         /* asynchronous call to hotplug_exec() */
 288         uloop_timeout_set(&pc->timeout, 50);
 289
 290         return UBUS_STATUS_OK;
 291 }
 292
 293 static const struct ubus_method hotplug_methods[] = {
 294         UBUS_METHOD("call", hotplug_call, hotplug_policy),
 295 };
 296
 297 static struct ubus_object_type hotplug_object_type =
 298         UBUS_OBJECT_TYPE("hotplug", hotplug_methods);
 299
 300 static void add_subsystem(int nlen, char *newname)
 301 {
 302         struct hotplug_subsys *nh = calloc(1, sizeof(struct hotplug_subsys));
 303         char *name;
 304
 305         asprintf(&name, "%s%.*s", HOTPLUG_OBJECT_PREFIX, nlen, newname);
 306
 307         /* prepare and add ubus object */
 308         nh->ubus.name = name;
 309         nh->ubus.type = &hotplug_object_type;
 310         nh->ubus.methods = hotplug_object_type.methods;
 311         nh->ubus.n_methods = hotplug_object_type.n_methods;
 312         list_add(&nh->list, &subsystems);
 313         ubus_add_object(ctx, &nh->ubus);
 314 }
 315
 316 static void remove_subsystem(int nlen, char *name)
 317 {
 318         struct hotplug_subsys *n, *h;
 319
 320         /* find match subsystem object by name or any if not given */
 321         list_for_each_entry_safe(h, n, &subsystems, list) {
 322                 if (nlen && (strlen(h->ubus.name) != strnlen(name, nlen) + strlen(HOTPLUG_OBJECT_PREFIX)))
 323                         continue;
 324                 if (nlen && (strncmp(name, &h->ubus.name[strlen(HOTPLUG_OBJECT_PREFIX)], nlen)))
 325                         continue;
 326
 327                 list_del(&h->list);
 328                 ubus_remove_object(ctx, &h->ubus);
 329                 free((void*)h->ubus.name);
 330                 free(h);
 331         }
 332 }
 333
 334 static int init_subsystems(void)
 335 {
 336         DIR *dir;
 337         struct dirent *dirent;
 338
 339         dir = opendir(HOTPLUG_BASEDIR);
 340         if (dir == NULL)
 341                 return ENOENT;
 342
 343         while ((dirent = readdir(dir))) {
 344                 /* skip everything but directories */
 345                 if (dirent->d_type != DT_DIR)
 346                         continue;
 347
 348                 /* skip '.' and '..' as well as hidden files */
 349                 if (dirent->d_name[0] == '.')
 350                         continue;
 351
 352                 add_subsystem(strlen(dirent->d_name), dirent->d_name);
 353         }
 354         closedir(dir);
 355
 356         return 0;
 357 }
 358
 359 static void inotify_read_handler(struct uloop_fd *u, unsigned int events)
 360 {
 361         int rc;
 362         char *p;
 363         struct inotify_event *in;
 364
 365         /* read inotify events */
 366         while ((rc = read(u->fd, inotify_buffer, INOTIFY_SZ)) == -1 && errno == EINTR);
 367
 368         if (rc <= 0)
 369                 return;
 370
 371         /* process events from buffer */
 372         for (p = inotify_buffer;
 373              rc - (p - inotify_buffer) >= (int)sizeof(struct inotify_event);
 374              p += sizeof(struct inotify_event) + in->len) {
 375                 in = (struct inotify_event*)p;
 376
 377                 /* skip everything but directories */
 378                 if (!(in->mask & IN_ISDIR))
 379                         continue;
 380
 381                 if (in->len < 1)
 382                         continue;
 383
 384                 /* skip hidden files */
 385                 if (in->name[0] == '.')
 386                         continue;
 387
 388                 /* add/remove subsystem objects */
 389                 if (in->mask & (IN_CREATE | IN_MOVED_TO))
 390                         add_subsystem(in->len, in->name);
 391                 else if (in->mask & (IN_DELETE | IN_MOVED_FROM))
 392                         remove_subsystem(in->len, in->name);
 393         }
 394 }
 395
 396 void ubus_init_hotplug(struct ubus_context *newctx)
 397 {
 398         ctx = newctx;
 399         remove_subsystem(0, NULL);
 400         if (init_subsystems()) {
 401                 printf("failed to initialize hotplug subsystems from %s\n", HOTPLUG_BASEDIR);
 402                 return;
 403         }
 404         fd_inotify_read.fd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
 405         fd_inotify_read.cb = inotify_read_handler;
 406         assert(fd_inotify_read.fd != -1);
 407
 408         inotify_buffer = calloc(1, INOTIFY_SZ);
 409         assert(inotify_buffer != NULL);
 410         inotify_add_watch(fd_inotify_read.fd, HOTPLUG_BASEDIR, IN_CREATE | IN_MOVED_TO | IN_DELETE | IN_MOVED_FROM | IN_ONLYDIR);
 411         uloop_fd_add(&fd_inotify_read, ULOOP_READ);
 412 }