interface.c

   1 #include <string.h>
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4
   5 #include "netifd.h"
   6 #include "proto.h"
   7 #include "ubus.h"
   8
   9 static LIST_HEAD(interfaces);
  10
  11 static void
  12 clear_interface_errors(struct interface *iface)
  13 {
  14         struct interface_error *error, *tmp;
  15
  16         list_for_each_entry_safe(error, tmp, &iface->errors, list) {
  17                 list_del(&error->list);
  18                 free(error);
  19         }
  20 }
  21
  22 void interface_add_error(struct interface *iface, const char *subsystem,
  23                          const char *code, const char **data, int n_data)
  24 {
  25         struct interface_error *error;
  26         int i, len = 0;
  27         int *datalen;
  28         char *dest;
  29
  30         if (n_data) {
  31                 len = n_data * sizeof(char *);
  32                 datalen = alloca(len);
  33                 for (i = 0; i < n_data; i++) {
  34                         datalen[i] = strlen(data[i]) + 1;
  35                         len += datalen[i];
  36                 }
  37         }
  38
  39         error = calloc(1, sizeof(*error) + sizeof(char *) + len);
  40         if (!error)
  41                 return;
  42
  43         list_add_tail(&error->list, &iface->errors);
  44         error->subsystem = subsystem;
  45         error->code = code;
  46
  47         dest = (char *) &error->data[n_data + 1];
  48         for (i = 0; i < n_data; i++) {
  49                 error->data[i] = dest;
  50                 memcpy(dest, data[i], datalen[i]);
  51                 dest += datalen[i];
  52         }
  53         error->data[n_data] = NULL;
  54 }
  55
  56 static void
  57 interface_event(struct interface *iface, enum interface_event ev)
  58 {
  59         /* TODO */
  60 }
  61
  62 static void
  63 mark_interface_down(struct interface *iface)
  64 {
  65         release_device(iface->main_dev.dev);
  66         iface->state = IFS_DOWN;
  67 }
  68
  69 static int
  70 __set_interface_up(struct interface *iface)
  71 {
  72         int ret;
  73
  74         if (iface->state != IFS_DOWN)
  75                 return 0;
  76
  77         ret = claim_device(iface->main_dev.dev);
  78         if (ret)
  79                 return ret;
  80
  81         iface->state = IFS_SETUP;
  82         ret = iface->proto->handler(iface->proto, PROTO_CMD_SETUP, false);
  83         if (ret) {
  84                 mark_interface_down(iface);
  85                 return ret;
  86         }
  87
  88         return 0;
  89
  90 }
  91
  92 static void
  93 __set_interface_down(struct interface *iface, bool force)
  94 {
  95         clear_interface_errors(iface);
  96
  97         if (iface->state == IFS_DOWN ||
  98                 iface->state == IFS_TEARDOWN)
  99                 return;
 100
 101         iface->state = IFS_TEARDOWN;
 102         interface_event(iface, IFEV_DOWN);
 103
 104         iface->proto->handler(iface->proto, PROTO_CMD_TEARDOWN, force);
 105         release_device(iface->main_dev.dev);
 106 }
 107
 108 static void
 109 interface_cb(struct device_user *dep, enum device_event ev)
 110 {
 111         struct interface *iface;
 112         bool new_state;
 113
 114         iface = container_of(dep, struct interface, main_dev);
 115         switch (ev) {
 116         case DEV_EVENT_ADD:
 117                 new_state = true;
 118                 break;
 119         case DEV_EVENT_REMOVE:
 120                 new_state = false;
 121                 break;
 122         default:
 123                 return;
 124         }
 125
 126         if (iface->active == new_state)
 127                 return;
 128
 129         iface->active = new_state;
 130
 131         if (new_state) {
 132                 if (iface->autostart)
 133                         set_interface_up(iface);
 134         } else
 135                 __set_interface_down(iface, true);
 136 }
 137
 138 static void
 139 interface_proto_cb(struct interface_proto_state *state, enum interface_proto_event ev)
 140 {
 141         struct interface *iface = state->iface;
 142
 143         switch (ev) {
 144         case IFPEV_UP:
 145                 if (iface->state != IFS_SETUP)
 146                         return;
 147
 148                 iface->state = IFS_UP;
 149                 interface_event(iface, IFEV_UP);
 150                 break;
 151         case IFPEV_DOWN:
 152                 if (iface->state == IFS_DOWN)
 153                         return;
 154
 155                 mark_interface_down(iface);
 156                 break;
 157         }
 158 }
 159
 160 void interface_set_proto_state(struct interface *iface, struct interface_proto_state *state)
 161 {
 162         if (iface->proto) {
 163                 iface->proto->handler(iface->proto, PROTO_CMD_TEARDOWN, true);
 164                 iface->proto->free(iface->proto);
 165                 iface->proto = NULL;
 166         }
 167         iface->state = IFS_DOWN;
 168         iface->proto = state;
 169         if (!state)
 170                 return;
 171
 172         state->proto_event = interface_proto_cb;
 173         state->iface = iface;
 174 }
 175
 176 struct interface *
 177 alloc_interface(const char *name)
 178 {
 179         struct interface *iface;
 180
 181         iface = get_interface(name);
 182         if (iface)
 183                 return iface;
 184
 185         iface = calloc(1, sizeof(*iface));
 186
 187         interface_set_proto_state(iface, get_default_proto());
 188         if (!iface->proto) {
 189                 free(iface);
 190                 return NULL;
 191         }
 192
 193         iface->main_dev.cb = interface_cb;
 194         iface->l3_iface = &iface->main_dev;
 195         strncpy(iface->name, name, sizeof(iface->name) - 1);
 196         list_add(&iface->list, &interfaces);
 197         INIT_LIST_HEAD(&iface->errors);
 198
 199         netifd_ubus_add_interface(iface);
 200
 201         return iface;
 202 }
 203
 204 void
 205 free_interface(struct interface *iface)
 206 {
 207         netifd_ubus_remove_interface(iface);
 208         list_del(&iface->list);
 209         if (iface->proto->free)
 210                 iface->proto->free(iface->proto);
 211         free(iface);
 212 }
 213
 214 struct interface *
 215 get_interface(const char *name)
 216 {
 217         struct interface *iface;
 218
 219         list_for_each_entry(iface, &interfaces, list) {
 220                 if (!strcmp(iface->name, name))
 221                         return iface;
 222         }
 223         return NULL;
 224 }
 225
 226 void
 227 interface_remove_link(struct interface *iface, struct device *llif)
 228 {
 229         struct device *dev = iface->main_dev.dev;
 230
 231         if (dev && dev->hotplug_ops) {
 232                 dev->hotplug_ops->del(dev, llif);
 233                 return;
 234         }
 235
 236         remove_device_user(&iface->main_dev);
 237 }
 238
 239 int
 240 interface_add_link(struct interface *iface, struct device *llif)
 241 {
 242         struct device *dev = iface->main_dev.dev;
 243
 244         if (dev && dev->hotplug_ops)
 245                 return dev->hotplug_ops->add(dev, llif);
 246
 247         if (iface->main_dev.dev)
 248                 interface_remove_link(iface, NULL);
 249
 250         add_device_user(&iface->main_dev, llif);
 251
 252         return 0;
 253 }
 254
 255 int
 256 set_interface_up(struct interface *iface)
 257 {
 258         iface->autostart = true;
 259
 260         if (!iface->active) {
 261                 interface_add_error(iface, "interface", "NO_DEVICE", NULL, 0);
 262                 return -1;
 263         }
 264
 265         if (iface->state != IFS_DOWN)
 266                 return 0;
 267
 268         return __set_interface_up(iface);
 269 }
 270
 271 int
 272 set_interface_down(struct interface *iface)
 273 {
 274         iface->autostart = false;
 275         __set_interface_down(iface, false);
 276
 277         return 0;
 278 }