src/xt_user.c

   1 /*
   2  * Lightweight Autonomic Network Architecture
   3  *
   4  * LANA NETLINK handler for Functional Block userspace control.
   5  *
   6  * Copyright 2011 Daniel Borkmann <dborkma@tik.ee.ethz.ch>,
   7  * Swiss federal institute of technology (ETH Zurich)
   8  * Subject to the GPL.
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/init.h>
  14 #include <linux/socket.h>
  15 #include <linux/net.h>
  16 #include <linux/skbuff.h>
  17 #include <linux/rcupdate.h>
  18 #include <net/netlink.h>
  19 #include <net/sock.h>
  20
  21 #include "xt_idp.h"
  22 #include "xt_user.h"
  23 #include "xt_fblock.h"
  24 #include "xt_builder.h"
  25
  26 static struct sock *userctl_sock = NULL;
  27
  28 static int userctl_add(struct lananlmsg *lmsg)
  29 {
  30         struct fblock *fb;
  31         struct lananlmsg_add *msg = (struct lananlmsg_add *) lmsg->buff;
  32
  33         fb = search_fblock_n(msg->name);
  34         if (fb) {
  35                 put_fblock(fb);
  36                 return -EINVAL;
  37         }
  38
  39         fb = build_fblock_object(msg->type, msg->name);
  40
  41         return !fb ? -ENOMEM : 0;
  42 }
  43
  44 static int userctl_set(struct lananlmsg *lmsg)
  45 {
  46         int ret;
  47         struct fblock *fb;
  48         struct lananlmsg_set *msg = (struct lananlmsg_set *) lmsg->buff;
  49
  50         fb = search_fblock_n(msg->name);
  51         if (!fb)
  52                 return -EINVAL;
  53
  54         ret = fblock_set_option(fb, msg->option);
  55
  56         put_fblock(fb);
  57
  58         return ret;
  59 }
  60
  61 static int userctl_replace(struct lananlmsg *lmsg)
  62 {
  63         int ret;
  64         struct fblock *fb1, *fb2;
  65         struct lananlmsg_replace *msg = (struct lananlmsg_replace *) lmsg->buff;
  66
  67         /*
  68          * XXX: vlink blocks may not be replaced during runtime, since they
  69          * are directly bound to hardware. Fuckup? Yes or no? Too many side
  70          * effects. These blocks should not be changed anyway.
  71          */
  72
  73         fb1 = search_fblock_n(msg->name1);
  74         if (!fb1 || !fb1->factory)
  75                 return -EINVAL;
  76
  77         fb2 = search_fblock_n(msg->name2);
  78         if (!fb2 || !fb2->factory) {
  79                 put_fblock(fb1);
  80                 return -EINVAL;
  81         }
  82
  83         if (atomic_read(&fb2->refcnt) > 2) {
  84                 /* Still in use by others */
  85                 printk(KERN_ERR "[lana] %s is still in use by others. "
  86                        "Drop refs first!\n", fb2->name);
  87                 put_fblock(fb1);
  88                 put_fblock(fb2);
  89                 return -EBUSY;
  90         }
  91
  92         unregister_fblock_namespace_no_rcu(fb2);
  93
  94         if (!strncmp(fb1->factory->type, fb2->factory->type,
  95                      sizeof(fb1->factory->type)) && !msg->drop_priv)
  96                 fblock_migrate_p(fb2, fb1);
  97         fblock_migrate_r(fb2, fb1);
  98
  99         unregister_fblock(fb1);
 100
 101         ret = register_fblock(fb2, fb2->idp);
 102
 103         put_fblock(fb1);
 104         put_fblock(fb2);
 105
 106         return ret;
 107 }
 108
 109 static int userctl_subscribe(struct lananlmsg *lmsg)
 110 {
 111         int ret;
 112         struct fblock *fb1, *fb2;
 113         struct lananlmsg_tuple *msg = (struct lananlmsg_tuple *) lmsg->buff;
 114
 115         fb1 = search_fblock_n(msg->name1);
 116         if (!fb1)
 117                 return -EINVAL;
 118
 119         fb2 = search_fblock_n(msg->name2);
 120         if (!fb2) {
 121                 put_fblock(fb1);
 122                 return -EINVAL;
 123         }
 124         /*
 125          * fb1 is remote block, fb2 is the one that
 126          * wishes to be notified.
 127          */
 128         ret = subscribe_to_remote_fblock(fb2, fb1);
 129
 130         put_fblock(fb1);
 131         put_fblock(fb2);
 132
 133         return ret;
 134 }
 135
 136 static int userctl_unsubscribe(struct lananlmsg *lmsg)
 137 {
 138         struct fblock *fb1, *fb2;
 139         struct lananlmsg_tuple *msg = (struct lananlmsg_tuple *) lmsg->buff;
 140
 141         fb1 = search_fblock_n(msg->name1);
 142         if (!fb1)
 143                 return -EINVAL;
 144
 145         fb2 = search_fblock_n(msg->name2);
 146         if (!fb2) {
 147                 put_fblock(fb1);
 148                 return -EINVAL;
 149         }
 150
 151         unsubscribe_from_remote_fblock(fb2, fb1);
 152
 153         put_fblock(fb1);
 154         put_fblock(fb2);
 155
 156         return 0;
 157 }
 158
 159 static int userctl_remove(struct lananlmsg *lmsg)
 160 {
 161         struct fblock *fb;
 162         struct lananlmsg_rm *msg = (struct lananlmsg_rm *) lmsg->buff;
 163
 164         fb = search_fblock_n(msg->name);
 165         if (!fb)
 166                 return -EINVAL;
 167         if (!fb->factory) {
 168                 /* vlink types have no factory */
 169                 put_fblock(fb);
 170                 return -EINVAL;
 171         }
 172
 173         if (atomic_read(&fb->refcnt) > 2) {
 174                 /* Still in use by others */
 175                 put_fblock(fb);
 176                 return -EBUSY;
 177         }
 178
 179         unregister_fblock_namespace(fb);
 180         put_fblock(fb);
 181
 182         return 0;
 183 }
 184
 185 static int userctl_bind(struct lananlmsg *lmsg)
 186 {
 187         int ret;
 188         struct fblock *fb1, *fb2;
 189         struct lananlmsg_tuple *msg = (struct lananlmsg_tuple *) lmsg->buff;
 190
 191         fb1 = search_fblock_n(msg->name1);
 192         if (!fb1)
 193                 return -EINVAL;
 194
 195         fb2 = search_fblock_n(msg->name2);
 196         if (!fb2) {
 197                 put_fblock(fb1);
 198                 return -EINVAL;
 199         }
 200
 201         ret = fblock_bind(fb1, fb2);
 202
 203         put_fblock(fb1);
 204         put_fblock(fb2);
 205
 206         return ret;
 207 }
 208
 209 static int userctl_unbind(struct lananlmsg *lmsg)
 210 {
 211         int ret;
 212         struct fblock *fb1, *fb2;
 213         struct lananlmsg_tuple *msg = (struct lananlmsg_tuple *) lmsg->buff;
 214
 215         fb1 = search_fblock_n(msg->name1);
 216         if (!fb1)
 217                 return -EINVAL;
 218
 219         fb2 = search_fblock_n(msg->name2);
 220         if (!fb2) {
 221                 put_fblock(fb1);
 222                 return -EINVAL;
 223         }
 224
 225         ret = fblock_unbind(fb1, fb2);
 226
 227         put_fblock(fb1);
 228         put_fblock(fb2);
 229
 230         return ret;
 231 }
 232
 233 static int __userctl_rcv(struct sk_buff *skb, struct nlmsghdr *nlh)
 234 {
 235         int ret = 0;
 236         struct lananlmsg *lmsg;
 237
 238         if (security_netlink_recv(skb, CAP_NET_ADMIN))
 239                 return -EPERM;
 240         if (nlh->nlmsg_len < NLMSG_LENGTH(sizeof(struct lananlmsg)))
 241                 return 0;
 242
 243         lmsg = NLMSG_DATA(nlh);
 244
 245         switch (lmsg->cmd) {
 246         case NETLINK_USERCTL_CMD_ADD:
 247                 ret = userctl_add(lmsg);
 248                 break;
 249         case NETLINK_USERCTL_CMD_SET:
 250                 ret = userctl_set(lmsg);
 251                 break;
 252         case NETLINK_USERCTL_CMD_REPLACE:
 253                 ret = userctl_replace(lmsg);
 254                 break;
 255         case NETLINK_USERCTL_CMD_SUBSCRIBE:
 256                 ret = userctl_subscribe(lmsg);
 257                 break;
 258         case NETLINK_USERCTL_CMD_UNSUBSCRIBE:
 259                 ret = userctl_unsubscribe(lmsg);
 260                 break;
 261         case NETLINK_USERCTL_CMD_RM:
 262                 ret = userctl_remove(lmsg);
 263                 break;
 264         case NETLINK_USERCTL_CMD_BIND:
 265                 ret = userctl_bind(lmsg);
 266                 break;
 267         case NETLINK_USERCTL_CMD_UNBIND:
 268                 ret = userctl_unbind(lmsg);
 269                 break;
 270         default:
 271                 printk(KERN_INFO "[lana] Unknown command!\n");
 272                 ret = -ENOENT;
 273                 break;
 274         }
 275
 276         return ret;
 277 }
 278
 279 static void userctl_rcv(struct sk_buff *skb)
 280 {
 281         netlink_rcv_skb(skb, &__userctl_rcv);
 282 }
 283
 284 int init_userctl_system(void)
 285 {
 286         userctl_sock = netlink_kernel_create(&init_net, NETLINK_USERCTL,
 287                                              USERCTLGRP_MAX, userctl_rcv,
 288                                              NULL, THIS_MODULE);
 289         return !userctl_sock ? -ENOMEM : 0;
 290 }
 291 EXPORT_SYMBOL_GPL(init_userctl_system);
 292
 293 void cleanup_userctl_system(void)
 294 {
 295         netlink_kernel_release(userctl_sock);
 296 }
 297 EXPORT_SYMBOL_GPL(cleanup_userctl_system);
 298