1 /* 2 * Some IBSS support code for cfg80211. 3 * 4 * Copyright 2009 Johannes Berg <johannes@sipsolutions.net> 5 */ 6 7 #include <linux/etherdevice.h> 8 #include <linux/if_arp.h> 9 #include <linux/slab.h> 10 #include <linux/export.h> 11 #include <net/cfg80211.h> 12 #include "wext-compat.h" 13 #include "nl80211.h" 14 #include "rdev-ops.h" 15 16 17 void __cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid) 18 { 19 struct wireless_dev *wdev = dev->ieee80211_ptr; 20 struct cfg80211_bss *bss; 21 #ifdef CONFIG_CFG80211_WEXT 22 union iwreq_data wrqu; 23 #endif 24 25 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC)) 26 return; 27 28 if (!wdev->ssid_len) 29 return; 30 31 bss = cfg80211_get_bss(wdev->wiphy, NULL, bssid, 32 wdev->ssid, wdev->ssid_len, 33 WLAN_CAPABILITY_IBSS, WLAN_CAPABILITY_IBSS); 34 35 if (WARN_ON(!bss)) 36 return; 37 38 if (wdev->current_bss) { 39 cfg80211_unhold_bss(wdev->current_bss); 40 cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub); 41 } 42 43 cfg80211_hold_bss(bss_from_pub(bss)); 44 wdev->current_bss = bss_from_pub(bss); 45 46 cfg80211_upload_connect_keys(wdev); 47 48 nl80211_send_ibss_bssid(wiphy_to_dev(wdev->wiphy), dev, bssid, 49 GFP_KERNEL); 50 #ifdef CONFIG_CFG80211_WEXT 51 memset(&wrqu, 0, sizeof(wrqu)); 52 memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN); 53 wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL); 54 #endif 55 } 56 57 void cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid, gfp_t gfp) 58 { 59 struct wireless_dev *wdev = dev->ieee80211_ptr; 60 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy); 61 struct cfg80211_event *ev; 62 unsigned long flags; 63 64 trace_cfg80211_ibss_joined(dev, bssid); 65 66 ev = kzalloc(sizeof(*ev), gfp); 67 if (!ev) 68 return; 69 70 ev->type = EVENT_IBSS_JOINED; 71 memcpy(ev->cr.bssid, bssid, ETH_ALEN); 72 73 spin_lock_irqsave(&wdev->event_lock, flags); 74 list_add_tail(&ev->list, &wdev->event_list); 75 spin_unlock_irqrestore(&wdev->event_lock, flags); 76 queue_work(cfg80211_wq, &rdev->event_work); 77 } 78 EXPORT_SYMBOL(cfg80211_ibss_joined); 79 80 int __cfg80211_join_ibss(struct cfg80211_registered_device *rdev, 81 struct net_device *dev, 82 struct cfg80211_ibss_params *params, 83 struct cfg80211_cached_keys *connkeys) 84 { 85 struct wireless_dev *wdev = dev->ieee80211_ptr; 86 struct ieee80211_channel *check_chan; 87 u8 radar_detect_width = 0; 88 int err; 89 90 ASSERT_WDEV_LOCK(wdev); 91 92 if (wdev->ssid_len) 93 return -EALREADY; 94 95 if (!params->basic_rates) { 96 /* 97 * If no rates were explicitly configured, 98 * use the mandatory rate set for 11b or 99 * 11a for maximum compatibility. 100 */ 101 struct ieee80211_supported_band *sband = 102 rdev->wiphy.bands[params->chandef.chan->band]; 103 int j; 104 u32 flag = params->chandef.chan->band == IEEE80211_BAND_5GHZ ? 105 IEEE80211_RATE_MANDATORY_A : 106 IEEE80211_RATE_MANDATORY_B; 107 108 for (j = 0; j < sband->n_bitrates; j++) { 109 if (sband->bitrates[j].flags & flag) 110 params->basic_rates |= BIT(j); 111 } 112 } 113 114 if (WARN_ON(wdev->connect_keys)) 115 kfree(wdev->connect_keys); 116 wdev->connect_keys = connkeys; 117 118 wdev->ibss_fixed = params->channel_fixed; 119 wdev->ibss_dfs_possible = params->userspace_handles_dfs; 120 #ifdef CONFIG_CFG80211_WEXT 121 wdev->wext.ibss.chandef = params->chandef; 122 #endif 123 check_chan = params->chandef.chan; 124 if (params->userspace_handles_dfs) { 125 /* use channel NULL to check for radar even if the current 126 * channel is not a radar channel - it might decide to change 127 * to DFS channel later. 128 */ 129 radar_detect_width = BIT(params->chandef.width); 130 check_chan = NULL; 131 } 132 133 err = cfg80211_can_use_iftype_chan(rdev, wdev, wdev->iftype, 134 check_chan, 135 (params->channel_fixed && 136 !radar_detect_width) 137 ? CHAN_MODE_SHARED 138 : CHAN_MODE_EXCLUSIVE, 139 radar_detect_width); 140 141 if (err) { 142 wdev->connect_keys = NULL; 143 return err; 144 } 145 146 err = rdev_join_ibss(rdev, dev, params); 147 if (err) { 148 wdev->connect_keys = NULL; 149 return err; 150 } 151 152 memcpy(wdev->ssid, params->ssid, params->ssid_len); 153 wdev->ssid_len = params->ssid_len; 154 155 return 0; 156 } 157 158 int cfg80211_join_ibss(struct cfg80211_registered_device *rdev, 159 struct net_device *dev, 160 struct cfg80211_ibss_params *params, 161 struct cfg80211_cached_keys *connkeys) 162 { 163 struct wireless_dev *wdev = dev->ieee80211_ptr; 164 int err; 165 166 ASSERT_RTNL(); 167 168 wdev_lock(wdev); 169 err = __cfg80211_join_ibss(rdev, dev, params, connkeys); 170 wdev_unlock(wdev); 171 172 return err; 173 } 174 175 static void __cfg80211_clear_ibss(struct net_device *dev, bool nowext) 176 { 177 struct wireless_dev *wdev = dev->ieee80211_ptr; 178 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy); 179 int i; 180 181 ASSERT_WDEV_LOCK(wdev); 182 183 kfree(wdev->connect_keys); 184 wdev->connect_keys = NULL; 185 186 rdev_set_qos_map(rdev, dev, NULL); 187 188 /* 189 * Delete all the keys ... pairwise keys can't really 190 * exist any more anyway, but default keys might. 191 */ 192 if (rdev->ops->del_key) 193 for (i = 0; i < 6; i++) 194 rdev_del_key(rdev, dev, i, false, NULL); 195 196 if (wdev->current_bss) { 197 cfg80211_unhold_bss(wdev->current_bss); 198 cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub); 199 } 200 201 wdev->current_bss = NULL; 202 wdev->ssid_len = 0; 203 #ifdef CONFIG_CFG80211_WEXT 204 if (!nowext) 205 wdev->wext.ibss.ssid_len = 0; 206 #endif 207 } 208 209 void cfg80211_clear_ibss(struct net_device *dev, bool nowext) 210 { 211 struct wireless_dev *wdev = dev->ieee80211_ptr; 212 213 wdev_lock(wdev); 214 __cfg80211_clear_ibss(dev, nowext); 215 wdev_unlock(wdev); 216 } 217 218 int __cfg80211_leave_ibss(struct cfg80211_registered_device *rdev, 219 struct net_device *dev, bool nowext) 220 { 221 struct wireless_dev *wdev = dev->ieee80211_ptr; 222 int err; 223 224 ASSERT_WDEV_LOCK(wdev); 225 226 if (!wdev->ssid_len) 227 return -ENOLINK; 228 229 err = rdev_leave_ibss(rdev, dev); 230 231 if (err) 232 return err; 233 234 __cfg80211_clear_ibss(dev, nowext); 235 236 return 0; 237 } 238 239 int cfg80211_leave_ibss(struct cfg80211_registered_device *rdev, 240 struct net_device *dev, bool nowext) 241 { 242 struct wireless_dev *wdev = dev->ieee80211_ptr; 243 int err; 244 245 wdev_lock(wdev); 246 err = __cfg80211_leave_ibss(rdev, dev, nowext); 247 wdev_unlock(wdev); 248 249 return err; 250 } 251 252 #ifdef CONFIG_CFG80211_WEXT 253 int cfg80211_ibss_wext_join(struct cfg80211_registered_device *rdev, 254 struct wireless_dev *wdev) 255 { 256 struct cfg80211_cached_keys *ck = NULL; 257 enum ieee80211_band band; 258 int i, err; 259 260 ASSERT_WDEV_LOCK(wdev); 261 262 if (!wdev->wext.ibss.beacon_interval) 263 wdev->wext.ibss.beacon_interval = 100; 264 265 /* try to find an IBSS channel if none requested ... */ 266 if (!wdev->wext.ibss.chandef.chan) { 267 struct ieee80211_channel *new_chan = NULL; 268 269 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 270 struct ieee80211_supported_band *sband; 271 struct ieee80211_channel *chan; 272 273 sband = rdev->wiphy.bands[band]; 274 if (!sband) 275 continue; 276 277 for (i = 0; i < sband->n_channels; i++) { 278 chan = &sband->channels[i]; 279 if (chan->flags & IEEE80211_CHAN_NO_IR) 280 continue; 281 if (chan->flags & IEEE80211_CHAN_DISABLED) 282 continue; 283 new_chan = chan; 284 break; 285 } 286 287 if (new_chan) 288 break; 289 } 290 291 if (!new_chan) 292 return -EINVAL; 293 294 cfg80211_chandef_create(&wdev->wext.ibss.chandef, new_chan, 295 NL80211_CHAN_NO_HT); 296 } 297 298 /* don't join -- SSID is not there */ 299 if (!wdev->wext.ibss.ssid_len) 300 return 0; 301 302 if (!netif_running(wdev->netdev)) 303 return 0; 304 305 if (wdev->wext.keys) { 306 wdev->wext.keys->def = wdev->wext.default_key; 307 wdev->wext.keys->defmgmt = wdev->wext.default_mgmt_key; 308 } 309 310 wdev->wext.ibss.privacy = wdev->wext.default_key != -1; 311 312 if (wdev->wext.keys) { 313 ck = kmemdup(wdev->wext.keys, sizeof(*ck), GFP_KERNEL); 314 if (!ck) 315 return -ENOMEM; 316 for (i = 0; i < 6; i++) 317 ck->params[i].key = ck->data[i]; 318 } 319 err = __cfg80211_join_ibss(rdev, wdev->netdev, 320 &wdev->wext.ibss, ck); 321 if (err) 322 kfree(ck); 323 324 return err; 325 } 326 327 int cfg80211_ibss_wext_siwfreq(struct net_device *dev, 328 struct iw_request_info *info, 329 struct iw_freq *wextfreq, char *extra) 330 { 331 struct wireless_dev *wdev = dev->ieee80211_ptr; 332 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy); 333 struct ieee80211_channel *chan = NULL; 334 int err, freq; 335 336 /* call only for ibss! */ 337 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC)) 338 return -EINVAL; 339 340 if (!rdev->ops->join_ibss) 341 return -EOPNOTSUPP; 342 343 freq = cfg80211_wext_freq(wdev->wiphy, wextfreq); 344 if (freq < 0) 345 return freq; 346 347 if (freq) { 348 chan = ieee80211_get_channel(wdev->wiphy, freq); 349 if (!chan) 350 return -EINVAL; 351 if (chan->flags & IEEE80211_CHAN_NO_IR || 352 chan->flags & IEEE80211_CHAN_DISABLED) 353 return -EINVAL; 354 } 355 356 if (wdev->wext.ibss.chandef.chan == chan) 357 return 0; 358 359 wdev_lock(wdev); 360 err = 0; 361 if (wdev->ssid_len) 362 err = __cfg80211_leave_ibss(rdev, dev, true); 363 wdev_unlock(wdev); 364 365 if (err) 366 return err; 367 368 if (chan) { 369 cfg80211_chandef_create(&wdev->wext.ibss.chandef, chan, 370 NL80211_CHAN_NO_HT); 371 wdev->wext.ibss.channel_fixed = true; 372 } else { 373 /* cfg80211_ibss_wext_join will pick one if needed */ 374 wdev->wext.ibss.channel_fixed = false; 375 } 376 377 wdev_lock(wdev); 378 err = cfg80211_ibss_wext_join(rdev, wdev); 379 wdev_unlock(wdev); 380 381 return err; 382 } 383 384 int cfg80211_ibss_wext_giwfreq(struct net_device *dev, 385 struct iw_request_info *info, 386 struct iw_freq *freq, char *extra) 387 { 388 struct wireless_dev *wdev = dev->ieee80211_ptr; 389 struct ieee80211_channel *chan = NULL; 390 391 /* call only for ibss! */ 392 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC)) 393 return -EINVAL; 394 395 wdev_lock(wdev); 396 if (wdev->current_bss) 397 chan = wdev->current_bss->pub.channel; 398 else if (wdev->wext.ibss.chandef.chan) 399 chan = wdev->wext.ibss.chandef.chan; 400 wdev_unlock(wdev); 401 402 if (chan) { 403 freq->m = chan->center_freq; 404 freq->e = 6; 405 return 0; 406 } 407 408 /* no channel if not joining */ 409 return -EINVAL; 410 } 411 412 int cfg80211_ibss_wext_siwessid(struct net_device *dev, 413 struct iw_request_info *info, 414 struct iw_point *data, char *ssid) 415 { 416 struct wireless_dev *wdev = dev->ieee80211_ptr; 417 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy); 418 size_t len = data->length; 419 int err; 420 421 /* call only for ibss! */ 422 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC)) 423 return -EINVAL; 424 425 if (!rdev->ops->join_ibss) 426 return -EOPNOTSUPP; 427 428 wdev_lock(wdev); 429 err = 0; 430 if (wdev->ssid_len) 431 err = __cfg80211_leave_ibss(rdev, dev, true); 432 wdev_unlock(wdev); 433 434 if (err) 435 return err; 436 437 /* iwconfig uses nul termination in SSID.. */ 438 if (len > 0 && ssid[len - 1] == '\0') 439 len--; 440 441 wdev->wext.ibss.ssid = wdev->ssid; 442 memcpy(wdev->wext.ibss.ssid, ssid, len); 443 wdev->wext.ibss.ssid_len = len; 444 445 wdev_lock(wdev); 446 err = cfg80211_ibss_wext_join(rdev, wdev); 447 wdev_unlock(wdev); 448 449 return err; 450 } 451 452 int cfg80211_ibss_wext_giwessid(struct net_device *dev, 453 struct iw_request_info *info, 454 struct iw_point *data, char *ssid) 455 { 456 struct wireless_dev *wdev = dev->ieee80211_ptr; 457 458 /* call only for ibss! */ 459 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC)) 460 return -EINVAL; 461 462 data->flags = 0; 463 464 wdev_lock(wdev); 465 if (wdev->ssid_len) { 466 data->flags = 1; 467 data->length = wdev->ssid_len; 468 memcpy(ssid, wdev->ssid, data->length); 469 } else if (wdev->wext.ibss.ssid && wdev->wext.ibss.ssid_len) { 470 data->flags = 1; 471 data->length = wdev->wext.ibss.ssid_len; 472 memcpy(ssid, wdev->wext.ibss.ssid, data->length); 473 } 474 wdev_unlock(wdev); 475 476 return 0; 477 } 478 479 int cfg80211_ibss_wext_siwap(struct net_device *dev, 480 struct iw_request_info *info, 481 struct sockaddr *ap_addr, char *extra) 482 { 483 struct wireless_dev *wdev = dev->ieee80211_ptr; 484 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy); 485 u8 *bssid = ap_addr->sa_data; 486 int err; 487 488 /* call only for ibss! */ 489 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC)) 490 return -EINVAL; 491 492 if (!rdev->ops->join_ibss) 493 return -EOPNOTSUPP; 494 495 if (ap_addr->sa_family != ARPHRD_ETHER) 496 return -EINVAL; 497 498 /* automatic mode */ 499 if (is_zero_ether_addr(bssid) || is_broadcast_ether_addr(bssid)) 500 bssid = NULL; 501 502 /* both automatic */ 503 if (!bssid && !wdev->wext.ibss.bssid) 504 return 0; 505 506 /* fixed already - and no change */ 507 if (wdev->wext.ibss.bssid && bssid && 508 ether_addr_equal(bssid, wdev->wext.ibss.bssid)) 509 return 0; 510 511 wdev_lock(wdev); 512 err = 0; 513 if (wdev->ssid_len) 514 err = __cfg80211_leave_ibss(rdev, dev, true); 515 wdev_unlock(wdev); 516 517 if (err) 518 return err; 519 520 if (bssid) { 521 memcpy(wdev->wext.bssid, bssid, ETH_ALEN); 522 wdev->wext.ibss.bssid = wdev->wext.bssid; 523 } else 524 wdev->wext.ibss.bssid = NULL; 525 526 wdev_lock(wdev); 527 err = cfg80211_ibss_wext_join(rdev, wdev); 528 wdev_unlock(wdev); 529 530 return err; 531 } 532 533 int cfg80211_ibss_wext_giwap(struct net_device *dev, 534 struct iw_request_info *info, 535 struct sockaddr *ap_addr, char *extra) 536 { 537 struct wireless_dev *wdev = dev->ieee80211_ptr; 538 539 /* call only for ibss! */ 540 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC)) 541 return -EINVAL; 542 543 ap_addr->sa_family = ARPHRD_ETHER; 544 545 wdev_lock(wdev); 546 if (wdev->current_bss) 547 memcpy(ap_addr->sa_data, wdev->current_bss->pub.bssid, ETH_ALEN); 548 else if (wdev->wext.ibss.bssid) 549 memcpy(ap_addr->sa_data, wdev->wext.ibss.bssid, ETH_ALEN); 550 else 551 memset(ap_addr->sa_data, 0, ETH_ALEN); 552 553 wdev_unlock(wdev); 554 555 return 0; 556 } 557 #endif 558