X-Git-Url: http://git.archive.openwrt.org/?p=project%2Fnetifd.git;a=blobdiff_plain;f=proto-shell.c;h=b5d436ad7b743f501936c8462cd9a2310feacfa8;hp=1481b66e2773aee616c3b6c3e3c200b6c198f484;hb=b7d1c27b752df3e6c5dfe6a5b789d6cb0c87d0f6;hpb=924d9c4e48ed2044efe712eac9cd170f4da4b447 diff --git a/proto-shell.c b/proto-shell.c index 1481b66..b5d436a 100644 --- a/proto-shell.c +++ b/proto-shell.c @@ -1,3 +1,5 @@ +#define _GNU_SOURCE + #include #include #include @@ -6,6 +8,9 @@ #include #include +#include +#include + #include #include "netifd.h" @@ -13,14 +18,21 @@ #include "interface-ip.h" #include "proto.h" -static LIST_HEAD(handlers); -static int proto_fd; +static struct netifd_fd proto_fd; + +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; char *config_buf; + bool init_available; char script_name[]; }; @@ -29,45 +41,16 @@ struct proto_shell_state { struct proto_shell_handler *handler; struct blob_attr *config; - struct device_user l3_dev; + struct uloop_timeout teardown_timeout; - struct uloop_timeout setup_timeout; - struct uloop_process setup_task; - struct uloop_process teardown_task; - bool teardown_pending; -}; + struct netifd_process script_task; + struct netifd_process proto_task; -static int -run_script(const char **argv, struct uloop_process *proc) -{ - int pid; - - if ((pid = fork()) < 0) - return -1; - - if (!pid) { - fchdir(proto_fd); - execvp(argv[0], (char **) argv); - exit(127); - } - - if (pid < 0) - return -1; - - proc->pid = pid; - uloop_process_add(proc); - - return 0; -} - -static void -proto_shell_set_down(struct proto_shell_state *state) -{ - if (!state->l3_dev.dev) - return; + enum proto_shell_sm sm; + bool proto_task_killed; - device_remove_user(&state->l3_dev); -} + int last_error; +}; static int proto_shell_handler(struct interface_proto_state *proto, @@ -75,27 +58,43 @@ proto_shell_handler(struct interface_proto_state *proto, { struct proto_shell_state *state; struct proto_shell_handler *handler; - struct uloop_process *proc; - const char *argv[6]; + struct netifd_process *proc; + 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; } else { - action = "teardown"; - proc = &state->teardown_task; - if (state->setup_task.pending) { - uloop_timeout_set(&state->setup_timeout, 1000); - kill(state->setup_task.pid, SIGINT); - 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); @@ -110,43 +109,88 @@ 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 = run_script(argv, 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_task_finish(struct proto_shell_state *state, + struct netifd_process *task) +{ + 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; + + case S_TEARDOWN: + if (state->script_task.uloop.pending) + break; + + 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, setup_timeout); - kill(state->setup_task.pid, SIGKILL); + state = container_of(timeout, struct proto_shell_state, teardown_timeout); + + netifd_kill_process(&state->script_task); + netifd_kill_process(&state->proto_task); + proto_shell_task_finish(state, NULL); } static void -proto_shell_setup_cb(struct uloop_process *p, int ret) +proto_shell_script_cb(struct netifd_process *p, int ret) { 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 = 0; - proto_shell_handler(&state->proto, PROTO_CMD_TEARDOWN, false); - } + state = container_of(p, struct proto_shell_state, script_task); + proto_shell_task_finish(state, p); } static void -proto_shell_teardown_cb(struct uloop_process *p, int ret) +proto_shell_task_cb(struct netifd_process *p, int ret) { struct proto_shell_state *state; - state = container_of(p, struct proto_shell_state, teardown_task); - proto_shell_set_down(state); - state->proto.proto_event(&state->proto, IFPEV_DOWN); + state = container_of(p, struct proto_shell_state, proto_task); + + if (state->sm == S_IDLE || state->sm == S_SETUP) + state->last_error = WEXITSTATUS(ret); + + proto_shell_task_finish(state, p); } static void @@ -155,52 +199,290 @@ proto_shell_free(struct interface_proto_state *proto) struct proto_shell_state *state; state = container_of(proto, struct proto_shell_state, proto); + netifd_kill_process(&state->script_task); + netifd_kill_process(&state->proto_task); free(state->config); free(state); } +static void +proto_shell_parse_route_list(struct interface *iface, struct blob_attr *attr, + bool v6) +{ + 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; + } + + 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_ROUTES, + NOTIFY_ROUTES6, + NOTIFY_TUNNEL, __NOTIFY_LAST }; 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_ROUTES] = { .name = "routes", .type = BLOBMSG_TYPE_ARRAY }, + [NOTIFY_ROUTES6] = { .name = "routes6", .type = BLOBMSG_TYPE_ARRAY }, + [NOTIFY_TUNNEL] = { .name = "tunnel", .type = BLOBMSG_TYPE_TABLE }, }; static int -proto_shell_notify(struct interface_proto_state *proto, struct blob_attr *attr) +proto_shell_update_link(struct proto_shell_state *state, struct blob_attr *data, struct blob_attr **tb) { - struct proto_shell_state *state; - struct blob_attr *tb[__NOTIFY_LAST]; + 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 up; - state = container_of(proto, struct proto_shell_state, proto); - - blobmsg_parse(notify_attr, __NOTIFY_LAST, tb, blob_data(attr), blob_len(attr)); if (!tb[NOTIFY_LINK_UP]) return UBUS_STATUS_INVALID_ARGUMENT; up = blobmsg_get_bool(tb[NOTIFY_LINK_UP]); - if (up) { - if (!tb[NOTIFY_IFNAME]) - return UBUS_STATUS_INVALID_ARGUMENT; + if (!up) { + state->proto.proto_event(&state->proto, IFPEV_LINK_LOST); + return 0; + } + + if ((cur = tb[NOTIFY_ADDR_EXT]) != NULL) { + addr_ext = blobmsg_get_bool(cur); + if (addr_ext) + dev_create = 2; + } - device_add_user(&state->l3_dev, - device_get(blobmsg_data(tb[NOTIFY_IFNAME]), true)); - device_claim(&state->l3_dev); - state->proto.iface->l3_dev = &state->l3_dev; - state->proto.proto_event(&state->proto, IFPEV_UP); + if (!tb[NOTIFY_IFNAME]) { + if (!iface->main_dev.dev) + return UBUS_STATUS_INVALID_ARGUMENT; } else { - proto_shell_set_down(state); + 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; + } + + interface_set_l3_dev(iface, dev); + device_claim(&iface->l3_dev); } + interface_update_start(iface); + proto_apply_ip_settings(iface, data, addr_ext); + + if ((cur = tb[NOTIFY_ROUTES]) != NULL) + proto_shell_parse_route_list(state->proto.iface, cur, false); + + if ((cur = tb[NOTIFY_ROUTES6]) != NULL) + proto_shell_parse_route_list(state->proto.iface, cur, true); + + interface_update_complete(state->proto.iface); + + state->proto.proto_event(&state->proto, IFPEV_UP); + return 0; } -struct interface_proto_state * +static bool +fill_string_list(struct blob_attr *attr, char **argv, int max) +{ + struct blob_attr *cur; + int argc = 0; + int rem; + + if (!attr) + goto out; + + blobmsg_for_each_attr(cur, attr, rem) { + if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING) + return false; + + if (!blobmsg_check_attr(cur, NULL)) + return false; + + argv[argc++] = blobmsg_data(cur); + if (argc == max - 1) + return false; + } + +out: + argv[argc] = NULL; + return true; +} + +static int +proto_shell_run_command(struct proto_shell_state *state, struct blob_attr **tb) +{ + static char *argv[64]; + static char *env[32]; + + if (!tb[NOTIFY_COMMAND]) + goto error; + + if (!fill_string_list(tb[NOTIFY_COMMAND], argv, ARRAY_SIZE(argv))) + goto error; + + if (!fill_string_list(tb[NOTIFY_ENV], env, ARRAY_SIZE(env))) + goto error; + + netifd_start_process((const char **) argv, (char **) env, &state->proto_task); + + return 0; + +error: + return UBUS_STATUS_INVALID_ARGUMENT; +} + +static int +proto_shell_kill_command(struct proto_shell_state *state, struct blob_attr **tb) +{ + unsigned int signal = ~0; + + if (tb[NOTIFY_SIGNAL]) + signal = blobmsg_get_u32(tb[NOTIFY_SIGNAL]); + + if (signal > 31) + signal = SIGTERM; + + if (state->proto_task.uloop.pending) { + state->proto_task_killed = true; + kill(state->proto_task.uloop.pid, signal); + } + + 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_notify(struct interface_proto_state *proto, struct blob_attr *attr) +{ + struct proto_shell_state *state; + struct blob_attr *tb[__NOTIFY_LAST]; + + state = container_of(proto, struct proto_shell_state, proto); + + blobmsg_parse(notify_attr, __NOTIFY_LAST, tb, blob_data(attr), blob_len(attr)); + if (!tb[NOTIFY_ACTION]) + return UBUS_STATUS_INVALID_ARGUMENT; + + switch(blobmsg_get_u32(tb[NOTIFY_ACTION])) { + case 0: + 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); + default: + return UBUS_STATUS_INVALID_ARGUMENT; + } +} + +static struct interface_proto_state * proto_shell_attach(const struct proto_handler *h, struct interface *iface, struct blob_attr *attr) { @@ -215,9 +497,13 @@ 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->teardown_task.cb = proto_shell_teardown_cb; + state->teardown_timeout.cb = proto_shell_teardown_timeout_cb; + state->script_task.cb = proto_shell_script_cb; + state->script_task.dir_fd = proto_fd.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.log_prefix = iface->name; state->handler = container_of(h, struct proto_shell_handler, proto); return &state->proto; @@ -253,11 +539,11 @@ proto_shell_parse_config(struct config_param_list *config, json_object *obj) int str_len = 0; int i; - attrs = calloc(1, sizeof(*attrs)); + config->n_params = json_object_array_length(obj); + attrs = calloc(1, sizeof(*attrs) * config->n_params); if (!attrs) return NULL; - config->n_params = json_object_array_length(obj); config->params = attrs; for (i = 0; i < config->n_params; i++) { json_object *cur, *name, *type; @@ -279,7 +565,7 @@ proto_shell_parse_config(struct config_param_list *config, json_object *obj) if (attrs[i].type > BLOBMSG_TYPE_LAST) goto error; - str_len += strlen(attrs[i].name + 1); + str_len += strlen(attrs[i].name) + 1; } str_buf = malloc(str_len); @@ -340,6 +626,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); @@ -353,9 +643,9 @@ static void proto_shell_add_script(const char *name) struct json_tokener *tok = NULL; json_object *obj; static char buf[512]; - char *start, *end, *cmd; + char *start, *cmd; FILE *f; - int buflen, len; + int len; #define DUMP_SUFFIX " '' dump" @@ -367,33 +657,25 @@ static void proto_shell_add_script(const char *name) return; do { - buflen = fread(buf, 1, sizeof(buf) - 1, f); - if (buflen <= 0) + start = fgets(buf, sizeof(buf), f); + if (!start) continue; - start = buf; - len = buflen; - do { - end = memchr(start, '\n', len); - if (end) - len = end - start; - - if (!tok) - tok = json_tokener_new(); - - obj = json_tokener_parse_ex(tok, start, len); - if (!is_error(obj)) { - proto_shell_add_handler(name, obj); - json_object_put(obj); - json_tokener_free(tok); - tok = NULL; - } + len = strlen(start); - if (end) { - start = end + 1; - len = buflen - (start - buf); - } - } while (len > 0); + if (!tok) + tok = json_tokener_new(); + + obj = json_tokener_parse_ex(tok, start, len); + if (!is_error(obj)) { + proto_shell_add_handler(name, obj); + json_object_put(obj); + json_tokener_free(tok); + tok = NULL; + } else if (start[len - 1] == '\n') { + json_tokener_free(tok); + tok = NULL; + } } while (!feof(f) && !ferror(f)); if (tok) @@ -402,7 +684,7 @@ static void proto_shell_add_script(const char *name) pclose(f); } -void __init proto_shell_init(void) +static void __init proto_shell_init(void) { glob_t g; int main_fd; @@ -420,10 +702,11 @@ void __init proto_shell_init(void) if (chdir("./proto")) goto close_cur; - proto_fd = open(".", O_RDONLY | O_DIRECTORY); - if (proto_fd < 0) + proto_fd.fd = open(".", O_RDONLY | O_DIRECTORY); + if (proto_fd.fd < 0) goto close_cur; + netifd_fd_add(&proto_fd); glob("./*.sh", 0, NULL, &g); for (i = 0; i < g.gl_pathc; i++) proto_shell_add_script(g.gl_pathv[i]);