hotplug: fix uninitialized variable
[project/procd.git] / plug / hotplug.c
1 /*
2  * Copyright (C) 2013 Felix Fietkau <nbd@openwrt.org>
3  * Copyright (C) 2013 John Crispin <blogic@openwrt.org>
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU Lesser General Public License version 2.1
7  * as published by the Free Software Foundation
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  */
14
15 #include <sys/stat.h>
16 #include <sys/socket.h>
17 #include <sys/types.h>
18
19 #include <linux/types.h>
20 #include <linux/netlink.h>
21
22 #include <libubox/blobmsg_json.h>
23 #include <libubox/json_script.h>
24 #include <libubox/uloop.h>
25 #include <json-c/json.h>
26
27 #include <fcntl.h>
28 #include <unistd.h>
29 #include <stdlib.h>
30 #include <libgen.h>
31 #include <grp.h>
32
33 #include "../procd.h"
34
35 #include "hotplug.h"
36
37 #define HOTPLUG_WAIT    500
38
39 struct cmd_handler;
40 struct cmd_queue {
41         struct list_head list;
42
43         struct blob_attr *msg;
44         struct blob_attr *data;
45         int timeout;
46
47         void (*handler)(struct blob_attr *msg, struct blob_attr *data);
48         void (*start)(struct blob_attr *msg, struct blob_attr *data);
49         void (*complete)(struct blob_attr *msg, struct blob_attr *data, int ret);
50 };
51
52 struct button_timeout {
53         struct list_head list;
54         struct uloop_timeout timeout;
55         char *name;
56         int seen;
57         struct blob_attr *data;
58 };
59
60 static LIST_HEAD(cmd_queue);
61 static LIST_HEAD(button_timer);
62 static struct uloop_process queue_proc;
63 static struct uloop_timeout last_event;
64 static struct blob_buf b, button_buf;
65 static char *rule_file;
66 static struct blob_buf script;
67 static struct cmd_queue *current;
68
69 static void queue_add(struct cmd_handler *h, struct blob_attr *msg, struct blob_attr *data);
70 static void handle_button_complete(struct blob_attr *msg, struct blob_attr *data, int ret);
71
72 static void button_free(struct button_timeout *b)
73 {
74         uloop_timeout_cancel(&b->timeout);
75         list_del(&b->list);
76         free(b->data);
77         free(b->name);
78         free(b);
79 }
80
81 static void button_timeout_remove(char *button)
82 {
83         struct button_timeout *b, *c;
84
85         if (!list_empty(&button_timer)) list_for_each_entry_safe(b, c, &button_timer, list) {
86                 if (!strcmp(b->name, button))
87                         button_free(b);
88         }
89 }
90
91 static char *hotplug_msg_find_var(struct blob_attr *msg, const char *name)
92 {
93         struct blob_attr *cur;
94         int rem;
95
96         blobmsg_for_each_attr(cur, msg, rem) {
97                 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
98                         continue;
99
100                 if (strcmp(blobmsg_name(cur), name) != 0)
101                         continue;
102
103                 return blobmsg_data(cur);
104         }
105
106         return NULL;
107 }
108
109 static void mkdir_p(char *dir)
110 {
111         char *l = strrchr(dir, '/');
112
113         if (l) {
114                 *l = '\0';
115                 mkdir_p(dir);
116                 *l = '/';
117                 mkdir(dir, 0755);
118         }
119 }
120
121 static void handle_makedev(struct blob_attr *msg, struct blob_attr *data)
122 {
123         unsigned int oldumask = umask(0);
124         static struct blobmsg_policy mkdev_policy[3] = {
125                 { .type = BLOBMSG_TYPE_STRING },
126                 { .type = BLOBMSG_TYPE_STRING },
127                 { .type = BLOBMSG_TYPE_STRING },
128         };
129         struct blob_attr *tb[3];
130         char *minor = hotplug_msg_find_var(msg, "MINOR");
131         char *major = hotplug_msg_find_var(msg, "MAJOR");
132         char *subsystem = hotplug_msg_find_var(msg, "SUBSYSTEM");
133         int ret = 0;
134
135         blobmsg_parse_array(mkdev_policy, 3, tb, blobmsg_data(data), blobmsg_data_len(data));
136         if (tb[0] && tb[1] && minor && major && subsystem) {
137                 mode_t m = S_IFCHR;
138                 char *d = strdup(blobmsg_get_string(tb[0]));
139
140                 d = dirname(d);
141                 mkdir_p(d);
142                 free(d);
143
144                 if (!strcmp(subsystem, "block"))
145                         m = S_IFBLK;
146                 mknod(blobmsg_get_string(tb[0]),
147                                 m | strtoul(blobmsg_data(tb[1]), NULL, 8),
148                                 makedev(atoi(major), atoi(minor)));
149                 if (tb[2]) {
150                         struct group *g = getgrnam(blobmsg_get_string(tb[2]));
151
152                         if (g)
153                                 ret = chown(blobmsg_get_string(tb[0]), 0, g->gr_gid);
154
155                         if (!g || ret < 0)
156                                 ERROR("cannot set group %s for %s\n",
157                                         blobmsg_get_string(tb[2]),
158                                         blobmsg_get_string(tb[0]));
159                 }
160         }
161         umask(oldumask);
162 }
163
164 static void handle_rm(struct blob_attr *msg, struct blob_attr *data)
165 {
166         static struct blobmsg_policy rm_policy = {
167                 .type = BLOBMSG_TYPE_STRING,
168         };
169         struct blob_attr *tb;
170
171         blobmsg_parse_array(&rm_policy, 1, &tb, blobmsg_data(data), blobmsg_data_len(data));
172         if (tb)
173                 unlink(blobmsg_data(tb));
174 }
175
176 static void handle_exec(struct blob_attr *msg, struct blob_attr *data)
177 {
178         char *argv[8];
179         struct blob_attr *cur;
180         int rem, fd;
181         int i = 0;
182
183         blobmsg_for_each_attr(cur, msg, rem)
184                 setenv(blobmsg_name(cur), blobmsg_data(cur), 1);
185
186         blobmsg_for_each_attr(cur, data, rem) {
187                 argv[i] = blobmsg_data(cur);
188                 i++;
189                 if (i == 7)
190                         break;
191         }
192
193         if (debug < 3) {
194                 fd = open("/dev/null", O_RDWR);
195                 if (fd > -1) {
196                         dup2(fd, STDIN_FILENO);
197                         dup2(fd, STDOUT_FILENO);
198                         dup2(fd, STDERR_FILENO);
199                         if (fd > STDERR_FILENO)
200                                 close(fd);
201                 }
202         }
203
204         if (i > 0) {
205                 argv[i] = NULL;
206                 execvp(argv[0], &argv[0]);
207         }
208         exit(-1);
209 }
210
211 static void handle_button_start(struct blob_attr *msg, struct blob_attr *data)
212 {
213         char *button = hotplug_msg_find_var(msg, "BUTTON");
214
215         if (button)
216                 button_timeout_remove(button);
217 }
218
219 static void handle_firmware(struct blob_attr *msg, struct blob_attr *data)
220 {
221         char *dir = blobmsg_get_string(blobmsg_data(data));
222         char *file = hotplug_msg_find_var(msg, "FIRMWARE");
223         char *dev = hotplug_msg_find_var(msg, "DEVPATH");
224         struct stat s = { 0 };
225         char *path, loadpath[256], syspath[256];
226         int fw, src, load, len;
227         static char buf[4096];
228
229         DEBUG(2, "Firmware request for %s/%s\n", dir, file);
230
231         if (!file || !dir || !dev) {
232                 ERROR("Request for unknown firmware %s/%s\n", dir, file);
233                 exit(-1);
234         }
235
236         path = alloca(strlen(dir) + strlen(file) + 2);
237         sprintf(path, "%s/%s", dir, file);
238
239         if (stat(path, &s)) {
240                 ERROR("Could not find firmware %s\n", path);
241                 src = -1;
242                 s.st_size = 0;
243                 goto send_to_kernel;
244         }
245
246         src = open(path, O_RDONLY);
247         if (src < 0) {
248                 ERROR("Failed to open %s\n", path);
249                 s.st_size = 0;
250                 goto send_to_kernel;
251         }
252
253 send_to_kernel:
254         snprintf(loadpath, sizeof(loadpath), "/sys/%s/loading", dev);
255         load = open(loadpath, O_WRONLY);
256         if (!load) {
257                 ERROR("Failed to open %s\n", loadpath);
258                 exit(-1);
259         }
260         if (write(load, "1", 1) == -1) {
261                 ERROR("Failed to write to %s\n", loadpath);
262                 exit(-1);
263         }
264         close(load);
265
266         snprintf(syspath, sizeof(syspath), "/sys/%s/data", dev);
267         fw = open(syspath, O_WRONLY);
268         if (fw < 0) {
269                 ERROR("Failed to open %s\n", syspath);
270                 exit(-1);
271         }
272
273         len = s.st_size;
274         while (len) {
275                 len = read(src, buf, sizeof(buf));
276                 if (len <= 0)
277                         break;
278
279                 if (write(fw, buf, len) == -1) {
280                         ERROR("failed to write firmware file %s/%s to %s\n", dir, file, dev);
281                         break;
282                 }
283         }
284
285         if (src >= 0)
286                 close(src);
287         close(fw);
288
289         load = open(loadpath, O_WRONLY);
290         if (write(load, "0", 1) == -1)
291                 ERROR("failed to write to %s\n", loadpath);
292         close(load);
293
294         DEBUG(2, "Done loading %s\n", path);
295
296         exit(-1);
297 }
298
299 enum {
300         HANDLER_MKDEV = 0,
301         HANDLER_RM,
302         HANDLER_EXEC,
303         HANDLER_BUTTON,
304         HANDLER_FW,
305 };
306
307 static struct cmd_handler {
308         char *name;
309         int atomic;
310         void (*handler)(struct blob_attr *msg, struct blob_attr *data);
311         void (*start)(struct blob_attr *msg, struct blob_attr *data);
312         void (*complete)(struct blob_attr *msg, struct blob_attr *data, int ret);
313 } handlers[] = {
314         [HANDLER_MKDEV] = {
315                 .name = "makedev",
316                 .atomic = 1,
317                 .handler = handle_makedev,
318         },
319         [HANDLER_RM] = {
320                 .name = "rm",
321                 .atomic = 1,
322                 .handler = handle_rm,
323         },
324         [HANDLER_EXEC] = {
325                 .name = "exec",
326                 .handler = handle_exec,
327         },
328         [HANDLER_BUTTON] = {
329                 .name = "button",
330                 .handler = handle_exec,
331                 .start = handle_button_start,
332                 .complete = handle_button_complete,
333         },
334         [HANDLER_FW] = {
335                 .name = "load-firmware",
336                 .handler = handle_firmware,
337         },
338 };
339
340 static void queue_next(void)
341 {
342         struct cmd_queue *c;
343
344         if (queue_proc.pending || list_empty(&cmd_queue))
345                 return;
346
347         c = list_first_entry(&cmd_queue, struct cmd_queue, list);
348
349         queue_proc.pid = fork();
350         if (!queue_proc.pid) {
351                 uloop_done();
352                 c->handler(c->msg, c->data);
353                 exit(0);
354         }
355         if (c->start)
356                 c->start(c->msg, c->data);
357         list_del(&c->list);
358         if (c->complete)
359                 current = c;
360         else
361                 free(c);
362         if (queue_proc.pid <= 0) {
363                 queue_next();
364                 return;
365         }
366
367         uloop_process_add(&queue_proc);
368
369         DEBUG(4, "Launched hotplug exec instance, pid=%d\n", (int) queue_proc.pid);
370 }
371
372 static void queue_proc_cb(struct uloop_process *c, int ret)
373 {
374         DEBUG(4, "Finished hotplug exec instance, pid=%d\n", (int) c->pid);
375
376         if (current) {
377                 current->complete(current->msg, current->data, ret);
378                 free(current);
379                 current = NULL;
380         }
381         queue_next();
382 }
383
384 static void queue_add(struct cmd_handler *h, struct blob_attr *msg, struct blob_attr *data)
385 {
386         struct cmd_queue *c = NULL;
387         struct blob_attr *_msg, *_data;
388
389         c = calloc_a(sizeof(struct cmd_queue),
390                 &_msg, blob_pad_len(msg),
391                 &_data, blob_pad_len(data),
392                 NULL);
393
394         c->msg = _msg;
395         c->data = _data;
396
397         if (!c)
398                 return;
399
400         memcpy(c->msg, msg, blob_pad_len(msg));
401         memcpy(c->data, data, blob_pad_len(data));
402         c->handler = h->handler;
403         c->complete = h->complete;
404         c->start = h->start;
405         list_add_tail(&c->list, &cmd_queue);
406         queue_next();
407 }
408
409 static void handle_button_timeout(struct uloop_timeout *t)
410 {
411         struct button_timeout *b;
412         char seen[16];
413
414         b = container_of(t, struct button_timeout, timeout);
415         blob_buf_init(&button_buf, 0);
416         blobmsg_add_string(&button_buf, "BUTTON", b->name);
417         blobmsg_add_string(&button_buf, "ACTION", "timeout");
418         snprintf(seen, sizeof(seen), "%d", b->seen);
419         blobmsg_add_string(&button_buf, "SEEN", seen);
420         queue_add(&handlers[HANDLER_EXEC], button_buf.head, b->data);
421         button_free(b);
422 }
423
424 static void handle_button_complete(struct blob_attr *msg, struct blob_attr *data, int ret)
425 {
426         char *name = hotplug_msg_find_var(msg, "BUTTON");
427         struct button_timeout *b;
428         int timeout = ret >> 8;
429
430         if (!timeout)
431                 return;
432
433         b = malloc(sizeof(*b));
434         if (!b || !name)
435                 return;
436
437         memset(b, 0, sizeof(*b));
438
439         b->data = malloc(blob_pad_len(data));
440         b->name = strdup(name);
441         b->seen = timeout;
442
443         memcpy(b->data, data, blob_pad_len(data));
444         b->timeout.cb = handle_button_timeout;
445
446         uloop_timeout_set(&b->timeout, timeout * 1000);
447         list_add(&b->list, &button_timer);
448 }
449
450 static const char* rule_handle_var(struct json_script_ctx *ctx, const char *name, struct blob_attr *vars)
451 {
452         const char *str, *sep;
453
454         if (!strcmp(name, "DEVICENAME") || !strcmp(name, "DEVNAME")) {
455                 str = json_script_find_var(ctx, vars, "DEVPATH");
456                 if (!str)
457                         return NULL;
458
459                 sep = strrchr(str, '/');
460                 if (sep)
461                         return sep + 1;
462
463                 return str;
464         }
465
466         return NULL;
467 }
468
469 static struct json_script_file *
470 rule_handle_file(struct json_script_ctx *ctx, const char *name)
471 {
472         json_object *obj;
473
474         obj = json_object_from_file((char*)name);
475         if (!obj)
476                 return NULL;
477
478         blob_buf_init(&script, 0);
479         blobmsg_add_json_element(&script, "", obj);
480
481         return json_script_file_from_blobmsg(name, blob_data(script.head), blob_len(script.head));
482 }
483
484 static void rule_handle_command(struct json_script_ctx *ctx, const char *name,
485                                 struct blob_attr *data, struct blob_attr *vars)
486 {
487         struct blob_attr *cur;
488         int rem, i;
489
490         if (debug > 3) {
491                 DEBUG(4, "Command: %s", name);
492                 blobmsg_for_each_attr(cur, data, rem)
493                         DEBUG(4, " %s", (char *) blobmsg_data(cur));
494                 DEBUG(4, "\n");
495
496                 DEBUG(4, "Message:");
497                 blobmsg_for_each_attr(cur, vars, rem)
498                         DEBUG(4, " %s=%s", blobmsg_name(cur), (char *) blobmsg_data(cur));
499                 DEBUG(4, "\n");
500         }
501
502         for (i = 0; i < ARRAY_SIZE(handlers); i++)
503                 if (!strcmp(handlers[i].name, name)) {
504                         if (handlers[i].atomic)
505                                 handlers[i].handler(vars, data);
506                         else
507                                 queue_add(&handlers[i], vars, data);
508                         break;
509                 }
510
511         if (last_event.cb)
512                 uloop_timeout_set(&last_event, HOTPLUG_WAIT);
513 }
514
515 static void rule_handle_error(struct json_script_ctx *ctx, const char *msg,
516                                 struct blob_attr *context)
517 {
518         char *s;
519
520         s = blobmsg_format_json(context, false);
521         ERROR("ERROR: %s in block: %s\n", msg, s);
522         free(s);
523 }
524
525 static struct json_script_ctx jctx = {
526         .handle_var = rule_handle_var,
527         .handle_error = rule_handle_error,
528         .handle_command = rule_handle_command,
529         .handle_file = rule_handle_file,
530 };
531
532 static void hotplug_handler_debug(struct blob_attr *data)
533 {
534         char *str;
535
536         if (debug < 3)
537                 return;
538
539         str = blobmsg_format_json(data, true);
540         DEBUG(3, "%s\n", str);
541         free(str);
542 }
543
544 static void hotplug_handler(struct uloop_fd *u, unsigned int ev)
545 {
546         int i = 0;
547         static char buf[4096];
548         int len = recv(u->fd, buf, sizeof(buf), MSG_DONTWAIT);
549         void *index;
550         if (len < 1)
551                 return;
552
553         blob_buf_init(&b, 0);
554         index = blobmsg_open_table(&b, NULL);
555         while (i < len) {
556                 int l = strlen(buf + i) + 1;
557                 char *e = strstr(&buf[i], "=");
558
559                 if (e) {
560                         *e = '\0';
561                         blobmsg_add_string(&b, &buf[i], &e[1]);
562                 }
563                 i += l;
564         }
565         blobmsg_close_table(&b, index);
566         hotplug_handler_debug(b.head);
567         json_script_run(&jctx, rule_file, blob_data(b.head));
568 }
569
570 static struct uloop_fd hotplug_fd = {
571         .cb = hotplug_handler,
572 };
573
574 void hotplug_last_event(uloop_timeout_handler handler)
575 {
576         last_event.cb = handler;
577         if (handler)
578                 uloop_timeout_set(&last_event, HOTPLUG_WAIT);
579         else
580                 uloop_timeout_cancel(&last_event);
581 }
582
583 void hotplug(char *rules)
584 {
585         struct sockaddr_nl nls;
586         int nlbufsize = 512 * 1024;
587
588         rule_file = strdup(rules);
589         memset(&nls,0,sizeof(struct sockaddr_nl));
590         nls.nl_family = AF_NETLINK;
591         nls.nl_pid = getpid();
592         nls.nl_groups = -1;
593
594         if ((hotplug_fd.fd = socket(PF_NETLINK, SOCK_DGRAM | SOCK_CLOEXEC, NETLINK_KOBJECT_UEVENT)) == -1) {
595                 ERROR("Failed to open hotplug socket: %s\n", strerror(errno));
596                 exit(1);
597         }
598         if (bind(hotplug_fd.fd, (void *)&nls, sizeof(struct sockaddr_nl))) {
599                 ERROR("Failed to bind hotplug socket: %s\n", strerror(errno));
600                 exit(1);
601         }
602
603         if (setsockopt(hotplug_fd.fd, SOL_SOCKET, SO_RCVBUFFORCE, &nlbufsize, sizeof(nlbufsize)))
604                 ERROR("Failed to resize receive buffer: %s\n", strerror(errno));
605
606         json_script_init(&jctx);
607         queue_proc.cb = queue_proc_cb;
608         uloop_fd_add(&hotplug_fd, ULOOP_READ);
609 }
610
611 int hotplug_run(char *rules)
612 {
613         uloop_init();
614         hotplug(rules);
615         uloop_run();
616
617         return 0;
618 }
619
620 void hotplug_shutdown(void)
621 {
622         uloop_fd_delete(&hotplug_fd);
623         close(hotplug_fd.fd);
624 }