net/wireless/nl80211.c

   1 /*
   2  * This is the new netlink-based wireless configuration interface.
   3  *
   4  * Copyright 2006, 2007 Johannes Berg <johannes@sipsolutions.net>
   5  */
   6
   7 #include <linux/if.h>
   8 #include <linux/module.h>
   9 #include <linux/err.h>
  10 #include <linux/mutex.h>
  11 #include <linux/list.h>
  12 #include <linux/if_ether.h>
  13 #include <linux/ieee80211.h>
  14 #include <linux/nl80211.h>
  15 #include <linux/rtnetlink.h>
  16 #include <linux/netlink.h>
  17 #include <net/genetlink.h>
  18 #include <net/cfg80211.h>
  19 #include "core.h"
  20 #include "nl80211.h"
  21
  22 /* the netlink family */
  23 static struct genl_family nl80211_fam = {
  24         .id = GENL_ID_GENERATE, /* don't bother with a hardcoded ID */
  25         .name = "nl80211",      /* have users key off the name instead */
  26         .hdrsize = 0,           /* no private header */
  27         .version = 1,           /* no particular meaning now */
  28         .maxattr = NL80211_ATTR_MAX,
  29 };
  30
  31 /* internal helper: get drv and dev */
  32 static int get_drv_dev_by_info_ifindex(struct genl_info *info,
  33                                        struct cfg80211_registered_device **drv,
  34                                        struct net_device **dev)
  35 {
  36         int ifindex;
  37
  38         if (!info->attrs[NL80211_ATTR_IFINDEX])
  39                 return -EINVAL;
  40
  41         ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
  42         *dev = dev_get_by_index(&init_net, ifindex);
  43         if (!*dev)
  44                 return -ENODEV;
  45
  46         *drv = cfg80211_get_dev_from_ifindex(ifindex);
  47         if (IS_ERR(*drv)) {
  48                 dev_put(*dev);
  49                 return PTR_ERR(*drv);
  50         }
  51
  52         return 0;
  53 }
  54
  55 /* policy for the attributes */
  56 static struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] __read_mostly = {
  57         [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
  58         [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
  59                                       .len = BUS_ID_SIZE-1 },
  60
  61         [NL80211_ATTR_IFTYPE] = { .type = NLA_U32 },
  62         [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
  63         [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
  64
  65         [NL80211_ATTR_MAC] = { .type = NLA_BINARY, .len = ETH_ALEN },
  66
  67         [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
  68                                     .len = WLAN_MAX_KEY_LEN },
  69         [NL80211_ATTR_KEY_IDX] = { .type = NLA_U8 },
  70         [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
  71         [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
  72
  73         [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
  74         [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
  75         [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,
  76                                        .len = IEEE80211_MAX_DATA_LEN },
  77         [NL80211_ATTR_BEACON_TAIL] = { .type = NLA_BINARY,
  78                                        .len = IEEE80211_MAX_DATA_LEN },
  79         [NL80211_ATTR_STA_AID] = { .type = NLA_U16 },
  80         [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
  81         [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
  82         [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
  83                                                .len = NL80211_MAX_SUPP_RATES },
  84         [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
  85 };
  86
  87 /* message building helper */
  88 static inline void *nl80211hdr_put(struct sk_buff *skb, u32 pid, u32 seq,
  89                                    int flags, u8 cmd)
  90 {
  91         /* since there is no private header just add the generic one */
  92         return genlmsg_put(skb, pid, seq, &nl80211_fam, flags, cmd);
  93 }
  94
  95 /* netlink command implementations */
  96
  97 static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
  98                               struct cfg80211_registered_device *dev)
  99 {
 100         void *hdr;
 101
 102         hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_WIPHY);
 103         if (!hdr)
 104                 return -1;
 105
 106         NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, dev->idx);
 107         NLA_PUT_STRING(msg, NL80211_ATTR_WIPHY_NAME, wiphy_name(&dev->wiphy));
 108         return genlmsg_end(msg, hdr);
 109
 110  nla_put_failure:
 111         return genlmsg_cancel(msg, hdr);
 112 }
 113
 114 static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
 115 {
 116         int idx = 0;
 117         int start = cb->args[0];
 118         struct cfg80211_registered_device *dev;
 119
 120         mutex_lock(&cfg80211_drv_mutex);
 121         list_for_each_entry(dev, &cfg80211_drv_list, list) {
 122                 if (++idx < start)
 123                         continue;
 124                 if (nl80211_send_wiphy(skb, NETLINK_CB(cb->skb).pid,
 125                                        cb->nlh->nlmsg_seq, NLM_F_MULTI,
 126                                        dev) < 0)
 127                         break;
 128         }
 129         mutex_unlock(&cfg80211_drv_mutex);
 130
 131         cb->args[0] = idx;
 132
 133         return skb->len;
 134 }
 135
 136 static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
 137 {
 138         struct sk_buff *msg;
 139         struct cfg80211_registered_device *dev;
 140
 141         dev = cfg80211_get_dev_from_info(info);
 142         if (IS_ERR(dev))
 143                 return PTR_ERR(dev);
 144
 145         msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 146         if (!msg)
 147                 goto out_err;
 148
 149         if (nl80211_send_wiphy(msg, info->snd_pid, info->snd_seq, 0, dev) < 0)
 150                 goto out_free;
 151
 152         cfg80211_put_dev(dev);
 153
 154         return genlmsg_unicast(msg, info->snd_pid);
 155
 156  out_free:
 157         nlmsg_free(msg);
 158  out_err:
 159         cfg80211_put_dev(dev);
 160         return -ENOBUFS;
 161 }
 162
 163 static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
 164 {
 165         struct cfg80211_registered_device *rdev;
 166         int result;
 167
 168         if (!info->attrs[NL80211_ATTR_WIPHY_NAME])
 169                 return -EINVAL;
 170
 171         rdev = cfg80211_get_dev_from_info(info);
 172         if (IS_ERR(rdev))
 173                 return PTR_ERR(rdev);
 174
 175         result = cfg80211_dev_rename(rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
 176
 177         cfg80211_put_dev(rdev);
 178         return result;
 179 }
 180
 181
 182 static int nl80211_send_iface(struct sk_buff *msg, u32 pid, u32 seq, int flags,
 183                               struct net_device *dev)
 184 {
 185         void *hdr;
 186
 187         hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_INTERFACE);
 188         if (!hdr)
 189                 return -1;
 190
 191         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
 192         NLA_PUT_STRING(msg, NL80211_ATTR_IFNAME, dev->name);
 193         /* TODO: interface type */
 194         return genlmsg_end(msg, hdr);
 195
 196  nla_put_failure:
 197         return genlmsg_cancel(msg, hdr);
 198 }
 199
 200 static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
 201 {
 202         int wp_idx = 0;
 203         int if_idx = 0;
 204         int wp_start = cb->args[0];
 205         int if_start = cb->args[1];
 206         struct cfg80211_registered_device *dev;
 207         struct wireless_dev *wdev;
 208
 209         mutex_lock(&cfg80211_drv_mutex);
 210         list_for_each_entry(dev, &cfg80211_drv_list, list) {
 211                 if (++wp_idx < wp_start)
 212                         continue;
 213                 if_idx = 0;
 214
 215                 mutex_lock(&dev->devlist_mtx);
 216                 list_for_each_entry(wdev, &dev->netdev_list, list) {
 217                         if (++if_idx < if_start)
 218                                 continue;
 219                         if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).pid,
 220                                                cb->nlh->nlmsg_seq, NLM_F_MULTI,
 221                                                wdev->netdev) < 0)
 222                                 break;
 223                 }
 224                 mutex_unlock(&dev->devlist_mtx);
 225         }
 226         mutex_unlock(&cfg80211_drv_mutex);
 227
 228         cb->args[0] = wp_idx;
 229         cb->args[1] = if_idx;
 230
 231         return skb->len;
 232 }
 233
 234 static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
 235 {
 236         struct sk_buff *msg;
 237         struct cfg80211_registered_device *dev;
 238         struct net_device *netdev;
 239         int err;
 240
 241         err = get_drv_dev_by_info_ifindex(info, &dev, &netdev);
 242         if (err)
 243                 return err;
 244
 245         msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 246         if (!msg)
 247                 goto out_err;
 248
 249         if (nl80211_send_iface(msg, info->snd_pid, info->snd_seq, 0, netdev) < 0)
 250                 goto out_free;
 251
 252         dev_put(netdev);
 253         cfg80211_put_dev(dev);
 254
 255         return genlmsg_unicast(msg, info->snd_pid);
 256
 257  out_free:
 258         nlmsg_free(msg);
 259  out_err:
 260         dev_put(netdev);
 261         cfg80211_put_dev(dev);
 262         return -ENOBUFS;
 263 }
 264
 265 static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
 266 {
 267         struct cfg80211_registered_device *drv;
 268         int err, ifindex;
 269         enum nl80211_iftype type;
 270         struct net_device *dev;
 271
 272         if (info->attrs[NL80211_ATTR_IFTYPE]) {
 273                 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
 274                 if (type > NL80211_IFTYPE_MAX)
 275                         return -EINVAL;
 276         } else
 277                 return -EINVAL;
 278
 279         err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
 280         if (err)
 281                 return err;
 282         ifindex = dev->ifindex;
 283         dev_put(dev);
 284
 285         if (!drv->ops->change_virtual_intf) {
 286                 err = -EOPNOTSUPP;
 287                 goto unlock;
 288         }
 289
 290         rtnl_lock();
 291         err = drv->ops->change_virtual_intf(&drv->wiphy, ifindex, type);
 292         rtnl_unlock();
 293
 294  unlock:
 295         cfg80211_put_dev(drv);
 296         return err;
 297 }
 298
 299 static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
 300 {
 301         struct cfg80211_registered_device *drv;
 302         int err;
 303         enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
 304
 305         if (!info->attrs[NL80211_ATTR_IFNAME])
 306                 return -EINVAL;
 307
 308         if (info->attrs[NL80211_ATTR_IFTYPE]) {
 309                 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
 310                 if (type > NL80211_IFTYPE_MAX)
 311                         return -EINVAL;
 312         }
 313
 314         drv = cfg80211_get_dev_from_info(info);
 315         if (IS_ERR(drv))
 316                 return PTR_ERR(drv);
 317
 318         if (!drv->ops->add_virtual_intf) {
 319                 err = -EOPNOTSUPP;
 320                 goto unlock;
 321         }
 322
 323         rtnl_lock();
 324         err = drv->ops->add_virtual_intf(&drv->wiphy,
 325                 nla_data(info->attrs[NL80211_ATTR_IFNAME]), type);
 326         rtnl_unlock();
 327
 328  unlock:
 329         cfg80211_put_dev(drv);
 330         return err;
 331 }
 332
 333 static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
 334 {
 335         struct cfg80211_registered_device *drv;
 336         int ifindex, err;
 337         struct net_device *dev;
 338
 339         err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
 340         if (err)
 341                 return err;
 342         ifindex = dev->ifindex;
 343         dev_put(dev);
 344
 345         if (!drv->ops->del_virtual_intf) {
 346                 err = -EOPNOTSUPP;
 347                 goto out;
 348         }
 349
 350         rtnl_lock();
 351         err = drv->ops->del_virtual_intf(&drv->wiphy, ifindex);
 352         rtnl_unlock();
 353
 354  out:
 355         cfg80211_put_dev(drv);
 356         return err;
 357 }
 358
 359 struct get_key_cookie {
 360         struct sk_buff *msg;
 361         int error;
 362 };
 363
 364 static void get_key_callback(void *c, struct key_params *params)
 365 {
 366         struct get_key_cookie *cookie = c;
 367
 368         if (params->key)
 369                 NLA_PUT(cookie->msg, NL80211_ATTR_KEY_DATA,
 370                         params->key_len, params->key);
 371
 372         if (params->seq)
 373                 NLA_PUT(cookie->msg, NL80211_ATTR_KEY_SEQ,
 374                         params->seq_len, params->seq);
 375
 376         if (params->cipher)
 377                 NLA_PUT_U32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
 378                             params->cipher);
 379
 380         return;
 381  nla_put_failure:
 382         cookie->error = 1;
 383 }
 384
 385 static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
 386 {
 387         struct cfg80211_registered_device *drv;
 388         int err;
 389         struct net_device *dev;
 390         u8 key_idx = 0;
 391         u8 *mac_addr = NULL;
 392         struct get_key_cookie cookie = {
 393                 .error = 0,
 394         };
 395         void *hdr;
 396         struct sk_buff *msg;
 397
 398         if (info->attrs[NL80211_ATTR_KEY_IDX])
 399                 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
 400
 401         if (key_idx > 3)
 402                 return -EINVAL;
 403
 404         if (info->attrs[NL80211_ATTR_MAC])
 405                 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 406
 407         err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
 408         if (err)
 409                 return err;
 410
 411         if (!drv->ops->get_key) {
 412                 err = -EOPNOTSUPP;
 413                 goto out;
 414         }
 415
 416         msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 417         if (!msg) {
 418                 err = -ENOMEM;
 419                 goto out;
 420         }
 421
 422         hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
 423                              NL80211_CMD_NEW_KEY);
 424
 425         if (IS_ERR(hdr)) {
 426                 err = PTR_ERR(hdr);
 427                 goto out;
 428         }
 429
 430         cookie.msg = msg;
 431
 432         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
 433         NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_idx);
 434         if (mac_addr)
 435                 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr);
 436
 437         rtnl_lock();
 438         err = drv->ops->get_key(&drv->wiphy, dev, key_idx, mac_addr,
 439                                 &cookie, get_key_callback);
 440         rtnl_unlock();
 441
 442         if (err)
 443                 goto out;
 444
 445         if (cookie.error)
 446                 goto nla_put_failure;
 447
 448         genlmsg_end(msg, hdr);
 449         err = genlmsg_unicast(msg, info->snd_pid);
 450         goto out;
 451
 452  nla_put_failure:
 453         err = -ENOBUFS;
 454         nlmsg_free(msg);
 455  out:
 456         cfg80211_put_dev(drv);
 457         dev_put(dev);
 458         return err;
 459 }
 460
 461 static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
 462 {
 463         struct cfg80211_registered_device *drv;
 464         int err;
 465         struct net_device *dev;
 466         u8 key_idx;
 467
 468         if (!info->attrs[NL80211_ATTR_KEY_IDX])
 469                 return -EINVAL;
 470
 471         key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
 472
 473         if (key_idx > 3)
 474                 return -EINVAL;
 475
 476         /* currently only support setting default key */
 477         if (!info->attrs[NL80211_ATTR_KEY_DEFAULT])
 478                 return -EINVAL;
 479
 480         err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
 481         if (err)
 482                 return err;
 483
 484         if (!drv->ops->set_default_key) {
 485                 err = -EOPNOTSUPP;
 486                 goto out;
 487         }
 488
 489         rtnl_lock();
 490         err = drv->ops->set_default_key(&drv->wiphy, dev, key_idx);
 491         rtnl_unlock();
 492
 493  out:
 494         cfg80211_put_dev(drv);
 495         dev_put(dev);
 496         return err;
 497 }
 498
 499 static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
 500 {
 501         struct cfg80211_registered_device *drv;
 502         int err;
 503         struct net_device *dev;
 504         struct key_params params;
 505         u8 key_idx = 0;
 506         u8 *mac_addr = NULL;
 507
 508         memset(&params, 0, sizeof(params));
 509
 510         if (!info->attrs[NL80211_ATTR_KEY_CIPHER])
 511                 return -EINVAL;
 512
 513         if (info->attrs[NL80211_ATTR_KEY_DATA]) {
 514                 params.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
 515                 params.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
 516         }
 517
 518         if (info->attrs[NL80211_ATTR_KEY_IDX])
 519                 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
 520
 521         params.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
 522
 523         if (info->attrs[NL80211_ATTR_MAC])
 524                 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 525
 526         if (key_idx > 3)
 527                 return -EINVAL;
 528
 529         /*
 530          * Disallow pairwise keys with non-zero index unless it's WEP
 531          * (because current deployments use pairwise WEP keys with
 532          * non-zero indizes but 802.11i clearly specifies to use zero)
 533          */
 534         if (mac_addr && key_idx &&
 535             params.cipher != WLAN_CIPHER_SUITE_WEP40 &&
 536             params.cipher != WLAN_CIPHER_SUITE_WEP104)
 537                 return -EINVAL;
 538
 539         /* TODO: add definitions for the lengths to linux/ieee80211.h */
 540         switch (params.cipher) {
 541         case WLAN_CIPHER_SUITE_WEP40:
 542                 if (params.key_len != 5)
 543                         return -EINVAL;
 544                 break;
 545         case WLAN_CIPHER_SUITE_TKIP:
 546                 if (params.key_len != 32)
 547                         return -EINVAL;
 548                 break;
 549         case WLAN_CIPHER_SUITE_CCMP:
 550                 if (params.key_len != 16)
 551                         return -EINVAL;
 552                 break;
 553         case WLAN_CIPHER_SUITE_WEP104:
 554                 if (params.key_len != 13)
 555                         return -EINVAL;
 556                 break;
 557         default:
 558                 return -EINVAL;
 559         }
 560
 561         err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
 562         if (err)
 563                 return err;
 564
 565         if (!drv->ops->add_key) {
 566                 err = -EOPNOTSUPP;
 567                 goto out;
 568         }
 569
 570         rtnl_lock();
 571         err = drv->ops->add_key(&drv->wiphy, dev, key_idx, mac_addr, &params);
 572         rtnl_unlock();
 573
 574  out:
 575         cfg80211_put_dev(drv);
 576         dev_put(dev);
 577         return err;
 578 }
 579
 580 static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
 581 {
 582         struct cfg80211_registered_device *drv;
 583         int err;
 584         struct net_device *dev;
 585         u8 key_idx = 0;
 586         u8 *mac_addr = NULL;
 587
 588         if (info->attrs[NL80211_ATTR_KEY_IDX])
 589                 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
 590
 591         if (key_idx > 3)
 592                 return -EINVAL;
 593
 594         if (info->attrs[NL80211_ATTR_MAC])
 595                 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 596
 597         err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
 598         if (err)
 599                 return err;
 600
 601         if (!drv->ops->del_key) {
 602                 err = -EOPNOTSUPP;
 603                 goto out;
 604         }
 605
 606         rtnl_lock();
 607         err = drv->ops->del_key(&drv->wiphy, dev, key_idx, mac_addr);
 608         rtnl_unlock();
 609
 610  out:
 611         cfg80211_put_dev(drv);
 612         dev_put(dev);
 613         return err;
 614 }
 615
 616 static int nl80211_addset_beacon(struct sk_buff *skb, struct genl_info *info)
 617 {
 618         int (*call)(struct wiphy *wiphy, struct net_device *dev,
 619                     struct beacon_parameters *info);
 620         struct cfg80211_registered_device *drv;
 621         int err;
 622         struct net_device *dev;
 623         struct beacon_parameters params;
 624         int haveinfo = 0;
 625
 626         err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
 627         if (err)
 628                 return err;
 629
 630         switch (info->genlhdr->cmd) {
 631         case NL80211_CMD_NEW_BEACON:
 632                 /* these are required for NEW_BEACON */
 633                 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
 634                     !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
 635                     !info->attrs[NL80211_ATTR_BEACON_HEAD]) {
 636                         err = -EINVAL;
 637                         goto out;
 638                 }
 639
 640                 call = drv->ops->add_beacon;
 641                 break;
 642         case NL80211_CMD_SET_BEACON:
 643                 call = drv->ops->set_beacon;
 644                 break;
 645         default:
 646                 WARN_ON(1);
 647                 err = -EOPNOTSUPP;
 648                 goto out;
 649         }
 650
 651         if (!call) {
 652                 err = -EOPNOTSUPP;
 653                 goto out;
 654         }
 655
 656         memset(&params, 0, sizeof(params));
 657
 658         if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
 659                 params.interval =
 660                     nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
 661                 haveinfo = 1;
 662         }
 663
 664         if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
 665                 params.dtim_period =
 666                     nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
 667                 haveinfo = 1;
 668         }
 669
 670         if (info->attrs[NL80211_ATTR_BEACON_HEAD]) {
 671                 params.head = nla_data(info->attrs[NL80211_ATTR_BEACON_HEAD]);
 672                 params.head_len =
 673                     nla_len(info->attrs[NL80211_ATTR_BEACON_HEAD]);
 674                 haveinfo = 1;
 675         }
 676
 677         if (info->attrs[NL80211_ATTR_BEACON_TAIL]) {
 678                 params.tail = nla_data(info->attrs[NL80211_ATTR_BEACON_TAIL]);
 679                 params.tail_len =
 680                     nla_len(info->attrs[NL80211_ATTR_BEACON_TAIL]);
 681                 haveinfo = 1;
 682         }
 683
 684         if (!haveinfo) {
 685                 err = -EINVAL;
 686                 goto out;
 687         }
 688
 689         rtnl_lock();
 690         err = call(&drv->wiphy, dev, &params);
 691         rtnl_unlock();
 692
 693  out:
 694         cfg80211_put_dev(drv);
 695         dev_put(dev);
 696         return err;
 697 }
 698
 699 static int nl80211_del_beacon(struct sk_buff *skb, struct genl_info *info)
 700 {
 701         struct cfg80211_registered_device *drv;
 702         int err;
 703         struct net_device *dev;
 704
 705         err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
 706         if (err)
 707                 return err;
 708
 709         if (!drv->ops->del_beacon) {
 710                 err = -EOPNOTSUPP;
 711                 goto out;
 712         }
 713
 714         rtnl_lock();
 715         err = drv->ops->del_beacon(&drv->wiphy, dev);
 716         rtnl_unlock();
 717
 718  out:
 719         cfg80211_put_dev(drv);
 720         dev_put(dev);
 721         return err;
 722 }
 723
 724 static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
 725         [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
 726         [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
 727         [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
 728 };
 729
 730 static int parse_station_flags(struct nlattr *nla, u32 *staflags)
 731 {
 732         struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
 733         int flag;
 734
 735         *staflags = 0;
 736
 737         if (!nla)
 738                 return 0;
 739
 740         if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX,
 741                              nla, sta_flags_policy))
 742                 return -EINVAL;
 743
 744         *staflags = STATION_FLAG_CHANGED;
 745
 746         for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++)
 747                 if (flags[flag])
 748                         *staflags |= (1<<flag);
 749
 750         return 0;
 751 }
 752
 753 static int nl80211_send_station(struct sk_buff *msg, u32 pid, u32 seq,
 754                                 int flags, struct net_device *dev,
 755                                 u8 *mac_addr, struct station_stats *stats)
 756 {
 757         void *hdr;
 758         struct nlattr *statsattr;
 759
 760         hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
 761         if (!hdr)
 762                 return -1;
 763
 764         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
 765         NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr);
 766
 767         statsattr = nla_nest_start(msg, NL80211_ATTR_STA_STATS);
 768         if (!statsattr)
 769                 goto nla_put_failure;
 770         if (stats->filled & STATION_STAT_INACTIVE_TIME)
 771                 NLA_PUT_U32(msg, NL80211_STA_STAT_INACTIVE_TIME,
 772                             stats->inactive_time);
 773         if (stats->filled & STATION_STAT_RX_BYTES)
 774                 NLA_PUT_U32(msg, NL80211_STA_STAT_RX_BYTES,
 775                             stats->rx_bytes);
 776         if (stats->filled & STATION_STAT_TX_BYTES)
 777                 NLA_PUT_U32(msg, NL80211_STA_STAT_TX_BYTES,
 778                             stats->tx_bytes);
 779
 780         nla_nest_end(msg, statsattr);
 781
 782         return genlmsg_end(msg, hdr);
 783
 784  nla_put_failure:
 785         return genlmsg_cancel(msg, hdr);
 786 }
 787
 788
 789 static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
 790 {
 791         struct cfg80211_registered_device *drv;
 792         int err;
 793         struct net_device *dev;
 794         struct station_stats stats;
 795         struct sk_buff *msg;
 796         u8 *mac_addr = NULL;
 797
 798         memset(&stats, 0, sizeof(stats));
 799
 800         if (!info->attrs[NL80211_ATTR_MAC])
 801                 return -EINVAL;
 802
 803         mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 804
 805         err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
 806         if (err)
 807                 return err;
 808
 809         if (!drv->ops->get_station) {
 810                 err = -EOPNOTSUPP;
 811                 goto out;
 812         }
 813
 814         rtnl_lock();
 815         err = drv->ops->get_station(&drv->wiphy, dev, mac_addr, &stats);
 816         rtnl_unlock();
 817
 818         msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 819         if (!msg)
 820                 goto out;
 821
 822         if (nl80211_send_station(msg, info->snd_pid, info->snd_seq, 0,
 823                                  dev, mac_addr, &stats) < 0)
 824                 goto out_free;
 825
 826         err = genlmsg_unicast(msg, info->snd_pid);
 827         goto out;
 828
 829  out_free:
 830         nlmsg_free(msg);
 831
 832  out:
 833         cfg80211_put_dev(drv);
 834         dev_put(dev);
 835         return err;
 836 }
 837
 838 /*
 839  * Get vlan interface making sure it is on the right wiphy.
 840  */
 841 static int get_vlan(struct nlattr *vlanattr,
 842                     struct cfg80211_registered_device *rdev,
 843                     struct net_device **vlan)
 844 {
 845         *vlan = NULL;
 846
 847         if (vlanattr) {
 848                 *vlan = dev_get_by_index(&init_net, nla_get_u32(vlanattr));
 849                 if (!*vlan)
 850                         return -ENODEV;
 851                 if (!(*vlan)->ieee80211_ptr)
 852                         return -EINVAL;
 853                 if ((*vlan)->ieee80211_ptr->wiphy != &rdev->wiphy)
 854                         return -EINVAL;
 855         }
 856         return 0;
 857 }
 858
 859 static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
 860 {
 861         struct cfg80211_registered_device *drv;
 862         int err;
 863         struct net_device *dev;
 864         struct station_parameters params;
 865         u8 *mac_addr = NULL;
 866
 867         memset(&params, 0, sizeof(params));
 868
 869         params.listen_interval = -1;
 870
 871         if (info->attrs[NL80211_ATTR_STA_AID])
 872                 return -EINVAL;
 873
 874         if (!info->attrs[NL80211_ATTR_MAC])
 875                 return -EINVAL;
 876
 877         mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 878
 879         if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
 880                 params.supported_rates =
 881                         nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
 882                 params.supported_rates_len =
 883                         nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
 884         }
 885
 886         if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
 887                 params.listen_interval =
 888                     nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
 889
 890         if (parse_station_flags(info->attrs[NL80211_ATTR_STA_FLAGS],
 891                                 &params.station_flags))
 892                 return -EINVAL;
 893
 894         err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
 895         if (err)
 896                 return err;
 897
 898         err = get_vlan(info->attrs[NL80211_ATTR_STA_VLAN], drv, &params.vlan);
 899         if (err)
 900                 goto out;
 901
 902         if (!drv->ops->change_station) {
 903                 err = -EOPNOTSUPP;
 904                 goto out;
 905         }
 906
 907         rtnl_lock();
 908         err = drv->ops->change_station(&drv->wiphy, dev, mac_addr, &params);
 909         rtnl_unlock();
 910
 911  out:
 912         if (params.vlan)
 913                 dev_put(params.vlan);
 914         cfg80211_put_dev(drv);
 915         dev_put(dev);
 916         return err;
 917 }
 918
 919 static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
 920 {
 921         struct cfg80211_registered_device *drv;
 922         int err;
 923         struct net_device *dev;
 924         struct station_parameters params;
 925         u8 *mac_addr = NULL;
 926
 927         memset(&params, 0, sizeof(params));
 928
 929         if (!info->attrs[NL80211_ATTR_MAC])
 930                 return -EINVAL;
 931
 932         if (!info->attrs[NL80211_ATTR_STA_AID])
 933                 return -EINVAL;
 934
 935         if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
 936                 return -EINVAL;
 937
 938         if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
 939                 return -EINVAL;
 940
 941         mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 942         params.supported_rates =
 943                 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
 944         params.supported_rates_len =
 945                 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
 946         params.listen_interval =
 947                 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
 948         params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
 949
 950         if (parse_station_flags(info->attrs[NL80211_ATTR_STA_FLAGS],
 951                                 &params.station_flags))
 952                 return -EINVAL;
 953
 954         err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
 955         if (err)
 956                 return err;
 957
 958         err = get_vlan(info->attrs[NL80211_ATTR_STA_VLAN], drv, &params.vlan);
 959         if (err)
 960                 goto out;
 961
 962         if (!drv->ops->add_station) {
 963                 err = -EOPNOTSUPP;
 964                 goto out;
 965         }
 966
 967         rtnl_lock();
 968         err = drv->ops->add_station(&drv->wiphy, dev, mac_addr, &params);
 969         rtnl_unlock();
 970
 971  out:
 972         if (params.vlan)
 973                 dev_put(params.vlan);
 974         cfg80211_put_dev(drv);
 975         dev_put(dev);
 976         return err;
 977 }
 978
 979 static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
 980 {
 981         struct cfg80211_registered_device *drv;
 982         int err;
 983         struct net_device *dev;
 984         u8 *mac_addr = NULL;
 985
 986         if (info->attrs[NL80211_ATTR_MAC])
 987                 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 988
 989         err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
 990         if (err)
 991                 return err;
 992
 993         if (!drv->ops->del_station) {
 994                 err = -EOPNOTSUPP;
 995                 goto out;
 996         }
 997
 998         rtnl_lock();
 999         err = drv->ops->del_station(&drv->wiphy, dev, mac_addr);
1000         rtnl_unlock();
1001
1002  out:
1003         cfg80211_put_dev(drv);
1004         dev_put(dev);
1005         return err;
1006 }
1007
1008 static struct genl_ops nl80211_ops[] = {
1009         {
1010                 .cmd = NL80211_CMD_GET_WIPHY,
1011                 .doit = nl80211_get_wiphy,
1012                 .dumpit = nl80211_dump_wiphy,
1013                 .policy = nl80211_policy,
1014                 /* can be retrieved by unprivileged users */
1015         },
1016         {
1017                 .cmd = NL80211_CMD_SET_WIPHY,
1018                 .doit = nl80211_set_wiphy,
1019                 .policy = nl80211_policy,
1020                 .flags = GENL_ADMIN_PERM,
1021         },
1022         {
1023                 .cmd = NL80211_CMD_GET_INTERFACE,
1024                 .doit = nl80211_get_interface,
1025                 .dumpit = nl80211_dump_interface,
1026                 .policy = nl80211_policy,
1027                 /* can be retrieved by unprivileged users */
1028         },
1029         {
1030                 .cmd = NL80211_CMD_SET_INTERFACE,
1031                 .doit = nl80211_set_interface,
1032                 .policy = nl80211_policy,
1033                 .flags = GENL_ADMIN_PERM,
1034         },
1035         {
1036                 .cmd = NL80211_CMD_NEW_INTERFACE,
1037                 .doit = nl80211_new_interface,
1038                 .policy = nl80211_policy,
1039                 .flags = GENL_ADMIN_PERM,
1040         },
1041         {
1042                 .cmd = NL80211_CMD_DEL_INTERFACE,
1043                 .doit = nl80211_del_interface,
1044                 .policy = nl80211_policy,
1045                 .flags = GENL_ADMIN_PERM,
1046         },
1047         {
1048                 .cmd = NL80211_CMD_GET_KEY,
1049                 .doit = nl80211_get_key,
1050                 .policy = nl80211_policy,
1051                 .flags = GENL_ADMIN_PERM,
1052         },
1053         {
1054                 .cmd = NL80211_CMD_SET_KEY,
1055                 .doit = nl80211_set_key,
1056                 .policy = nl80211_policy,
1057                 .flags = GENL_ADMIN_PERM,
1058         },
1059         {
1060                 .cmd = NL80211_CMD_NEW_KEY,
1061                 .doit = nl80211_new_key,
1062                 .policy = nl80211_policy,
1063                 .flags = GENL_ADMIN_PERM,
1064         },
1065         {
1066                 .cmd = NL80211_CMD_DEL_KEY,
1067                 .doit = nl80211_del_key,
1068                 .policy = nl80211_policy,
1069                 .flags = GENL_ADMIN_PERM,
1070         },
1071         {
1072                 .cmd = NL80211_CMD_SET_BEACON,
1073                 .policy = nl80211_policy,
1074                 .flags = GENL_ADMIN_PERM,
1075                 .doit = nl80211_addset_beacon,
1076         },
1077         {
1078                 .cmd = NL80211_CMD_NEW_BEACON,
1079                 .policy = nl80211_policy,
1080                 .flags = GENL_ADMIN_PERM,
1081                 .doit = nl80211_addset_beacon,
1082         },
1083         {
1084                 .cmd = NL80211_CMD_DEL_BEACON,
1085                 .policy = nl80211_policy,
1086                 .flags = GENL_ADMIN_PERM,
1087                 .doit = nl80211_del_beacon,
1088         },
1089         {
1090                 .cmd = NL80211_CMD_GET_STATION,
1091                 .doit = nl80211_get_station,
1092                 /* TODO: implement dumpit */
1093                 .policy = nl80211_policy,
1094                 .flags = GENL_ADMIN_PERM,
1095         },
1096         {
1097                 .cmd = NL80211_CMD_SET_STATION,
1098                 .doit = nl80211_set_station,
1099                 .policy = nl80211_policy,
1100                 .flags = GENL_ADMIN_PERM,
1101         },
1102         {
1103                 .cmd = NL80211_CMD_NEW_STATION,
1104                 .doit = nl80211_new_station,
1105                 .policy = nl80211_policy,
1106                 .flags = GENL_ADMIN_PERM,
1107         },
1108         {
1109                 .cmd = NL80211_CMD_DEL_STATION,
1110                 .doit = nl80211_del_station,
1111                 .policy = nl80211_policy,
1112                 .flags = GENL_ADMIN_PERM,
1113         },
1114 };
1115
1116 /* multicast groups */
1117 static struct genl_multicast_group nl80211_config_mcgrp = {
1118         .name = "config",
1119 };
1120
1121 /* notification functions */
1122
1123 void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev)
1124 {
1125         struct sk_buff *msg;
1126
1127         msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
1128         if (!msg)
1129                 return;
1130
1131         if (nl80211_send_wiphy(msg, 0, 0, 0, rdev) < 0) {
1132                 nlmsg_free(msg);
1133                 return;
1134         }
1135
1136         genlmsg_multicast(msg, 0, nl80211_config_mcgrp.id, GFP_KERNEL);
1137 }
1138
1139 /* initialisation/exit functions */
1140
1141 int nl80211_init(void)
1142 {
1143         int err, i;
1144
1145         err = genl_register_family(&nl80211_fam);
1146         if (err)
1147                 return err;
1148
1149         for (i = 0; i < ARRAY_SIZE(nl80211_ops); i++) {
1150                 err = genl_register_ops(&nl80211_fam, &nl80211_ops[i]);
1151                 if (err)
1152                         goto err_out;
1153         }
1154
1155         err = genl_register_mc_group(&nl80211_fam, &nl80211_config_mcgrp);
1156         if (err)
1157                 goto err_out;
1158
1159         return 0;
1160  err_out:
1161         genl_unregister_family(&nl80211_fam);
1162         return err;
1163 }
1164
1165 void nl80211_exit(void)
1166 {
1167         genl_unregister_family(&nl80211_fam);
1168 }