X-Git-Url: http://git.archive.openwrt.org/?a=blobdiff_plain;ds=sidebyside;f=proto-shell.c;h=c90f65c7004a7cf57fb17b45339d866d07543acc;hb=c000b546d97aa97144ee2cdf396d46a039bb7f98;hp=7eeff2892f676dc82f6b3cc856f40c6211a775e5;hpb=958012387b5bd493ea5fdabe815e9f4fd4e55dc5;p=project%2Fnetifd.git diff --git a/proto-shell.c b/proto-shell.c index 7eeff28..c90f65c 100644 --- a/proto-shell.c +++ b/proto-shell.c @@ -1,3 +1,5 @@ +#define _GNU_SOURCE + #include #include #include @@ -37,13 +39,28 @@ struct proto_shell_state { struct uloop_process setup_task; struct uloop_process teardown_task; bool teardown_pending; + bool teardown_wait_task; + + struct uloop_process proto_task; }; +static void +kill_process(struct uloop_process *proc) +{ + if (!proc->pending) + return; + + kill(proc->pid, SIGTERM); + uloop_process_delete(proc); +} + static int -run_script(const char **argv, struct uloop_process *proc) +start_process(const char **argv, struct uloop_process *proc) { int pid; + kill_process(proc); + if ((pid = fork()) < 0) return -1; @@ -83,9 +100,9 @@ proto_shell_handler(struct interface_proto_state *proto, } else { action = "teardown"; proc = &state->teardown_task; - if (state->setup_task.pending) { + if (state->setup_task.pending && !state->teardown_wait_task) { uloop_timeout_set(&state->setup_timeout, 1000); - kill(state->setup_task.pid, SIGINT); + kill(state->setup_task.pid, SIGTERM); state->teardown_pending = true; return 0; } @@ -104,7 +121,7 @@ proto_shell_handler(struct interface_proto_state *proto, argv[i++] = proto->iface->main_dev.dev->ifname; argv[i] = NULL; - ret = run_script(argv, proc); + ret = start_process(argv, proc); free(config); return ret; @@ -138,9 +155,38 @@ proto_shell_teardown_cb(struct uloop_process *p, int ret) struct proto_shell_state *state; state = container_of(p, struct proto_shell_state, teardown_task); - state->proto.proto_event(&state->proto, IFPEV_DOWN); + + if (state->teardown_wait_task) + return; + + kill_process(&state->proto_task); + if (state->l3_dev.dev) device_remove_user(&state->l3_dev); + + state->proto.proto_event(&state->proto, IFPEV_DOWN); +} + +static void +proto_shell_task_cb(struct uloop_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.pending) + return; + + 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); } static void @@ -190,7 +236,7 @@ enum { static const struct blobmsg_policy route_attr[__ROUTE_LAST] = { [ROUTE_TARGET] = { .name = "target", .type = BLOBMSG_TYPE_STRING }, - [ROUTE_MASK] = { .name = "mask", .type = BLOBMSG_TYPE_INT32 }, + [ROUTE_MASK] = { .name = "mask", .type = BLOBMSG_TYPE_STRING }, [ROUTE_GATEWAY] = { .name = "gateway", .type = BLOBMSG_TYPE_STRING }, [ROUTE_DEVICE] = { .name = "device", .type = BLOBMSG_TYPE_STRING }, }; @@ -261,6 +307,9 @@ proto_shell_parse_route_list(struct interface *iface, struct blob_attr *attr, enum { + NOTIFY_ACTION, + NOTIFY_COMMAND, + NOTIFY_SIGNAL, NOTIFY_LINK_UP, NOTIFY_IFNAME, NOTIFY_ADDR_EXT, @@ -268,10 +317,14 @@ enum { NOTIFY_IP6ADDR, NOTIFY_ROUTES, NOTIFY_ROUTES6, + NOTIFY_DNS, __NOTIFY_LAST }; static const struct blobmsg_policy notify_attr[__NOTIFY_LAST] = { + [NOTIFY_ACTION] = { .name = "action", .type = BLOBMSG_TYPE_INT32 }, + [NOTIFY_COMMAND] = { .name = "command", .type = BLOBMSG_TYPE_ARRAY }, + [NOTIFY_SIGNAL] = { .name = "signal", .type = BLOBMSG_TYPE_INT32 }, [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 }, @@ -279,38 +332,37 @@ static const struct blobmsg_policy notify_attr[__NOTIFY_LAST] = { [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_DNS] = { .name = "dns", .type = BLOBMSG_TYPE_ARRAY }, }; 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 **tb) { - struct proto_shell_state *state; - struct blob_attr *tb[__NOTIFY_LAST], *cur; + struct blob_attr *cur; 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 (!state->l3_dev.dev) { - 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); - } else { + if (!up) { state->proto.proto_event(&state->proto, IFPEV_LINK_LOST); + return 0; } + if (!tb[NOTIFY_IFNAME]) { + if (!state->proto.iface->main_dev.dev) + return UBUS_STATUS_INVALID_ARGUMENT; + } else if (!state->l3_dev.dev) { + 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; + } + + interface_ip_update_start(state->proto.iface); + if ((cur = tb[NOTIFY_ADDR_EXT]) != NULL) addr_ext = blobmsg_get_bool(cur); @@ -326,9 +378,90 @@ proto_shell_notify(struct interface_proto_state *proto, struct blob_attr *attr) 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(state->proto.iface, cur); + + interface_ip_update_complete(state->proto.iface); + + state->proto.proto_event(&state->proto, IFPEV_UP); + + return 0; +} + +static int +proto_shell_run_command(struct proto_shell_state *state, struct blob_attr **tb) +{ + struct blob_attr *cur; + char *argv[64]; + int argc = 0; + int rem; + + if (!tb[NOTIFY_COMMAND]) + goto error; + + blobmsg_for_each_attr(cur, tb[NOTIFY_COMMAND], rem) { + if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING) + goto error; + + if (!blobmsg_check_attr(cur, NULL)) + goto error; + + argv[argc++] = blobmsg_data(cur); + if (argc == ARRAY_SIZE(argv) - 1) + goto error; + } + argv[argc] = NULL; + start_process((const char **) argv, &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.pending) { + kill(state->proto_task.pid, signal); + state->teardown_wait_task = true; + } + 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, tb); + case 1: + return proto_shell_run_command(state, tb); + case 2: + return proto_shell_kill_command(state, tb); + default: + return UBUS_STATUS_INVALID_ARGUMENT; + } +} + struct interface_proto_state * proto_shell_attach(const struct proto_handler *h, struct interface *iface, struct blob_attr *attr) @@ -347,6 +480,7 @@ proto_shell_attach(const struct proto_handler *h, struct interface *iface, 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->proto_task.cb = proto_shell_task_cb; state->handler = container_of(h, struct proto_shell_handler, proto); return &state->proto;