nterface-ip: remove superfluous iface check in interface_ip_set_enabled()
[project/netifd.git] / alias.c
diff --git a/alias.c b/alias.c
index 07ed5fe..649f2d1 100644 (file)
--- a/alias.c
+++ b/alias.c
@@ -17,6 +17,7 @@
 
 #include "netifd.h"
 #include "device.h"
 
 #include "netifd.h"
 #include "device.h"
+#include "interface.h"
 
 static struct avl_tree aliases;
 
 
 static struct avl_tree aliases;
 
@@ -24,11 +25,45 @@ struct alias_device {
        struct avl_node avl;
        struct device dev;
        struct device_user dep;
        struct avl_node avl;
        struct device dev;
        struct device_user dep;
-       bool cleanup;
+       struct device_user new_dep;
+       bool update;
        char name[];
 };
 
        char name[];
 };
 
-static const struct device_type alias_device_type;
+static void alias_set_device(struct alias_device *alias, struct device *dev)
+{
+       if (dev == alias->dep.dev) {
+               if (alias->update) {
+                       device_remove_user(&alias->new_dep);
+                       alias->update = false;
+                       if (dev)
+                               device_set_present(&alias->dev, true);
+               }
+               return;
+       }
+
+       device_set_present(&alias->dev, false);
+       device_remove_user(&alias->new_dep);
+       if (alias->dev.active) {
+               if (dev)
+                       device_add_user(&alias->new_dep, dev);
+
+               alias->update = true;
+               return;
+       }
+
+       alias->update = false;
+       device_remove_user(&alias->dep);
+       alias->dev.hidden = !dev;
+       if (dev) {
+               device_set_ifindex(&alias->dev, dev->ifindex);
+               device_set_ifname(&alias->dev, dev->ifname);
+               device_add_user(&alias->dep, dev);
+       } else {
+               device_set_ifname(&alias->dev, "");
+               device_set_link(&alias->dev, false);
+       }
+}
 
 static int
 alias_device_set_state(struct device *dev, bool state)
 
 static int
 alias_device_set_state(struct device *dev, bool state)
@@ -43,22 +78,31 @@ alias_device_set_state(struct device *dev, bool state)
                return device_claim(&alias->dep);
 
        device_release(&alias->dep);
                return device_claim(&alias->dep);
 
        device_release(&alias->dep);
-       if (alias->cleanup)
-               device_remove_user(&alias->dep);
+       if (alias->update)
+               alias_set_device(alias, alias->new_dep.dev);
+
        return 0;
 }
 
 static void alias_device_cb(struct device_user *dep, enum device_event ev)
 {
        struct alias_device *alias;
        return 0;
 }
 
 static void alias_device_cb(struct device_user *dep, enum device_event ev)
 {
        struct alias_device *alias;
-       bool present = false;
+       bool new_state = false;
 
        alias = container_of(dep, struct alias_device, dep);
        switch (ev) {
        case DEV_EVENT_ADD:
 
        alias = container_of(dep, struct alias_device, dep);
        switch (ev) {
        case DEV_EVENT_ADD:
-               present = true;
+               new_state = true;
        case DEV_EVENT_REMOVE:
        case DEV_EVENT_REMOVE:
-               device_set_present(&alias->dev, present);
+               device_set_present(&alias->dev, new_state);
+               break;
+       case DEV_EVENT_LINK_UP:
+               new_state = true;
+       case DEV_EVENT_LINK_DOWN:
+               device_set_link(&alias->dev, new_state);
+               break;
+       case DEV_EVENT_UPDATE_IFINDEX:
+               device_set_ifindex(&alias->dev, dep->dev->ifindex);
                break;
        default:
                device_broadcast_event(&alias->dev, ev);
                break;
        default:
                device_broadcast_event(&alias->dev, ev);
@@ -67,19 +111,24 @@ static void alias_device_cb(struct device_user *dep, enum device_event ev)
 }
 
 static struct device *
 }
 
 static struct device *
-alias_device_create(const char *name, struct blob_attr *attr)
+alias_device_create(const char *name, struct device_type *devtype,
+                   struct blob_attr *attr)
 {
        struct alias_device *alias;
 
        alias = calloc(1, sizeof(*alias) + strlen(name) + 1);
 {
        struct alias_device *alias;
 
        alias = calloc(1, sizeof(*alias) + strlen(name) + 1);
+       if (!alias)
+               return NULL;
+
        strcpy(alias->name, name);
        alias->dev.set_state = alias_device_set_state;
        alias->dev.hidden = true;
        strcpy(alias->name, name);
        alias->dev.set_state = alias_device_set_state;
        alias->dev.hidden = true;
-       device_init_virtual(&alias->dev, &alias_device_type, NULL);
+       device_init_virtual(&alias->dev, devtype, NULL);
        alias->avl.key = alias->name;
        avl_insert(&aliases, &alias->avl);
        alias->dep.alias = true;
        alias->dep.cb = alias_device_cb;
        alias->avl.key = alias->name;
        avl_insert(&aliases, &alias->avl);
        alias->dep.alias = true;
        alias->dep.cb = alias_device_cb;
+       device_check_state(&alias->dev);
 
        return &alias->dev;
 }
 
        return &alias->dev;
 }
@@ -89,14 +138,34 @@ static void alias_device_free(struct device *dev)
        struct alias_device *alias;
 
        alias = container_of(dev, struct alias_device, dev);
        struct alias_device *alias;
 
        alias = container_of(dev, struct alias_device, dev);
+       device_remove_user(&alias->new_dep);
+       device_remove_user(&alias->dep);
        avl_delete(&aliases, &alias->avl);
        free(alias);
 }
 
        avl_delete(&aliases, &alias->avl);
        free(alias);
 }
 
