SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 #include "reg.h"
  22
  23 /* the netlink family */
  24 static struct genl_family nl80211_fam = {
  25         .id = GENL_ID_GENERATE, /* don't bother with a hardcoded ID */
  26         .name = "nl80211",      /* have users key off the name instead */
  27         .hdrsize = 0,           /* no private header */
  28         .version = 1,           /* no particular meaning now */
  29         .maxattr = NL80211_ATTR_MAX,
  30 };
  31
  32 /* internal helper: get drv and dev */
  33 static int get_drv_dev_by_info_ifindex(struct nlattr **attrs,
  34                                        struct cfg80211_registered_device **drv,
  35                                        struct net_device **dev)
  36 {
  37         int ifindex;
  38
  39         if (!attrs[NL80211_ATTR_IFINDEX])
  40                 return -EINVAL;
  41
  42         ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
  43         *dev = dev_get_by_index(&init_net, ifindex);
  44         if (!*dev)
  45                 return -ENODEV;
  46
  47         *drv = cfg80211_get_dev_from_ifindex(ifindex);
  48         if (IS_ERR(*drv)) {
  49                 dev_put(*dev);
  50                 return PTR_ERR(*drv);
  51         }
  52
  53         return 0;
  54 }
  55
  56 /* policy for the attributes */
  57 static struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] __read_mostly = {
  58         [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
  59         [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
  60                                       .len = BUS_ID_SIZE-1 },
  61         [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
  62         [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
  63         [NL80211_ATTR_WIPHY_SEC_CHAN_OFFSET] = { .type = NLA_U32 },
  64
  65         [NL80211_ATTR_IFTYPE] = { .type = NLA_U32 },
  66         [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
  67         [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
  68
  69         [NL80211_ATTR_MAC] = { .type = NLA_BINARY, .len = ETH_ALEN },
  70
  71         [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
  72                                     .len = WLAN_MAX_KEY_LEN },
  73         [NL80211_ATTR_KEY_IDX] = { .type = NLA_U8 },
  74         [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
  75         [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
  76
  77         [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
  78         [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
  79         [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,
  80                                        .len = IEEE80211_MAX_DATA_LEN },
  81         [NL80211_ATTR_BEACON_TAIL] = { .type = NLA_BINARY,
  82                                        .len = IEEE80211_MAX_DATA_LEN },
  83         [NL80211_ATTR_STA_AID] = { .type = NLA_U16 },
  84         [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
  85         [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
  86         [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
  87                                                .len = NL80211_MAX_SUPP_RATES },
  88         [NL80211_ATTR_STA_PLINK_ACTION] = { .type = NLA_U8 },
  89         [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
  90         [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
  91         [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
  92                                 .len = IEEE80211_MAX_MESH_ID_LEN },
  93         [NL80211_ATTR_MPATH_NEXT_HOP] = { .type = NLA_U32 },
  94
  95         [NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
  96         [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
  97
  98         [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
  99         [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
 100         [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
 101         [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
 102                                            .len = NL80211_MAX_SUPP_RATES },
 103
 104         [NL80211_ATTR_MESH_PARAMS] = { .type = NLA_NESTED },
 105
 106         [NL80211_ATTR_HT_CAPABILITY] = { .type = NLA_BINARY,
 107                                          .len = NL80211_HT_CAPABILITY_LEN },
 108 };
 109
 110 /* message building helper */
 111 static inline void *nl80211hdr_put(struct sk_buff *skb, u32 pid, u32 seq,
 112                                    int flags, u8 cmd)
 113 {
 114         /* since there is no private header just add the generic one */
 115         return genlmsg_put(skb, pid, seq, &nl80211_fam, flags, cmd);
 116 }
 117
 118 /* netlink command implementations */
 119
 120 static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
 121                               struct cfg80211_registered_device *dev)
 122 {
 123         void *hdr;
 124         struct nlattr *nl_bands, *nl_band;
 125         struct nlattr *nl_freqs, *nl_freq;
 126         struct nlattr *nl_rates, *nl_rate;
 127         struct nlattr *nl_modes;
 128         enum ieee80211_band band;
 129         struct ieee80211_channel *chan;
 130         struct ieee80211_rate *rate;
 131         int i;
 132         u16 ifmodes = dev->wiphy.interface_modes;
 133
 134         hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_WIPHY);
 135         if (!hdr)
 136                 return -1;
 137
 138         NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, dev->idx);
 139         NLA_PUT_STRING(msg, NL80211_ATTR_WIPHY_NAME, wiphy_name(&dev->wiphy));
 140
 141         nl_modes = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_IFTYPES);
 142         if (!nl_modes)
 143                 goto nla_put_failure;
 144
 145         i = 0;
 146         while (ifmodes) {
 147                 if (ifmodes & 1)
 148                         NLA_PUT_FLAG(msg, i);
 149                 ifmodes >>= 1;
 150                 i++;
 151         }
 152
 153         nla_nest_end(msg, nl_modes);
 154
 155         nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS);
 156         if (!nl_bands)
 157                 goto nla_put_failure;
 158
 159         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
 160                 if (!dev->wiphy.bands[band])
 161                         continue;
 162
 163                 nl_band = nla_nest_start(msg, band);
 164                 if (!nl_band)
 165                         goto nla_put_failure;
 166
 167                 /* add HT info */
 168                 if (dev->wiphy.bands[band]->ht_cap.ht_supported) {
 169                         NLA_PUT(msg, NL80211_BAND_ATTR_HT_MCS_SET,
 170                                 sizeof(dev->wiphy.bands[band]->ht_cap.mcs),
 171                                 &dev->wiphy.bands[band]->ht_cap.mcs);
 172                         NLA_PUT_U16(msg, NL80211_BAND_ATTR_HT_CAPA,
 173                                 dev->wiphy.bands[band]->ht_cap.cap);
 174                         NLA_PUT_U8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
 175                                 dev->wiphy.bands[band]->ht_cap.ampdu_factor);
 176                         NLA_PUT_U8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
 177                                 dev->wiphy.bands[band]->ht_cap.ampdu_density);
 178                 }
 179
 180                 /* add frequencies */
 181                 nl_freqs = nla_nest_start(msg, NL80211_BAND_ATTR_FREQS);
 182                 if (!nl_freqs)
 183                         goto nla_put_failure;
 184
 185                 for (i = 0; i < dev->wiphy.bands[band]->n_channels; i++) {
 186                         nl_freq = nla_nest_start(msg, i);
 187                         if (!nl_freq)
 188                                 goto nla_put_failure;
 189
 190                         chan = &dev->wiphy.bands[band]->channels[i];
 191                         NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_FREQ,
 192                                     chan->center_freq);
 193
 194                         if (chan->flags & IEEE80211_CHAN_DISABLED)
 195                                 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_DISABLED);
 196                         if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)
 197                                 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_PASSIVE_SCAN);
 198                         if (chan->flags & IEEE80211_CHAN_NO_IBSS)
 199                                 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_NO_IBSS);
 200                         if (chan->flags & IEEE80211_CHAN_RADAR)
 201                                 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_RADAR);
 202
 203                         NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
 204                                     DBM_TO_MBM(chan->max_power));
 205
 206                         nla_nest_end(msg, nl_freq);
 207                 }
 208
 209                 nla_nest_end(msg, nl_freqs);
 210
 211                 /* add bitrates */
 212                 nl_rates = nla_nest_start(msg, NL80211_BAND_ATTR_RATES);
 213                 if (!nl_rates)
 214                         goto nla_put_failure;
 215
 216                 for (i = 0; i < dev->wiphy.bands[band]->n_bitrates; i++) {
 217                         nl_rate = nla_nest_start(msg, i);
 218                         if (!nl_rate)
 219                                 goto nla_put_failure;
 220
 221                         rate = &dev->wiphy.bands[band]->bitrates[i];
 222                         NLA_PUT_U32(msg, NL80211_BITRATE_ATTR_RATE,
 223                                     rate->bitrate);
 224                         if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE)
 225                                 NLA_PUT_FLAG(msg,
 226                                         NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE);
 227
 228                         nla_nest_end(msg, nl_rate);
 229                 }
 230
 231                 nla_nest_end(msg, nl_rates);
 232
 233                 nla_nest_end(msg, nl_band);
 234         }
 235         nla_nest_end(msg, nl_bands);
 236
 237         return genlmsg_end(msg, hdr);
 238
 239  nla_put_failure:
 240         genlmsg_cancel(msg, hdr);
 241         return -EMSGSIZE;
 242 }
 243
 244 static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
 245 {
 246         int idx = 0;
 247         int start = cb->args[0];
 248         struct cfg80211_registered_device *dev;
 249
 250         mutex_lock(&cfg80211_drv_mutex);
 251         list_for_each_entry(dev, &cfg80211_drv_list, list) {
 252                 if (++idx <= start)
 253                         continue;
 254                 if (nl80211_send_wiphy(skb, NETLINK_CB(cb->skb).pid,
 255                                        cb->nlh->nlmsg_seq, NLM_F_MULTI,
 256                                        dev) < 0) {
 257                         idx--;
 258                         break;
 259                 }
 260         }
 261         mutex_unlock(&cfg80211_drv_mutex);
 262
 263         cb->args[0] = idx;
 264
 265         return skb->len;
 266 }
 267
 268 static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
 269 {
 270         struct sk_buff *msg;
 271         struct cfg80211_registered_device *dev;
 272
 273         dev = cfg80211_get_dev_from_info(info);
 274         if (IS_ERR(dev))
 275                 return PTR_ERR(dev);
 276
 277         msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 278         if (!msg)
 279                 goto out_err;
 280
 281         if (nl80211_send_wiphy(msg, info->snd_pid, info->snd_seq, 0, dev) < 0)
 282                 goto out_free;
 283
 284         cfg80211_put_dev(dev);
 285
 286         return genlmsg_unicast(msg, info->snd_pid);
 287
 288  out_free:
 289         nlmsg_free(msg);
 290  out_err:
 291         cfg80211_put_dev(dev);
 292         return -ENOBUFS;
 293 }
 294
 295 static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
 296         [NL80211_TXQ_ATTR_QUEUE]                = { .type = NLA_U8 },
 297         [NL80211_TXQ_ATTR_TXOP]                 = { .type = NLA_U16 },
 298         [NL80211_TXQ_ATTR_CWMIN]                = { .type = NLA_U16 },
 299         [NL80211_TXQ_ATTR_CWMAX]                = { .type = NLA_U16 },
 300         [NL80211_TXQ_ATTR_AIFS]                 = { .type = NLA_U8 },
 301 };
 302
 303 static int parse_txq_params(struct nlattr *tb[],
 304                             struct ieee80211_txq_params *txq_params)
 305 {
 306         if (!tb[NL80211_TXQ_ATTR_QUEUE] || !tb[NL80211_TXQ_ATTR_TXOP] ||
 307             !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
 308             !tb[NL80211_TXQ_ATTR_AIFS])
 309                 return -EINVAL;
 310
 311         txq_params->queue = nla_get_u8(tb[NL80211_TXQ_ATTR_QUEUE]);
 312         txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
 313         txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
 314         txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
 315         txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
 316
 317         return 0;
 318 }
 319
 320 static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
 321 {
 322         struct cfg80211_registered_device *rdev;
 323         int result = 0, rem_txq_params = 0;
 324         struct nlattr *nl_txq_params;
 325
 326         rdev = cfg80211_get_dev_from_info(info);
 327         if (IS_ERR(rdev))
 328                 return PTR_ERR(rdev);
 329
 330         if (info->attrs[NL80211_ATTR_WIPHY_NAME]) {
 331                 result = cfg80211_dev_rename(
 332                         rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
 333                 if (result)
 334                         goto bad_res;
 335         }
 336
 337         if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
 338                 struct ieee80211_txq_params txq_params;
 339                 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
 340
 341                 if (!rdev->ops->set_txq_params) {
 342                         result = -EOPNOTSUPP;
 343                         goto bad_res;
 344                 }
 345
 346                 nla_for_each_nested(nl_txq_params,
 347                                     info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
 348                                     rem_txq_params) {
 349                         nla_parse(tb, NL80211_TXQ_ATTR_MAX,
 350                                   nla_data(nl_txq_params),
 351                                   nla_len(nl_txq_params),
 352                                   txq_params_policy);
 353                         result = parse_txq_params(tb, &txq_params);
 354                         if (result)
 355                                 goto bad_res;
 356
 357                         result = rdev->ops->set_txq_params(&rdev->wiphy,
 358                                                            &txq_params);
 359                         if (result)
 360                                 goto bad_res;
 361                 }
 362         }
 363
 364         if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
 365                 enum nl80211_sec_chan_offset sec_chan_offset =
 366                         NL80211_SEC_CHAN_NO_HT;
 367                 struct ieee80211_channel *chan;
 368                 u32 freq, sec_freq;
 369
 370                 if (!rdev->ops->set_channel) {
 371                         result = -EOPNOTSUPP;
 372                         goto bad_res;
 373                 }
 374
 375                 if (info->attrs[NL80211_ATTR_WIPHY_SEC_CHAN_OFFSET]) {
 376                         sec_chan_offset = nla_get_u32(
 377                                 info->attrs[
 378                                         NL80211_ATTR_WIPHY_SEC_CHAN_OFFSET]);
 379                         if (sec_chan_offset != NL80211_SEC_CHAN_NO_HT &&
 380                             sec_chan_offset != NL80211_SEC_CHAN_DISABLED &&
 381                             sec_chan_offset != NL80211_SEC_CHAN_BELOW &&
 382                             sec_chan_offset != NL80211_SEC_CHAN_ABOVE) {
 383                                 result = -EINVAL;
 384                                 goto bad_res;
 385                         }
 386                 }
 387
 388                 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
 389                 chan = ieee80211_get_channel(&rdev->wiphy, freq);
 390                 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED) {
 391                         /* Primary channel not allowed */
 392                         result = -EINVAL;
 393                         goto bad_res;
 394                 }
 395                 if (sec_chan_offset == NL80211_SEC_CHAN_BELOW)
 396                         sec_freq = freq - 20;
 397                 else if (sec_chan_offset == NL80211_SEC_CHAN_ABOVE)
 398                         sec_freq = freq + 20;
 399                 else
 400                         sec_freq = 0;
 401
 402                 if (sec_freq) {
 403                         struct ieee80211_channel *schan;
 404                         schan = ieee80211_get_channel(&rdev->wiphy, sec_freq);
 405                         if (!schan || schan->flags & IEEE80211_CHAN_DISABLED) {
 406                                 /* Secondary channel not allowed */
 407                                 result = -EINVAL;
 408                                 goto bad_res;
 409                         }
 410                 }
 411
 412                 result = rdev->ops->set_channel(&rdev->wiphy, chan,
 413                                                 sec_chan_offset);
 414                 if (result)
 415                         goto bad_res;
 416         }
 417
 418
 419 bad_res:
 420         cfg80211_put_dev(rdev);
 421         return result;
 422 }
 423
 424
 425 static int nl80211_send_iface(struct sk_buff *msg, u32 pid, u32 seq, int flags,
 426                               struct net_device *dev)
 427 {
 428         void *hdr;
 429
 430         hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_INTERFACE);
 431         if (!hdr)
 432                 return -1;
 433
 434         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
 435         NLA_PUT_STRING(msg, NL80211_ATTR_IFNAME, dev->name);
 436         NLA_PUT_U32(msg, NL80211_ATTR_IFTYPE, dev->ieee80211_ptr->iftype);
 437         return genlmsg_end(msg, hdr);
 438
 439  nla_put_failure:
 440         genlmsg_cancel(msg, hdr);
 441         return -EMSGSIZE;
 442 }
 443
 444 static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
 445 {
 446         int wp_idx = 0;
 447         int if_idx = 0;
 448         int wp_start = cb->args[0];
 449         int if_start = cb->args[1];
 450         struct cfg80211_registered_device *dev;
 451         struct wireless_dev *wdev;
 452
 453         mutex_lock(&cfg80211_drv_mutex);
 454         list_for_each_entry(dev, &cfg80211_drv_list, list) {
 455                 if (wp_idx < wp_start) {
 456                         wp_idx++;
 457                         continue;
 458                 }
 459                 if_idx = 0;
 460
 461                 mutex_lock(&dev->devlist_mtx);
 462                 list_for_each_entry(wdev, &dev->netdev_list, list) {
 463                         if (if_idx < if_start) {
 464                                 if_idx++;
 465                                 continue;
 466                         }
 467                         if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).pid,
 468                                                cb->nlh->nlmsg_seq, NLM_F_MULTI,
 469                                                wdev->netdev) < 0) {
 470                                 mutex_unlock(&dev->devlist_mtx);
 471                                 goto out;
 472                         }
 473                         if_idx++;
 474                 }
 475                 mutex_unlock(&dev->devlist_mtx);
 476
 477                 wp_idx++;
 478         }
 479  out:
 480         mutex_unlock(&cfg80211_drv_mutex);
 481
 482         cb->args[0] = wp_idx;
 483         cb->args[1] = if_idx;
 484
 485         return skb->len;
 486 }
 487
 488 static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
 489 {
 490         struct sk_buff *msg;
 491         struct cfg80211_registered_device *dev;
 492         struct net_device *netdev;
 493         int err;
 494
 495         err = get_drv_dev_by_info_ifindex(info->attrs, &dev, &netdev);
 496         if (err)
 497                 return err;
 498
 499         msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 500         if (!msg)
 501                 goto out_err;
 502
 503         if (nl80211_send_iface(msg, info->snd_pid, info->snd_seq, 0, netdev) < 0)
 504                 goto out_free;
 505
 506         dev_put(netdev);
 507         cfg80211_put_dev(dev);
 508
 509         return genlmsg_unicast(msg, info->snd_pid);
 510
 511  out_free:
 512         nlmsg_free(msg);
 513  out_err:
 514         dev_put(netdev);
 515         cfg80211_put_dev(dev);
 516         return -ENOBUFS;
 517 }
 518
 519 static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
 520         [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
 521         [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
 522         [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
 523         [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
 524         [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
 525 };
 526
 527 static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
 528 {
 529         struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
 530         int flag;
 531
 532         *mntrflags = 0;
 533
 534         if (!nla)
 535                 return -EINVAL;
 536
 537         if (nla_parse_nested(flags, NL80211_MNTR_FLAG_MAX,
 538                              nla, mntr_flags_policy))
 539                 return -EINVAL;
 540
 541         for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
 542                 if (flags[flag])
 543                         *mntrflags |= (1<<flag);
 544
 545         return 0;
 546 }
 547
 548 static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
 549 {
 550         struct cfg80211_registered_device *drv;
 551         struct vif_params params;
 552         int err, ifindex;
 553         enum nl80211_iftype type;
 554         struct net_device *dev;
 555         u32 _flags, *flags = NULL;
 556
 557         memset(&params, 0, sizeof(params));
 558
 559         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 560         if (err)
 561                 return err;
 562         ifindex = dev->ifindex;
 563         type = dev->ieee80211_ptr->iftype;
 564         dev_put(dev);
 565
 566         err = -EINVAL;
 567         if (info->attrs[NL80211_ATTR_IFTYPE]) {
 568                 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
 569                 if (type > NL80211_IFTYPE_MAX)
 570                         goto unlock;
 571         }
 572
 573         if (!drv->ops->change_virtual_intf ||
 574             !(drv->wiphy.interface_modes & (1 << type))) {
 575                 err = -EOPNOTSUPP;
 576                 goto unlock;
 577         }
 578
 579         if (info->attrs[NL80211_ATTR_MESH_ID]) {
 580                 if (type != NL80211_IFTYPE_MESH_POINT) {
 581                         err = -EINVAL;
 582                         goto unlock;
 583                 }
 584                 params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
 585                 params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
 586         }
 587
 588         if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
 589                 if (type != NL80211_IFTYPE_MONITOR) {
 590                         err = -EINVAL;
 591                         goto unlock;
 592                 }
 593                 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
 594                                           &_flags);
 595                 if (!err)
 596                         flags = &_flags;
 597         }
 598         rtnl_lock();
 599         err = drv->ops->change_virtual_intf(&drv->wiphy, ifindex,
 600                                             type, flags, &params);
 601
 602         dev = __dev_get_by_index(&init_net, ifindex);
 603         WARN_ON(!dev || (!err && dev->ieee80211_ptr->iftype != type));
 604
 605         rtnl_unlock();
 606
 607  unlock:
 608         cfg80211_put_dev(drv);
 609         return err;
 610 }
 611
 612 static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
 613 {
 614         struct cfg80211_registered_device *drv;
 615         struct vif_params params;
 616         int err;
 617         enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
 618         u32 flags;
 619
 620         memset(&params, 0, sizeof(params));
 621
 622         if (!info->attrs[NL80211_ATTR_IFNAME])
 623                 return -EINVAL;
 624
 625         if (info->attrs[NL80211_ATTR_IFTYPE]) {
 626                 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
 627                 if (type > NL80211_IFTYPE_MAX)
 628                         return -EINVAL;
 629         }
 630
 631         drv = cfg80211_get_dev_from_info(info);
 632         if (IS_ERR(drv))
 633                 return PTR_ERR(drv);
 634
 635         if (!drv->ops->add_virtual_intf ||
 636             !(drv->wiphy.interface_modes & (1 << type))) {
 637                 err = -EOPNOTSUPP;
 638                 goto unlock;
 639         }
 640
 641         if (type == NL80211_IFTYPE_MESH_POINT &&
 642             info->attrs[NL80211_ATTR_MESH_ID]) {
 643                 params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
 644                 params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
 645         }
 646
 647         rtnl_lock();
 648         err = parse_monitor_flags(type == NL80211_IFTYPE_MONITOR ?
 649                                   info->attrs[NL80211_ATTR_MNTR_FLAGS] : NULL,
 650                                   &flags);
 651         err = drv->ops->add_virtual_intf(&drv->wiphy,
 652                 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
 653                 type, err ? NULL : &flags, &params);
 654         rtnl_unlock();
 655
 656
 657  unlock:
 658         cfg80211_put_dev(drv);
 659         return err;
 660 }
 661
 662 static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
 663 {
 664         struct cfg80211_registered_device *drv;
 665         int ifindex, err;
 666         struct net_device *dev;
 667
 668         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 669         if (err)
 670                 return err;
 671         ifindex = dev->ifindex;
 672         dev_put(dev);
 673
 674         if (!drv->ops->del_virtual_intf) {
 675                 err = -EOPNOTSUPP;
 676                 goto out;
 677         }
 678
 679         rtnl_lock();
 680         err = drv->ops->del_virtual_intf(&drv->wiphy, ifindex);
 681         rtnl_unlock();
 682
 683  out:
 684         cfg80211_put_dev(drv);
 685         return err;
 686 }
 687
 688 struct get_key_cookie {
 689         struct sk_buff *msg;
 690         int error;
 691 };
 692
 693 static void get_key_callback(void *c, struct key_params *params)
 694 {
 695         struct get_key_cookie *cookie = c;
 696
 697         if (params->key)
 698                 NLA_PUT(cookie->msg, NL80211_ATTR_KEY_DATA,
 699                         params->key_len, params->key);
 700
 701         if (params->seq)
 702                 NLA_PUT(cookie->msg, NL80211_ATTR_KEY_SEQ,
 703                         params->seq_len, params->seq);
 704
 705         if (params->cipher)
 706                 NLA_PUT_U32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
 707                             params->cipher);
 708
 709         return;
 710  nla_put_failure:
 711         cookie->error = 1;
 712 }
 713
 714 static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
 715 {
 716         struct cfg80211_registered_device *drv;
 717         int err;
 718         struct net_device *dev;
 719         u8 key_idx = 0;
 720         u8 *mac_addr = NULL;
 721         struct get_key_cookie cookie = {
 722                 .error = 0,
 723         };
 724         void *hdr;
 725         struct sk_buff *msg;
 726
 727         if (info->attrs[NL80211_ATTR_KEY_IDX])
 728                 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
 729
 730         if (key_idx > 3)
 731                 return -EINVAL;
 732
 733         if (info->attrs[NL80211_ATTR_MAC])
 734                 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 735
 736         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 737         if (err)
 738                 return err;
 739
 740         if (!drv->ops->get_key) {
 741                 err = -EOPNOTSUPP;
 742                 goto out;
 743         }
 744
 745         msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 746         if (!msg) {
 747                 err = -ENOMEM;
 748                 goto out;
 749         }
 750
 751         hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
 752                              NL80211_CMD_NEW_KEY);
 753
 754         if (IS_ERR(hdr)) {
 755                 err = PTR_ERR(hdr);
 756                 goto out;
 757         }
 758
 759         cookie.msg = msg;
 760
 761         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
 762         NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_idx);
 763         if (mac_addr)
 764                 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr);
 765
 766         rtnl_lock();
 767         err = drv->ops->get_key(&drv->wiphy, dev, key_idx, mac_addr,
 768                                 &cookie, get_key_callback);
 769         rtnl_unlock();
 770
 771         if (err)
 772                 goto out;
 773
 774         if (cookie.error)
 775                 goto nla_put_failure;
 776
 777         genlmsg_end(msg, hdr);
 778         err = genlmsg_unicast(msg, info->snd_pid);
 779         goto out;
 780
 781  nla_put_failure:
 782         err = -ENOBUFS;
 783         nlmsg_free(msg);
 784  out:
 785         cfg80211_put_dev(drv);
 786         dev_put(dev);
 787         return err;
 788 }
 789
 790 static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
 791 {
 792         struct cfg80211_registered_device *drv;
 793         int err;
 794         struct net_device *dev;
 795         u8 key_idx;
 796
 797         if (!info->attrs[NL80211_ATTR_KEY_IDX])
 798                 return -EINVAL;
 799
 800         key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
 801
 802         if (key_idx > 3)
 803                 return -EINVAL;
 804
 805         /* currently only support setting default key */
 806         if (!info->attrs[NL80211_ATTR_KEY_DEFAULT])
 807                 return -EINVAL;
 808
 809         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 810         if (err)
 811                 return err;
 812
 813         if (!drv->ops->set_default_key) {
 814                 err = -EOPNOTSUPP;
 815                 goto out;
 816         }
 817
 818         rtnl_lock();
 819         err = drv->ops->set_default_key(&drv->wiphy, dev, key_idx);
 820         rtnl_unlock();
 821
 822  out:
 823         cfg80211_put_dev(drv);
 824         dev_put(dev);
 825         return err;
 826 }
 827
 828 static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
 829 {
 830         struct cfg80211_registered_device *drv;
 831         int err;
 832         struct net_device *dev;
 833         struct key_params params;
 834         u8 key_idx = 0;
 835         u8 *mac_addr = NULL;
 836
 837         memset(&params, 0, sizeof(params));
 838
 839         if (!info->attrs[NL80211_ATTR_KEY_CIPHER])
 840                 return -EINVAL;
 841
 842         if (info->attrs[NL80211_ATTR_KEY_DATA]) {
 843                 params.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
 844                 params.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
 845         }
 846
 847         if (info->attrs[NL80211_ATTR_KEY_IDX])
 848                 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
 849
 850         params.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
 851
 852         if (info->attrs[NL80211_ATTR_MAC])
 853                 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 854
 855         if (key_idx > 3)
 856                 return -EINVAL;
 857
 858         /*
 859          * Disallow pairwise keys with non-zero index unless it's WEP
 860          * (because current deployments use pairwise WEP keys with
 861          * non-zero indizes but 802.11i clearly specifies to use zero)
 862          */
 863         if (mac_addr && key_idx &&
 864             params.cipher != WLAN_CIPHER_SUITE_WEP40 &&
 865             params.cipher != WLAN_CIPHER_SUITE_WEP104)
 866                 return -EINVAL;
 867
 868         /* TODO: add definitions for the lengths to linux/ieee80211.h */
 869         switch (params.cipher) {
 870         case WLAN_CIPHER_SUITE_WEP40:
 871                 if (params.key_len != 5)
 872                         return -EINVAL;
 873                 break;
 874         case WLAN_CIPHER_SUITE_TKIP:
 875                 if (params.key_len != 32)
 876                         return -EINVAL;
 877                 break;
 878         case WLAN_CIPHER_SUITE_CCMP:
 879                 if (params.key_len != 16)
 880                         return -EINVAL;
 881                 break;
 882         case WLAN_CIPHER_SUITE_WEP104:
 883                 if (params.key_len != 13)
 884                         return -EINVAL;
 885                 break;
 886         default:
 887                 return -EINVAL;
 888         }
 889
 890         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 891         if (err)
 892                 return err;
 893
 894         if (!drv->ops->add_key) {
 895                 err = -EOPNOTSUPP;
 896                 goto out;
 897         }
 898
 899         rtnl_lock();
 900         err = drv->ops->add_key(&drv->wiphy, dev, key_idx, mac_addr, &params);
 901         rtnl_unlock();
 902
 903  out:
 904         cfg80211_put_dev(drv);
 905         dev_put(dev);
 906         return err;
 907 }
 908
 909 static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
 910 {
 911         struct cfg80211_registered_device *drv;
 912         int err;
 913         struct net_device *dev;
 914         u8 key_idx = 0;
 915         u8 *mac_addr = NULL;
 916
 917         if (info->attrs[NL80211_ATTR_KEY_IDX])
 918                 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
 919
 920         if (key_idx > 3)
 921                 return -EINVAL;
 922
 923         if (info->attrs[NL80211_ATTR_MAC])
 924                 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 925
 926         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 927         if (err)
 928                 return err;
 929
 930         if (!drv->ops->del_key) {
 931                 err = -EOPNOTSUPP;
 932                 goto out;
 933         }
 934
 935         rtnl_lock();
 936         err = drv->ops->del_key(&drv->wiphy, dev, key_idx, mac_addr);
 937         rtnl_unlock();
 938
 939  out:
 940         cfg80211_put_dev(drv);
 941         dev_put(dev);
 942         return err;
 943 }
 944
 945 static int nl80211_addset_beacon(struct sk_buff *skb, struct genl_info *info)
 946 {
 947         int (*call)(struct wiphy *wiphy, struct net_device *dev,
 948                     struct beacon_parameters *info);
 949         struct cfg80211_registered_device *drv;
 950         int err;
 951         struct net_device *dev;
 952         struct beacon_parameters params;
 953         int haveinfo = 0;
 954
 955         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 956         if (err)
 957                 return err;
 958
 959         switch (info->genlhdr->cmd) {
 960         case NL80211_CMD_NEW_BEACON:
 961                 /* these are required for NEW_BEACON */
 962                 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
 963                     !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
 964                     !info->attrs[NL80211_ATTR_BEACON_HEAD]) {
 965                         err = -EINVAL;
 966                         goto out;
 967                 }
 968
 969                 call = drv->ops->add_beacon;
 970                 break;
 971         case NL80211_CMD_SET_BEACON:
 972                 call = drv->ops->set_beacon;
 973                 break;
 974         default:
 975                 WARN_ON(1);
 976                 err = -EOPNOTSUPP;
 977                 goto out;
 978         }
 979
 980         if (!call) {
 981                 err = -EOPNOTSUPP;
 982                 goto out;
 983         }
 984
 985         memset(&params, 0, sizeof(params));
 986
 987         if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
 988                 params.interval =
 989                     nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
 990                 haveinfo = 1;
 991         }
 992
 993         if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
 994                 params.dtim_period =
 995                     nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
 996                 haveinfo = 1;
 997         }
 998
 999         if (info->attrs[NL80211_ATTR_BEACON_HEAD]) {
1000                 params.head = nla_data(info->attrs[NL80211_ATTR_BEACON_HEAD]);
1001                 params.head_len =
1002                     nla_len(info->attrs[NL80211_ATTR_BEACON_HEAD]);
1003                 haveinfo = 1;
1004         }
1005
1006         if (info->attrs[NL80211_ATTR_BEACON_TAIL]) {
1007                 params.tail = nla_data(info->attrs[NL80211_ATTR_BEACON_TAIL]);
1008                 params.tail_len =
1009                     nla_len(info->attrs[NL80211_ATTR_BEACON_TAIL]);
1010                 haveinfo = 1;
1011         }
1012
1013         if (!haveinfo) {
1014                 err = -EINVAL;
1015                 goto out;
1016         }
1017
1018         rtnl_lock();
1019         err = call(&drv->wiphy, dev, &params);
1020         rtnl_unlock();
1021
1022  out:
1023         cfg80211_put_dev(drv);
1024         dev_put(dev);
1025         return err;
1026 }
1027
1028 static int nl80211_del_beacon(struct sk_buff *skb, struct genl_info *info)
1029 {
1030         struct cfg80211_registered_device *drv;
1031         int err;
1032         struct net_device *dev;
1033
1034         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1035         if (err)
1036                 return err;
1037
1038         if (!drv->ops->del_beacon) {
1039                 err = -EOPNOTSUPP;
1040                 goto out;
1041         }
1042
1043         rtnl_lock();
1044         err = drv->ops->del_beacon(&drv->wiphy, dev);
1045         rtnl_unlock();
1046
1047  out:
1048         cfg80211_put_dev(drv);
1049         dev_put(dev);
1050         return err;
1051 }
1052
1053 static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
1054         [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
1055         [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
1056         [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
1057 };
1058
1059 static int parse_station_flags(struct nlattr *nla, u32 *staflags)
1060 {
1061         struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
1062         int flag;
1063
1064         *staflags = 0;
1065
1066         if (!nla)
1067                 return 0;
1068
1069         if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX,
1070                              nla, sta_flags_policy))
1071                 return -EINVAL;
1072
1073         *staflags = STATION_FLAG_CHANGED;
1074
1075         for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++)
1076                 if (flags[flag])
1077                         *staflags |= (1<<flag);
1078
1079         return 0;
1080 }
1081
1082 static int nl80211_send_station(struct sk_buff *msg, u32 pid, u32 seq,
1083                                 int flags, struct net_device *dev,
1084                                 u8 *mac_addr, struct station_info *sinfo)
1085 {
1086         void *hdr;
1087         struct nlattr *sinfoattr;
1088
1089         hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
1090         if (!hdr)
1091                 return -1;
1092
1093         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
1094         NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr);
1095
1096         sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
1097         if (!sinfoattr)
1098                 goto nla_put_failure;
1099         if (sinfo->filled & STATION_INFO_INACTIVE_TIME)
1100                 NLA_PUT_U32(msg, NL80211_STA_INFO_INACTIVE_TIME,
1101                             sinfo->inactive_time);
1102         if (sinfo->filled & STATION_INFO_RX_BYTES)
1103                 NLA_PUT_U32(msg, NL80211_STA_INFO_RX_BYTES,
1104                             sinfo->rx_bytes);
1105         if (sinfo->filled & STATION_INFO_TX_BYTES)
1106                 NLA_PUT_U32(msg, NL80211_STA_INFO_TX_BYTES,
1107                             sinfo->tx_bytes);
1108         if (sinfo->filled & STATION_INFO_LLID)
1109                 NLA_PUT_U16(msg, NL80211_STA_INFO_LLID,
1110                             sinfo->llid);
1111         if (sinfo->filled & STATION_INFO_PLID)
1112                 NLA_PUT_U16(msg, NL80211_STA_INFO_PLID,
1113                             sinfo->plid);
1114         if (sinfo->filled & STATION_INFO_PLINK_STATE)
1115                 NLA_PUT_U8(msg, NL80211_STA_INFO_PLINK_STATE,
1116                             sinfo->plink_state);
1117
1118         nla_nest_end(msg, sinfoattr);
1119
1120         return genlmsg_end(msg, hdr);
1121
1122  nla_put_failure:
1123         genlmsg_cancel(msg, hdr);
1124         return -EMSGSIZE;
1125 }
1126
1127 static int nl80211_dump_station(struct sk_buff *skb,
1128                                 struct netlink_callback *cb)
1129 {
1130         struct station_info sinfo;
1131         struct cfg80211_registered_device *dev;
1132         struct net_device *netdev;
1133         u8 mac_addr[ETH_ALEN];
1134         int ifidx = cb->args[0];
1135         int sta_idx = cb->args[1];
1136         int err;
1137
1138         if (!ifidx) {
1139                 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
1140                                   nl80211_fam.attrbuf, nl80211_fam.maxattr,
1141                                   nl80211_policy);
1142                 if (err)
1143                         return err;
1144
1145                 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
1146                         return -EINVAL;
1147
1148                 ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
1149                 if (!ifidx)
1150                         return -EINVAL;
1151         }
1152
1153         netdev = dev_get_by_index(&init_net, ifidx);
1154         if (!netdev)
1155                 return -ENODEV;
1156
1157         dev = cfg80211_get_dev_from_ifindex(ifidx);
1158         if (IS_ERR(dev)) {
1159                 err = PTR_ERR(dev);
1160                 goto out_put_netdev;
1161         }
1162
1163         if (!dev->ops->dump_station) {
1164                 err = -ENOSYS;
1165                 goto out_err;
1166         }
1167
1168         rtnl_lock();
1169
1170         while (1) {
1171                 err = dev->ops->dump_station(&dev->wiphy, netdev, sta_idx,
1172                                              mac_addr, &sinfo);
1173                 if (err == -ENOENT)
1174                         break;
1175                 if (err)
1176                         goto out_err_rtnl;
1177
1178                 if (nl80211_send_station(skb,
1179                                 NETLINK_CB(cb->skb).pid,
1180                                 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1181                                 netdev, mac_addr,
1182                                 &sinfo) < 0)
1183                         goto out;
1184
1185                 sta_idx++;
1186         }
1187
1188
1189  out:
1190         cb->args[1] = sta_idx;
1191         err = skb->len;
1192  out_err_rtnl:
1193         rtnl_unlock();
1194  out_err:
1195         cfg80211_put_dev(dev);
1196  out_put_netdev:
1197         dev_put(netdev);
1198
1199         return err;
1200 }
1201
1202 static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
1203 {
1204         struct cfg80211_registered_device *drv;
1205         int err;
1206         struct net_device *dev;
1207         struct station_info sinfo;
1208         struct sk_buff *msg;
1209         u8 *mac_addr = NULL;
1210
1211         memset(&sinfo, 0, sizeof(sinfo));
1212
1213         if (!info->attrs[NL80211_ATTR_MAC])
1214                 return -EINVAL;
1215
1216         mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1217
1218         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1219         if (err)
1220                 return err;
1221
1222         if (!drv->ops->get_station) {
1223                 err = -EOPNOTSUPP;
1224                 goto out;
1225         }
1226
1227         rtnl_lock();
1228         err = drv->ops->get_station(&drv->wiphy, dev, mac_addr, &sinfo);
1229         rtnl_unlock();
1230
1231         if (err)
1232                 goto out;
1233
1234         msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
1235         if (!msg)
1236                 goto out;
1237
1238         if (nl80211_send_station(msg, info->snd_pid, info->snd_seq, 0,
1239                                  dev, mac_addr, &sinfo) < 0)
1240                 goto out_free;
1241
1242         err = genlmsg_unicast(msg, info->snd_pid);
1243         goto out;
1244
1245  out_free:
1246         nlmsg_free(msg);
1247
1248  out:
1249         cfg80211_put_dev(drv);
1250         dev_put(dev);
1251         return err;
1252 }
1253
1254 /*
1255  * Get vlan interface making sure it is on the right wiphy.
1256  */
1257 static int get_vlan(struct nlattr *vlanattr,
1258                     struct cfg80211_registered_device *rdev,
1259                     struct net_device **vlan)
1260 {
1261         *vlan = NULL;
1262
1263         if (vlanattr) {
1264                 *vlan = dev_get_by_index(&init_net, nla_get_u32(vlanattr));
1265                 if (!*vlan)
1266                         return -ENODEV;
1267                 if (!(*vlan)->ieee80211_ptr)
1268                         return -EINVAL;
1269                 if ((*vlan)->ieee80211_ptr->wiphy != &rdev->wiphy)
1270                         return -EINVAL;
1271         }
1272         return 0;
1273 }
1274
1275 static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
1276 {
1277         struct cfg80211_registered_device *drv;
1278         int err;
1279         struct net_device *dev;
1280         struct station_parameters params;
1281         u8 *mac_addr = NULL;
1282
1283         memset(&params, 0, sizeof(params));
1284
1285         params.listen_interval = -1;
1286
1287         if (info->attrs[NL80211_ATTR_STA_AID])
1288                 return -EINVAL;
1289
1290         if (!info->attrs[NL80211_ATTR_MAC])
1291                 return -EINVAL;
1292
1293         mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1294
1295         if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
1296                 params.supported_rates =
1297                         nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1298                 params.supported_rates_len =
1299                         nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1300         }
1301
1302         if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
1303                 params.listen_interval =
1304                     nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
1305
1306         if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
1307                 params.ht_capa =
1308                         nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
1309
1310         if (parse_station_flags(info->attrs[NL80211_ATTR_STA_FLAGS],
1311                                 &params.station_flags))
1312                 return -EINVAL;
1313
1314         if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
1315                 params.plink_action =
1316                     nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
1317
1318         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1319         if (err)
1320                 return err;
1321
1322         err = get_vlan(info->attrs[NL80211_ATTR_STA_VLAN], drv, &params.vlan);
1323         if (err)
1324                 goto out;
1325
1326         if (!drv->ops->change_station) {
1327                 err = -EOPNOTSUPP;
1328                 goto out;
1329         }
1330
1331         rtnl_lock();
1332         err = drv->ops->change_station(&drv->wiphy, dev, mac_addr, &params);
1333         rtnl_unlock();
1334
1335  out:
1336         if (params.vlan)
1337                 dev_put(params.vlan);
1338         cfg80211_put_dev(drv);
1339         dev_put(dev);
1340         return err;
1341 }
1342
1343 static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
1344 {
1345         struct cfg80211_registered_device *drv;
1346         int err;
1347         struct net_device *dev;
1348         struct station_parameters params;
1349         u8 *mac_addr = NULL;
1350
1351         memset(&params, 0, sizeof(params));
1352
1353         if (!info->attrs[NL80211_ATTR_MAC])
1354                 return -EINVAL;
1355
1356         if (!info->attrs[NL80211_ATTR_STA_AID])
1357                 return -EINVAL;
1358
1359         if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
1360                 return -EINVAL;
1361
1362         if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
1363                 return -EINVAL;
1364
1365         mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1366         params.supported_rates =
1367                 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1368         params.supported_rates_len =
1369                 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1370         params.listen_interval =
1371                 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
1372         params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
1373         if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
1374                 params.ht_capa =
1375                         nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
1376
1377         if (parse_station_flags(info->attrs[NL80211_ATTR_STA_FLAGS],
1378                                 &params.station_flags))
1379                 return -EINVAL;
1380
1381         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1382         if (err)
1383                 return err;
1384
1385         err = get_vlan(info->attrs[NL80211_ATTR_STA_VLAN], drv, &params.vlan);
1386         if (err)
1387                 goto out;
1388
1389         if (!drv->ops->add_station) {
1390                 err = -EOPNOTSUPP;
1391                 goto out;
1392         }
1393
1394         rtnl_lock();
1395         err = drv->ops->add_station(&drv->wiphy, dev, mac_addr, &params);
1396         rtnl_unlock();
1397
1398  out:
1399         if (params.vlan)
1400                 dev_put(params.vlan);
1401         cfg80211_put_dev(drv);
1402         dev_put(dev);
1403         return err;
1404 }
1405
1406 static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
1407 {
1408         struct cfg80211_registered_device *drv;
1409         int err;
1410         struct net_device *dev;
1411         u8 *mac_addr = NULL;
1412
1413         if (info->attrs[NL80211_ATTR_MAC])
1414                 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1415
1416         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1417         if (err)
1418                 return err;
1419
1420         if (!drv->ops->del_station) {
1421                 err = -EOPNOTSUPP;
1422                 goto out;
1423         }
1424
1425         rtnl_lock();
1426         err = drv->ops->del_station(&drv->wiphy, dev, mac_addr);
1427         rtnl_unlock();
1428
1429  out:
1430         cfg80211_put_dev(drv);
1431         dev_put(dev);
1432         return err;
1433 }
1434
1435 static int nl80211_send_mpath(struct sk_buff *msg, u32 pid, u32 seq,
1436                                 int flags, struct net_device *dev,
1437                                 u8 *dst, u8 *next_hop,
1438                                 struct mpath_info *pinfo)
1439 {
1440         void *hdr;
1441         struct nlattr *pinfoattr;
1442
1443         hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
1444         if (!hdr)
1445                 return -1;
1446
1447         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
1448         NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, dst);
1449         NLA_PUT(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop);
1450
1451         pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO);
1452         if (!pinfoattr)
1453                 goto nla_put_failure;
1454         if (pinfo->filled & MPATH_INFO_FRAME_QLEN)
1455                 NLA_PUT_U32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
1456                             pinfo->frame_qlen);
1457         if (pinfo->filled & MPATH_INFO_DSN)
1458                 NLA_PUT_U32(msg, NL80211_MPATH_INFO_DSN,
1459                             pinfo->dsn);
1460         if (pinfo->filled & MPATH_INFO_METRIC)
1461                 NLA_PUT_U32(msg, NL80211_MPATH_INFO_METRIC,
1462                             pinfo->metric);
1463         if (pinfo->filled & MPATH_INFO_EXPTIME)
1464                 NLA_PUT_U32(msg, NL80211_MPATH_INFO_EXPTIME,
1465                             pinfo->exptime);
1466         if (pinfo->filled & MPATH_INFO_FLAGS)
1467                 NLA_PUT_U8(msg, NL80211_MPATH_INFO_FLAGS,
1468                             pinfo->flags);
1469         if (pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT)
1470                 NLA_PUT_U32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
1471                             pinfo->discovery_timeout);
1472         if (pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES)
1473                 NLA_PUT_U8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
1474                             pinfo->discovery_retries);
1475
1476         nla_nest_end(msg, pinfoattr);
1477
1478         return genlmsg_end(msg, hdr);
1479
1480  nla_put_failure:
1481         genlmsg_cancel(msg, hdr);
1482         return -EMSGSIZE;
1483 }
1484
1485 static int nl80211_dump_mpath(struct sk_buff *skb,
1486                               struct netlink_callback *cb)
1487 {
1488         struct mpath_info pinfo;
1489         struct cfg80211_registered_device *dev;
1490         struct net_device *netdev;
1491         u8 dst[ETH_ALEN];
1492         u8 next_hop[ETH_ALEN];
1493         int ifidx = cb->args[0];
1494         int path_idx = cb->args[1];
1495         int err;
1496
1497         if (!ifidx) {
1498                 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
1499                                   nl80211_fam.attrbuf, nl80211_fam.maxattr,
1500                                   nl80211_policy);
1501                 if (err)
1502                         return err;
1503
1504                 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
1505                         return -EINVAL;
1506
1507                 ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
1508                 if (!ifidx)
1509                         return -EINVAL;
1510         }
1511
1512         netdev = dev_get_by_index(&init_net, ifidx);
1513         if (!netdev)
1514                 return -ENODEV;
1515
1516         dev = cfg80211_get_dev_from_ifindex(ifidx);
1517         if (IS_ERR(dev)) {
1518                 err = PTR_ERR(dev);
1519                 goto out_put_netdev;
1520         }
1521
1522         if (!dev->ops->dump_mpath) {
1523                 err = -ENOSYS;
1524                 goto out_err;
1525         }
1526
1527         rtnl_lock();
1528
1529         while (1) {
1530                 err = dev->ops->dump_mpath(&dev->wiphy, netdev, path_idx,
1531                                            dst, next_hop, &pinfo);
1532                 if (err == -ENOENT)
1533                         break;
1534                 if (err)
1535                         goto out_err_rtnl;
1536
1537                 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).pid,
1538                                        cb->nlh->nlmsg_seq, NLM_F_MULTI,
1539                                        netdev, dst, next_hop,
1540                                        &pinfo) < 0)
1541                         goto out;
1542
1543                 path_idx++;
1544         }
1545
1546
1547  out:
1548         cb->args[1] = path_idx;
1549         err = skb->len;
1550  out_err_rtnl:
1551         rtnl_unlock();
1552  out_err:
1553         cfg80211_put_dev(dev);
1554  out_put_netdev:
1555         dev_put(netdev);
1556
1557         return err;
1558 }
1559
1560 static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
1561 {
1562         struct cfg80211_registered_device *drv;
1563         int err;
1564         struct net_device *dev;
1565         struct mpath_info pinfo;
1566         struct sk_buff *msg;
1567         u8 *dst = NULL;
1568         u8 next_hop[ETH_ALEN];
1569
1570         memset(&pinfo, 0, sizeof(pinfo));
1571
1572         if (!info->attrs[NL80211_ATTR_MAC])
1573                 return -EINVAL;
1574
1575         dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
1576
1577         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1578         if (err)
1579                 return err;
1580
1581         if (!drv->ops->get_mpath) {
1582                 err = -EOPNOTSUPP;
1583                 goto out;
1584         }
1585
1586         rtnl_lock();
1587         err = drv->ops->get_mpath(&drv->wiphy, dev, dst, next_hop, &pinfo);
1588         rtnl_unlock();
1589
1590         if (err)
1591                 goto out;
1592
1593         msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
1594         if (!msg)
1595                 goto out;
1596
1597         if (nl80211_send_mpath(msg, info->snd_pid, info->snd_seq, 0,
1598                                  dev, dst, next_hop, &pinfo) < 0)
1599                 goto out_free;
1600
1601         err = genlmsg_unicast(msg, info->snd_pid);
1602         goto out;
1603
1604  out_free:
1605         nlmsg_free(msg);
1606
1607  out:
1608         cfg80211_put_dev(drv);
1609         dev_put(dev);
1610         return err;
1611 }
1612
1613 static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
1614 {
1615         struct cfg80211_registered_device *drv;
1616         int err;
1617         struct net_device *dev;
1618         u8 *dst = NULL;
1619         u8 *next_hop = NULL;
1620
1621         if (!info->attrs[NL80211_ATTR_MAC])
1622                 return -EINVAL;
1623
1624         if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
1625                 return -EINVAL;
1626
1627         dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
1628         next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
1629
1630         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1631         if (err)
1632                 return err;
1633
1634         if (!drv->ops->change_mpath) {
1635                 err = -EOPNOTSUPP;
1636                 goto out;
1637         }
1638
1639         rtnl_lock();
1640         err = drv->ops->change_mpath(&drv->wiphy, dev, dst, next_hop);
1641         rtnl_unlock();
1642
1643  out:
1644         cfg80211_put_dev(drv);
1645         dev_put(dev);
1646         return err;
1647 }
1648 static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
1649 {
1650         struct cfg80211_registered_device *drv;
1651         int err;
1652         struct net_device *dev;
1653         u8 *dst = NULL;
1654         u8 *next_hop = NULL;
1655
1656         if (!info->attrs[NL80211_ATTR_MAC])
1657                 return -EINVAL;
1658
1659         if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
1660                 return -EINVAL;
1661
1662         dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
1663         next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
1664
1665         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1666         if (err)
1667                 return err;
1668
1669         if (!drv->ops->add_mpath) {
1670                 err = -EOPNOTSUPP;
1671                 goto out;
1672         }
1673
1674         rtnl_lock();
1675         err = drv->ops->add_mpath(&drv->wiphy, dev, dst, next_hop);
1676         rtnl_unlock();
1677
1678  out:
1679         cfg80211_put_dev(drv);
1680         dev_put(dev);
1681         return err;
1682 }
1683
1684 static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
1685 {
1686         struct cfg80211_registered_device *drv;
1687         int err;
1688         struct net_device *dev;
1689         u8 *dst = NULL;
1690
1691         if (info->attrs[NL80211_ATTR_MAC])
1692                 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
1693
1694         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1695         if (err)
1696                 return err;
1697
1698         if (!drv->ops->del_mpath) {
1699                 err = -EOPNOTSUPP;
1700                 goto out;
1701         }
1702
1703         rtnl_lock();
1704         err = drv->ops->del_mpath(&drv->wiphy, dev, dst);
1705         rtnl_unlock();
1706
1707  out:
1708         cfg80211_put_dev(drv);
1709         dev_put(dev);
1710         return err;
1711 }
1712
1713 static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
1714 {
1715         struct cfg80211_registered_device *drv;
1716         int err;
1717         struct net_device *dev;
1718         struct bss_parameters params;
1719
1720         memset(&params, 0, sizeof(params));
1721         /* default to not changing parameters */
1722         params.use_cts_prot = -1;
1723         params.use_short_preamble = -1;
1724         params.use_short_slot_time = -1;
1725
1726         if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
1727                 params.use_cts_prot =
1728                     nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
1729         if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
1730                 params.use_short_preamble =
1731                     nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
1732         if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
1733                 params.use_short_slot_time =
1734                     nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
1735         if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
1736                 params.basic_rates =
1737                         nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
1738                 params.basic_rates_len =
1739                         nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
1740         }
1741
1742         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1743         if (err)
1744                 return err;
1745
1746         if (!drv->ops->change_bss) {
1747                 err = -EOPNOTSUPP;
1748                 goto out;
1749         }
1750
1751         rtnl_lock();
1752         err = drv->ops->change_bss(&drv->wiphy, dev, &params);
1753         rtnl_unlock();
1754
1755  out:
1756         cfg80211_put_dev(drv);
1757         dev_put(dev);
1758         return err;
1759 }
1760
1761 static const struct nla_policy
1762         reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
1763         [NL80211_ATTR_REG_RULE_FLAGS]           = { .type = NLA_U32 },
1764         [NL80211_ATTR_FREQ_RANGE_START]         = { .type = NLA_U32 },
1765         [NL80211_ATTR_FREQ_RANGE_END]           = { .type = NLA_U32 },
1766         [NL80211_ATTR_FREQ_RANGE_MAX_BW]        = { .type = NLA_U32 },
1767         [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]  = { .type = NLA_U32 },
1768         [NL80211_ATTR_POWER_RULE_MAX_EIRP]      = { .type = NLA_U32 },
1769 };
1770
1771 static int parse_reg_rule(struct nlattr *tb[],
1772         struct ieee80211_reg_rule *reg_rule)
1773 {
1774         struct ieee80211_freq_range *freq_range = &reg_rule->freq_range;
1775         struct ieee80211_power_rule *power_rule = &reg_rule->power_rule;
1776
1777         if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
1778                 return -EINVAL;
1779         if (!tb[NL80211_ATTR_FREQ_RANGE_START])
1780                 return -EINVAL;
1781         if (!tb[NL80211_ATTR_FREQ_RANGE_END])
1782                 return -EINVAL;
1783         if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
1784                 return -EINVAL;
1785         if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
1786                 return -EINVAL;
1787
1788         reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
1789
1790         freq_range->start_freq_khz =
1791                 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
1792         freq_range->end_freq_khz =
1793                 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
1794         freq_range->max_bandwidth_khz =
1795                 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
1796
1797         power_rule->max_eirp =
1798                 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
1799
1800         if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
1801                 power_rule->max_antenna_gain =
1802                         nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
1803
1804         return 0;
1805 }
1806
1807 static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
1808 {
1809         int r;
1810         char *data = NULL;
1811
1812         if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
1813                 return -EINVAL;
1814
1815         data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
1816
1817 #ifdef CONFIG_WIRELESS_OLD_REGULATORY
1818         /* We ignore world regdom requests with the old regdom setup */
1819         if (is_world_regdom(data))
1820                 return -EINVAL;
1821 #endif
1822         mutex_lock(&cfg80211_drv_mutex);
1823         r = __regulatory_hint(NULL, REGDOM_SET_BY_USER, data, 0, ENVIRON_ANY);
1824         mutex_unlock(&cfg80211_drv_mutex);
1825         return r;
1826 }
1827
1828 static int nl80211_get_mesh_params(struct sk_buff *skb,
1829         struct genl_info *info)
1830 {
1831         struct cfg80211_registered_device *drv;
1832         struct mesh_config cur_params;
1833         int err;
1834         struct net_device *dev;
1835         void *hdr;
1836         struct nlattr *pinfoattr;
1837         struct sk_buff *msg;
1838
1839         /* Look up our device */
1840         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1841         if (err)
1842                 return err;
1843
1844         /* Get the mesh params */
1845         rtnl_lock();
1846         err = drv->ops->get_mesh_params(&drv->wiphy, dev, &cur_params);
1847         rtnl_unlock();
1848         if (err)
1849                 goto out;
1850
1851         /* Draw up a netlink message to send back */
1852         msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
1853         if (!msg) {
1854                 err = -ENOBUFS;
1855                 goto out;
1856         }
1857         hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
1858                              NL80211_CMD_GET_MESH_PARAMS);
1859         if (!hdr)
1860                 goto nla_put_failure;
1861         pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_PARAMS);
1862         if (!pinfoattr)
1863                 goto nla_put_failure;
1864         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
1865         NLA_PUT_U16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
1866                         cur_params.dot11MeshRetryTimeout);
1867         NLA_PUT_U16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
1868                         cur_params.dot11MeshConfirmTimeout);
1869         NLA_PUT_U16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
1870                         cur_params.dot11MeshHoldingTimeout);
1871         NLA_PUT_U16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
1872                         cur_params.dot11MeshMaxPeerLinks);
1873         NLA_PUT_U8(msg, NL80211_MESHCONF_MAX_RETRIES,
1874                         cur_params.dot11MeshMaxRetries);
1875         NLA_PUT_U8(msg, NL80211_MESHCONF_TTL,
1876                         cur_params.dot11MeshTTL);
1877         NLA_PUT_U8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
1878                         cur_params.auto_open_plinks);
1879         NLA_PUT_U8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
1880                         cur_params.dot11MeshHWMPmaxPREQretries);
1881         NLA_PUT_U32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
1882                         cur_params.path_refresh_time);
1883         NLA_PUT_U16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
1884                         cur_params.min_discovery_timeout);
1885         NLA_PUT_U32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
1886                         cur_params.dot11MeshHWMPactivePathTimeout);
1887         NLA_PUT_U16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
1888                         cur_params.dot11MeshHWMPpreqMinInterval);
1889         NLA_PUT_U16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
1890                         cur_params.dot11MeshHWMPnetDiameterTraversalTime);
1891         nla_nest_end(msg, pinfoattr);
1892         genlmsg_end(msg, hdr);
1893         err = genlmsg_unicast(msg, info->snd_pid);
1894         goto out;
1895
1896 nla_put_failure:
1897         genlmsg_cancel(msg, hdr);
1898         err = -EMSGSIZE;
1899 out:
1900         /* Cleanup */
1901         cfg80211_put_dev(drv);
1902         dev_put(dev);
1903         return err;
1904 }
1905
1906 #define FILL_IN_MESH_PARAM_IF_SET(table, cfg, param, mask, attr_num, nla_fn) \
1907 do {\
1908         if (table[attr_num]) {\
1909                 cfg.param = nla_fn(table[attr_num]); \
1910                 mask |= (1 << (attr_num - 1)); \
1911         } \
1912 } while (0);\
1913
1914 static struct nla_policy
1915 nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] __read_mostly = {
1916         [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
1917         [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
1918         [NL80211_MESHCONF_HOLDING_TIMEOUT] = { .type = NLA_U16 },
1919         [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
1920         [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
1921         [NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
1922         [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
1923
1924         [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
1925         [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
1926         [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 },
1927         [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
1928         [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 },
1929         [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
1930 };
1931
1932 static int nl80211_set_mesh_params(struct sk_buff *skb, struct genl_info *info)
1933 {
1934         int err;
1935         u32 mask;
1936         struct cfg80211_registered_device *drv;
1937         struct net_device *dev;
1938         struct mesh_config cfg;
1939         struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
1940         struct nlattr *parent_attr;
1941
1942         parent_attr = info->attrs[NL80211_ATTR_MESH_PARAMS];
1943         if (!parent_attr)
1944                 return -EINVAL;
1945         if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
1946                         parent_attr, nl80211_meshconf_params_policy))
1947                 return -EINVAL;
1948
1949         err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
1950         if (err)
1951                 return err;
1952
1953         /* This makes sure that there aren't more than 32 mesh config
1954          * parameters (otherwise our bitfield scheme would not work.) */
1955         BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
1956
1957         /* Fill in the params struct */
1958         mask = 0;
1959         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout,
1960                         mask, NL80211_MESHCONF_RETRY_TIMEOUT, nla_get_u16);
1961         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout,
1962                         mask, NL80211_MESHCONF_CONFIRM_TIMEOUT, nla_get_u16);
1963         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout,
1964                         mask, NL80211_MESHCONF_HOLDING_TIMEOUT, nla_get_u16);
1965         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks,
1966                         mask, NL80211_MESHCONF_MAX_PEER_LINKS, nla_get_u16);
1967         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries,
1968                         mask, NL80211_MESHCONF_MAX_RETRIES, nla_get_u8);
1969         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL,
1970                         mask, NL80211_MESHCONF_TTL, nla_get_u8);
1971         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks,
1972                         mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS, nla_get_u8);
1973         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries,
1974                         mask, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
1975                         nla_get_u8);
1976         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time,
1977                         mask, NL80211_MESHCONF_PATH_REFRESH_TIME, nla_get_u32);
1978         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout,
1979                         mask, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
1980                         nla_get_u16);
1981         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
1982                         mask, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
1983                         nla_get_u32);
1984         FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval,
1985                         mask, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
1986                         nla_get_u16);
1987         FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
1988                         dot11MeshHWMPnetDiameterTraversalTime,
1989                         mask, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
1990                         nla_get_u16);
1991
1992         /* Apply changes */
1993         rtnl_lock();
1994         err = drv->ops->set_mesh_params(&drv->wiphy, dev, &cfg, mask);
1995         rtnl_unlock();
1996
1997         /* cleanup */
1998         cfg80211_put_dev(drv);
1999         dev_put(dev);
2000         return err;
2001 }
2002
2003 #undef FILL_IN_MESH_PARAM_IF_SET
2004
2005 static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
2006 {
2007         struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
2008         struct nlattr *nl_reg_rule;
2009         char *alpha2 = NULL;
2010         int rem_reg_rules = 0, r = 0;
2011         u32 num_rules = 0, rule_idx = 0, size_of_regd;
2012         struct ieee80211_regdomain *rd = NULL;
2013
2014         if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
2015                 return -EINVAL;
2016
2017         if (!info->attrs[NL80211_ATTR_REG_RULES])
2018                 return -EINVAL;
2019
2020         alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
2021
2022         nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
2023                         rem_reg_rules) {
2024                 num_rules++;
2025                 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
2026                         goto bad_reg;
2027         }
2028
2029         if (!reg_is_valid_request(alpha2))
2030                 return -EINVAL;
2031
2032         size_of_regd = sizeof(struct ieee80211_regdomain) +
2033                 (num_rules * sizeof(struct ieee80211_reg_rule));
2034
2035         rd = kzalloc(size_of_regd, GFP_KERNEL);
2036         if (!rd)
2037                 return -ENOMEM;
2038
2039         rd->n_reg_rules = num_rules;
2040         rd->alpha2[0] = alpha2[0];
2041         rd->alpha2[1] = alpha2[1];
2042
2043         nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
2044                         rem_reg_rules) {
2045                 nla_parse(tb, NL80211_REG_RULE_ATTR_MAX,
2046                         nla_data(nl_reg_rule), nla_len(nl_reg_rule),
2047                         reg_rule_policy);
2048                 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
2049                 if (r)
2050                         goto bad_reg;
2051
2052                 rule_idx++;
2053
2054                 if (rule_idx > NL80211_MAX_SUPP_REG_RULES)
2055                         goto bad_reg;
2056         }
2057
2058         BUG_ON(rule_idx != num_rules);
2059
2060         mutex_lock(&cfg80211_drv_mutex);
2061         r = set_regdom(rd);
2062         mutex_unlock(&cfg80211_drv_mutex);
2063         return r;
2064
2065  bad_reg:
2066         kfree(rd);
2067         return -EINVAL;
2068 }
2069
2070 static struct genl_ops nl80211_ops[] = {
2071         {
2072                 .cmd = NL80211_CMD_GET_WIPHY,
2073                 .doit = nl80211_get_wiphy,
2074                 .dumpit = nl80211_dump_wiphy,
2075                 .policy = nl80211_policy,
2076                 /* can be retrieved by unprivileged users */
2077         },
2078         {
2079                 .cmd = NL80211_CMD_SET_WIPHY,
2080                 .doit = nl80211_set_wiphy,
2081                 .policy = nl80211_policy,
2082                 .flags = GENL_ADMIN_PERM,
2083         },
2084         {
2085                 .cmd = NL80211_CMD_GET_INTERFACE,
2086                 .doit = nl80211_get_interface,
2087                 .dumpit = nl80211_dump_interface,
2088                 .policy = nl80211_policy,
2089                 /* can be retrieved by unprivileged users */
2090         },
2091         {
2092                 .cmd = NL80211_CMD_SET_INTERFACE,
2093                 .doit = nl80211_set_interface,
2094                 .policy = nl80211_policy,
2095                 .flags = GENL_ADMIN_PERM,
2096         },
2097         {
2098                 .cmd = NL80211_CMD_NEW_INTERFACE,
2099                 .doit = nl80211_new_interface,
2100                 .policy = nl80211_policy,
2101                 .flags = GENL_ADMIN_PERM,
2102         },
2103         {
2104                 .cmd = NL80211_CMD_DEL_INTERFACE,
2105                 .doit = nl80211_del_interface,
2106                 .policy = nl80211_policy,
2107                 .flags = GENL_ADMIN_PERM,
2108         },
2109         {
2110                 .cmd = NL80211_CMD_GET_KEY,
2111                 .doit = nl80211_get_key,
2112                 .policy = nl80211_policy,
2113                 .flags = GENL_ADMIN_PERM,
2114         },
2115         {
2116                 .cmd = NL80211_CMD_SET_KEY,
2117                 .doit = nl80211_set_key,
2118                 .policy = nl80211_policy,
2119                 .flags = GENL_ADMIN_PERM,
2120         },
2121         {
2122                 .cmd = NL80211_CMD_NEW_KEY,
2123                 .doit = nl80211_new_key,
2124                 .policy = nl80211_policy,
2125                 .flags = GENL_ADMIN_PERM,
2126         },
2127         {
2128                 .cmd = NL80211_CMD_DEL_KEY,
2129                 .doit = nl80211_del_key,
2130                 .policy = nl80211_policy,
2131                 .flags = GENL_ADMIN_PERM,
2132         },
2133         {
2134                 .cmd = NL80211_CMD_SET_BEACON,
2135                 .policy = nl80211_policy,
2136                 .flags = GENL_ADMIN_PERM,
2137                 .doit = nl80211_addset_beacon,
2138         },
2139         {
2140                 .cmd = NL80211_CMD_NEW_BEACON,
2141                 .policy = nl80211_policy,
2142                 .flags = GENL_ADMIN_PERM,
2143                 .doit = nl80211_addset_beacon,
2144         },
2145         {
2146                 .cmd = NL80211_CMD_DEL_BEACON,
2147                 .policy = nl80211_policy,
2148                 .flags = GENL_ADMIN_PERM,
2149                 .doit = nl80211_del_beacon,
2150         },
2151         {
2152                 .cmd = NL80211_CMD_GET_STATION,
2153                 .doit = nl80211_get_station,
2154                 .dumpit = nl80211_dump_station,
2155                 .policy = nl80211_policy,
2156                 .flags = GENL_ADMIN_PERM,
2157         },
2158         {
2159                 .cmd = NL80211_CMD_SET_STATION,
2160                 .doit = nl80211_set_station,
2161                 .policy = nl80211_policy,
2162                 .flags = GENL_ADMIN_PERM,
2163         },
2164         {
2165                 .cmd = NL80211_CMD_NEW_STATION,
2166                 .doit = nl80211_new_station,
2167                 .policy = nl80211_policy,
2168                 .flags = GENL_ADMIN_PERM,
2169         },
2170         {
2171                 .cmd = NL80211_CMD_DEL_STATION,
2172                 .doit = nl80211_del_station,
2173                 .policy = nl80211_policy,
2174                 .flags = GENL_ADMIN_PERM,
2175         },
2176         {
2177                 .cmd = NL80211_CMD_GET_MPATH,
2178                 .doit = nl80211_get_mpath,
2179                 .dumpit = nl80211_dump_mpath,
2180                 .policy = nl80211_policy,
2181                 .flags = GENL_ADMIN_PERM,
2182         },
2183         {
2184                 .cmd = NL80211_CMD_SET_MPATH,
2185                 .doit = nl80211_set_mpath,
2186                 .policy = nl80211_policy,
2187                 .flags = GENL_ADMIN_PERM,
2188         },
2189         {
2190                 .cmd = NL80211_CMD_NEW_MPATH,
2191                 .doit = nl80211_new_mpath,
2192                 .policy = nl80211_policy,
2193                 .flags = GENL_ADMIN_PERM,
2194         },
2195         {
2196                 .cmd = NL80211_CMD_DEL_MPATH,
2197                 .doit = nl80211_del_mpath,
2198                 .policy = nl80211_policy,
2199                 .flags = GENL_ADMIN_PERM,
2200         },
2201         {
2202                 .cmd = NL80211_CMD_SET_BSS,
2203                 .doit = nl80211_set_bss,
2204                 .policy = nl80211_policy,
2205                 .flags = GENL_ADMIN_PERM,
2206         },
2207         {
2208                 .cmd = NL80211_CMD_SET_REG,
2209                 .doit = nl80211_set_reg,
2210                 .policy = nl80211_policy,
2211                 .flags = GENL_ADMIN_PERM,
2212         },
2213         {
2214                 .cmd = NL80211_CMD_REQ_SET_REG,
2215                 .doit = nl80211_req_set_reg,
2216                 .policy = nl80211_policy,
2217                 .flags = GENL_ADMIN_PERM,
2218         },
2219         {
2220                 .cmd = NL80211_CMD_GET_MESH_PARAMS,
2221                 .doit = nl80211_get_mesh_params,
2222                 .policy = nl80211_policy,
2223                 /* can be retrieved by unprivileged users */
2224         },
2225         {
2226                 .cmd = NL80211_CMD_SET_MESH_PARAMS,
2227                 .doit = nl80211_set_mesh_params,
2228                 .policy = nl80211_policy,
2229                 .flags = GENL_ADMIN_PERM,
2230         },
2231 };
2232
2233 /* multicast groups */
2234 static struct genl_multicast_group nl80211_config_mcgrp = {
2235         .name = "config",
2236 };
2237
2238 /* notification functions */
2239
2240 void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev)
2241 {
2242         struct sk_buff *msg;
2243
2244         msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
2245         if (!msg)
2246                 return;
2247
2248         if (nl80211_send_wiphy(msg, 0, 0, 0, rdev) < 0) {
2249                 nlmsg_free(msg);
2250                 return;
2251         }
2252
2253         genlmsg_multicast(msg, 0, nl80211_config_mcgrp.id, GFP_KERNEL);
2254 }
2255
2256 /* initialisation/exit functions */
2257
2258 int nl80211_init(void)
2259 {
2260         int err, i;
2261
2262         err = genl_register_family(&nl80211_fam);
2263         if (err)
2264                 return err;
2265
2266         for (i = 0; i < ARRAY_SIZE(nl80211_ops); i++) {
2267                 err = genl_register_ops(&nl80211_fam, &nl80211_ops[i]);
2268                 if (err)
2269                         goto err_out;
2270         }
2271
2272         err = genl_register_mc_group(&nl80211_fam, &nl80211_config_mcgrp);
2273         if (err)
2274                 goto err_out;
2275
2276         return 0;
2277  err_out:
2278         genl_unregister_family(&nl80211_fam);
2279         return err;
2280 }
2281
2282 void nl80211_exit(void)
2283 {
2284         genl_unregister_family(&nl80211_fam);
2285 }