1 /* 2 * mac80211 configuration hooks for cfg80211 3 * 4 * Copyright 2006, 2007 Johannes Berg <johannes@sipsolutions.net> 5 * 6 * This file is GPLv2 as found in COPYING. 7 */ 8 9 #include <linux/ieee80211.h> 10 #include <linux/nl80211.h> 11 #include <linux/rtnetlink.h> 12 #include <net/net_namespace.h> 13 #include <linux/rcupdate.h> 14 #include <net/cfg80211.h> 15 #include "ieee80211_i.h" 16 #include "cfg.h" 17 #include "ieee80211_rate.h" 18 19 static enum ieee80211_if_types 20 nl80211_type_to_mac80211_type(enum nl80211_iftype type) 21 { 22 switch (type) { 23 case NL80211_IFTYPE_UNSPECIFIED: 24 return IEEE80211_IF_TYPE_STA; 25 case NL80211_IFTYPE_ADHOC: 26 return IEEE80211_IF_TYPE_IBSS; 27 case NL80211_IFTYPE_STATION: 28 return IEEE80211_IF_TYPE_STA; 29 case NL80211_IFTYPE_MONITOR: 30 return IEEE80211_IF_TYPE_MNTR; 31 default: 32 return IEEE80211_IF_TYPE_INVALID; 33 } 34 } 35 36 static int ieee80211_add_iface(struct wiphy *wiphy, char *name, 37 enum nl80211_iftype type) 38 { 39 struct ieee80211_local *local = wiphy_priv(wiphy); 40 enum ieee80211_if_types itype; 41 42 if (unlikely(local->reg_state != IEEE80211_DEV_REGISTERED)) 43 return -ENODEV; 44 45 itype = nl80211_type_to_mac80211_type(type); 46 if (itype == IEEE80211_IF_TYPE_INVALID) 47 return -EINVAL; 48 49 return ieee80211_if_add(local->mdev, name, NULL, itype); 50 } 51 52 static int ieee80211_del_iface(struct wiphy *wiphy, int ifindex) 53 { 54 struct ieee80211_local *local = wiphy_priv(wiphy); 55 struct net_device *dev; 56 char *name; 57 58 if (unlikely(local->reg_state != IEEE80211_DEV_REGISTERED)) 59 return -ENODEV; 60 61 /* we're under RTNL */ 62 dev = __dev_get_by_index(&init_net, ifindex); 63 if (!dev) 64 return 0; 65 66 name = dev->name; 67 68 return ieee80211_if_remove(local->mdev, name, -1); 69 } 70 71 static int ieee80211_change_iface(struct wiphy *wiphy, int ifindex, 72 enum nl80211_iftype type) 73 { 74 struct ieee80211_local *local = wiphy_priv(wiphy); 75 struct net_device *dev; 76 enum ieee80211_if_types itype; 77 struct ieee80211_sub_if_data *sdata; 78 79 if (unlikely(local->reg_state != IEEE80211_DEV_REGISTERED)) 80 return -ENODEV; 81 82 /* we're under RTNL */ 83 dev = __dev_get_by_index(&init_net, ifindex); 84 if (!dev) 85 return -ENODEV; 86 87 if (netif_running(dev)) 88 return -EBUSY; 89 90 itype = nl80211_type_to_mac80211_type(type); 91 if (itype == IEEE80211_IF_TYPE_INVALID) 92 return -EINVAL; 93 94 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 95 96 if (sdata->vif.type == IEEE80211_IF_TYPE_VLAN) 97 return -EOPNOTSUPP; 98 99 ieee80211_if_reinit(dev); 100 ieee80211_if_set_type(dev, itype); 101 102 return 0; 103 } 104 105 static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev, 106 u8 key_idx, u8 *mac_addr, 107 struct key_params *params) 108 { 109 struct ieee80211_sub_if_data *sdata; 110 struct sta_info *sta = NULL; 111 enum ieee80211_key_alg alg; 112 int ret; 113 114 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 115 116 switch (params->cipher) { 117 case WLAN_CIPHER_SUITE_WEP40: 118 case WLAN_CIPHER_SUITE_WEP104: 119 alg = ALG_WEP; 120 break; 121 case WLAN_CIPHER_SUITE_TKIP: 122 alg = ALG_TKIP; 123 break; 124 case WLAN_CIPHER_SUITE_CCMP: 125 alg = ALG_CCMP; 126 break; 127 default: 128 return -EINVAL; 129 } 130 131 if (mac_addr) { 132 sta = sta_info_get(sdata->local, mac_addr); 133 if (!sta) 134 return -ENOENT; 135 } 136 137 ret = 0; 138 if (!ieee80211_key_alloc(sdata, sta, alg, key_idx, 139 params->key_len, params->key)) 140 ret = -ENOMEM; 141 142 if (sta) 143 sta_info_put(sta); 144 145 return ret; 146 } 147 148 static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev, 149 u8 key_idx, u8 *mac_addr) 150 { 151 struct ieee80211_sub_if_data *sdata; 152 struct sta_info *sta; 153 int ret; 154 155 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 156 157 if (mac_addr) { 158 sta = sta_info_get(sdata->local, mac_addr); 159 if (!sta) 160 return -ENOENT; 161 162 ret = 0; 163 if (sta->key) 164 ieee80211_key_free(sta->key); 165 else 166 ret = -ENOENT; 167 168 sta_info_put(sta); 169 return ret; 170 } 171 172 if (!sdata->keys[key_idx]) 173 return -ENOENT; 174 175 ieee80211_key_free(sdata->keys[key_idx]); 176 177 return 0; 178 } 179 180 static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev, 181 u8 key_idx, u8 *mac_addr, void *cookie, 182 void (*callback)(void *cookie, 183 struct key_params *params)) 184 { 185 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 186 struct sta_info *sta = NULL; 187 u8 seq[6] = {0}; 188 struct key_params params; 189 struct ieee80211_key *key; 190 u32 iv32; 191 u16 iv16; 192 int err = -ENOENT; 193 194 if (mac_addr) { 195 sta = sta_info_get(sdata->local, mac_addr); 196 if (!sta) 197 goto out; 198 199 key = sta->key; 200 } else 201 key = sdata->keys[key_idx]; 202 203 if (!key) 204 goto out; 205 206 memset(¶ms, 0, sizeof(params)); 207 208 switch (key->conf.alg) { 209 case ALG_TKIP: 210 params.cipher = WLAN_CIPHER_SUITE_TKIP; 211 212 iv32 = key->u.tkip.iv32; 213 iv16 = key->u.tkip.iv16; 214 215 if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE && 216 sdata->local->ops->get_tkip_seq) 217 sdata->local->ops->get_tkip_seq( 218 local_to_hw(sdata->local), 219 key->conf.hw_key_idx, 220 &iv32, &iv16); 221 222 seq[0] = iv16 & 0xff; 223 seq[1] = (iv16 >> 8) & 0xff; 224 seq[2] = iv32 & 0xff; 225 seq[3] = (iv32 >> 8) & 0xff; 226 seq[4] = (iv32 >> 16) & 0xff; 227 seq[5] = (iv32 >> 24) & 0xff; 228 params.seq = seq; 229 params.seq_len = 6; 230 break; 231 case ALG_CCMP: 232 params.cipher = WLAN_CIPHER_SUITE_CCMP; 233 seq[0] = key->u.ccmp.tx_pn[5]; 234 seq[1] = key->u.ccmp.tx_pn[4]; 235 seq[2] = key->u.ccmp.tx_pn[3]; 236 seq[3] = key->u.ccmp.tx_pn[2]; 237 seq[4] = key->u.ccmp.tx_pn[1]; 238 seq[5] = key->u.ccmp.tx_pn[0]; 239 params.seq = seq; 240 params.seq_len = 6; 241 break; 242 case ALG_WEP: 243 if (key->conf.keylen == 5) 244 params.cipher = WLAN_CIPHER_SUITE_WEP40; 245 else 246 params.cipher = WLAN_CIPHER_SUITE_WEP104; 247 break; 248 } 249 250 params.key = key->conf.key; 251 params.key_len = key->conf.keylen; 252 253 callback(cookie, ¶ms); 254 err = 0; 255 256 out: 257 if (sta) 258 sta_info_put(sta); 259 return err; 260 } 261 262 static int ieee80211_config_default_key(struct wiphy *wiphy, 263 struct net_device *dev, 264 u8 key_idx) 265 { 266 struct ieee80211_sub_if_data *sdata; 267 268 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 269 ieee80211_set_default_key(sdata, key_idx); 270 271 return 0; 272 } 273 274 static int ieee80211_get_station(struct wiphy *wiphy, struct net_device *dev, 275 u8 *mac, struct station_stats *stats) 276 { 277 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 278 struct sta_info *sta; 279 280 sta = sta_info_get(local, mac); 281 if (!sta) 282 return -ENOENT; 283 284 /* XXX: verify sta->dev == dev */ 285 286 stats->filled = STATION_STAT_INACTIVE_TIME | 287 STATION_STAT_RX_BYTES | 288 STATION_STAT_TX_BYTES; 289 290 stats->inactive_time = jiffies_to_msecs(jiffies - sta->last_rx); 291 stats->rx_bytes = sta->rx_bytes; 292 stats->tx_bytes = sta->tx_bytes; 293 294 sta_info_put(sta); 295 296 return 0; 297 } 298 299 /* 300 * This handles both adding a beacon and setting new beacon info 301 */ 302 static int ieee80211_config_beacon(struct ieee80211_sub_if_data *sdata, 303 struct beacon_parameters *params) 304 { 305 struct beacon_data *new, *old; 306 int new_head_len, new_tail_len; 307 int size; 308 int err = -EINVAL; 309 310 old = sdata->u.ap.beacon; 311 312 /* head must not be zero-length */ 313 if (params->head && !params->head_len) 314 return -EINVAL; 315 316 /* 317 * This is a kludge. beacon interval should really be part 318 * of the beacon information. 319 */ 320 if (params->interval) { 321 sdata->local->hw.conf.beacon_int = params->interval; 322 if (ieee80211_hw_config(sdata->local)) 323 return -EINVAL; 324 /* 325 * We updated some parameter so if below bails out 326 * it's not an error. 327 */ 328 err = 0; 329 } 330 331 /* Need to have a beacon head if we don't have one yet */ 332 if (!params->head && !old) 333 return err; 334 335 /* sorry, no way to start beaconing without dtim period */ 336 if (!params->dtim_period && !old) 337 return err; 338 339 /* new or old head? */ 340 if (params->head) 341 new_head_len = params->head_len; 342 else 343 new_head_len = old->head_len; 344 345 /* new or old tail? */ 346 if (params->tail || !old) 347 /* params->tail_len will be zero for !params->tail */ 348 new_tail_len = params->tail_len; 349 else 350 new_tail_len = old->tail_len; 351 352 size = sizeof(*new) + new_head_len + new_tail_len; 353 354 new = kzalloc(size, GFP_KERNEL); 355 if (!new) 356 return -ENOMEM; 357 358 /* start filling the new info now */ 359 360 /* new or old dtim period? */ 361 if (params->dtim_period) 362 new->dtim_period = params->dtim_period; 363 else 364 new->dtim_period = old->dtim_period; 365 366 /* 367 * pointers go into the block we allocated, 368 * memory is | beacon_data | head | tail | 369 */ 370 new->head = ((u8 *) new) + sizeof(*new); 371 new->tail = new->head + new_head_len; 372 new->head_len = new_head_len; 373 new->tail_len = new_tail_len; 374 375 /* copy in head */ 376 if (params->head) 377 memcpy(new->head, params->head, new_head_len); 378 else 379 memcpy(new->head, old->head, new_head_len); 380 381 /* copy in optional tail */ 382 if (params->tail) 383 memcpy(new->tail, params->tail, new_tail_len); 384 else 385 if (old) 386 memcpy(new->tail, old->tail, new_tail_len); 387 388 rcu_assign_pointer(sdata->u.ap.beacon, new); 389 390 synchronize_rcu(); 391 392 kfree(old); 393 394 return ieee80211_if_config_beacon(sdata->dev); 395 } 396 397 static int ieee80211_add_beacon(struct wiphy *wiphy, struct net_device *dev, 398 struct beacon_parameters *params) 399 { 400 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 401 struct beacon_data *old; 402 403 if (sdata->vif.type != IEEE80211_IF_TYPE_AP) 404 return -EINVAL; 405 406 old = sdata->u.ap.beacon; 407 408 if (old) 409 return -EALREADY; 410 411 return ieee80211_config_beacon(sdata, params); 412 } 413 414 static int ieee80211_set_beacon(struct wiphy *wiphy, struct net_device *dev, 415 struct beacon_parameters *params) 416 { 417 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 418 struct beacon_data *old; 419 420 if (sdata->vif.type != IEEE80211_IF_TYPE_AP) 421 return -EINVAL; 422 423 old = sdata->u.ap.beacon; 424 425 if (!old) 426 return -ENOENT; 427 428 return ieee80211_config_beacon(sdata, params); 429 } 430 431 static int ieee80211_del_beacon(struct wiphy *wiphy, struct net_device *dev) 432 { 433 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 434 struct beacon_data *old; 435 436 if (sdata->vif.type != IEEE80211_IF_TYPE_AP) 437 return -EINVAL; 438 439 old = sdata->u.ap.beacon; 440 441 if (!old) 442 return -ENOENT; 443 444 rcu_assign_pointer(sdata->u.ap.beacon, NULL); 445 synchronize_rcu(); 446 kfree(old); 447 448 return ieee80211_if_config_beacon(dev); 449 } 450 451 /* Layer 2 Update frame (802.2 Type 1 LLC XID Update response) */ 452 struct iapp_layer2_update { 453 u8 da[ETH_ALEN]; /* broadcast */ 454 u8 sa[ETH_ALEN]; /* STA addr */ 455 __be16 len; /* 6 */ 456 u8 dsap; /* 0 */ 457 u8 ssap; /* 0 */ 458 u8 control; 459 u8 xid_info[3]; 460 } __attribute__ ((packed)); 461 462 static void ieee80211_send_layer2_update(struct sta_info *sta) 463 { 464 struct iapp_layer2_update *msg; 465 struct sk_buff *skb; 466 467 /* Send Level 2 Update Frame to update forwarding tables in layer 2 468 * bridge devices */ 469 470 skb = dev_alloc_skb(sizeof(*msg)); 471 if (!skb) 472 return; 473 msg = (struct iapp_layer2_update *)skb_put(skb, sizeof(*msg)); 474 475 /* 802.2 Type 1 Logical Link Control (LLC) Exchange Identifier (XID) 476 * Update response frame; IEEE Std 802.2-1998, 5.4.1.2.1 */ 477 478 memset(msg->da, 0xff, ETH_ALEN); 479 memcpy(msg->sa, sta->addr, ETH_ALEN); 480 msg->len = htons(6); 481 msg->dsap = 0; 482 msg->ssap = 0x01; /* NULL LSAP, CR Bit: Response */ 483 msg->control = 0xaf; /* XID response lsb.1111F101. 484 * F=0 (no poll command; unsolicited frame) */ 485 msg->xid_info[0] = 0x81; /* XID format identifier */ 486 msg->xid_info[1] = 1; /* LLC types/classes: Type 1 LLC */ 487 msg->xid_info[2] = 0; /* XID sender's receive window size (RW) */ 488 489 skb->dev = sta->dev; 490 skb->protocol = eth_type_trans(skb, sta->dev); 491 memset(skb->cb, 0, sizeof(skb->cb)); 492 netif_rx(skb); 493 } 494 495 static void sta_apply_parameters(struct ieee80211_local *local, 496 struct sta_info *sta, 497 struct station_parameters *params) 498 { 499 u32 rates; 500 int i, j; 501 struct ieee80211_hw_mode *mode; 502 503 if (params->station_flags & STATION_FLAG_CHANGED) { 504 sta->flags &= ~WLAN_STA_AUTHORIZED; 505 if (params->station_flags & STATION_FLAG_AUTHORIZED) 506 sta->flags |= WLAN_STA_AUTHORIZED; 507 508 sta->flags &= ~WLAN_STA_SHORT_PREAMBLE; 509 if (params->station_flags & STATION_FLAG_SHORT_PREAMBLE) 510 sta->flags |= WLAN_STA_SHORT_PREAMBLE; 511 512 sta->flags &= ~WLAN_STA_WME; 513 if (params->station_flags & STATION_FLAG_WME) 514 sta->flags |= WLAN_STA_WME; 515 } 516 517 if (params->aid) { 518 sta->aid = params->aid; 519 if (sta->aid > IEEE80211_MAX_AID) 520 sta->aid = 0; /* XXX: should this be an error? */ 521 } 522 523 if (params->listen_interval >= 0) 524 sta->listen_interval = params->listen_interval; 525 526 if (params->supported_rates) { 527 rates = 0; 528 mode = local->oper_hw_mode; 529 for (i = 0; i < params->supported_rates_len; i++) { 530 int rate = (params->supported_rates[i] & 0x7f) * 5; 531 for (j = 0; j < mode->num_rates; j++) { 532 if (mode->rates[j].rate == rate) 533 rates |= BIT(j); 534 } 535 } 536 sta->supp_rates = rates; 537 } 538 } 539 540 static int ieee80211_add_station(struct wiphy *wiphy, struct net_device *dev, 541 u8 *mac, struct station_parameters *params) 542 { 543 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 544 struct sta_info *sta; 545 struct ieee80211_sub_if_data *sdata; 546 547 /* Prevent a race with changing the rate control algorithm */ 548 if (!netif_running(dev)) 549 return -ENETDOWN; 550 551 /* XXX: get sta belonging to dev */ 552 sta = sta_info_get(local, mac); 553 if (sta) { 554 sta_info_put(sta); 555 return -EEXIST; 556 } 557 558 if (params->vlan) { 559 sdata = IEEE80211_DEV_TO_SUB_IF(params->vlan); 560 561 if (sdata->vif.type != IEEE80211_IF_TYPE_VLAN || 562 sdata->vif.type != IEEE80211_IF_TYPE_AP) 563 return -EINVAL; 564 } else 565 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 566 567 sta = sta_info_add(local, dev, mac, GFP_KERNEL); 568 if (!sta) 569 return -ENOMEM; 570 571 sta->dev = sdata->dev; 572 if (sdata->vif.type == IEEE80211_IF_TYPE_VLAN || 573 sdata->vif.type == IEEE80211_IF_TYPE_AP) 574 ieee80211_send_layer2_update(sta); 575 576 sta->flags = WLAN_STA_AUTH | WLAN_STA_ASSOC; 577 578 sta_apply_parameters(local, sta, params); 579 580 rate_control_rate_init(sta, local); 581 582 sta_info_put(sta); 583 584 return 0; 585 } 586 587 static int ieee80211_del_station(struct wiphy *wiphy, struct net_device *dev, 588 u8 *mac) 589 { 590 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 591 struct sta_info *sta; 592 593 if (mac) { 594 /* XXX: get sta belonging to dev */ 595 sta = sta_info_get(local, mac); 596 if (!sta) 597 return -ENOENT; 598 599 sta_info_free(sta); 600 sta_info_put(sta); 601 } else 602 sta_info_flush(local, dev); 603 604 return 0; 605 } 606 607 static int ieee80211_change_station(struct wiphy *wiphy, 608 struct net_device *dev, 609 u8 *mac, 610 struct station_parameters *params) 611 { 612 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 613 struct sta_info *sta; 614 struct ieee80211_sub_if_data *vlansdata; 615 616 /* XXX: get sta belonging to dev */ 617 sta = sta_info_get(local, mac); 618 if (!sta) 619 return -ENOENT; 620 621 if (params->vlan && params->vlan != sta->dev) { 622 vlansdata = IEEE80211_DEV_TO_SUB_IF(params->vlan); 623 624 if (vlansdata->vif.type != IEEE80211_IF_TYPE_VLAN || 625 vlansdata->vif.type != IEEE80211_IF_TYPE_AP) 626 return -EINVAL; 627 628 sta->dev = params->vlan; 629 ieee80211_send_layer2_update(sta); 630 } 631 632 sta_apply_parameters(local, sta, params); 633 634 sta_info_put(sta); 635 636 return 0; 637 } 638 639 struct cfg80211_ops mac80211_config_ops = { 640 .add_virtual_intf = ieee80211_add_iface, 641 .del_virtual_intf = ieee80211_del_iface, 642 .change_virtual_intf = ieee80211_change_iface, 643 .add_key = ieee80211_add_key, 644 .del_key = ieee80211_del_key, 645 .get_key = ieee80211_get_key, 646 .set_default_key = ieee80211_config_default_key, 647 .add_beacon = ieee80211_add_beacon, 648 .set_beacon = ieee80211_set_beacon, 649 .del_beacon = ieee80211_del_beacon, 650 .add_station = ieee80211_add_station, 651 .del_station = ieee80211_del_station, 652 .change_station = ieee80211_change_station, 653 .get_station = ieee80211_get_station, 654 }; 655