net/wireless/ibss.c

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