media: video: tegra: Focuser range tuning support
[linux-2.6.git] / net / wireless / wext-sme.c
1 /*
2  * cfg80211 wext compat for managed mode.
3  *
4  * Copyright 2009       Johannes Berg <johannes@sipsolutions.net>
5  * Copyright (C) 2009   Intel Corporation. All rights reserved.
6  */
7
8 #include <linux/etherdevice.h>
9 #include <linux/if_arp.h>
10 #include <linux/slab.h>
11 #include <net/cfg80211.h>
12 #include "wext-compat.h"
13 #include "nl80211.h"
14
15 int cfg80211_mgd_wext_connect(struct cfg80211_registered_device *rdev,
16                               struct wireless_dev *wdev)
17 {
18         struct cfg80211_cached_keys *ck = NULL;
19         const u8 *prev_bssid = NULL;
20         int err, i;
21
22         ASSERT_RDEV_LOCK(rdev);
23         ASSERT_WDEV_LOCK(wdev);
24
25         if (!netif_running(wdev->netdev))
26                 return 0;
27
28         wdev->wext.connect.ie = wdev->wext.ie;
29         wdev->wext.connect.ie_len = wdev->wext.ie_len;
30
31         if (wdev->wext.keys) {
32                 wdev->wext.keys->def = wdev->wext.default_key;
33                 wdev->wext.keys->defmgmt = wdev->wext.default_mgmt_key;
34                 if (wdev->wext.default_key != -1)
35                         wdev->wext.connect.privacy = true;
36         }
37
38         if (!wdev->wext.connect.ssid_len)
39                 return 0;
40
41         if (wdev->wext.keys) {
42                 ck = kmemdup(wdev->wext.keys, sizeof(*ck), GFP_KERNEL);
43                 if (!ck)
44                         return -ENOMEM;
45                 for (i = 0; i < 6; i++)
46                         ck->params[i].key = ck->data[i];
47         }
48
49         if (wdev->wext.prev_bssid_valid)
50                 prev_bssid = wdev->wext.prev_bssid;
51
52         err = __cfg80211_connect(rdev, wdev->netdev,
53                                  &wdev->wext.connect, ck, prev_bssid);
54         if (err)
55                 kfree(ck);
56
57         return err;
58 }
59
60 int cfg80211_mgd_wext_siwfreq(struct net_device *dev,
61                               struct iw_request_info *info,
62                               struct iw_freq *wextfreq, char *extra)
63 {
64         struct wireless_dev *wdev = dev->ieee80211_ptr;
65         struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
66         struct ieee80211_channel *chan = NULL;
67         int err, freq;
68
69         /* call only for station! */
70         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
71                 return -EINVAL;
72
73         freq = cfg80211_wext_freq(wdev->wiphy, wextfreq);
74         if (freq < 0)
75                 return freq;
76
77         if (freq) {
78                 chan = ieee80211_get_channel(wdev->wiphy, freq);
79                 if (!chan)
80                         return -EINVAL;
81                 if (chan->flags & IEEE80211_CHAN_DISABLED)
82                         return -EINVAL;
83         }
84
85         cfg80211_lock_rdev(rdev);
86         mutex_lock(&rdev->devlist_mtx);
87         wdev_lock(wdev);
88
89         if (wdev->sme_state != CFG80211_SME_IDLE) {
90                 bool event = true;
91
92                 if (wdev->wext.connect.channel == chan) {
93                         err = 0;
94                         goto out;
95                 }
96
97                 /* if SSID set, we'll try right again, avoid event */
98                 if (wdev->wext.connect.ssid_len)
99                         event = false;
100                 err = __cfg80211_disconnect(rdev, dev,
101                                             WLAN_REASON_DEAUTH_LEAVING, event);
102                 if (err)
103                         goto out;
104         }
105
106
107         wdev->wext.connect.channel = chan;
108
109         /* SSID is not set, we just want to switch channel */
110         if (chan && !wdev->wext.connect.ssid_len) {
111                 err = cfg80211_set_freq(rdev, wdev, freq, NL80211_CHAN_NO_HT);
112                 goto out;
113         }
114
115         err = cfg80211_mgd_wext_connect(rdev, wdev);
116  out:
117         wdev_unlock(wdev);
118         mutex_unlock(&rdev->devlist_mtx);
119         cfg80211_unlock_rdev(rdev);
120         return err;
121 }
122
123 int cfg80211_mgd_wext_giwfreq(struct net_device *dev,
124                               struct iw_request_info *info,
125                               struct iw_freq *freq, char *extra)
126 {
127         struct wireless_dev *wdev = dev->ieee80211_ptr;
128         struct ieee80211_channel *chan = NULL;
129
130         /* call only for station! */
131         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
132                 return -EINVAL;
133
134         wdev_lock(wdev);
135         if (wdev->current_bss)
136                 chan = wdev->current_bss->pub.channel;
137         else if (wdev->wext.connect.channel)
138                 chan = wdev->wext.connect.channel;
139         wdev_unlock(wdev);
140
141         if (chan) {
142                 freq->m = chan->center_freq;
143                 freq->e = 6;
144                 return 0;
145         }
146
147         /* no channel if not joining */
148         return -EINVAL;
149 }
150
151 int cfg80211_mgd_wext_siwessid(struct net_device *dev,
152                                struct iw_request_info *info,
153                                struct iw_point *data, char *ssid)
154 {
155         struct wireless_dev *wdev = dev->ieee80211_ptr;
156         struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
157         size_t len = data->length;
158         int err;
159
160         /* call only for station! */
161         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
162                 return -EINVAL;
163
164         if (!data->flags)
165                 len = 0;
166
167         /* iwconfig uses nul termination in SSID.. */
168         if (len > 0 && ssid[len - 1] == '\0')
169                 len--;
170
171         cfg80211_lock_rdev(rdev);
172         mutex_lock(&rdev->devlist_mtx);
173         wdev_lock(wdev);
174
175         err = 0;
176
177         if (wdev->sme_state != CFG80211_SME_IDLE) {
178                 bool event = true;
179
180                 if (wdev->wext.connect.ssid && len &&
181                     len == wdev->wext.connect.ssid_len &&
182                     memcmp(wdev->wext.connect.ssid, ssid, len) == 0)
183                         goto out;
184
185                 /* if SSID set now, we'll try to connect, avoid event */
186                 if (len)
187                         event = false;
188                 err = __cfg80211_disconnect(rdev, dev,
189                                             WLAN_REASON_DEAUTH_LEAVING, event);
190                 if (err)
191                         goto out;
192         }
193
194         wdev->wext.prev_bssid_valid = false;
195         wdev->wext.connect.ssid = wdev->wext.ssid;
196         memcpy(wdev->wext.ssid, ssid, len);
197         wdev->wext.connect.ssid_len = len;
198
199         wdev->wext.connect.crypto.control_port = false;
200         wdev->wext.connect.crypto.control_port_ethertype =
201                                         cpu_to_be16(ETH_P_PAE);
202
203         err = cfg80211_mgd_wext_connect(rdev, wdev);
204  out:
205         wdev_unlock(wdev);
206         mutex_unlock(&rdev->devlist_mtx);
207         cfg80211_unlock_rdev(rdev);
208         return err;
209 }
210
211 int cfg80211_mgd_wext_giwessid(struct net_device *dev,
212                                struct iw_request_info *info,
213                                struct iw_point *data, char *ssid)
214 {
215         struct wireless_dev *wdev = dev->ieee80211_ptr;
216
217         /* call only for station! */
218         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
219                 return -EINVAL;
220
221         data->flags = 0;
222
223         wdev_lock(wdev);
224         if (wdev->current_bss) {
225                 const u8 *ie = ieee80211_bss_get_ie(&wdev->current_bss->pub,
226                                                     WLAN_EID_SSID);
227                 if (ie) {
228                         data->flags = 1;
229                         data->length = ie[1];
230                         memcpy(ssid, ie + 2, data->length);
231                 }
232         } else if (wdev->wext.connect.ssid && wdev->wext.connect.ssid_len) {
233                 data->flags = 1;
234                 data->length = wdev->wext.connect.ssid_len;
235                 memcpy(ssid, wdev->wext.connect.ssid, data->length);
236         }
237         wdev_unlock(wdev);
238
239         return 0;
240 }
241
242 int cfg80211_mgd_wext_siwap(struct net_device *dev,
243                             struct iw_request_info *info,
244                             struct sockaddr *ap_addr, char *extra)
245 {
246         struct wireless_dev *wdev = dev->ieee80211_ptr;
247         struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
248         u8 *bssid = ap_addr->sa_data;
249         int err;
250
251         /* call only for station! */
252         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
253                 return -EINVAL;
254
255         if (ap_addr->sa_family != ARPHRD_ETHER)
256                 return -EINVAL;
257
258         /* automatic mode */
259         if (is_zero_ether_addr(bssid) || is_broadcast_ether_addr(bssid))
260                 bssid = NULL;
261
262         cfg80211_lock_rdev(rdev);
263         mutex_lock(&rdev->devlist_mtx);
264         wdev_lock(wdev);
265
266         if (wdev->sme_state != CFG80211_SME_IDLE) {
267                 err = 0;
268                 /* both automatic */
269                 if (!bssid && !wdev->wext.connect.bssid)
270                         goto out;
271
272                 /* fixed already - and no change */
273                 if (wdev->wext.connect.bssid && bssid &&
274                     compare_ether_addr(bssid, wdev->wext.connect.bssid) == 0)
275                         goto out;
276
277                 err = __cfg80211_disconnect(rdev, dev,
278                                             WLAN_REASON_DEAUTH_LEAVING, false);
279                 if (err)
280                         goto out;
281         }
282
283         if (bssid) {
284                 memcpy(wdev->wext.bssid, bssid, ETH_ALEN);
285                 wdev->wext.connect.bssid = wdev->wext.bssid;
286         } else
287                 wdev->wext.connect.bssid = NULL;
288
289         err = cfg80211_mgd_wext_connect(rdev, wdev);
290  out:
291         wdev_unlock(wdev);
292         mutex_unlock(&rdev->devlist_mtx);
293         cfg80211_unlock_rdev(rdev);
294         return err;
295 }
296
297 int cfg80211_mgd_wext_giwap(struct net_device *dev,
298                             struct iw_request_info *info,
299                             struct sockaddr *ap_addr, char *extra)
300 {
301         struct wireless_dev *wdev = dev->ieee80211_ptr;
302
303         /* call only for station! */
304         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
305                 return -EINVAL;
306
307         ap_addr->sa_family = ARPHRD_ETHER;
308
309         wdev_lock(wdev);
310         if (wdev->current_bss)
311                 memcpy(ap_addr->sa_data, wdev->current_bss->pub.bssid, ETH_ALEN);
312         else
313                 memset(ap_addr->sa_data, 0, ETH_ALEN);
314         wdev_unlock(wdev);
315
316         return 0;
317 }
318
319 int cfg80211_wext_siwgenie(struct net_device *dev,
320                            struct iw_request_info *info,
321                            struct iw_point *data, char *extra)
322 {
323         struct wireless_dev *wdev = dev->ieee80211_ptr;
324         struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
325         u8 *ie = extra;
326         int ie_len = data->length, err;
327
328         if (wdev->iftype != NL80211_IFTYPE_STATION)
329                 return -EOPNOTSUPP;
330
331         if (!ie_len)
332                 ie = NULL;
333
334         wdev_lock(wdev);
335
336         /* no change */
337         err = 0;
338         if (wdev->wext.ie_len == ie_len &&
339             memcmp(wdev->wext.ie, ie, ie_len) == 0)
340                 goto out;
341
342         if (ie_len) {
343                 ie = kmemdup(extra, ie_len, GFP_KERNEL);
344                 if (!ie) {
345                         err = -ENOMEM;
346                         goto out;
347                 }
348         } else
349                 ie = NULL;
350
351         kfree(wdev->wext.ie);
352         wdev->wext.ie = ie;
353         wdev->wext.ie_len = ie_len;
354
355         if (wdev->sme_state != CFG80211_SME_IDLE) {
356                 err = __cfg80211_disconnect(rdev, dev,
357                                             WLAN_REASON_DEAUTH_LEAVING, false);
358                 if (err)
359                         goto out;
360         }
361
362         /* userspace better not think we'll reconnect */
363         err = 0;
364  out:
365         wdev_unlock(wdev);
366         return err;
367 }
368 EXPORT_SYMBOL_GPL(cfg80211_wext_siwgenie);
369
370 int cfg80211_wext_siwmlme(struct net_device *dev,
371                           struct iw_request_info *info,
372                           struct iw_point *data, char *extra)
373 {
374         struct wireless_dev *wdev = dev->ieee80211_ptr;
375         struct iw_mlme *mlme = (struct iw_mlme *)extra;
376         struct cfg80211_registered_device *rdev;
377         int err;
378
379         if (!wdev)
380                 return -EOPNOTSUPP;
381
382         rdev = wiphy_to_dev(wdev->wiphy);
383
384         if (wdev->iftype != NL80211_IFTYPE_STATION)
385                 return -EINVAL;
386
387         if (mlme->addr.sa_family != ARPHRD_ETHER)
388                 return -EINVAL;
389
390         wdev_lock(wdev);
391         switch (mlme->cmd) {
392         case IW_MLME_DEAUTH:
393         case IW_MLME_DISASSOC:
394                 err = __cfg80211_disconnect(rdev, dev, mlme->reason_code,
395                                             true);
396                 break;
397         default:
398                 err = -EOPNOTSUPP;
399                 break;
400         }
401         wdev_unlock(wdev);
402
403         return err;
404 }
405 EXPORT_SYMBOL_GPL(cfg80211_wext_siwmlme);