ubus: split address from mask in interface status
[project/netifd.git] / proto-shell.c
1 #define _GNU_SOURCE
2
3 #include <string.h>
4 #include <stdlib.h>
5 #include <stdio.h>
6 #include <glob.h>
7 #include <unistd.h>
8 #include <fcntl.h>
9 #include <signal.h>
10
11 #include <arpa/inet.h>
12 #include <netinet/in.h>
13
14 #include <libubox/blobmsg_json.h>
15
16 #include "netifd.h"
17 #include "interface.h"
18 #include "interface-ip.h"
19 #include "proto.h"
20
21 static struct netifd_fd proto_fd;
22
23 enum proto_shell_sm {
24         S_IDLE,
25         S_SETUP,
26         S_SETUP_ABORT,
27         S_TEARDOWN,
28 };
29
30 struct proto_shell_handler {
31         struct list_head list;
32         struct proto_handler proto;
33         struct config_param_list config;
34         char *config_buf;
35         bool init_available;
36         char script_name[];
37 };
38
39 struct proto_shell_state {
40         struct interface_proto_state proto;
41         struct proto_shell_handler *handler;
42         struct blob_attr *config;
43
44         struct uloop_timeout teardown_timeout;
45
46         struct netifd_process script_task;
47         struct netifd_process proto_task;
48
49         enum proto_shell_sm sm;
50         bool proto_task_killed;
51
52         int last_error;
53 };
54
55 static int
56 proto_shell_handler(struct interface_proto_state *proto,
57                     enum interface_proto_cmd cmd, bool force)
58 {
59         struct proto_shell_state *state;
60         struct proto_shell_handler *handler;
61         struct netifd_process *proc;
62         static char error_buf[32];
63         const char *argv[7];
64         char *envp[2];
65         const char *action;
66         char *config;
67         int ret, i = 0, j = 0;
68
69         state = container_of(proto, struct proto_shell_state, proto);
70         handler = state->handler;
71         proc = &state->script_task;
72
73         if (cmd == PROTO_CMD_SETUP) {
74                 action = "setup";
75                 state->last_error = -1;
76         } else {
77                 if (state->sm == S_TEARDOWN)
78                         return 0;
79
80                 if (state->script_task.uloop.pending) {
81                         if (state->sm != S_SETUP_ABORT) {
82                                 uloop_timeout_set(&state->teardown_timeout, 1000);
83                                 kill(state->script_task.uloop.pid, SIGTERM);
84                                 if (state->proto_task.uloop.pending)
85                                         kill(state->proto_task.uloop.pid, SIGTERM);
86                                 state->sm = S_SETUP_ABORT;
87                         }
88                         return 0;
89                 }
90
91                 action = "teardown";
92                 state->sm = S_TEARDOWN;
93                 if (state->last_error >= 0) {
94                         snprintf(error_buf, sizeof(error_buf), "ERROR=%d", state->last_error);
95                         envp[j++] = error_buf;
96                 }
97                 uloop_timeout_set(&state->teardown_timeout, 5000);
98         }
99
100         config = blobmsg_format_json(state->config, true);
101         if (!config)
102                 return -1;
103
104         argv[i++] = handler->script_name;
105         argv[i++] = handler->proto.name;
106         argv[i++] = action;
107         argv[i++] = proto->iface->name;
108         argv[i++] = config;
109         if (proto->iface->main_dev.dev)
110                 argv[i++] = proto->iface->main_dev.dev->ifname;
111         argv[i] = NULL;
112         envp[j] = NULL;
113
114         ret = netifd_start_process(argv, envp, proc);
115         free(config);
116
117         return ret;
118 }
119
120 static void
121 proto_shell_task_finish(struct proto_shell_state *state,
122                         struct netifd_process *task)
123 {
124         switch (state->sm) {
125         case S_IDLE:
126                 if (task == &state->proto_task)
127                         state->proto.proto_event(&state->proto, IFPEV_LINK_LOST);
128                 /* fall through */
129         case S_SETUP:
130                 if (task == &state->proto_task)
131                         proto_shell_handler(&state->proto, PROTO_CMD_TEARDOWN,
132                                             false);
133                 break;
134
135         case S_SETUP_ABORT:
136                 if (state->script_task.uloop.pending ||
137                     state->proto_task.uloop.pending)
138                         break;
139
140                 uloop_timeout_cancel(&state->teardown_timeout);
141                 state->sm = S_IDLE;
142                 proto_shell_handler(&state->proto, PROTO_CMD_TEARDOWN, false);
143                 break;
144
145         case S_TEARDOWN:
146                 if (state->script_task.uloop.pending)
147                         break;
148
149                 if (state->proto_task.uloop.pending) {
150                         if (!state->proto_task_killed)
151                                 kill(state->proto_task.uloop.pid, SIGTERM);
152                         break;
153                 }
154
155                 uloop_timeout_cancel(&state->teardown_timeout);
156                 state->sm = S_IDLE;
157                 state->proto.proto_event(&state->proto, IFPEV_DOWN);
158                 break;
159         }
160 }
161
162 static void
163 proto_shell_teardown_timeout_cb(struct uloop_timeout *timeout)
164 {
165         struct proto_shell_state *state;
166
167         state = container_of(timeout, struct proto_shell_state, teardown_timeout);
168
169         netifd_kill_process(&state->script_task);
170         netifd_kill_process(&state->proto_task);
171         proto_shell_task_finish(state, NULL);
172 }
173
174 static void
175 proto_shell_script_cb(struct netifd_process *p, int ret)
176 {
177         struct proto_shell_state *state;
178
179         state = container_of(p, struct proto_shell_state, script_task);
180         proto_shell_task_finish(state, p);
181 }
182
183 static void
184 proto_shell_task_cb(struct netifd_process *p, int ret)
185 {
186         struct proto_shell_state *state;
187
188         state = container_of(p, struct proto_shell_state, proto_task);
189
190         if (state->sm == S_IDLE || state->sm == S_SETUP)
191                 state->last_error = WEXITSTATUS(ret);
192
193         proto_shell_task_finish(state, p);
194 }
195
196 static void
197 proto_shell_free(struct interface_proto_state *proto)
198 {
199         struct proto_shell_state *state;
200
201         state = container_of(proto, struct proto_shell_state, proto);
202         netifd_kill_process(&state->script_task);
203         netifd_kill_process(&state->proto_task);
204         free(state->config);
205         free(state);
206 }
207
208 static void
209 proto_shell_parse_route_list(struct interface *iface, struct blob_attr *attr,
210                              bool v6)
211 {
212         struct blob_attr *cur;
213         int rem;
214
215         blobmsg_for_each_attr(cur, attr, rem) {
216                 if (blobmsg_type(cur) != BLOBMSG_TYPE_TABLE) {
217                         DPRINTF("Ignore wrong route type: %d\n", blobmsg_type(cur));
218                         continue;
219                 }
220
221                 interface_ip_add_route(iface, cur, v6);
222         }
223 }
224
225 static void
226 proto_shell_parse_data(struct interface *iface, struct blob_attr *attr)
227 {
228         struct blob_attr *cur;
229         int rem;
230
231         blobmsg_for_each_attr(cur, attr, rem)
232                 interface_add_data(iface, cur);
233 }
234
235 static struct device *
236 proto_shell_create_tunnel(const char *name, struct blob_attr *attr)
237 {
238         struct device *dev;
239         struct blob_buf b;
240
241         memset(&b, 0, sizeof(b));
242         blob_buf_init(&b, 0);
243         blob_put(&b, 0, blobmsg_data(attr), blobmsg_data_len(attr));
244         dev = device_create(name, &tunnel_device_type, blob_data(b.head));
245         blob_buf_free(&b);
246
247         return dev;
248 }
249
250 enum {
251         NOTIFY_ACTION,
252         NOTIFY_ERROR,
253         NOTIFY_COMMAND,
254         NOTIFY_ENV,
255         NOTIFY_SIGNAL,
256         NOTIFY_AVAILABLE,
257         NOTIFY_LINK_UP,
258         NOTIFY_IFNAME,
259         NOTIFY_ADDR_EXT,
260         NOTIFY_ROUTES,
261         NOTIFY_ROUTES6,
262         NOTIFY_TUNNEL,
263         NOTIFY_DATA,
264         __NOTIFY_LAST
265 };
266
267 static const struct blobmsg_policy notify_attr[__NOTIFY_LAST] = {
268         [NOTIFY_ACTION] = { .name = "action", .type = BLOBMSG_TYPE_INT32 },
269         [NOTIFY_ERROR] = { .name = "error", .type = BLOBMSG_TYPE_ARRAY },
270         [NOTIFY_COMMAND] = { .name = "command", .type = BLOBMSG_TYPE_ARRAY },
271         [NOTIFY_ENV] = { .name = "env", .type = BLOBMSG_TYPE_ARRAY },
272         [NOTIFY_SIGNAL] = { .name = "signal", .type = BLOBMSG_TYPE_INT32 },
273         [NOTIFY_AVAILABLE] = { .name = "available", .type = BLOBMSG_TYPE_BOOL },
274         [NOTIFY_LINK_UP] = { .name = "link-up", .type = BLOBMSG_TYPE_BOOL },
275         [NOTIFY_IFNAME] = { .name = "ifname", .type = BLOBMSG_TYPE_STRING },
276         [NOTIFY_ADDR_EXT] = { .name = "address-external", .type = BLOBMSG_TYPE_BOOL },
277         [NOTIFY_ROUTES] = { .name = "routes", .type = BLOBMSG_TYPE_ARRAY },
278         [NOTIFY_ROUTES6] = { .name = "routes6", .type = BLOBMSG_TYPE_ARRAY },
279         [NOTIFY_TUNNEL] = { .name = "tunnel", .type = BLOBMSG_TYPE_TABLE },
280         [NOTIFY_DATA] = { .name = "data", .type = BLOBMSG_TYPE_TABLE },
281 };
282
283 static int
284 proto_shell_update_link(struct proto_shell_state *state, struct blob_attr *data, struct blob_attr **tb)
285 {
286         struct interface *iface = state->proto.iface;
287         struct blob_attr *cur;
288         struct device *dev;
289         const char *devname;
290         int dev_create = 1;
291         bool addr_ext = false;
292         bool up;
293
294         if (!tb[NOTIFY_LINK_UP])
295                 return UBUS_STATUS_INVALID_ARGUMENT;
296
297         up = blobmsg_get_bool(tb[NOTIFY_LINK_UP]);
298         if (!up) {
299                 state->proto.proto_event(&state->proto, IFPEV_LINK_LOST);
300                 return 0;
301         }
302
303         if ((cur = tb[NOTIFY_ADDR_EXT]) != NULL) {
304                 addr_ext = blobmsg_get_bool(cur);
305                 if (addr_ext)
306                         dev_create = 2;
307         }
308
309         if (!tb[NOTIFY_IFNAME]) {
310                 if (!iface->main_dev.dev)
311                         return UBUS_STATUS_INVALID_ARGUMENT;
312         } else {
313                 devname = blobmsg_data(tb[NOTIFY_IFNAME]);
314                 if (tb[NOTIFY_TUNNEL]) {
315                         dev = proto_shell_create_tunnel(devname,
316                                 tb[NOTIFY_TUNNEL]);
317                         if (!dev)
318                                 return UBUS_STATUS_INVALID_ARGUMENT;
319                 } else {
320                         dev = device_get(devname, dev_create);
321                         if (!dev)
322                                 return UBUS_STATUS_NOT_FOUND;
323                 }
324
325                 interface_set_l3_dev(iface, dev);
326                 device_claim(&iface->l3_dev);
327         }
328
329         interface_update_start(iface);
330         proto_apply_ip_settings(iface, data, addr_ext);
331
332         if ((cur = tb[NOTIFY_ROUTES]) != NULL)
333                 proto_shell_parse_route_list(state->proto.iface, cur, false);
334
335         if ((cur = tb[NOTIFY_ROUTES6]) != NULL)
336                 proto_shell_parse_route_list(state->proto.iface, cur, true);
337
338         interface_update_complete(state->proto.iface);
339
340         state->proto.proto_event(&state->proto, IFPEV_UP);
341         state->sm = S_IDLE;
342
343         if ((cur = tb[NOTIFY_DATA]))
344                 proto_shell_parse_data(state->proto.iface, cur);
345
346         return 0;
347 }
348
349 static bool
350 fill_string_list(struct blob_attr *attr, char **argv, int max)
351 {
352         struct blob_attr *cur;
353         int argc = 0;
354         int rem;
355
356         if (!attr)
357                 goto out;
358
359         blobmsg_for_each_attr(cur, attr, rem) {
360                 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
361                         return false;
362
363                 if (!blobmsg_check_attr(cur, NULL))
364                         return false;
365
366                 argv[argc++] = blobmsg_data(cur);
367                 if (argc == max - 1)
368                         return false;
369         }
370
371 out:
372         argv[argc] = NULL;
373         return true;
374 }
375
376 static int
377 proto_shell_run_command(struct proto_shell_state *state, struct blob_attr **tb)
378 {
379         static char *argv[64];
380         static char *env[32];
381
382         if (!tb[NOTIFY_COMMAND])
383                 goto error;
384
385         if (!fill_string_list(tb[NOTIFY_COMMAND], argv, ARRAY_SIZE(argv)))
386                 goto error;
387
388         if (!fill_string_list(tb[NOTIFY_ENV], env, ARRAY_SIZE(env)))
389                 goto error;
390
391         netifd_start_process((const char **) argv, (char **) env, &state->proto_task);
392
393         return 0;
394
395 error:
396         return UBUS_STATUS_INVALID_ARGUMENT;
397 }
398
399 static int
400 proto_shell_kill_command(struct proto_shell_state *state, struct blob_attr **tb)
401 {
402         unsigned int signal = ~0;
403
404         if (tb[NOTIFY_SIGNAL])
405                 signal = blobmsg_get_u32(tb[NOTIFY_SIGNAL]);
406
407         if (signal > 31)
408                 signal = SIGTERM;
409
410         if (state->proto_task.uloop.pending) {
411                 state->proto_task_killed = true;
412                 kill(state->proto_task.uloop.pid, signal);
413         }
414
415         return 0;
416 }
417
418 static int
419 proto_shell_notify_error(struct proto_shell_state *state, struct blob_attr **tb)
420 {
421         struct blob_attr *cur;
422         char *data[16];
423         int n_data = 0;
424         int rem;
425
426         if (!tb[NOTIFY_ERROR])
427                 return UBUS_STATUS_INVALID_ARGUMENT;
428
429         blobmsg_for_each_attr(cur, tb[NOTIFY_ERROR], rem) {
430                 if (n_data + 1 == ARRAY_SIZE(data))
431                         goto error;
432
433                 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
434                         goto error;
435
436                 if (!blobmsg_check_attr(cur, NULL))
437                         goto error;
438
439                 data[n_data++] = blobmsg_data(cur);
440         }
441
442         if (!n_data)
443                 goto error;
444
445         interface_add_error(state->proto.iface, state->handler->proto.name,
446                         data[0], (const char **) &data[1], n_data - 1);
447
448         return 0;
449
450 error:
451         return UBUS_STATUS_INVALID_ARGUMENT;
452 }
453
454 static int
455 proto_shell_block_restart(struct proto_shell_state *state, struct blob_attr **tb)
456 {
457         state->proto.iface->autostart = false;
458         return 0;
459 }
460
461 static int
462 proto_shell_set_available(struct proto_shell_state *state, struct blob_attr **tb)
463 {
464         if (!tb[NOTIFY_AVAILABLE])
465                 return UBUS_STATUS_INVALID_ARGUMENT;
466
467         interface_set_available(state->proto.iface, blobmsg_get_bool(tb[NOTIFY_AVAILABLE]));
468         return 0;
469 }
470
471 static int
472 proto_shell_notify(struct interface_proto_state *proto, struct blob_attr *attr)
473 {
474         struct proto_shell_state *state;
475         struct blob_attr *tb[__NOTIFY_LAST];
476
477         state = container_of(proto, struct proto_shell_state, proto);
478
479         blobmsg_parse(notify_attr, __NOTIFY_LAST, tb, blob_data(attr), blob_len(attr));
480         if (!tb[NOTIFY_ACTION])
481                 return UBUS_STATUS_INVALID_ARGUMENT;
482
483         switch(blobmsg_get_u32(tb[NOTIFY_ACTION])) {
484         case 0:
485                 return proto_shell_update_link(state, attr, tb);
486         case 1:
487                 return proto_shell_run_command(state, tb);
488         case 2:
489                 return proto_shell_kill_command(state, tb);
490         case 3:
491                 return proto_shell_notify_error(state, tb);
492         case 4:
493                 return proto_shell_block_restart(state, tb);
494         case 5:
495                 return proto_shell_set_available(state, tb);
496         default:
497                 return UBUS_STATUS_INVALID_ARGUMENT;
498         }
499 }
500
501 static struct interface_proto_state *
502 proto_shell_attach(const struct proto_handler *h, struct interface *iface,
503                    struct blob_attr *attr)
504 {
505         struct proto_shell_state *state;
506
507         state = calloc(1, sizeof(*state));
508         state->config = malloc(blob_pad_len(attr));
509         if (!state->config)
510                 goto error;
511
512         memcpy(state->config, attr, blob_pad_len(attr));
513         state->proto.free = proto_shell_free;
514         state->proto.notify = proto_shell_notify;
515         state->proto.cb = proto_shell_handler;
516         state->teardown_timeout.cb = proto_shell_teardown_timeout_cb;
517         state->script_task.cb = proto_shell_script_cb;
518         state->script_task.dir_fd = proto_fd.fd;
519         state->script_task.log_prefix = iface->name;
520         state->proto_task.cb = proto_shell_task_cb;
521         state->proto_task.dir_fd = proto_fd.fd;
522         state->proto_task.log_prefix = iface->name;
523         state->handler = container_of(h, struct proto_shell_handler, proto);
524
525         return &state->proto;
526
527 error:
528         free(state);
529         return NULL;
530 }
531
532 static json_object *
533 check_type(json_object *obj, json_type type)
534 {
535         if (!obj)
536                 return NULL;
537
538         if (json_object_get_type(obj) != type)
539                 return NULL;
540
541         return obj;
542 }
543
544 static inline json_object *
545 get_field(json_object *obj, const char *name, json_type type)
546 {
547         return check_type(json_object_object_get(obj, name), type);
548 }
549
550 static char *
551 proto_shell_parse_config(struct config_param_list *config, json_object *obj)
552 {
553         struct blobmsg_policy *attrs;
554         char *str_buf, *str_cur;
555         int str_len = 0;
556         int i;
557
558         config->n_params = json_object_array_length(obj);
559         attrs = calloc(1, sizeof(*attrs) * config->n_params);
560         if (!attrs)
561                 return NULL;
562
563         config->params = attrs;
564         for (i = 0; i < config->n_params; i++) {
565                 json_object *cur, *name, *type;
566
567                 cur = check_type(json_object_array_get_idx(obj, i), json_type_array);
568                 if (!cur)
569                         goto error;
570
571                 name = check_type(json_object_array_get_idx(cur, 0), json_type_string);
572                 if (!name)
573                         goto error;
574
575                 type = check_type(json_object_array_get_idx(cur, 1), json_type_int);
576                 if (!type)
577                         goto error;
578
579                 attrs[i].name = json_object_get_string(name);
580                 attrs[i].type = json_object_get_int(type);
581                 if (attrs[i].type > BLOBMSG_TYPE_LAST)
582                         goto error;
583
584                 str_len += strlen(attrs[i].name) + 1;
585         }
586
587         str_buf = malloc(str_len);
588         if (!str_buf)
589                 goto error;
590
591         str_cur = str_buf;
592         for (i = 0; i < config->n_params; i++) {
593                 const char *name = attrs[i].name;
594
595                 attrs[i].name = str_cur;
596                 str_cur += sprintf(str_cur, "%s", name) + 1;
597         }
598
599         return str_buf;
600
601 error:
602         free(attrs);
603         config->n_params = 0;
604         return NULL;
605 }
606
607 static void
608 proto_shell_add_handler(const char *script, json_object *obj)
609 {
610         struct proto_shell_handler *handler;
611         struct proto_handler *proto;
612         json_object *config, *tmp;
613         const char *name;
614         char *str;
615
616         if (!check_type(obj, json_type_object))
617                 return;
618
619         tmp = get_field(obj, "name", json_type_string);
620         if (!tmp)
621                 return;
622
623         name = json_object_get_string(tmp);
624
625         handler = calloc(1, sizeof(*handler) +
626                          strlen(script) + 1 +
627                          strlen(name) + 1);
628         if (!handler)
629                 return;
630
631         strcpy(handler->script_name, script);
632
633         str = handler->script_name + strlen(handler->script_name) + 1;
634         strcpy(str, name);
635
636         proto = &handler->proto;
637         proto->name = str;
638         proto->config_params = &handler->config;
639         proto->attach = proto_shell_attach;
640
641         tmp = get_field(obj, "no-device", json_type_boolean);
642         if (tmp && json_object_get_boolean(tmp))
643                 handler->proto.flags |= PROTO_FLAG_NODEV;
644
645         tmp = get_field(obj, "available", json_type_boolean);
646         if (tmp && json_object_get_boolean(tmp))
647                 handler->proto.flags |= PROTO_FLAG_INIT_AVAILABLE;
648
649         config = get_field(obj, "config", json_type_array);
650         if (config)
651                 handler->config_buf = proto_shell_parse_config(&handler->config, config);
652
653         DPRINTF("Add handler for script %s: %s\n", script, proto->name);
654         add_proto_handler(proto);
655 }
656
657 static void proto_shell_add_script(const char *name)
658 {
659         struct json_tokener *tok = NULL;
660         json_object *obj;
661         static char buf[512];
662         char *start, *cmd;
663         FILE *f;
664         int len;
665
666 #define DUMP_SUFFIX     " '' dump"
667
668         cmd = alloca(strlen(name) + 1 + sizeof(DUMP_SUFFIX));
669         sprintf(cmd, "%s" DUMP_SUFFIX, name);
670
671         f = popen(cmd, "r");
672         if (!f)
673                 return;
674
675         do {
676                 start = fgets(buf, sizeof(buf), f);
677                 if (!start)
678                         continue;
679
680                 len = strlen(start);
681
682                 if (!tok)
683                         tok = json_tokener_new();
684
685                 obj = json_tokener_parse_ex(tok, start, len);
686                 if (!is_error(obj)) {
687                         proto_shell_add_handler(name, obj);
688                         json_object_put(obj);
689                         json_tokener_free(tok);
690                         tok = NULL;
691                 } else if (start[len - 1] == '\n') {
692                         json_tokener_free(tok);
693                         tok = NULL;
694                 }
695         } while (!feof(f) && !ferror(f));
696
697         if (tok)
698                 json_tokener_free(tok);
699
700         pclose(f);
701 }
702
703 static void __init proto_shell_init(void)
704 {
705         glob_t g;
706         int main_fd;
707         int i;
708
709         main_fd = open(".", O_RDONLY | O_DIRECTORY);
710         if (main_fd < 0)
711                 return;
712
713         if (chdir(main_path)) {
714                 perror("chdir(main path)");
715                 goto close_cur;
716         }
717
718         if (chdir("./proto"))
719                 goto close_cur;
720
721         proto_fd.fd = open(".", O_RDONLY | O_DIRECTORY);
722         if (proto_fd.fd < 0)
723                 goto close_cur;
724
725         netifd_fd_add(&proto_fd);
726         glob("./*.sh", 0, NULL, &g);
727         for (i = 0; i < g.gl_pathc; i++)
728                 proto_shell_add_script(g.gl_pathv[i]);
729
730 close_cur:
731         fchdir(main_fd);
732         close(main_fd);
733 }