2 * netifd - network interface daemon
3 * Copyright (C) 2012 Felix Fietkau <nbd@openwrt.org>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2
7 * as published by the Free Software Foundation
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.
21 #include <arpa/inet.h>
22 #include <netinet/in.h>
26 #include "interface.h"
27 #include "interface-ip.h"
32 static int proto_fd = -1;
41 struct proto_shell_handler {
42 struct list_head list;
43 struct proto_handler proto;
49 struct uci_blob_param_list config;
52 struct proto_shell_dependency {
53 struct list_head list;
55 struct proto_shell_state *proto;
56 struct interface_user dep;
65 struct proto_shell_state {
66 struct interface_proto_state proto;
67 struct proto_shell_handler *handler;
68 struct blob_attr *config;
70 struct uloop_timeout teardown_timeout;
73 * Teardown and setup interface again if it is still not up (IFS_UP)
74 * after checkup_interval seconds since previous attempt. This check
75 * will be disabled when the config option "checkup_interval" is
76 * missing or has a negative value
79 struct uloop_timeout checkup_timeout;
81 struct netifd_process script_task;
82 struct netifd_process proto_task;
84 enum proto_shell_sm sm;
85 bool proto_task_killed;
90 struct list_head deps;
94 proto_shell_check_dependencies(struct proto_shell_state *state)
96 struct proto_shell_dependency *dep;
97 bool available = true;
99 list_for_each_entry(dep, &state->deps, list) {
107 interface_set_available(state->proto.iface, available);
111 proto_shell_if_up_cb(struct interface_user *dep, struct interface *iface,
112 enum interface_event ev);
114 proto_shell_if_down_cb(struct interface_user *dep, struct interface *iface,
115 enum interface_event ev);
118 proto_shell_update_host_dep(struct proto_shell_dependency *dep)
120 struct interface *iface = NULL;
125 if (dep->interface[0]) {
126 iface = vlist_find(&interfaces, dep->interface, iface, node);
128 if (!iface || iface->state != IFS_UP)
133 iface = interface_ip_add_target_route(&dep->host, dep->v6, iface);
138 interface_remove_user(&dep->dep);
139 dep->dep.cb = proto_shell_if_down_cb;
140 interface_add_user(&dep->dep, iface);
143 proto_shell_check_dependencies(dep->proto);
147 proto_shell_clear_host_dep(struct proto_shell_state *state)
149 struct proto_shell_dependency *dep, *tmp;
151 list_for_each_entry_safe(dep, tmp, &state->deps, list) {
152 interface_remove_user(&dep->dep);
153 list_del(&dep->list);
159 proto_shell_handler(struct interface_proto_state *proto,
160 enum interface_proto_cmd cmd, bool force)
162 struct proto_shell_state *state;
163 struct proto_shell_handler *handler;
164 struct netifd_process *proc;
165 static char error_buf[32];
170 int ret, i = 0, j = 0;
172 state = container_of(proto, struct proto_shell_state, proto);
173 handler = state->handler;
174 proc = &state->script_task;
176 if (cmd == PROTO_CMD_SETUP) {
180 state->last_error = -1;
181 proto_shell_clear_host_dep(state);
193 } else if (cmd == PROTO_CMD_RENEW) {
194 if (!(handler->proto.flags & PROTO_FLAG_RENEW_AVAILABLE))
197 if (state->script_task.uloop.pending) {
198 state->renew_pending = true;
202 state->renew_pending = false;
207 if (state->script_task.uloop.pending) {
208 uloop_timeout_set(&state->teardown_timeout, 1000);
209 kill(state->script_task.uloop.pid, SIGTERM);
210 if (state->proto_task.uloop.pending)
211 kill(state->proto_task.uloop.pid, SIGTERM);
212 state->renew_pending = false;
213 state->sm = S_SETUP_ABORT;
216 /* fall through if no script task is running */
219 state->renew_pending = false;
220 state->sm = S_TEARDOWN;
221 if (state->last_error >= 0) {
222 snprintf(error_buf, sizeof(error_buf), "ERROR=%d", state->last_error);
223 envp[j++] = error_buf;
225 uloop_timeout_set(&state->teardown_timeout, 5000);
236 D(INTERFACE, "run %s for interface '%s'\n", action, proto->iface->name);
237 config = blobmsg_format_json(state->config, true);
241 argv[i++] = handler->script_name;
242 argv[i++] = handler->proto.name;
244 argv[i++] = proto->iface->name;
246 if (proto->iface->main_dev.dev)
247 argv[i++] = proto->iface->main_dev.dev->ifname;
251 ret = netifd_start_process(argv, envp, proc);
258 proto_shell_if_up_cb(struct interface_user *dep, struct interface *iface,
259 enum interface_event ev)
261 struct proto_shell_dependency *pdep;
263 if (ev != IFEV_UP && ev != IFEV_UPDATE)
266 pdep = container_of(dep, struct proto_shell_dependency, dep);
267 proto_shell_update_host_dep(pdep);
271 proto_shell_if_down_cb(struct interface_user *dep, struct interface *iface,
272 enum interface_event ev)
274 struct proto_shell_dependency *pdep;
275 struct proto_shell_state *state;
277 if (ev == IFEV_UP || ev == IFEV_UPDATE)
280 pdep = container_of(dep, struct proto_shell_dependency, dep);
281 interface_remove_user(dep);
282 dep->cb = proto_shell_if_up_cb;
283 interface_add_user(dep, NULL);
286 if (state->sm == S_IDLE) {
287 state->proto.proto_event(&state->proto, IFPEV_LINK_LOST);
288 proto_shell_handler(&state->proto, PROTO_CMD_TEARDOWN, false);
293 proto_shell_task_finish(struct proto_shell_state *state,
294 struct netifd_process *task)
298 if (task == &state->proto_task)
299 state->proto.proto_event(&state->proto, IFPEV_LINK_LOST);
302 if (task == &state->proto_task)
303 proto_shell_handler(&state->proto, PROTO_CMD_TEARDOWN,
305 else if (task == &state->script_task) {
306 if (state->renew_pending)
307 proto_shell_handler(&state->proto,
308 PROTO_CMD_RENEW, false);
309 else if (!state->handler->no_proto_task &&
310 !state->proto_task.uloop.pending &&
311 state->sm == S_SETUP)
312 proto_shell_handler(&state->proto,
316 /* check up status after setup attempt by this script_task */
317 if (state->sm == S_SETUP && state->checkup_interval > 0) {
318 uloop_timeout_set(&state->checkup_timeout,
319 state->checkup_interval * 1000);
325 if (state->script_task.uloop.pending ||
326 state->proto_task.uloop.pending)
329 /* completed aborting all tasks, now idle */
330 uloop_timeout_cancel(&state->teardown_timeout);
331 uloop_timeout_cancel(&state->checkup_timeout);
333 proto_shell_handler(&state->proto, PROTO_CMD_TEARDOWN, false);
337 if (state->script_task.uloop.pending)
340 if (state->proto_task.uloop.pending) {
341 if (!state->proto_task_killed)
342 kill(state->proto_task.uloop.pid, SIGTERM);
346 /* completed tearing down all tasks, now idle */
347 uloop_timeout_cancel(&state->teardown_timeout);
348 uloop_timeout_cancel(&state->checkup_timeout);
350 state->proto.proto_event(&state->proto, IFPEV_DOWN);
356 proto_shell_teardown_timeout_cb(struct uloop_timeout *timeout)
358 struct proto_shell_state *state;
360 state = container_of(timeout, struct proto_shell_state, teardown_timeout);
362 netifd_kill_process(&state->script_task);
363 netifd_kill_process(&state->proto_task);
364 proto_shell_task_finish(state, NULL);
368 proto_shell_script_cb(struct netifd_process *p, int ret)
370 struct proto_shell_state *state;
372 state = container_of(p, struct proto_shell_state, script_task);
373 proto_shell_task_finish(state, p);
377 proto_shell_task_cb(struct netifd_process *p, int ret)
379 struct proto_shell_state *state;
381 state = container_of(p, struct proto_shell_state, proto_task);
383 if (state->sm == S_IDLE || state->sm == S_SETUP)
384 state->last_error = WEXITSTATUS(ret);
386 proto_shell_task_finish(state, p);
390 proto_shell_free(struct interface_proto_state *proto)
392 struct proto_shell_state *state;
394 state = container_of(proto, struct proto_shell_state, proto);
395 uloop_timeout_cancel(&state->teardown_timeout);
396 uloop_timeout_cancel(&state->checkup_timeout);
397 proto_shell_clear_host_dep(state);
398 netifd_kill_process(&state->script_task);
399 netifd_kill_process(&state->proto_task);
405 proto_shell_parse_route_list(struct interface *iface, struct blob_attr *attr,
408 struct blob_attr *cur;
411 blobmsg_for_each_attr(cur, attr, rem) {
412 if (blobmsg_type(cur) != BLOBMSG_TYPE_TABLE) {
413 DPRINTF("Ignore wrong route type: %d\n", blobmsg_type(cur));
417 interface_ip_add_route(iface, cur, v6);
422 proto_shell_parse_data(struct interface *iface, struct blob_attr *attr)
424 struct blob_attr *cur;
427 blobmsg_for_each_attr(cur, attr, rem)
428 interface_add_data(iface, cur);
431 static struct device *
432 proto_shell_create_tunnel(const char *name, struct blob_attr *attr)
437 memset(&b, 0, sizeof(b));
438 blob_buf_init(&b, 0);
439 blob_put(&b, 0, blobmsg_data(attr), blobmsg_data_len(attr));
440 dev = device_create(name, &tunnel_device_type, blob_data(b.head));
467 static const struct blobmsg_policy notify_attr[__NOTIFY_LAST] = {
468 [NOTIFY_ACTION] = { .name = "action", .type = BLOBMSG_TYPE_INT32 },
469 [NOTIFY_ERROR] = { .name = "error", .type = BLOBMSG_TYPE_ARRAY },
470 [NOTIFY_COMMAND] = { .name = "command", .type = BLOBMSG_TYPE_ARRAY },
471 [NOTIFY_ENV] = { .name = "env", .type = BLOBMSG_TYPE_ARRAY },
472 [NOTIFY_SIGNAL] = { .name = "signal", .type = BLOBMSG_TYPE_INT32 },
473 [NOTIFY_AVAILABLE] = { .name = "available", .type = BLOBMSG_TYPE_BOOL },
474 [NOTIFY_LINK_UP] = { .name = "link-up", .type = BLOBMSG_TYPE_BOOL },
475 [NOTIFY_IFNAME] = { .name = "ifname", .type = BLOBMSG_TYPE_STRING },
476 [NOTIFY_ADDR_EXT] = { .name = "address-external", .type = BLOBMSG_TYPE_BOOL },
477 [NOTIFY_ROUTES] = { .name = "routes", .type = BLOBMSG_TYPE_ARRAY },
478 [NOTIFY_ROUTES6] = { .name = "routes6", .type = BLOBMSG_TYPE_ARRAY },
479 [NOTIFY_TUNNEL] = { .name = "tunnel", .type = BLOBMSG_TYPE_TABLE },
480 [NOTIFY_DATA] = { .name = "data", .type = BLOBMSG_TYPE_TABLE },
481 [NOTIFY_KEEP] = { .name = "keep", .type = BLOBMSG_TYPE_BOOL },
482 [NOTIFY_HOST] = { .name = "host", .type = BLOBMSG_TYPE_STRING },
483 [NOTIFY_DNS] = { .name = "dns", .type = BLOBMSG_TYPE_ARRAY },
484 [NOTIFY_DNS_SEARCH] = { .name = "dns_search", .type = BLOBMSG_TYPE_ARRAY },
488 proto_shell_update_link(struct proto_shell_state *state, struct blob_attr *data, struct blob_attr **tb)
490 struct interface *iface = state->proto.iface;
491 struct blob_attr *cur;
495 bool addr_ext = false;
499 if (state->sm == S_TEARDOWN || state->sm == S_SETUP_ABORT)
500 return UBUS_STATUS_PERMISSION_DENIED;
502 if (!tb[NOTIFY_LINK_UP])
503 return UBUS_STATUS_INVALID_ARGUMENT;
505 up = blobmsg_get_bool(tb[NOTIFY_LINK_UP]);
507 state->proto.proto_event(&state->proto, IFPEV_LINK_LOST);
511 if ((cur = tb[NOTIFY_KEEP]) != NULL)
512 keep = blobmsg_get_bool(cur);
514 if ((cur = tb[NOTIFY_ADDR_EXT]) != NULL) {
515 addr_ext = blobmsg_get_bool(cur);
520 if (iface->state != IFS_UP || !iface->l3_dev.dev)
524 dev = iface->main_dev.dev;
525 if (tb[NOTIFY_IFNAME]) {
527 devname = blobmsg_data(tb[NOTIFY_IFNAME]);
528 if (tb[NOTIFY_TUNNEL])
529 dev = proto_shell_create_tunnel(devname, tb[NOTIFY_TUNNEL]);
531 dev = device_get(devname, dev_create);
535 return UBUS_STATUS_INVALID_ARGUMENT;
537 interface_set_l3_dev(iface, dev);
538 if (device_claim(&iface->l3_dev) < 0)
539 return UBUS_STATUS_UNKNOWN_ERROR;
541 device_set_present(dev, true);
543 interface_update_start(iface);
546 proto_apply_ip_settings(iface, data, addr_ext);
548 if ((cur = tb[NOTIFY_ROUTES]) != NULL)
549 proto_shell_parse_route_list(state->proto.iface, cur, false);
551 if ((cur = tb[NOTIFY_ROUTES6]) != NULL)
552 proto_shell_parse_route_list(state->proto.iface, cur, true);
554 if ((cur = tb[NOTIFY_DNS]))
555 interface_add_dns_server_list(&iface->proto_ip, cur);
557 if ((cur = tb[NOTIFY_DNS_SEARCH]))
558 interface_add_dns_search_list(&iface->proto_ip, cur);
560 if ((cur = tb[NOTIFY_DATA]))
561 proto_shell_parse_data(state->proto.iface, cur);
563 interface_update_complete(state->proto.iface);
565 if ((state->sm != S_SETUP_ABORT) && (state->sm != S_TEARDOWN)) {
567 state->proto.proto_event(&state->proto, IFPEV_UP);
575 fill_string_list(struct blob_attr *attr, char **argv, int max)
577 struct blob_attr *cur;
584 blobmsg_for_each_attr(cur, attr, rem) {
585 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
588 if (!blobmsg_check_attr(cur, NULL))
591 argv[argc++] = blobmsg_data(cur);
602 proto_shell_run_command(struct proto_shell_state *state, struct blob_attr **tb)
604 static char *argv[64];
605 static char *env[32];
607 if (state->sm == S_TEARDOWN || state->sm == S_SETUP_ABORT)
608 return UBUS_STATUS_PERMISSION_DENIED;
610 if (!tb[NOTIFY_COMMAND])
613 if (!fill_string_list(tb[NOTIFY_COMMAND], argv, ARRAY_SIZE(argv)))
616 if (!fill_string_list(tb[NOTIFY_ENV], env, ARRAY_SIZE(env)))
619 netifd_start_process((const char **) argv, (char **) env, &state->proto_task);
624 return UBUS_STATUS_INVALID_ARGUMENT;
628 proto_shell_kill_command(struct proto_shell_state *state, struct blob_attr **tb)
630 unsigned int signal = ~0;
632 if (tb[NOTIFY_SIGNAL])
633 signal = blobmsg_get_u32(tb[NOTIFY_SIGNAL]);
638 if (state->proto_task.uloop.pending) {
639 if (signal == SIGTERM || signal == SIGKILL)
640 state->proto_task_killed = true;
641 kill(state->proto_task.uloop.pid, signal);
648 proto_shell_notify_error(struct proto_shell_state *state, struct blob_attr **tb)
650 struct blob_attr *cur;
655 if (!tb[NOTIFY_ERROR])
656 return UBUS_STATUS_INVALID_ARGUMENT;
658 blobmsg_for_each_attr(cur, tb[NOTIFY_ERROR], rem) {
659 if (n_data + 1 == ARRAY_SIZE(data))
662 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
665 if (!blobmsg_check_attr(cur, NULL))
668 data[n_data++] = blobmsg_data(cur);
674 interface_add_error(state->proto.iface, state->handler->proto.name,
675 data[0], (const char **) &data[1], n_data - 1);
680 return UBUS_STATUS_INVALID_ARGUMENT;
684 proto_shell_block_restart(struct proto_shell_state *state, struct blob_attr **tb)
686 state->proto.iface->autostart = false;
691 proto_shell_set_available(struct proto_shell_state *state, struct blob_attr **tb)
693 if (!tb[NOTIFY_AVAILABLE])
694 return UBUS_STATUS_INVALID_ARGUMENT;
696 interface_set_available(state->proto.iface, blobmsg_get_bool(tb[NOTIFY_AVAILABLE]));
701 proto_shell_add_host_dependency(struct proto_shell_state *state, struct blob_attr **tb)
703 struct proto_shell_dependency *dep;
704 const char *ifname = tb[NOTIFY_IFNAME] ? blobmsg_data(tb[NOTIFY_IFNAME]) : "";
705 const char *host = tb[NOTIFY_HOST] ? blobmsg_data(tb[NOTIFY_HOST]) : "";
707 if (state->sm == S_TEARDOWN || state->sm == S_SETUP_ABORT)
708 return UBUS_STATUS_PERMISSION_DENIED;
710 dep = calloc(1, sizeof(*dep) + strlen(ifname) + 1);
712 if (!host[0] && ifname[0]) {
714 } else if (inet_pton(AF_INET, host, &dep->host) < 1) {
715 if (inet_pton(AF_INET6, host, &dep->host) < 1) {
717 return UBUS_STATUS_INVALID_ARGUMENT;
724 strcpy(dep->interface, ifname);
726 dep->dep.cb = proto_shell_if_up_cb;
727 interface_add_user(&dep->dep, NULL);
728 list_add(&dep->list, &state->deps);
729 proto_shell_update_host_dep(dep);
731 return UBUS_STATUS_NOT_FOUND;
737 proto_shell_setup_failed(struct proto_shell_state *state)
743 state->proto.proto_event(&state->proto, IFPEV_LINK_LOST);
746 proto_shell_handler(&state->proto, PROTO_CMD_TEARDOWN, false);
751 ret = UBUS_STATUS_PERMISSION_DENIED;
758 proto_shell_notify(struct interface_proto_state *proto, struct blob_attr *attr)
760 struct proto_shell_state *state;
761 struct blob_attr *tb[__NOTIFY_LAST];
763 state = container_of(proto, struct proto_shell_state, proto);
765 blobmsg_parse(notify_attr, __NOTIFY_LAST, tb, blob_data(attr), blob_len(attr));
766 if (!tb[NOTIFY_ACTION])
767 return UBUS_STATUS_INVALID_ARGUMENT;
769 switch(blobmsg_get_u32(tb[NOTIFY_ACTION])) {
771 return proto_shell_update_link(state, attr, tb);
773 return proto_shell_run_command(state, tb);
775 return proto_shell_kill_command(state, tb);
777 return proto_shell_notify_error(state, tb);
779 return proto_shell_block_restart(state, tb);
781 return proto_shell_set_available(state, tb);
783 return proto_shell_add_host_dependency(state, tb);
785 return proto_shell_setup_failed(state);
787 return UBUS_STATUS_INVALID_ARGUMENT;
792 proto_shell_checkup_timeout_cb(struct uloop_timeout *timeout)
794 struct proto_shell_state *state = container_of(timeout, struct
795 proto_shell_state, checkup_timeout);
796 struct interface_proto_state *proto = &state->proto;
797 struct interface *iface = proto->iface;
799 if (!iface->autostart)
802 if (iface->state == IFS_UP)
805 D(INTERFACE, "Interface '%s' is not up after %d sec\n",
806 iface->name, state->checkup_interval);
807 proto_shell_handler(proto, PROTO_CMD_TEARDOWN, false);
811 proto_shell_checkup_attach(struct proto_shell_state *state,
812 const struct blob_attr *attr)
814 struct blob_attr *tb;
815 struct blobmsg_policy checkup_policy = {
816 .name = "checkup_interval",
817 .type = BLOBMSG_TYPE_INT32
820 blobmsg_parse(&checkup_policy, 1, &tb, blob_data(attr), blob_len(attr));
822 state->checkup_interval = -1;
823 state->checkup_timeout.cb = NULL;
825 state->checkup_interval = blobmsg_get_u32(tb);
826 state->checkup_timeout.cb = proto_shell_checkup_timeout_cb;
830 static struct interface_proto_state *
831 proto_shell_attach(const struct proto_handler *h, struct interface *iface,
832 struct blob_attr *attr)
834 struct proto_shell_state *state;
836 state = calloc(1, sizeof(*state));
837 INIT_LIST_HEAD(&state->deps);
839 state->config = malloc(blob_pad_len(attr));
843 memcpy(state->config, attr, blob_pad_len(attr));
844 proto_shell_checkup_attach(state, state->config);
845 state->proto.free = proto_shell_free;
846 state->proto.notify = proto_shell_notify;
847 state->proto.cb = proto_shell_handler;
848 state->teardown_timeout.cb = proto_shell_teardown_timeout_cb;
849 state->script_task.cb = proto_shell_script_cb;
850 state->script_task.dir_fd = proto_fd;
851 state->script_task.log_prefix = iface->name;
852 state->proto_task.cb = proto_shell_task_cb;
853 state->proto_task.dir_fd = proto_fd;
854 state->proto_task.log_prefix = iface->name;
855 state->handler = container_of(h, struct proto_shell_handler, proto);
857 return &state->proto;
865 proto_shell_add_handler(const char *script, const char *name, json_object *obj)
867 struct proto_shell_handler *handler;
868 struct proto_handler *proto;
869 json_object *config, *tmp;
870 char *proto_name, *script_name;
872 handler = calloc_a(sizeof(*handler),
873 &proto_name, strlen(name) + 1,
874 &script_name, strlen(script) + 1);
878 handler->script_name = strcpy(script_name, script);
880 proto = &handler->proto;
881 proto->name = strcpy(proto_name, name);
882 proto->config_params = &handler->config;
883 proto->attach = proto_shell_attach;
885 tmp = json_get_field(obj, "no-device", json_type_boolean);
886 if (tmp && json_object_get_boolean(tmp))
887 handler->proto.flags |= PROTO_FLAG_NODEV;
889 tmp = json_get_field(obj, "no-proto-task", json_type_boolean);
890 handler->no_proto_task = tmp && json_object_get_boolean(tmp);
892 tmp = json_get_field(obj, "available", json_type_boolean);
893 if (tmp && json_object_get_boolean(tmp))
894 handler->proto.flags |= PROTO_FLAG_INIT_AVAILABLE;
896 tmp = json_get_field(obj, "renew-handler", json_type_boolean);
897 if (tmp && json_object_get_boolean(tmp))
898 handler->proto.flags |= PROTO_FLAG_RENEW_AVAILABLE;
900 tmp = json_get_field(obj, "lasterror", json_type_boolean);
901 if (tmp && json_object_get_boolean(tmp))
902 handler->proto.flags |= PROTO_FLAG_LASTERROR;
904 config = json_get_field(obj, "config", json_type_array);
906 handler->config_buf = netifd_handler_parse_config(&handler->config, config);
908 DPRINTF("Add handler for script %s: %s\n", script, proto->name);
909 add_proto_handler(proto);
912 void proto_shell_init(void)
914 proto_fd = netifd_open_subdir("proto");
918 netifd_init_script_handlers(proto_fd, proto_shell_add_handler);