-static const struct device_type alias_device_type = {
+static int alias_check_state(struct device *dev)
+{
+       struct alias_device *alias;
+       struct interface *iface;
+       struct device *ndev = NULL;
+
+       alias = container_of(dev, struct alias_device, dev);
+
+       iface = vlist_find(&interfaces, alias->name, iface, node);
+       if (iface && iface->state == IFS_UP)
+               ndev = iface->l3_dev.dev;
+
+       alias_set_device(alias, ndev);
+
+       return 0;
+}
+
+static struct device_type alias_device_type = {
        .name = "Network alias",
        .create = alias_device_create,
        .free = alias_device_free,
        .name = "Network alias",
        .create = alias_device_create,
        .free = alias_device_free,
+       .check_state = alias_check_state,
 };
 
 void
 };
 
 void
@@ -107,26 +176,8 @@ alias_notify_device(const char *name, struct device *dev)
        device_lock();
 
        alias = avl_find_element(&aliases, name, alias, avl);
        device_lock();
 
        alias = avl_find_element(&aliases, name, alias, avl);
-       if (!alias)
-               return;
-
-       alias->cleanup = !dev;
-       if (dev) {
-               if (dev != alias->dep.dev) {
-                       device_remove_user(&alias->dep);
-                       strcpy(alias->dev.ifname, dev->ifname);
-                       device_add_user(&alias->dep, dev);
-                       alias->dev.hidden = false;
-                       device_broadcast_event(&alias->dev, DEV_EVENT_UPDATE_IFNAME);
-               }
-       }
-
-       if (!dev && alias->dep.dev && !alias->dep.dev->active) {
-               device_remove_user(&alias->dep);
-               alias->dev.hidden = true;
-               alias->dev.ifname[0] = 0;
-               device_broadcast_event(&alias->dev, DEV_EVENT_UPDATE_IFNAME);
-       }
+       if (alias)
+               alias_set_device(alias, dev);
 
        device_unlock();
 }
 
        device_unlock();
 }
@@ -140,7 +191,7 @@ device_alias_get(const char *name)
        if (alias)
                return &alias->dev;
 
        if (alias)
                return &alias->dev;
 
-       return alias_device_create(name, NULL);
+       return alias_device_create(name, &alias_device_type, NULL);
 }
 
 static void __init alias_init(void)
 }
 
 static void __init alias_init(void)