src/xt_vlink.c

   1 /*
   2  * Lightweight Autonomic Network Architecture
   3  *
   4  * LANA vlink control messages via netlink socket. This allows userspace
   5  * applications like 'vlink' to control the whole LANA vlink layer. Each
   6  * vlink type (e.g. Ethernet, Bluetooth, ...) gets its own subsystem with
   7  * its operations. Access via a single socket type (NETLINK_VLINK). We are
   8  * furthermore not in fast-path here.
   9  *
  10  * Copyright 2011 Daniel Borkmann <dborkma@tik.ee.ethz.ch>,
  11  * Swiss federal institute of technology (ETH Zurich)
  12  * Subject to the GPL.
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/kernel.h>
  17 #include <linux/init.h>
  18 #include <linux/socket.h>
  19 #include <linux/slab.h>
  20 #include <linux/net.h>
  21 #include <linux/skbuff.h>
  22 #include <linux/proc_fs.h>
  23 #include <net/netlink.h>
  24 #include <net/sock.h>
  25
  26 #include "xt_vlink.h"
  27
  28 static DEFINE_MUTEX(vlink_mutex);
  29 static struct sock *vlink_sock = NULL;
  30 static struct vlink_subsys **vlink_subsystem_table = NULL;
  31 extern struct proc_dir_entry *lana_proc_dir;
  32 static struct proc_dir_entry *vlink_proc;
  33
  34 void vlink_lock(void)
  35 {
  36         mutex_lock(&vlink_mutex);
  37 }
  38 EXPORT_SYMBOL_GPL(vlink_lock);
  39
  40 void vlink_unlock(void)
  41 {
  42         mutex_unlock(&vlink_mutex);
  43 }
  44 EXPORT_SYMBOL_GPL(vlink_unlock);
  45
  46 int vlink_subsys_register(struct vlink_subsys *n)
  47 {
  48         int i, slot;
  49         struct vlink_subsys *vs;
  50
  51         if (!n)
  52                 return -EINVAL;
  53         vlink_lock();
  54         for (i = 0, slot = -1; i < MAX_VLINK_SUBSYSTEMS; ++i) {
  55                 if (!vlink_subsystem_table[i] && slot == -1)
  56                         slot = i;
  57                 else if (!vlink_subsystem_table[i])
  58                         continue;
  59                 else {
  60                         vs = vlink_subsystem_table[i];
  61                         if (n->type == vs->type) {
  62                                 vlink_unlock();
  63                                 return -EBUSY;
  64                         }
  65                 }
  66         }
  67         if (slot != -1) {
  68                 n->id = slot;
  69                 vlink_subsystem_table[slot] = n;
  70                 __module_get(THIS_MODULE);
  71         }
  72         vlink_unlock();
  73         return slot == -1 ? -ENOMEM : 0;
  74 }
  75 EXPORT_SYMBOL_GPL(vlink_subsys_register);
  76
  77 void vlink_subsys_unregister(struct vlink_subsys *n)
  78 {
  79         int i;
  80         if (!n)
  81                 return;
  82         vlink_lock();
  83         for (i = 0; i < MAX_VLINK_SUBSYSTEMS; ++i) {
  84                 if (vlink_subsystem_table[i] == n && i == n->id) {
  85                         vlink_subsystem_table[i] = NULL;
  86                         n->id = 0;
  87                         module_put(THIS_MODULE);
  88                         break;
  89                 }
  90         }
  91         vlink_unlock();
  92 }
  93 EXPORT_SYMBOL_GPL(vlink_subsys_unregister);
  94
  95 static struct vlink_subsys *__vlink_subsys_find(u16 type)
  96 {
  97         int i;
  98         for (i = 0; i < MAX_VLINK_SUBSYSTEMS; ++i)
  99                 if (vlink_subsystem_table[i])
 100                         if (vlink_subsystem_table[i]->type == type)
 101                                 return vlink_subsystem_table[i];
 102         return NULL;
 103 }
 104
 105 struct vlink_subsys *vlink_subsys_find(u16 type)
 106 {
 107         struct vlink_subsys *ret;
 108         vlink_lock();
 109         ret = __vlink_subsys_find(type);
 110         vlink_unlock();
 111         return ret;
 112 }
 113 EXPORT_SYMBOL_GPL(vlink_subsys_find);
 114
 115 static int __vlink_add_callback(struct vlink_subsys *n,
 116                                 struct vlink_callback *cb)
 117 {
 118         struct vlink_callback **hb;
 119
 120         if (!cb)
 121                 return -EINVAL;
 122         hb = &n->head;
 123         while (*hb != NULL) {
 124                 if (cb->priority > (*hb)->priority)
 125                         break;
 126                 hb = &((*hb)->next);
 127         }
 128         cb->next = *hb;
 129         *hb = cb;
 130         return 0;
 131 }
 132
 133 int vlink_add_callback(struct vlink_subsys *n,
 134                        struct vlink_callback *cb)
 135 {
 136         int ret;
 137
 138         if (!n)
 139                 return -EINVAL;
 140         down_write(&n->rwsem);
 141         ret = __vlink_add_callback(n, cb);
 142         up_write(&n->rwsem);
 143
 144         return ret;
 145 }
 146 EXPORT_SYMBOL_GPL(vlink_add_callback);
 147
 148 int vlink_add_callbacks_va(struct vlink_subsys *n,
 149                            struct vlink_callback *cb, va_list ap)
 150 {
 151         int ret = 0;
 152         struct vlink_callback *arg;
 153
 154         arg = cb;
 155         while (arg) {
 156                 ret = vlink_add_callback(n, arg);
 157                 if (ret)
 158                         break;
 159                 arg = va_arg(ap, struct vlink_callback *);
 160         }
 161
 162         return ret;
 163 }
 164 EXPORT_SYMBOL_GPL(vlink_add_callbacks_va);
 165
 166 int vlink_add_callbacks(struct vlink_subsys *n,
 167                         struct vlink_callback *cb, ...)
 168 {
 169         int ret;
 170         va_list vl;
 171
 172         va_start(vl, cb);
 173         ret = vlink_add_callbacks_va(n, cb, vl);
 174         va_end(vl);
 175
 176         return ret;
 177 }
 178 EXPORT_SYMBOL_GPL(vlink_add_callbacks);
 179
 180 static int __vlink_rm_callback(struct vlink_subsys *n,
 181                                struct vlink_callback *cb)
 182 {
 183         struct vlink_callback **hb;
 184
 185         if (!cb)
 186                 return -EINVAL;
 187         hb = &n->head;
 188         while (*hb != NULL) {
 189                 if (*hb == cb) {
 190                         *hb = cb->next;
 191                         return 0;
 192                 }
 193                 hb = &((*hb)->next);
 194         }
 195
 196         return -ENOENT;
 197 }
 198
 199 int vlink_rm_callback(struct vlink_subsys *n,
 200                       struct vlink_callback *cb)
 201 {
 202         int ret;
 203         if (!n)
 204                 return -EINVAL;
 205         down_write(&n->rwsem);
 206         ret = __vlink_rm_callback(n, cb);
 207         up_write(&n->rwsem);
 208         return ret;
 209 }
 210 EXPORT_SYMBOL_GPL(vlink_rm_callback);
 211
 212 void vlink_subsys_unregister_batch(struct vlink_subsys *n)
 213 {
 214         int i;
 215
 216         if (!n)
 217                 return;
 218         vlink_lock();
 219         for (i = 0; i < MAX_VLINK_SUBSYSTEMS; ++i) {
 220                 if (vlink_subsystem_table[i] == n && i == n->id) {
 221                         vlink_subsystem_table[i] = NULL;
 222                         n->id = 0;
 223                         module_put(THIS_MODULE);
 224                         break;
 225                 }
 226         }
 227         vlink_unlock();
 228         while (n-> head != NULL)
 229                 vlink_rm_callback(n, n->head);
 230 }
 231 EXPORT_SYMBOL_GPL(vlink_subsys_unregister_batch);
 232
 233 static int __vlink_invoke(struct vlink_subsys *n,
 234                           struct vlinknlmsg *vmsg,
 235                           struct nlmsghdr *nlh)
 236 {
 237         int ret = 0, nret;
 238         struct vlink_callback *hb, *hn;
 239
 240         hb = n->head;
 241         while (hb) {
 242                 hn = hb->next;
 243                 nret = 0;
 244                 ret = hb->rx(vmsg, nlh);
 245                 if ((ret & NETLINK_VLINK_RX_EMERG) == NETLINK_VLINK_RX_EMERG ||
 246                     (nret = (ret & NETLINK_VLINK_RX_STOP) == NETLINK_VLINK_RX_STOP)) {
 247                         if (vmsg->cmd == VLINKNLCMD_START_HOOK_DEVICE && nret)
 248                                 __module_get(n->owner);
 249                         if (vmsg->cmd == VLINKNLCMD_STOP_HOOK_DEVICE && nret)
 250                                 module_put(n->owner);
 251                         break;
 252                 }
 253                 hb = hn;
 254         }
 255
 256         return ret;
 257 }
 258
 259 static int __vlink_rcv(struct sk_buff *skb, struct nlmsghdr *nlh)
 260 {
 261         int ret;
 262         struct vlinknlmsg *vmsg;
 263         struct vlink_subsys *sys;
 264
 265         if (security_netlink_recv(skb, CAP_NET_ADMIN))
 266                 return -EPERM;
 267
 268         if (nlh->nlmsg_len < NLMSG_LENGTH(sizeof(struct vlinknlmsg)))
 269                 return 0;
 270
 271         sys = __vlink_subsys_find(nlh->nlmsg_type);
 272         if (!sys)
 273                 return -EINVAL;
 274
 275         vmsg = NLMSG_DATA(nlh);
 276
 277         down_read(&sys->rwsem);
 278         ret = __vlink_invoke(sys, vmsg, nlh);
 279         up_read(&sys->rwsem);
 280
 281         return ret;
 282 }
 283
 284 static void vlink_rcv(struct sk_buff *skb)
 285 {
 286         vlink_lock();
 287         netlink_rcv_skb(skb, &__vlink_rcv);
 288         vlink_unlock();
 289 }
 290
 291 static int vlink_procfs(char *page, char **start, off_t offset,
 292                         int count, int *eof, void *data)
 293 {
 294         int i;
 295         off_t len = 0;
 296
 297         vlink_lock();
 298         for (i = 0; i < MAX_VLINK_SUBSYSTEMS; ++i) {
 299                 if (vlink_subsystem_table[i])
 300                         len += sprintf(page + len, "%s %u %u\n",
 301                                        vlink_subsystem_table[i]->name,
 302                                        vlink_subsystem_table[i]->type,
 303                                        vlink_subsystem_table[i]->id);
 304         }
 305         vlink_unlock();
 306
 307         /* FIXME: fits in page? */
 308         *eof = 1;
 309         return len;
 310 }
 311
 312 int init_vlink_system(void)
 313 {
 314         int ret;
 315
 316         vlink_subsystem_table = kzalloc(sizeof(*vlink_subsystem_table) *
 317                                         MAX_VLINK_SUBSYSTEMS, GFP_KERNEL);
 318         if (!vlink_subsystem_table)
 319                 return -ENOMEM;
 320         vlink_sock = netlink_kernel_create(&init_net, NETLINK_VLINK,
 321                                            VLINKNLGRP_MAX, vlink_rcv,
 322                                            NULL, THIS_MODULE);
 323         if (!vlink_sock) {
 324                 ret = -ENOMEM;
 325                 goto err;
 326         }
 327         vlink_proc = create_proc_read_entry("vlink", 0400, lana_proc_dir,
 328                                             vlink_procfs, NULL);
 329         if (!vlink_proc)
 330                 goto err2;
 331         return 0;
 332 err2:
 333         netlink_kernel_release(vlink_sock);
 334 err:
 335         kfree(vlink_subsystem_table);
 336         return ret;
 337 }
 338
 339 void cleanup_vlink_system(void)
 340 {
 341         remove_proc_entry("vlink", lana_proc_dir);
 342         netlink_kernel_release(vlink_sock);
 343         kfree(vlink_subsystem_table);
 344 }
 345