proto.c

   1 #include <string.h>
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4
   5 #include <arpa/inet.h>
   6 #include <netinet/in.h>
   7
   8 #include "netifd.h"
   9 #include "interface.h"
  10 #include "interface-ip.h"
  11 #include "proto.h"
  12
  13 static struct avl_tree handlers;
  14
  15 unsigned int
  16 parse_netmask_string(const char *str, bool v6)
  17 {
  18         struct in_addr addr;
  19         unsigned int ret;
  20         char *err = NULL;
  21
  22         if (!strchr(str, '.')) {
  23                 ret = strtoul(str, &err, 0);
  24                 if (err && *err)
  25                         goto error;
  26
  27                 return ret;
  28         }
  29
  30         if (v6)
  31                 goto error;
  32
  33         if (inet_aton(str, &addr) != 1)
  34                 goto error;
  35
  36         return 32 - fls(~(ntohl(addr.s_addr)));
  37
  38 error:
  39         return ~0;
  40 }
  41
  42 static bool
  43 split_netmask(char *str, unsigned int *netmask, bool v6)
  44 {
  45         char *delim = strchr(str, '/');
  46
  47         if (delim) {
  48                 *(delim++) = 0;
  49
  50                 *netmask = parse_netmask_string(delim, v6);
  51         }
  52         return true;
  53 }
  54
  55 static int
  56 parse_ip_and_netmask(int af, const char *str, void *addr, unsigned int *netmask)
  57 {
  58         char *astr = alloca(strlen(str) + 1);
  59
  60         strcpy(astr, str);
  61         if (!split_netmask(astr, netmask, af == AF_INET6))
  62                 return 0;
  63
  64         if (af == AF_INET6) {
  65                 if (*netmask > 128)
  66                         return 0;
  67         } else {
  68                 if (*netmask > 32)
  69                         return 0;
  70         }
  71
  72         return inet_pton(af, astr, addr);
  73 }
  74
  75 struct device_addr *
  76 proto_parse_ip_addr_string(const char *str, bool v6, int mask)
  77 {
  78         struct device_addr *addr;
  79         int af = v6 ? AF_INET6 : AF_INET;
  80
  81         addr = calloc(1, sizeof(*addr));
  82         addr->flags = v6 ? DEVADDR_INET6 : DEVADDR_INET4;
  83         addr->mask = mask;
  84         if (!parse_ip_and_netmask(af, str, &addr->addr, &addr->mask)) {
  85                 free(addr);
  86                 return NULL;
  87         }
  88         return addr;
  89 }
  90
  91
  92 void add_proto_handler(struct proto_handler *p)
  93 {
  94         if (!handlers.comp)
  95                 avl_init(&handlers, avl_strcmp, false, NULL);
  96
  97         if (p->avl.key)
  98                 return;
  99
 100         p->avl.key = p->name;
 101         avl_insert(&handlers, &p->avl);
 102 }
 103
 104 static void
 105 default_proto_free(struct interface_proto_state *proto)
 106 {
 107         free(proto);
 108 }
 109
 110 static int
 111 invalid_proto_handler(struct interface_proto_state *proto,
 112                       enum interface_proto_cmd cmd, bool force)
 113 {
 114         return -1;
 115 }
 116
 117 static int
 118 no_proto_handler(struct interface_proto_state *proto,
 119                  enum interface_proto_cmd cmd, bool force)
 120 {
 121         return 0;
 122 }
 123
 124 static struct interface_proto_state *
 125 default_proto_attach(const struct proto_handler *h,
 126                      struct interface *iface, struct blob_attr *attr)
 127 {
 128         struct interface_proto_state *proto;
 129
 130         proto = calloc(1, sizeof(*proto));
 131         proto->free = default_proto_free;
 132         proto->cb = no_proto_handler;
 133
 134         return proto;
 135 }
 136
 137 static const struct proto_handler no_proto = {
 138         .name = "none",
 139         .flags = PROTO_FLAG_IMMEDIATE,
 140         .attach = default_proto_attach,
 141 };
 142
 143 static const struct proto_handler *
 144 get_proto_handler(const char *name)
 145 {
 146         struct proto_handler *proto;
 147
 148         if (!strcmp(name, "none"))
 149             return &no_proto;
 150
 151         if (!handlers.comp)
 152                 return NULL;
 153
 154         return avl_find_element(&handlers, name, proto, avl);
 155 }
 156
 157 void
 158 proto_init_interface(struct interface *iface, struct blob_attr *attr)
 159 {
 160         const struct proto_handler *proto = iface->proto_handler;
 161         struct interface_proto_state *state = NULL;
 162
 163         if (proto)
 164                 state = proto->attach(proto, iface, attr);
 165
 166         if (!state) {
 167                 state = no_proto.attach(&no_proto, iface, attr);
 168                 state->cb = invalid_proto_handler;
 169         }
 170
 171         state->handler = proto;
 172         interface_set_proto_state(iface, state);
 173 }
 174
 175 void
 176 proto_attach_interface(struct interface *iface, const char *proto_name)
 177 {
 178         const struct proto_handler *proto = NULL;
 179
 180         if (!proto_name) {
 181                 interface_add_error(iface, "proto", "NO_PROTO", NULL, 0);
 182                 return;
 183         }
 184
 185         proto = get_proto_handler(proto_name);
 186         if (!proto)
 187                 interface_add_error(iface, "proto", "INVALID_PROTO", NULL, 0);
 188
 189         iface->proto_handler = proto;
 190 }
 191
 192 int
 193 interface_proto_event(struct interface_proto_state *proto,
 194                       enum interface_proto_cmd cmd, bool force)
 195 {
 196         enum interface_proto_event ev;
 197         int ret;
 198
 199         ret = proto->cb(proto, cmd, force);
 200         if (ret || !(proto->handler->flags & PROTO_FLAG_IMMEDIATE))
 201                 goto out;
 202
 203         switch(cmd) {
 204         case PROTO_CMD_SETUP:
 205                 ev = IFPEV_UP;
 206                 break;
 207         case PROTO_CMD_TEARDOWN:
 208                 ev = IFPEV_DOWN;
 209                 break;
 210         default:
 211                 return -EINVAL;
 212         }
 213         proto->proto_event(proto, ev);
 214
 215 out:
 216         return ret;
 217 }