X-Git-Url: https://git.archive.openwrt.org/?p=project%2Fnetifd.git;a=blobdiff_plain;f=proto-shell.c;h=38d3871ff6f95858064e7f15b8c1576e30bcb0d2;hp=c2a6d0011f227efe556f596c27deaa1736f3f421;hb=81a3b50ef7fad3096a8d164c871521e6e6b55aa1;hpb=4b1a0ddadc70fbce76844bf09af261296ef4fd9f diff --git a/proto-shell.c b/proto-shell.c index c2a6d00..38d3871 100644 --- a/proto-shell.c +++ b/proto-shell.c @@ -1,3 +1,16 @@ +/* + * netifd - network interface daemon + * Copyright (C) 2012 Felix Fietkau + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 + * 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 @@ -17,33 +30,115 @@ #include "interface.h" #include "interface-ip.h" #include "proto.h" +#include "system.h" -static struct netifd_fd proto_fd; +static int proto_fd = -1; + +enum proto_shell_sm { + S_IDLE, + S_SETUP, + S_SETUP_ABORT, + S_TEARDOWN, +}; struct proto_shell_handler { struct list_head list; struct proto_handler proto; - struct config_param_list config; + struct uci_blob_param_list config; char *config_buf; + bool init_available; char script_name[]; }; +struct proto_shell_dependency { + struct list_head list; + + struct proto_shell_state *proto; + struct interface_user dep; + + union if_addr host; + bool v6; + + char interface[]; +}; + struct proto_shell_state { struct interface_proto_state proto; struct proto_shell_handler *handler; struct blob_attr *config; - struct device_user l3_dev; - - struct uloop_timeout setup_timeout; - struct netifd_process setup_task; - struct netifd_process teardown_task; - bool teardown_pending; - bool teardown_wait_task; + struct uloop_timeout teardown_timeout; + struct netifd_process script_task; struct netifd_process proto_task; + + enum proto_shell_sm sm; + bool proto_task_killed; + + int last_error; + + struct list_head deps; }; +static void +proto_shell_check_dependencies(struct proto_shell_state *state) +{ + struct proto_shell_dependency *dep; + bool available = true; + + list_for_each_entry(dep, &state->deps, list) { + if (dep->dep.iface) + continue; + + available = false; + break; + } + + interface_set_available(state->proto.iface, available); +} + +static void +proto_shell_if_up_cb(struct interface_user *dep, struct interface *iface, + enum interface_event ev); +static void +proto_shell_if_down_cb(struct interface_user *dep, struct interface *iface, + enum interface_event ev); + +static void +proto_shell_update_host_dep(struct proto_shell_dependency *dep) +{ + struct interface *iface = NULL; + + if (dep->dep.iface) + goto out; + + if (dep->interface[0]) + iface = vlist_find(&interfaces, dep->interface, iface, node); + + iface = interface_ip_add_target_route(&dep->host, dep->v6, iface); + if (!iface) + goto out; + + interface_remove_user(&dep->dep); + dep->dep.cb = proto_shell_if_down_cb; + interface_add_user(&dep->dep, iface); + +out: + proto_shell_check_dependencies(dep->proto); +} + +static void +proto_shell_clear_host_dep(struct proto_shell_state *state) +{ + struct proto_shell_dependency *dep, *tmp; + + list_for_each_entry_safe(dep, tmp, &state->deps, list) { + interface_remove_user(&dep->dep); + list_del(&dep->list); + free(dep); + } +} + static int proto_shell_handler(struct interface_proto_state *proto, enum interface_proto_cmd cmd, bool force) @@ -51,26 +146,43 @@ proto_shell_handler(struct interface_proto_state *proto, struct proto_shell_state *state; struct proto_shell_handler *handler; struct netifd_process *proc; - const char *argv[6]; + static char error_buf[32]; + const char *argv[7]; + char *envp[2]; const char *action; char *config; - int ret, i = 0; + int ret, i = 0, j = 0; state = container_of(proto, struct proto_shell_state, proto); handler = state->handler; + proc = &state->script_task; if (cmd == PROTO_CMD_SETUP) { action = "setup"; - proc = &state->setup_task; + state->last_error = -1; + proto_shell_clear_host_dep(state); } else { - action = "teardown"; - proc = &state->teardown_task; - if (state->setup_task.uloop.pending && !state->teardown_wait_task) { - uloop_timeout_set(&state->setup_timeout, 1000); - kill(state->setup_task.uloop.pid, SIGTERM); - state->teardown_pending = true; + if (state->sm == S_TEARDOWN) return 0; + + if (state->script_task.uloop.pending) { + if (state->sm != S_SETUP_ABORT) { + uloop_timeout_set(&state->teardown_timeout, 1000); + kill(state->script_task.uloop.pid, SIGTERM); + if (state->proto_task.uloop.pending) + kill(state->proto_task.uloop.pid, SIGTERM); + state->sm = S_SETUP_ABORT; + } + return 0; + } + + action = "teardown"; + state->sm = S_TEARDOWN; + if (state->last_error >= 0) { + snprintf(error_buf, sizeof(error_buf), "ERROR=%d", state->last_error); + envp[j++] = error_buf; } + uloop_timeout_set(&state->teardown_timeout, 5000); } config = blobmsg_format_json(state->config, true); @@ -85,69 +197,123 @@ proto_shell_handler(struct interface_proto_state *proto, if (proto->iface->main_dev.dev) argv[i++] = proto->iface->main_dev.dev->ifname; argv[i] = NULL; + envp[j] = NULL; - ret = netifd_start_process(argv, NULL, proc); + ret = netifd_start_process(argv, envp, proc); free(config); return ret; } static void -proto_shell_setup_timeout_cb(struct uloop_timeout *timeout) +proto_shell_if_up_cb(struct interface_user *dep, struct interface *iface, + enum interface_event ev) { - struct proto_shell_state *state; + struct proto_shell_dependency *pdep; - state = container_of(timeout, struct proto_shell_state, setup_timeout); - kill(state->setup_task.uloop.pid, SIGKILL); + if (ev != IFEV_UP) + return; + + pdep = container_of(dep, struct proto_shell_dependency, dep); + proto_shell_update_host_dep(pdep); } static void -proto_shell_setup_cb(struct netifd_process *p, int ret) +proto_shell_if_down_cb(struct interface_user *dep, struct interface *iface, + enum interface_event ev) { + struct proto_shell_dependency *pdep; struct proto_shell_state *state; - state = container_of(p, struct proto_shell_state, setup_task); - uloop_timeout_cancel(&state->setup_timeout); - if (state->teardown_pending) { - state->teardown_pending = false; + if (ev == IFEV_UP || ev == IFEV_UPDATE) + return; + + pdep = container_of(dep, struct proto_shell_dependency, dep); + interface_remove_user(dep); + dep->cb = proto_shell_if_up_cb; + interface_add_user(dep, NULL); + + state = pdep->proto; + if (state->sm == S_IDLE) { + state->proto.proto_event(&state->proto, IFPEV_LINK_LOST); proto_shell_handler(&state->proto, PROTO_CMD_TEARDOWN, false); } } static void -proto_shell_teardown_cb(struct netifd_process *p, int ret) +proto_shell_task_finish(struct proto_shell_state *state, + struct netifd_process *task) { - struct proto_shell_state *state; + switch (state->sm) { + case S_IDLE: + if (task == &state->proto_task) + state->proto.proto_event(&state->proto, IFPEV_LINK_LOST); + /* fall through */ + case S_SETUP: + if (task == &state->proto_task) + proto_shell_handler(&state->proto, PROTO_CMD_TEARDOWN, + false); + break; + + case S_SETUP_ABORT: + if (state->script_task.uloop.pending || + state->proto_task.uloop.pending) + break; + + uloop_timeout_cancel(&state->teardown_timeout); + state->sm = S_IDLE; + proto_shell_handler(&state->proto, PROTO_CMD_TEARDOWN, false); + break; - state = container_of(p, struct proto_shell_state, teardown_task); + case S_TEARDOWN: + if (state->script_task.uloop.pending) + break; - if (state->teardown_wait_task) - return; + if (state->proto_task.uloop.pending) { + if (!state->proto_task_killed) + kill(state->proto_task.uloop.pid, SIGTERM); + break; + } + + uloop_timeout_cancel(&state->teardown_timeout); + state->sm = S_IDLE; + state->proto.proto_event(&state->proto, IFPEV_DOWN); + break; + } +} + +static void +proto_shell_teardown_timeout_cb(struct uloop_timeout *timeout) +{ + struct proto_shell_state *state; + + state = container_of(timeout, struct proto_shell_state, teardown_timeout); + netifd_kill_process(&state->script_task); netifd_kill_process(&state->proto_task); - state->proto.proto_event(&state->proto, IFPEV_DOWN); + proto_shell_task_finish(state, NULL); +} + +static void +proto_shell_script_cb(struct netifd_process *p, int ret) +{ + struct proto_shell_state *state; + + state = container_of(p, struct proto_shell_state, script_task); + proto_shell_task_finish(state, p); } static void proto_shell_task_cb(struct netifd_process *p, int ret) { struct proto_shell_state *state; - bool teardown_wait_task; state = container_of(p, struct proto_shell_state, proto_task); - teardown_wait_task = state->teardown_wait_task; - state->teardown_wait_task = false; - if (state->teardown_pending || state->teardown_task.uloop.pending) - return; + if (state->sm == S_IDLE || state->sm == S_SETUP) + state->last_error = WEXITSTATUS(ret); - if (teardown_wait_task) { - proto_shell_teardown_cb(&state->teardown_task, 0); - return; - } - - state->proto.proto_event(&state->proto, IFPEV_LINK_LOST); - proto_shell_handler(&state->proto, PROTO_CMD_TEARDOWN, false); + proto_shell_task_finish(state, p); } static void @@ -156,66 +322,72 @@ proto_shell_free(struct interface_proto_state *proto) struct proto_shell_state *state; state = container_of(proto, struct proto_shell_state, proto); + uloop_timeout_cancel(&state->teardown_timeout); + proto_shell_clear_host_dep(state); + netifd_kill_process(&state->script_task); + netifd_kill_process(&state->proto_task); free(state->config); free(state); } static void -proto_shell_parse_addr_list(struct interface_ip_settings *ip, struct blob_attr *attr, - bool v6, bool external) +proto_shell_parse_route_list(struct interface *iface, struct blob_attr *attr, + bool v6) { - struct device_addr *addr; struct blob_attr *cur; int rem; blobmsg_for_each_attr(cur, attr, rem) { - if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING) { - DPRINTF("Ignore wrong address type: %d\n", blobmsg_type(cur)); - continue; - } - - addr = proto_parse_ip_addr_string(blobmsg_data(cur), v6, v6 ? 32 : 128); - if (!addr) { - DPRINTF("Failed to parse IP address string: %s\n", (char *) blobmsg_data(cur)); + if (blobmsg_type(cur) != BLOBMSG_TYPE_TABLE) { + DPRINTF("Ignore wrong route type: %d\n", blobmsg_type(cur)); continue; } - if (external) - addr->flags |= DEVADDR_EXTERNAL; - - vlist_add(&ip->addr, &addr->node); + interface_ip_add_route(iface, cur, v6); } } static void -proto_shell_parse_route_list(struct interface *iface, struct blob_attr *attr, - bool v6) +proto_shell_parse_data(struct interface *iface, struct blob_attr *attr) { struct blob_attr *cur; int rem; - blobmsg_for_each_attr(cur, attr, rem) { - if (blobmsg_type(cur) != BLOBMSG_TYPE_TABLE) { - DPRINTF("Ignore wrong route type: %d\n", blobmsg_type(cur)); - continue; - } + blobmsg_for_each_attr(cur, attr, rem) + interface_add_data(iface, cur); +} - interface_ip_add_route(iface, cur, v6); - } +static struct device * +proto_shell_create_tunnel(const char *name, struct blob_attr *attr) +{ + struct device *dev; + struct blob_buf b; + + memset(&b, 0, sizeof(b)); + blob_buf_init(&b, 0); + blob_put(&b, 0, blobmsg_data(attr), blobmsg_data_len(attr)); + dev = device_create(name, &tunnel_device_type, blob_data(b.head)); + blob_buf_free(&b); + + return dev; } enum { NOTIFY_ACTION, + NOTIFY_ERROR, NOTIFY_COMMAND, NOTIFY_ENV, NOTIFY_SIGNAL, + NOTIFY_AVAILABLE, NOTIFY_LINK_UP, NOTIFY_IFNAME, NOTIFY_ADDR_EXT, - NOTIFY_IPADDR, - NOTIFY_IP6ADDR, NOTIFY_ROUTES, NOTIFY_ROUTES6, + NOTIFY_TUNNEL, + NOTIFY_DATA, + NOTIFY_KEEP, + NOTIFY_HOST, NOTIFY_DNS, NOTIFY_DNS_SEARCH, __NOTIFY_LAST @@ -223,27 +395,34 @@ enum { static const struct blobmsg_policy notify_attr[__NOTIFY_LAST] = { [NOTIFY_ACTION] = { .name = "action", .type = BLOBMSG_TYPE_INT32 }, + [NOTIFY_ERROR] = { .name = "error", .type = BLOBMSG_TYPE_ARRAY }, [NOTIFY_COMMAND] = { .name = "command", .type = BLOBMSG_TYPE_ARRAY }, [NOTIFY_ENV] = { .name = "env", .type = BLOBMSG_TYPE_ARRAY }, [NOTIFY_SIGNAL] = { .name = "signal", .type = BLOBMSG_TYPE_INT32 }, + [NOTIFY_AVAILABLE] = { .name = "available", .type = BLOBMSG_TYPE_BOOL }, [NOTIFY_LINK_UP] = { .name = "link-up", .type = BLOBMSG_TYPE_BOOL }, [NOTIFY_IFNAME] = { .name = "ifname", .type = BLOBMSG_TYPE_STRING }, [NOTIFY_ADDR_EXT] = { .name = "address-external", .type = BLOBMSG_TYPE_BOOL }, - [NOTIFY_IPADDR] = { .name = "ipaddr", .type = BLOBMSG_TYPE_ARRAY }, - [NOTIFY_IP6ADDR] = { .name = "ip6addr", .type = BLOBMSG_TYPE_ARRAY }, [NOTIFY_ROUTES] = { .name = "routes", .type = BLOBMSG_TYPE_ARRAY }, [NOTIFY_ROUTES6] = { .name = "routes6", .type = BLOBMSG_TYPE_ARRAY }, + [NOTIFY_TUNNEL] = { .name = "tunnel", .type = BLOBMSG_TYPE_TABLE }, + [NOTIFY_DATA] = { .name = "data", .type = BLOBMSG_TYPE_TABLE }, + [NOTIFY_KEEP] = { .name = "keep", .type = BLOBMSG_TYPE_BOOL }, + [NOTIFY_HOST] = { .name = "host", .type = BLOBMSG_TYPE_STRING }, [NOTIFY_DNS] = { .name = "dns", .type = BLOBMSG_TYPE_ARRAY }, [NOTIFY_DNS_SEARCH] = { .name = "dns_search", .type = BLOBMSG_TYPE_ARRAY }, }; static int -proto_shell_update_link(struct proto_shell_state *state, struct blob_attr **tb) +proto_shell_update_link(struct proto_shell_state *state, struct blob_attr *data, struct blob_attr **tb) { - struct interface_ip_settings *ip; + struct interface *iface = state->proto.iface; struct blob_attr *cur; + struct device *dev; + const char *devname; int dev_create = 1; bool addr_ext = false; + bool keep = false; bool up; if (!tb[NOTIFY_LINK_UP]) @@ -255,6 +434,9 @@ proto_shell_update_link(struct proto_shell_state *state, struct blob_attr **tb) return 0; } + if ((cur = tb[NOTIFY_KEEP]) != NULL) + keep = blobmsg_get_bool(cur); + if ((cur = tb[NOTIFY_ADDR_EXT]) != NULL) { addr_ext = blobmsg_get_bool(cur); if (addr_ext) @@ -262,26 +444,31 @@ proto_shell_update_link(struct proto_shell_state *state, struct blob_attr **tb) } if (!tb[NOTIFY_IFNAME]) { - if (!state->proto.iface->main_dev.dev) + if (!iface->main_dev.dev) return UBUS_STATUS_INVALID_ARGUMENT; - } else { - if (state->l3_dev.dev) - device_remove_user(&state->l3_dev); + } else if (!keep || iface->state != IFS_UP) { + keep = false; + devname = blobmsg_data(tb[NOTIFY_IFNAME]); + if (tb[NOTIFY_TUNNEL]) { + dev = proto_shell_create_tunnel(devname, + tb[NOTIFY_TUNNEL]); + if (!dev) + return UBUS_STATUS_INVALID_ARGUMENT; + } else { + dev = device_get(devname, dev_create); + if (!dev) + return UBUS_STATUS_NOT_FOUND; + } - device_add_user(&state->l3_dev, - device_get(blobmsg_data(tb[NOTIFY_IFNAME]), dev_create)); - state->proto.iface->l3_dev = &state->l3_dev; - device_claim(&state->l3_dev); + interface_set_l3_dev(iface, dev); + device_claim(&iface->l3_dev); + device_set_present(dev, true); } - ip = &state->proto.iface->proto_ip; - interface_update_start(state->proto.iface); - - if ((cur = tb[NOTIFY_IPADDR]) != NULL) - proto_shell_parse_addr_list(ip, cur, false, addr_ext); + if (!keep) + interface_update_start(iface); - if ((cur = tb[NOTIFY_IP6ADDR]) != NULL) - proto_shell_parse_addr_list(ip, cur, true, addr_ext); + proto_apply_ip_settings(iface, data, addr_ext); if ((cur = tb[NOTIFY_ROUTES]) != NULL) proto_shell_parse_route_list(state->proto.iface, cur, false); @@ -289,15 +476,20 @@ proto_shell_update_link(struct proto_shell_state *state, struct blob_attr **tb) if ((cur = tb[NOTIFY_ROUTES6]) != NULL) proto_shell_parse_route_list(state->proto.iface, cur, true); - if ((cur = tb[NOTIFY_DNS]) != NULL) - interface_add_dns_server_list(ip, cur); + if ((cur = tb[NOTIFY_DNS])) + interface_add_dns_server_list(&iface->proto_ip, cur); - if ((cur = tb[NOTIFY_DNS_SEARCH]) != NULL) - interface_add_dns_search_list(ip, cur); + if ((cur = tb[NOTIFY_DNS_SEARCH])) + interface_add_dns_search_list(&iface->proto_ip, cur); interface_update_complete(state->proto.iface); - state->proto.proto_event(&state->proto, IFPEV_UP); + if (!keep) + state->proto.proto_event(&state->proto, IFPEV_UP); + state->sm = S_IDLE; + + if ((cur = tb[NOTIFY_DATA])) + proto_shell_parse_data(state->proto.iface, cur); return 0; } @@ -332,8 +524,8 @@ out: static int proto_shell_run_command(struct proto_shell_state *state, struct blob_attr **tb) { - char *argv[64]; - char *env[32]; + static char *argv[64]; + static char *env[32]; if (!tb[NOTIFY_COMMAND]) goto error; @@ -364,14 +556,120 @@ proto_shell_kill_command(struct proto_shell_state *state, struct blob_attr **tb) signal = SIGTERM; if (state->proto_task.uloop.pending) { + state->proto_task_killed = true; kill(state->proto_task.uloop.pid, signal); - state->teardown_wait_task = true; } return 0; } static int +proto_shell_notify_error(struct proto_shell_state *state, struct blob_attr **tb) +{ + struct blob_attr *cur; + char *data[16]; + int n_data = 0; + int rem; + + if (!tb[NOTIFY_ERROR]) + return UBUS_STATUS_INVALID_ARGUMENT; + + blobmsg_for_each_attr(cur, tb[NOTIFY_ERROR], rem) { + if (n_data + 1 == ARRAY_SIZE(data)) + goto error; + + if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING) + goto error; + + if (!blobmsg_check_attr(cur, NULL)) + goto error; + + data[n_data++] = blobmsg_data(cur); + } + + if (!n_data) + goto error; + + interface_add_error(state->proto.iface, state->handler->proto.name, + data[0], (const char **) &data[1], n_data - 1); + + return 0; + +error: + return UBUS_STATUS_INVALID_ARGUMENT; +} + +static int +proto_shell_block_restart(struct proto_shell_state *state, struct blob_attr **tb) +{ + state->proto.iface->autostart = false; + return 0; +} + +static int +proto_shell_set_available(struct proto_shell_state *state, struct blob_attr **tb) +{ + if (!tb[NOTIFY_AVAILABLE]) + return UBUS_STATUS_INVALID_ARGUMENT; + + interface_set_available(state->proto.iface, blobmsg_get_bool(tb[NOTIFY_AVAILABLE])); + return 0; +} + +static int +proto_shell_add_host_dependency(struct proto_shell_state *state, struct blob_attr **tb) +{ + struct proto_shell_dependency *dep; + struct blob_attr *host = tb[NOTIFY_HOST]; + struct blob_attr *ifname = tb[NOTIFY_IFNAME]; + size_t ifnamelen = (ifname) ? blobmsg_data_len(ifname) : 1; + + if (!host) + return UBUS_STATUS_INVALID_ARGUMENT; + + dep = calloc(1, sizeof(*dep) + ifnamelen); + if (inet_pton(AF_INET, blobmsg_data(host), &dep->host) < 1) { + if (inet_pton(AF_INET6, blobmsg_data(host), &dep->host) < 1) { + free(dep); + return UBUS_STATUS_INVALID_ARGUMENT; + } else { + dep->v6 = true; + } + } + + dep->proto = state; + if (ifname) + memcpy(dep->interface, blobmsg_data(ifname), ifnamelen); + else + dep->interface[0] = 0; + + dep->dep.cb = proto_shell_if_up_cb; + interface_add_user(&dep->dep, NULL); + list_add(&dep->list, &state->deps); + proto_shell_update_host_dep(dep); + if (!dep->dep.iface) + return UBUS_STATUS_NOT_FOUND; + + return 0; +} + +static int +proto_shell_setup_failed(struct proto_shell_state *state) +{ + switch (state->sm) { + case S_IDLE: + state->proto.proto_event(&state->proto, IFPEV_LINK_LOST); + /* fall through */ + case S_SETUP: + proto_shell_handler(&state->proto, PROTO_CMD_TEARDOWN, false); + break; + default: + break; + } + return 0; +} + +static int proto_shell_notify(struct interface_proto_state *proto, struct blob_attr *attr) { struct proto_shell_state *state; @@ -385,11 +683,21 @@ proto_shell_notify(struct interface_proto_state *proto, struct blob_attr *attr) switch(blobmsg_get_u32(tb[NOTIFY_ACTION])) { case 0: - return proto_shell_update_link(state, tb); + return proto_shell_update_link(state, attr, tb); case 1: return proto_shell_run_command(state, tb); case 2: return proto_shell_kill_command(state, tb); + case 3: + return proto_shell_notify_error(state, tb); + case 4: + return proto_shell_block_restart(state, tb); + case 5: + return proto_shell_set_available(state, tb); + case 6: + return proto_shell_add_host_dependency(state, tb); + case 7: + return proto_shell_setup_failed(state); default: return UBUS_STATUS_INVALID_ARGUMENT; } @@ -402,6 +710,8 @@ proto_shell_attach(const struct proto_handler *h, struct interface *iface, struct proto_shell_state *state; state = calloc(1, sizeof(*state)); + INIT_LIST_HEAD(&state->deps); + state->config = malloc(blob_pad_len(attr)); if (!state->config) goto error; @@ -410,15 +720,12 @@ proto_shell_attach(const struct proto_handler *h, struct interface *iface, state->proto.free = proto_shell_free; state->proto.notify = proto_shell_notify; state->proto.cb = proto_shell_handler; - state->setup_timeout.cb = proto_shell_setup_timeout_cb; - state->setup_task.cb = proto_shell_setup_cb; - state->setup_task.dir_fd = proto_fd.fd; - state->setup_task.log_prefix = iface->name; - state->teardown_task.cb = proto_shell_teardown_cb; - state->teardown_task.dir_fd = proto_fd.fd; - state->teardown_task.log_prefix = iface->name; + state->teardown_timeout.cb = proto_shell_teardown_timeout_cb; + state->script_task.cb = proto_shell_script_cb; + state->script_task.dir_fd = proto_fd; + state->script_task.log_prefix = iface->name; state->proto_task.cb = proto_shell_task_cb; - state->proto_task.dir_fd = proto_fd.fd; + state->proto_task.dir_fd = proto_fd; state->proto_task.log_prefix = iface->name; state->handler = container_of(h, struct proto_shell_handler, proto); @@ -448,7 +755,7 @@ get_field(json_object *obj, const char *name, json_type type) } static char * -proto_shell_parse_config(struct config_param_list *config, json_object *obj) +proto_shell_parse_config(struct uci_blob_param_list *config, json_object *obj) { struct blobmsg_policy *attrs; char *str_buf, *str_cur; @@ -522,15 +829,12 @@ proto_shell_add_handler(const char *script, json_object *obj) name = json_object_get_string(tmp); - handler = calloc(1, sizeof(*handler) + - strlen(script) + 1 + - strlen(name) + 1); + handler = calloc_a(sizeof(*handler) + strlen(script) + 1, + &str, strlen(name) + 1); if (!handler) return; strcpy(handler->script_name, script); - - str = handler->script_name + strlen(handler->script_name) + 1; strcpy(str, name); proto = &handler->proto; @@ -542,6 +846,10 @@ proto_shell_add_handler(const char *script, json_object *obj) if (tmp && json_object_get_boolean(tmp)) handler->proto.flags |= PROTO_FLAG_NODEV; + tmp = get_field(obj, "available", json_type_boolean); + if (tmp && json_object_get_boolean(tmp)) + handler->proto.flags |= PROTO_FLAG_INIT_AVAILABLE; + config = get_field(obj, "config", json_type_array); if (config) handler->config_buf = proto_shell_parse_config(&handler->config, config); @@ -614,11 +922,11 @@ static void __init proto_shell_init(void) if (chdir("./proto")) goto close_cur; - proto_fd.fd = open(".", O_RDONLY | O_DIRECTORY); - if (proto_fd.fd < 0) + proto_fd = open(".", O_RDONLY | O_DIRECTORY); + if (proto_fd < 0) goto close_cur; - netifd_fd_add(&proto_fd); + system_fd_set_cloexec(proto_fd); glob("./*.sh", 0, NULL, &g); for (i = 0; i < g.gl_pathc; i++) proto_shell_add_script(g.gl_pathv[i]);