blob: e37e39c29dfb82ada18f68fd3b065c92ff7a1093 [file] [log] [blame]
Johannes Berg04a773a2009-04-19 21:24:32 +02001/*
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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +09009#include <linux/slab.h>
Paul Gortmakerbc3b2d72011-07-15 11:47:34 -040010#include <linux/export.h>
Johannes Berg04a773a2009-04-19 21:24:32 +020011#include <net/cfg80211.h>
Johannes Berg0e82ffe2009-07-27 12:01:50 +020012#include "wext-compat.h"
Johannes Berg04a773a2009-04-19 21:24:32 +020013#include "nl80211.h"
Hila Gonene35e4d22012-06-27 17:19:42 +030014#include "rdev-ops.h"
Johannes Berg04a773a2009-04-19 21:24:32 +020015
16
Antonio Quartullife94f3a2014-01-29 17:53:43 +010017void __cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid,
18 struct ieee80211_channel *channel)
Johannes Berg04a773a2009-04-19 21:24:32 +020019{
20 struct wireless_dev *wdev = dev->ieee80211_ptr;
21 struct cfg80211_bss *bss;
Johannes Berg3d23e342009-09-29 23:27:28 +020022#ifdef CONFIG_CFG80211_WEXT
Johannes Berg04a773a2009-04-19 21:24:32 +020023 union iwreq_data wrqu;
24#endif
25
26 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
27 return;
28
Johannes Bergf7969962009-08-21 12:23:49 +020029 if (!wdev->ssid_len)
Johannes Berg04a773a2009-04-19 21:24:32 +020030 return;
31
Antonio Quartullife94f3a2014-01-29 17:53:43 +010032 bss = cfg80211_get_bss(wdev->wiphy, channel, bssid, NULL, 0,
Johannes Berg04a773a2009-04-19 21:24:32 +020033 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);
Johannes Berg5b112d32013-02-01 01:49:58 +010040 cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
Johannes Berg04a773a2009-04-19 21:24:32 +020041 }
42
Johannes Berg19957bb2009-07-02 17:20:43 +020043 cfg80211_hold_bss(bss_from_pub(bss));
44 wdev->current_bss = bss_from_pub(bss);
Johannes Berg04a773a2009-04-19 21:24:32 +020045
Johannes Bergfffd0932009-07-08 14:22:54 +020046 cfg80211_upload_connect_keys(wdev);
47
Johannes Berg667503dd2009-07-07 03:56:11 +020048 nl80211_send_ibss_bssid(wiphy_to_dev(wdev->wiphy), dev, bssid,
49 GFP_KERNEL);
Johannes Berg3d23e342009-09-29 23:27:28 +020050#ifdef CONFIG_CFG80211_WEXT
Johannes Berg04a773a2009-04-19 21:24:32 +020051 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}
Johannes Berg667503dd2009-07-07 03:56:11 +020056
Antonio Quartullife94f3a2014-01-29 17:53:43 +010057void cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid,
58 struct ieee80211_channel *channel, gfp_t gfp)
Johannes Berg667503dd2009-07-07 03:56:11 +020059{
60 struct wireless_dev *wdev = dev->ieee80211_ptr;
61 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
62 struct cfg80211_event *ev;
63 unsigned long flags;
64
Antonio Quartullife94f3a2014-01-29 17:53:43 +010065 trace_cfg80211_ibss_joined(dev, bssid, channel);
66
67 if (WARN_ON(!channel))
68 return;
Beni Lev4ee3e062012-08-27 12:49:39 +030069
Johannes Berg667503dd2009-07-07 03:56:11 +020070 ev = kzalloc(sizeof(*ev), gfp);
71 if (!ev)
72 return;
73
74 ev->type = EVENT_IBSS_JOINED;
Antonio Quartullife94f3a2014-01-29 17:53:43 +010075 memcpy(ev->ij.bssid, bssid, ETH_ALEN);
76 ev->ij.channel = channel;
Johannes Berg667503dd2009-07-07 03:56:11 +020077
78 spin_lock_irqsave(&wdev->event_lock, flags);
79 list_add_tail(&ev->list, &wdev->event_list);
80 spin_unlock_irqrestore(&wdev->event_lock, flags);
Alban Browaeyse60d7442009-11-25 15:13:00 +010081 queue_work(cfg80211_wq, &rdev->event_work);
Johannes Berg667503dd2009-07-07 03:56:11 +020082}
Johannes Berg04a773a2009-04-19 21:24:32 +020083EXPORT_SYMBOL(cfg80211_ibss_joined);
84
Johannes Berg667503dd2009-07-07 03:56:11 +020085int __cfg80211_join_ibss(struct cfg80211_registered_device *rdev,
86 struct net_device *dev,
Johannes Bergfffd0932009-07-08 14:22:54 +020087 struct cfg80211_ibss_params *params,
88 struct cfg80211_cached_keys *connkeys)
Johannes Berg04a773a2009-04-19 21:24:32 +020089{
90 struct wireless_dev *wdev = dev->ieee80211_ptr;
Simon Wunderlich5336fa82013-10-07 18:41:05 +020091 struct ieee80211_channel *check_chan;
92 u8 radar_detect_width = 0;
Johannes Berg04a773a2009-04-19 21:24:32 +020093 int err;
94
Johannes Berg667503dd2009-07-07 03:56:11 +020095 ASSERT_WDEV_LOCK(wdev);
96
Johannes Berg04a773a2009-04-19 21:24:32 +020097 if (wdev->ssid_len)
98 return -EALREADY;
99
Johannes Berg93b05232010-09-28 12:53:14 +0200100 if (!params->basic_rates) {
101 /*
102 * If no rates were explicitly configured,
103 * use the mandatory rate set for 11b or
104 * 11a for maximum compatibility.
105 */
106 struct ieee80211_supported_band *sband =
Johannes Berg683b6d32012-11-08 21:25:48 +0100107 rdev->wiphy.bands[params->chandef.chan->band];
Johannes Berg93b05232010-09-28 12:53:14 +0200108 int j;
Johannes Berg683b6d32012-11-08 21:25:48 +0100109 u32 flag = params->chandef.chan->band == IEEE80211_BAND_5GHZ ?
Johannes Berg93b05232010-09-28 12:53:14 +0200110 IEEE80211_RATE_MANDATORY_A :
111 IEEE80211_RATE_MANDATORY_B;
112
113 for (j = 0; j < sband->n_bitrates; j++) {
114 if (sband->bitrates[j].flags & flag)
115 params->basic_rates |= BIT(j);
116 }
117 }
118
Johannes Bergfffd0932009-07-08 14:22:54 +0200119 if (WARN_ON(wdev->connect_keys))
120 kfree(wdev->connect_keys);
121 wdev->connect_keys = connkeys;
122
Michal Kaziorc30a3d32012-06-29 12:46:59 +0200123 wdev->ibss_fixed = params->channel_fixed;
Simon Wunderlich5336fa82013-10-07 18:41:05 +0200124 wdev->ibss_dfs_possible = params->userspace_handles_dfs;
Johannes Berg3d23e342009-09-29 23:27:28 +0200125#ifdef CONFIG_CFG80211_WEXT
Johannes Berg683b6d32012-11-08 21:25:48 +0100126 wdev->wext.ibss.chandef = params->chandef;
Johannes Berg04a773a2009-04-19 21:24:32 +0200127#endif
Simon Wunderlich5336fa82013-10-07 18:41:05 +0200128 check_chan = params->chandef.chan;
129 if (params->userspace_handles_dfs) {
130 /* use channel NULL to check for radar even if the current
131 * channel is not a radar channel - it might decide to change
132 * to DFS channel later.
133 */
134 radar_detect_width = BIT(params->chandef.width);
135 check_chan = NULL;
136 }
Michal Kaziore4e32452012-06-29 12:47:08 +0200137
Simon Wunderlich5336fa82013-10-07 18:41:05 +0200138 err = cfg80211_can_use_iftype_chan(rdev, wdev, wdev->iftype,
139 check_chan,
140 (params->channel_fixed &&
141 !radar_detect_width)
142 ? CHAN_MODE_SHARED
143 : CHAN_MODE_EXCLUSIVE,
144 radar_detect_width);
145
Michal Kaziore4e32452012-06-29 12:47:08 +0200146 if (err) {
147 wdev->connect_keys = NULL;
148 return err;
149 }
150
Hila Gonene35e4d22012-06-27 17:19:42 +0300151 err = rdev_join_ibss(rdev, dev, params);
Johannes Bergfffd0932009-07-08 14:22:54 +0200152 if (err) {
153 wdev->connect_keys = NULL;
Johannes Berg04a773a2009-04-19 21:24:32 +0200154 return err;
Johannes Bergfffd0932009-07-08 14:22:54 +0200155 }
Johannes Berg04a773a2009-04-19 21:24:32 +0200156
157 memcpy(wdev->ssid, params->ssid, params->ssid_len);
158 wdev->ssid_len = params->ssid_len;
159
160 return 0;
161}
162
Johannes Berg667503dd2009-07-07 03:56:11 +0200163int cfg80211_join_ibss(struct cfg80211_registered_device *rdev,
164 struct net_device *dev,
Johannes Bergfffd0932009-07-08 14:22:54 +0200165 struct cfg80211_ibss_params *params,
166 struct cfg80211_cached_keys *connkeys)
Johannes Berg04a773a2009-04-19 21:24:32 +0200167{
168 struct wireless_dev *wdev = dev->ieee80211_ptr;
Johannes Berg667503dd2009-07-07 03:56:11 +0200169 int err;
170
Johannes Berg5fe231e2013-05-08 21:45:15 +0200171 ASSERT_RTNL();
172
Johannes Berg667503dd2009-07-07 03:56:11 +0200173 wdev_lock(wdev);
Johannes Bergfffd0932009-07-08 14:22:54 +0200174 err = __cfg80211_join_ibss(rdev, dev, params, connkeys);
Johannes Berg667503dd2009-07-07 03:56:11 +0200175 wdev_unlock(wdev);
176
177 return err;
178}
179
180static void __cfg80211_clear_ibss(struct net_device *dev, bool nowext)
181{
182 struct wireless_dev *wdev = dev->ieee80211_ptr;
Johannes Bergfffd0932009-07-08 14:22:54 +0200183 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
184 int i;
Johannes Berg667503dd2009-07-07 03:56:11 +0200185
186 ASSERT_WDEV_LOCK(wdev);
Johannes Berg04a773a2009-04-19 21:24:32 +0200187
Johannes Bergfffd0932009-07-08 14:22:54 +0200188 kfree(wdev->connect_keys);
189 wdev->connect_keys = NULL;
190
Kyeyoon Parkfa9ffc72013-12-16 23:01:30 -0800191 rdev_set_qos_map(rdev, dev, NULL);
192
Johannes Bergfffd0932009-07-08 14:22:54 +0200193 /*
194 * Delete all the keys ... pairwise keys can't really
195 * exist any more anyway, but default keys might.
196 */
197 if (rdev->ops->del_key)
198 for (i = 0; i < 6; i++)
Hila Gonene35e4d22012-06-27 17:19:42 +0300199 rdev_del_key(rdev, dev, i, false, NULL);
Johannes Bergfffd0932009-07-08 14:22:54 +0200200
Johannes Berg04a773a2009-04-19 21:24:32 +0200201 if (wdev->current_bss) {
202 cfg80211_unhold_bss(wdev->current_bss);
Johannes Berg5b112d32013-02-01 01:49:58 +0100203 cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
Johannes Berg04a773a2009-04-19 21:24:32 +0200204 }
205
206 wdev->current_bss = NULL;
207 wdev->ssid_len = 0;
Johannes Berg3d23e342009-09-29 23:27:28 +0200208#ifdef CONFIG_CFG80211_WEXT
Johannes Berg9d308422009-04-20 18:43:46 +0200209 if (!nowext)
Johannes Bergcbe8fa92009-05-09 20:09:03 +0200210 wdev->wext.ibss.ssid_len = 0;
Johannes Berg9d308422009-04-20 18:43:46 +0200211#endif
Johannes Berg04a773a2009-04-19 21:24:32 +0200212}
213
Johannes Berg667503dd2009-07-07 03:56:11 +0200214void cfg80211_clear_ibss(struct net_device *dev, bool nowext)
215{
216 struct wireless_dev *wdev = dev->ieee80211_ptr;
217
218 wdev_lock(wdev);
219 __cfg80211_clear_ibss(dev, nowext);
220 wdev_unlock(wdev);
221}
222
Johannes Berg98d3a7c2009-11-18 13:03:43 +0100223int __cfg80211_leave_ibss(struct cfg80211_registered_device *rdev,
224 struct net_device *dev, bool nowext)
Johannes Berg04a773a2009-04-19 21:24:32 +0200225{
Johannes Berg78485472009-07-07 03:56:05 +0200226 struct wireless_dev *wdev = dev->ieee80211_ptr;
Johannes Berg04a773a2009-04-19 21:24:32 +0200227 int err;
228
Johannes Berg667503dd2009-07-07 03:56:11 +0200229 ASSERT_WDEV_LOCK(wdev);
230
Johannes Berg78485472009-07-07 03:56:05 +0200231 if (!wdev->ssid_len)
232 return -ENOLINK;
233
Hila Gonene35e4d22012-06-27 17:19:42 +0300234 err = rdev_leave_ibss(rdev, dev);
Johannes Berg04a773a2009-04-19 21:24:32 +0200235
236 if (err)
237 return err;
238
Johannes Berg667503dd2009-07-07 03:56:11 +0200239 __cfg80211_clear_ibss(dev, nowext);
Johannes Berg04a773a2009-04-19 21:24:32 +0200240
241 return 0;
242}
243
Johannes Berg667503dd2009-07-07 03:56:11 +0200244int cfg80211_leave_ibss(struct cfg80211_registered_device *rdev,
245 struct net_device *dev, bool nowext)
246{
247 struct wireless_dev *wdev = dev->ieee80211_ptr;
248 int err;
249
250 wdev_lock(wdev);
251 err = __cfg80211_leave_ibss(rdev, dev, nowext);
252 wdev_unlock(wdev);
253
254 return err;
255}
256
Johannes Berg3d23e342009-09-29 23:27:28 +0200257#ifdef CONFIG_CFG80211_WEXT
Johannes Bergfffd0932009-07-08 14:22:54 +0200258int cfg80211_ibss_wext_join(struct cfg80211_registered_device *rdev,
259 struct wireless_dev *wdev)
Johannes Berg04a773a2009-04-19 21:24:32 +0200260{
Johannes Bergfffd0932009-07-08 14:22:54 +0200261 struct cfg80211_cached_keys *ck = NULL;
Johannes Berg04a773a2009-04-19 21:24:32 +0200262 enum ieee80211_band band;
Johannes Bergfffd0932009-07-08 14:22:54 +0200263 int i, err;
264
265 ASSERT_WDEV_LOCK(wdev);
Johannes Berg04a773a2009-04-19 21:24:32 +0200266
Johannes Bergcbe8fa92009-05-09 20:09:03 +0200267 if (!wdev->wext.ibss.beacon_interval)
268 wdev->wext.ibss.beacon_interval = 100;
Johannes Berg8e30bc52009-04-22 17:45:38 +0200269
Johannes Berg04a773a2009-04-19 21:24:32 +0200270 /* try to find an IBSS channel if none requested ... */
Johannes Berg683b6d32012-11-08 21:25:48 +0100271 if (!wdev->wext.ibss.chandef.chan) {
Simon Wunderlich1fe45172013-10-30 16:09:33 +0100272 struct ieee80211_channel *new_chan = NULL;
Johannes Berg683b6d32012-11-08 21:25:48 +0100273
Johannes Berg04a773a2009-04-19 21:24:32 +0200274 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
275 struct ieee80211_supported_band *sband;
276 struct ieee80211_channel *chan;
277
278 sband = rdev->wiphy.bands[band];
279 if (!sband)
280 continue;
281
282 for (i = 0; i < sband->n_channels; i++) {
283 chan = &sband->channels[i];
Luis R. Rodriguez8fe02e12013-10-21 19:22:25 +0200284 if (chan->flags & IEEE80211_CHAN_NO_IR)
Johannes Berg04a773a2009-04-19 21:24:32 +0200285 continue;
286 if (chan->flags & IEEE80211_CHAN_DISABLED)
287 continue;
Simon Wunderlich1fe45172013-10-30 16:09:33 +0100288 new_chan = chan;
Johannes Berg04a773a2009-04-19 21:24:32 +0200289 break;
290 }
291
Simon Wunderlich1fe45172013-10-30 16:09:33 +0100292 if (new_chan)
Johannes Berg04a773a2009-04-19 21:24:32 +0200293 break;
294 }
295
Simon Wunderlich1fe45172013-10-30 16:09:33 +0100296 if (!new_chan)
Johannes Berg04a773a2009-04-19 21:24:32 +0200297 return -EINVAL;
Simon Wunderlich1fe45172013-10-30 16:09:33 +0100298
299 cfg80211_chandef_create(&wdev->wext.ibss.chandef, new_chan,
300 NL80211_CHAN_NO_HT);
Johannes Berg04a773a2009-04-19 21:24:32 +0200301 }
302
303 /* don't join -- SSID is not there */
Johannes Bergcbe8fa92009-05-09 20:09:03 +0200304 if (!wdev->wext.ibss.ssid_len)
Johannes Berg04a773a2009-04-19 21:24:32 +0200305 return 0;
306
307 if (!netif_running(wdev->netdev))
308 return 0;
309
Johannes Berg3be61a32010-07-22 13:59:15 +0200310 if (wdev->wext.keys) {
Johannes Bergfffd0932009-07-08 14:22:54 +0200311 wdev->wext.keys->def = wdev->wext.default_key;
Johannes Berg3be61a32010-07-22 13:59:15 +0200312 wdev->wext.keys->defmgmt = wdev->wext.default_mgmt_key;
313 }
Johannes Bergfffd0932009-07-08 14:22:54 +0200314
315 wdev->wext.ibss.privacy = wdev->wext.default_key != -1;
316
317 if (wdev->wext.keys) {
318 ck = kmemdup(wdev->wext.keys, sizeof(*ck), GFP_KERNEL);
319 if (!ck)
320 return -ENOMEM;
321 for (i = 0; i < 6; i++)
322 ck->params[i].key = ck->data[i];
323 }
324 err = __cfg80211_join_ibss(rdev, wdev->netdev,
325 &wdev->wext.ibss, ck);
326 if (err)
327 kfree(ck);
328
329 return err;
Johannes Berg04a773a2009-04-19 21:24:32 +0200330}
331
332int cfg80211_ibss_wext_siwfreq(struct net_device *dev,
333 struct iw_request_info *info,
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200334 struct iw_freq *wextfreq, char *extra)
Johannes Berg04a773a2009-04-19 21:24:32 +0200335{
336 struct wireless_dev *wdev = dev->ieee80211_ptr;
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200337 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
338 struct ieee80211_channel *chan = NULL;
339 int err, freq;
Johannes Berg04a773a2009-04-19 21:24:32 +0200340
341 /* call only for ibss! */
342 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
343 return -EINVAL;
344
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200345 if (!rdev->ops->join_ibss)
Johannes Berg04a773a2009-04-19 21:24:32 +0200346 return -EOPNOTSUPP;
347
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200348 freq = cfg80211_wext_freq(wdev->wiphy, wextfreq);
349 if (freq < 0)
350 return freq;
Johannes Berg04a773a2009-04-19 21:24:32 +0200351
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200352 if (freq) {
353 chan = ieee80211_get_channel(wdev->wiphy, freq);
354 if (!chan)
355 return -EINVAL;
Luis R. Rodriguez8fe02e12013-10-21 19:22:25 +0200356 if (chan->flags & IEEE80211_CHAN_NO_IR ||
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200357 chan->flags & IEEE80211_CHAN_DISABLED)
358 return -EINVAL;
359 }
Johannes Berg04a773a2009-04-19 21:24:32 +0200360
Johannes Berg683b6d32012-11-08 21:25:48 +0100361 if (wdev->wext.ibss.chandef.chan == chan)
Johannes Berg04a773a2009-04-19 21:24:32 +0200362 return 0;
363
Johannes Berg667503dd2009-07-07 03:56:11 +0200364 wdev_lock(wdev);
365 err = 0;
366 if (wdev->ssid_len)
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200367 err = __cfg80211_leave_ibss(rdev, dev, true);
Johannes Berg667503dd2009-07-07 03:56:11 +0200368 wdev_unlock(wdev);
369
370 if (err)
371 return err;
Johannes Berg04a773a2009-04-19 21:24:32 +0200372
373 if (chan) {
Simon Wunderlich1fe45172013-10-30 16:09:33 +0100374 cfg80211_chandef_create(&wdev->wext.ibss.chandef, chan,
375 NL80211_CHAN_NO_HT);
Johannes Bergcbe8fa92009-05-09 20:09:03 +0200376 wdev->wext.ibss.channel_fixed = true;
Johannes Berg04a773a2009-04-19 21:24:32 +0200377 } else {
378 /* cfg80211_ibss_wext_join will pick one if needed */
Johannes Bergcbe8fa92009-05-09 20:09:03 +0200379 wdev->wext.ibss.channel_fixed = false;
Johannes Berg04a773a2009-04-19 21:24:32 +0200380 }
381
Johannes Bergfffd0932009-07-08 14:22:54 +0200382 wdev_lock(wdev);
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200383 err = cfg80211_ibss_wext_join(rdev, wdev);
Johannes Bergfffd0932009-07-08 14:22:54 +0200384 wdev_unlock(wdev);
385
386 return err;
Johannes Berg04a773a2009-04-19 21:24:32 +0200387}
Johannes Berg04a773a2009-04-19 21:24:32 +0200388
389int cfg80211_ibss_wext_giwfreq(struct net_device *dev,
390 struct iw_request_info *info,
391 struct iw_freq *freq, char *extra)
392{
393 struct wireless_dev *wdev = dev->ieee80211_ptr;
394 struct ieee80211_channel *chan = NULL;
395
396 /* call only for ibss! */
397 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
398 return -EINVAL;
399
Johannes Berg667503dd2009-07-07 03:56:11 +0200400 wdev_lock(wdev);
Johannes Berg04a773a2009-04-19 21:24:32 +0200401 if (wdev->current_bss)
Johannes Berg19957bb2009-07-02 17:20:43 +0200402 chan = wdev->current_bss->pub.channel;
Johannes Berg683b6d32012-11-08 21:25:48 +0100403 else if (wdev->wext.ibss.chandef.chan)
404 chan = wdev->wext.ibss.chandef.chan;
Johannes Berg667503dd2009-07-07 03:56:11 +0200405 wdev_unlock(wdev);
Johannes Berg04a773a2009-04-19 21:24:32 +0200406
407 if (chan) {
408 freq->m = chan->center_freq;
409 freq->e = 6;
410 return 0;
411 }
412
413 /* no channel if not joining */
414 return -EINVAL;
415}
Johannes Berg04a773a2009-04-19 21:24:32 +0200416
417int cfg80211_ibss_wext_siwessid(struct net_device *dev,
418 struct iw_request_info *info,
419 struct iw_point *data, char *ssid)
420{
421 struct wireless_dev *wdev = dev->ieee80211_ptr;
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200422 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
Johannes Berg04a773a2009-04-19 21:24:32 +0200423 size_t len = data->length;
424 int err;
425
426 /* call only for ibss! */
427 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
428 return -EINVAL;
429
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200430 if (!rdev->ops->join_ibss)
Johannes Berg04a773a2009-04-19 21:24:32 +0200431 return -EOPNOTSUPP;
432
Johannes Berg667503dd2009-07-07 03:56:11 +0200433 wdev_lock(wdev);
434 err = 0;
435 if (wdev->ssid_len)
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200436 err = __cfg80211_leave_ibss(rdev, dev, true);
Johannes Berg667503dd2009-07-07 03:56:11 +0200437 wdev_unlock(wdev);
438
439 if (err)
440 return err;
Johannes Berg04a773a2009-04-19 21:24:32 +0200441
442 /* iwconfig uses nul termination in SSID.. */
443 if (len > 0 && ssid[len - 1] == '\0')
444 len--;
445
Johannes Bergcbe8fa92009-05-09 20:09:03 +0200446 wdev->wext.ibss.ssid = wdev->ssid;
447 memcpy(wdev->wext.ibss.ssid, ssid, len);
448 wdev->wext.ibss.ssid_len = len;
Johannes Berg04a773a2009-04-19 21:24:32 +0200449
Johannes Bergfffd0932009-07-08 14:22:54 +0200450 wdev_lock(wdev);
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200451 err = cfg80211_ibss_wext_join(rdev, wdev);
Johannes Bergfffd0932009-07-08 14:22:54 +0200452 wdev_unlock(wdev);
453
454 return err;
Johannes Berg04a773a2009-04-19 21:24:32 +0200455}
Johannes Berg04a773a2009-04-19 21:24:32 +0200456
457int cfg80211_ibss_wext_giwessid(struct net_device *dev,
458 struct iw_request_info *info,
459 struct iw_point *data, char *ssid)
460{
461 struct wireless_dev *wdev = dev->ieee80211_ptr;
462
463 /* call only for ibss! */
464 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
465 return -EINVAL;
466
467 data->flags = 0;
468
Johannes Berg667503dd2009-07-07 03:56:11 +0200469 wdev_lock(wdev);
Johannes Berg04a773a2009-04-19 21:24:32 +0200470 if (wdev->ssid_len) {
471 data->flags = 1;
472 data->length = wdev->ssid_len;
473 memcpy(ssid, wdev->ssid, data->length);
Johannes Bergcbe8fa92009-05-09 20:09:03 +0200474 } else if (wdev->wext.ibss.ssid && wdev->wext.ibss.ssid_len) {
Johannes Berg04a773a2009-04-19 21:24:32 +0200475 data->flags = 1;
Johannes Bergcbe8fa92009-05-09 20:09:03 +0200476 data->length = wdev->wext.ibss.ssid_len;
477 memcpy(ssid, wdev->wext.ibss.ssid, data->length);
Johannes Berg04a773a2009-04-19 21:24:32 +0200478 }
Johannes Berg667503dd2009-07-07 03:56:11 +0200479 wdev_unlock(wdev);
Johannes Berg04a773a2009-04-19 21:24:32 +0200480
481 return 0;
482}
Johannes Berg04a773a2009-04-19 21:24:32 +0200483
484int cfg80211_ibss_wext_siwap(struct net_device *dev,
485 struct iw_request_info *info,
486 struct sockaddr *ap_addr, char *extra)
487{
488 struct wireless_dev *wdev = dev->ieee80211_ptr;
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200489 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
Johannes Berg04a773a2009-04-19 21:24:32 +0200490 u8 *bssid = ap_addr->sa_data;
491 int err;
492
493 /* call only for ibss! */
494 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
495 return -EINVAL;
496
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200497 if (!rdev->ops->join_ibss)
Johannes Berg04a773a2009-04-19 21:24:32 +0200498 return -EOPNOTSUPP;
499
500 if (ap_addr->sa_family != ARPHRD_ETHER)
501 return -EINVAL;
502
503 /* automatic mode */
504 if (is_zero_ether_addr(bssid) || is_broadcast_ether_addr(bssid))
505 bssid = NULL;
506
507 /* both automatic */
Johannes Bergcbe8fa92009-05-09 20:09:03 +0200508 if (!bssid && !wdev->wext.ibss.bssid)
Johannes Berg04a773a2009-04-19 21:24:32 +0200509 return 0;
510
511 /* fixed already - and no change */
Johannes Bergcbe8fa92009-05-09 20:09:03 +0200512 if (wdev->wext.ibss.bssid && bssid &&
Joe Perchesac422d32012-05-08 18:56:55 +0000513 ether_addr_equal(bssid, wdev->wext.ibss.bssid))
Johannes Berg04a773a2009-04-19 21:24:32 +0200514 return 0;
515
Johannes Berg667503dd2009-07-07 03:56:11 +0200516 wdev_lock(wdev);
517 err = 0;
518 if (wdev->ssid_len)
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200519 err = __cfg80211_leave_ibss(rdev, dev, true);
Johannes Berg667503dd2009-07-07 03:56:11 +0200520 wdev_unlock(wdev);
521
522 if (err)
523 return err;
Johannes Berg04a773a2009-04-19 21:24:32 +0200524
525 if (bssid) {
Johannes Bergcbe8fa92009-05-09 20:09:03 +0200526 memcpy(wdev->wext.bssid, bssid, ETH_ALEN);
527 wdev->wext.ibss.bssid = wdev->wext.bssid;
Johannes Berg04a773a2009-04-19 21:24:32 +0200528 } else
Johannes Bergcbe8fa92009-05-09 20:09:03 +0200529 wdev->wext.ibss.bssid = NULL;
Johannes Berg04a773a2009-04-19 21:24:32 +0200530
Johannes Bergfffd0932009-07-08 14:22:54 +0200531 wdev_lock(wdev);
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200532 err = cfg80211_ibss_wext_join(rdev, wdev);
Johannes Bergfffd0932009-07-08 14:22:54 +0200533 wdev_unlock(wdev);
534
535 return err;
Johannes Berg04a773a2009-04-19 21:24:32 +0200536}
Johannes Berg04a773a2009-04-19 21:24:32 +0200537
538int cfg80211_ibss_wext_giwap(struct net_device *dev,
539 struct iw_request_info *info,
540 struct sockaddr *ap_addr, char *extra)
541{
542 struct wireless_dev *wdev = dev->ieee80211_ptr;
543
544 /* call only for ibss! */
545 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
546 return -EINVAL;
547
548 ap_addr->sa_family = ARPHRD_ETHER;
549
Johannes Berg667503dd2009-07-07 03:56:11 +0200550 wdev_lock(wdev);
Johannes Berg7ebbe6b2009-07-01 21:26:48 +0200551 if (wdev->current_bss)
Johannes Berg19957bb2009-07-02 17:20:43 +0200552 memcpy(ap_addr->sa_data, wdev->current_bss->pub.bssid, ETH_ALEN);
Zhu Yi80e5b062009-07-09 16:59:49 +0800553 else if (wdev->wext.ibss.bssid)
Johannes Bergcbe8fa92009-05-09 20:09:03 +0200554 memcpy(ap_addr->sa_data, wdev->wext.ibss.bssid, ETH_ALEN);
Zhu Yi80e5b062009-07-09 16:59:49 +0800555 else
556 memset(ap_addr->sa_data, 0, ETH_ALEN);
557
Johannes Berg667503dd2009-07-07 03:56:11 +0200558 wdev_unlock(wdev);
559
Johannes Berg04a773a2009-04-19 21:24:32 +0200560 return 0;
561}
Johannes Berg04a773a2009-04-19 21:24:32 +0200562#endif