X-Git-Url: http://git.archive.openwrt.org/?p=project%2Fnetifd.git;a=blobdiff_plain;f=interface.c;h=331eaa197cca5d877b76c266187135c658df1a76;hp=eb2f754420f28f90c9b8c742279741e33b80ba61;hb=120cd39654a33401423f1b65bb19e12681a6e46f;hpb=d6ea48d146b4fa2905afa4acc2ff34b37ce5a623 diff --git a/interface.c b/interface.c index eb2f754..331eaa1 100644 --- a/interface.c +++ b/interface.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. + */ #include #include #include @@ -9,13 +22,20 @@ #include "proto.h" #include "ubus.h" #include "config.h" +#include "system.h" struct vlist_tree interfaces; +static LIST_HEAD(iface_all_users); enum { IFACE_ATTR_IFNAME, IFACE_ATTR_PROTO, IFACE_ATTR_AUTO, + IFACE_ATTR_DEFAULTROUTE, + IFACE_ATTR_PEERDNS, + IFACE_ATTR_DNS, + IFACE_ATTR_DNS_SEARCH, + IFACE_ATTR_METRIC, IFACE_ATTR_MAX }; @@ -23,11 +43,21 @@ static const struct blobmsg_policy iface_attrs[IFACE_ATTR_MAX] = { [IFACE_ATTR_PROTO] = { .name = "proto", .type = BLOBMSG_TYPE_STRING }, [IFACE_ATTR_IFNAME] = { .name = "ifname", .type = BLOBMSG_TYPE_STRING }, [IFACE_ATTR_AUTO] = { .name = "auto", .type = BLOBMSG_TYPE_BOOL }, + [IFACE_ATTR_DEFAULTROUTE] = { .name = "defaultroute", .type = BLOBMSG_TYPE_BOOL }, + [IFACE_ATTR_PEERDNS] = { .name = "peerdns", .type = BLOBMSG_TYPE_BOOL }, + [IFACE_ATTR_METRIC] = { .name = "metric", .type = BLOBMSG_TYPE_INT32 }, + [IFACE_ATTR_DNS] = { .name = "dns", .type = BLOBMSG_TYPE_ARRAY }, + [IFACE_ATTR_DNS_SEARCH] = { .name = "dns_search", .type = BLOBMSG_TYPE_ARRAY }, +}; + +static const union config_param_info iface_attr_info[IFACE_ATTR_MAX] = { + [IFACE_ATTR_DNS] = { .type = BLOBMSG_TYPE_STRING }, }; const struct config_param_list interface_attr_list = { .n_params = IFACE_ATTR_MAX, .params = iface_attrs, + .info = iface_attr_info, }; static void @@ -76,47 +106,76 @@ void interface_add_error(struct interface *iface, const char *subsystem, } static void -interface_event(struct interface *iface, enum interface_event ev) +interface_data_del(struct interface *iface, struct interface_data *data) { - /* TODO */ + avl_delete(&iface->data, &data->node); + free(data); } static void -mark_interface_down(struct interface *iface) +interface_data_flush(struct interface *iface) { - vlist_flush_all(&iface->proto_addr); - vlist_flush_all(&iface->proto_route); - if (iface->main_dev.dev) - device_release(&iface->main_dev); - iface->state = IFS_DOWN; + struct interface_data *d, *tmp; + + avl_for_each_element_safe(&iface->data, d, node, tmp) + interface_data_del(iface, d); } -static int -__interface_set_up(struct interface *iface) +int +interface_add_data(struct interface *iface, const struct blob_attr *data) { - int ret; + struct interface_data *n, *o; - if (iface->state != IFS_DOWN) - return 0; + if (!blobmsg_check_attr(data, true)) + return UBUS_STATUS_INVALID_ARGUMENT; - if (iface->main_dev.dev) { - ret = device_claim(&iface->main_dev); - if (ret) - return ret; - } + n = calloc(1, sizeof(*n) + blob_pad_len(data)); + memcpy(n->data, data, blob_pad_len(data)); + n->node.key = blobmsg_name(data); - iface->state = IFS_SETUP; - ret = interface_proto_event(iface->proto, PROTO_CMD_SETUP, false); - if (ret) { - mark_interface_down(iface); - return ret; - } + o = avl_find_element(&iface->data, n->node.key, o, node); + if (o) + interface_data_del(iface, o); + avl_insert(&iface->data, &n->node); return 0; +} + +static void +interface_event(struct interface *iface, enum interface_event ev) +{ + struct interface_user *dep, *tmp; + list_for_each_entry_safe(dep, tmp, &iface->users, list) + dep->cb(dep, iface, ev); + + list_for_each_entry_safe(dep, tmp, &iface_all_users, list) + dep->cb(dep, iface, ev); } static void +interface_flush_state(struct interface *iface) +{ + if (iface->main_dev.dev) + device_release(&iface->main_dev); + if (iface->l3_dev.dev) + device_release(&iface->l3_dev); + interface_data_flush(iface); +} + +static void +mark_interface_down(struct interface *iface) +{ + if (iface->state == IFS_UP) + interface_event(iface, IFEV_DOWN); + interface_ip_set_enabled(&iface->config_ip, false); + interface_ip_flush(&iface->proto_ip); + interface_flush_state(iface); + system_flush_routes(); + iface->state = IFS_DOWN; +} + +void __interface_set_down(struct interface *iface, bool force) { interface_clear_errors(iface); @@ -125,9 +184,12 @@ __interface_set_down(struct interface *iface, bool force) iface->state == IFS_TEARDOWN) return; + if (iface->state == IFS_UP) + interface_event(iface, IFEV_DOWN); iface->state = IFS_TEARDOWN; - interface_event(iface, IFEV_DOWN); interface_proto_event(iface->proto, PROTO_CMD_TEARDOWN, force); + if (force) + interface_flush_state(iface); } static void @@ -167,48 +229,78 @@ interface_set_available(struct interface *iface, bool new_state) __interface_set_down(iface, true); } +void +interface_add_user(struct interface_user *dep, struct interface *iface) +{ + if (!iface) { + list_add(&dep->list, &iface_all_users); + return; + } + + dep->iface = iface; + list_add(&dep->list, &iface->users); + if (iface->state == IFS_UP) + dep->cb(dep, iface, IFEV_UP); +} + +void +interface_remove_user(struct interface_user *dep) +{ + list_del_init(&dep->list); + dep->iface = NULL; +} + static void interface_claim_device(struct interface *iface) { struct device *dev; - if (iface->proto_handler && + if (iface->ifname && !(iface->proto_handler->flags & PROTO_FLAG_NODEV)) { dev = device_get(iface->ifname, true); if (dev) - device_add_user(&iface->main_dev, dev); + interface_set_main_dev(iface, dev); } + if (iface->proto_handler->flags & PROTO_FLAG_INIT_AVAILABLE) + interface_set_available(iface, true); } static void -interface_cleanup(struct interface *iface) +interface_cleanup(struct interface *iface, bool reload) { + struct interface_user *dep, *tmp; + + list_for_each_entry_safe(dep, tmp, &iface->users, list) + interface_remove_user(dep); + + interface_ip_flush(&iface->config_ip); + interface_flush_state(iface); interface_clear_errors(iface); - if (iface->main_dev.dev) - device_remove_user(&iface->main_dev); + if (iface->main_dev.dev && + (!reload || !iface->main_dev.hotplug)) + interface_set_main_dev(iface, NULL); interface_set_proto_state(iface, NULL); } static void interface_do_free(struct interface *iface) { - interface_cleanup(iface); + interface_event(iface, IFEV_FREE); + interface_cleanup(iface, false); free(iface->config); netifd_ubus_remove_interface(iface); + avl_delete(&interfaces.avl, &iface->node.avl); free(iface); } static void interface_do_reload(struct interface *iface) { - interface_cleanup(iface); - - interface_claim_device(iface); + interface_event(iface, IFEV_RELOAD); + interface_cleanup(iface, true); proto_init_interface(iface, iface->config); - - if (iface->autostart && !config_init) - interface_set_up(iface); + interface_claim_device(iface); } static void @@ -222,8 +314,10 @@ interface_handle_config_change(struct interface *iface) break; case IFC_REMOVE: interface_do_free(iface); - break; + return; } + if (iface->autostart && iface->available) + interface_set_up(iface); } static void @@ -236,13 +330,19 @@ interface_proto_cb(struct interface_proto_state *state, enum interface_proto_eve if (iface->state != IFS_SETUP) return; + interface_ip_set_enabled(&iface->config_ip, true); + system_flush_routes(); iface->state = IFS_UP; + iface->start_time = system_get_rtime(); interface_event(iface, IFEV_UP); + interface_write_resolv_conf(); + netifd_log_message(L_NOTICE, "Interface '%s' is now up\n", iface->name); break; case IFPEV_DOWN: if (iface->state == IFS_DOWN) return; + netifd_log_message(L_NOTICE, "Interface '%s' is now down\n", iface->name); mark_interface_down(iface); interface_handle_config_change(iface); break; @@ -250,8 +350,9 @@ interface_proto_cb(struct interface_proto_state *state, enum interface_proto_eve if (iface->state != IFS_UP) return; + netifd_log_message(L_NOTICE, "Interface '%s' has lost the connection\n", iface->name); + mark_interface_down(iface); iface->state = IFS_SETUP; - interface_event(iface, IFEV_DOWN); break; } } @@ -281,9 +382,13 @@ interface_init(struct interface *iface, const char *name, strncpy(iface->name, name, sizeof(iface->name) - 1); INIT_LIST_HEAD(&iface->errors); + INIT_LIST_HEAD(&iface->users); + INIT_LIST_HEAD(&iface->hotplug_list); + interface_ip_init(iface); + avl_init(&iface->data, avl_strcmp, false, NULL); + iface->config_ip.enabled = false; iface->main_dev.cb = interface_cb; - iface->l3_dev = &iface->main_dev; blobmsg_parse(iface_attrs, IFACE_ATTR_MAX, tb, blob_data(config), blob_len(config)); @@ -293,10 +398,21 @@ interface_init(struct interface *iface, const char *name, proto_attach_interface(iface, proto_name); - if ((cur = tb[IFACE_ATTR_AUTO])) - iface->autostart = blobmsg_get_bool(cur); - else - iface->autostart = true; + iface->autostart = blobmsg_get_bool_default(tb[IFACE_ATTR_AUTO], true); + iface->proto_ip.no_defaultroute = + !blobmsg_get_bool_default(tb[IFACE_ATTR_DEFAULTROUTE], true); + iface->proto_ip.no_dns = + !blobmsg_get_bool_default(tb[IFACE_ATTR_PEERDNS], true); + + if ((cur = tb[IFACE_ATTR_DNS])) + interface_add_dns_server_list(&iface->config_ip, cur); + + if ((cur = tb[IFACE_ATTR_DNS_SEARCH])) + interface_add_dns_search_list(&iface->config_ip, cur); + + if ((cur = tb[IFACE_ATTR_METRIC])) + iface->metric = blobmsg_get_u32(cur); + iface->config_autostart = iface->autostart; } @@ -313,20 +429,65 @@ interface_add(struct interface *iface, struct blob_attr *config) iface->ifname = blobmsg_data(cur); iface->config = config; - vlist_add(&interfaces, &iface->node); + vlist_add(&interfaces, &iface->node, iface->name); } void -interface_remove_link(struct interface *iface, struct device *dev) +interface_set_l3_dev(struct interface *iface, struct device *dev) { - struct device *mdev = iface->main_dev.dev; + bool enabled = iface->config_ip.enabled; + bool claimed = iface->l3_dev.claimed; - if (mdev && mdev->hotplug_ops) { - mdev->hotplug_ops->del(mdev, dev); + if (iface->l3_dev.dev == dev) return; + + interface_ip_set_enabled(&iface->config_ip, false); + interface_ip_flush(&iface->proto_ip); + device_add_user(&iface->l3_dev, dev); + + if (dev) { + if (claimed) + device_claim(&iface->l3_dev); + interface_ip_set_enabled(&iface->config_ip, enabled); } +} + +void +interface_set_main_dev(struct interface *iface, struct device *dev) +{ + bool set_l3 = (iface->main_dev.dev == iface->l3_dev.dev); + bool claimed = iface->l3_dev.claimed; + + if (iface->main_dev.dev == dev) + return; + + if (set_l3) + interface_set_l3_dev(iface, dev); + + device_add_user(&iface->main_dev, dev); + if (claimed) + device_claim(&iface->l3_dev); + + if (!iface->l3_dev.dev) + interface_set_l3_dev(iface, dev); +} + +int +interface_remove_link(struct interface *iface, struct device *dev) +{ + struct device *mdev = iface->main_dev.dev; + + if (mdev && mdev->hotplug_ops) + return mdev->hotplug_ops->del(mdev, dev); + + if (!iface->main_dev.hotplug) + return UBUS_STATUS_INVALID_ARGUMENT; + + if (dev != iface->main_dev.dev) + return UBUS_STATUS_INVALID_ARGUMENT; device_remove_user(&iface->main_dev); + return 0; } int @@ -334,31 +495,54 @@ interface_add_link(struct interface *iface, struct device *dev) { struct device *mdev = iface->main_dev.dev; - if (mdev && mdev->hotplug_ops) - return mdev->hotplug_ops->add(mdev, dev); + if (mdev == dev) + return 0; - if (iface->main_dev.dev) - interface_remove_link(iface, NULL); + if (iface->main_dev.hotplug) + device_remove_user(&iface->main_dev); - device_add_user(&iface->main_dev, dev); + if (mdev) { + if (mdev->hotplug_ops) + return mdev->hotplug_ops->add(mdev, dev); + else + return UBUS_STATUS_NOT_SUPPORTED; + } + interface_set_main_dev(iface, dev); + iface->main_dev.hotplug = true; return 0; } int interface_set_up(struct interface *iface) { + int ret; + iface->autostart = true; + if (iface->state != IFS_DOWN) + return 0; + + interface_clear_errors(iface); if (!iface->available) { interface_add_error(iface, "interface", "NO_DEVICE", NULL, 0); return -1; } - if (iface->state != IFS_DOWN) - return 0; + if (iface->main_dev.dev) { + ret = device_claim(&iface->main_dev); + if (ret) + return ret; + } - return __interface_set_up(iface); + iface->state = IFS_SETUP; + ret = interface_proto_event(iface->proto, PROTO_CMD_SETUP, false); + if (ret) { + mark_interface_down(iface); + return ret; + } + + return 0; } int @@ -396,10 +580,31 @@ set_config_state(struct interface *iface, enum interface_config_state s) __interface_set_down(iface, false); } +void +interface_update_start(struct interface *iface) +{ + interface_ip_update_start(&iface->proto_ip); +} + +void +interface_update_complete(struct interface *iface) +{ + interface_ip_update_complete(&iface->proto_ip); +} + +static void +interface_replace_dns(struct interface_ip_settings *old, struct interface_ip_settings *new) +{ + vlist_simple_replace(&new->dns_servers, &old->dns_servers); + vlist_simple_replace(&new->dns_search, &old->dns_search); +} + static void interface_change_config(struct interface *if_old, struct interface *if_new) { struct blob_attr *old_config = if_old->config; + const char *old_ifname = if_old->ifname; + const struct proto_handler *proto = if_old->proto_handler; interface_clear_errors(if_old); if_old->config = if_new->config; @@ -408,8 +613,50 @@ interface_change_config(struct interface *if_old, struct interface *if_new) if_old->config_autostart = if_new->config_autostart; if_old->ifname = if_new->ifname; + if_old->proto_handler = if_new->proto_handler; + + if ((!!old_ifname != !!if_new->ifname) || + (old_ifname && strcmp(old_ifname, if_new->ifname) != 0) || + proto != if_new->proto_handler) { + D(INTERFACE, "Reload interface '%s' because of ifname/proto change\n", + if_old->name); + goto reload; + } + if (!proto->config_params) + D(INTERFACE, "No config parameters for interface '%s'\n", + if_old->name); + else if (!config_check_equal(old_config, if_new->config, + proto->config_params)) { + D(INTERFACE, "Reload interface '%s because of config changes\n", + if_old->name); + goto reload; + } + +#define UPDATE(field) ({ \ + bool __changed = (if_old->field != if_new->field); \ + if_old->field = if_new->field; \ + __changed; \ + }) + + if (UPDATE(metric) || UPDATE(proto_ip.no_defaultroute)) { + interface_ip_set_enabled(&if_old->config_ip, false); + interface_ip_set_enabled(&if_old->config_ip, if_new->config_ip.enabled); + interface_ip_set_enabled(&if_old->proto_ip, false); + interface_ip_set_enabled(&if_old->proto_ip, if_new->proto_ip.enabled); + } + + UPDATE(proto_ip.no_dns); + interface_replace_dns(&if_old->config_ip, &if_new->config_ip); + interface_write_resolv_conf(); + +#undef UPDATE + + goto out; + +reload: set_config_state(if_old, IFC_RELOAD); +out: free(old_config); free(if_new); } @@ -429,9 +676,8 @@ interface_update(struct vlist_tree *tree, struct vlist_node *node_new, set_config_state(if_old, IFC_REMOVE); } else if (node_new) { D(INTERFACE, "Create interface '%s'\n", if_new->name); - interface_claim_device(if_new); proto_init_interface(if_new, if_new->config); - interface_ip_init(if_new); + interface_claim_device(if_new); netifd_ubus_add_interface(if_new); } } @@ -440,8 +686,7 @@ interface_update(struct vlist_tree *tree, struct vlist_node *node_new, static void __init interface_init_list(void) { - vlist_init(&interfaces, avl_strcmp, interface_update, - struct interface, node, name); + vlist_init(&interfaces, avl_strcmp, interface_update); interfaces.keep_old = true; interfaces.no_delete = true; }