include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[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 = rdev_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
201         err = cfg80211_mgd_wext_connect(rdev, wdev);
202  out:
203         wdev_unlock(wdev);
204         mutex_unlock(&rdev->devlist_mtx);
205         cfg80211_unlock_rdev(rdev);
206         return err;
207 }
208
209 int cfg80211_mgd_wext_giwessid(struct net_device *dev,
210                                struct iw_request_info *info,
211                                struct iw_point *data, char *ssid)
212 {
213         struct wireless_dev *wdev = dev->ieee80211_ptr;
214
215         /* call only for station! */
216         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
217                 return -EINVAL;
218
219         data->flags = 0;
220
221         wdev_lock(wdev);
222         if (wdev->current_bss) {
223                 const u8 *ie = ieee80211_bss_get_ie(&wdev->current_bss->pub,
224                                                     WLAN_EID_SSID);
225                 if (ie) {
226                         data->flags = 1;
227                         data->length = ie[1];
228                         memcpy(ssid, ie + 2, data->length);
229                 }
230         } else if (wdev->wext.connect.ssid && wdev->wext.connect.ssid_len) {
231                 data->flags = 1;
232                 data->length = wdev->wext.connect.ssid_len;
233                 memcpy(ssid, wdev->wext.connect.ssid, data->length);
234         }
235         wdev_unlock(wdev);
236
237         return 0;
238 }
239
240 int cfg80211_mgd_wext_siwap(struct net_device *dev,
241                             struct iw_request_info *info,
242                             struct sockaddr *ap_addr, char *extra)
243 {
244         struct wireless_dev *wdev = dev->ieee80211_ptr;
245         struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
246         u8 *bssid = ap_addr->sa_data;
247         int err;
248
249         /* call only for station! */
250         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
251                 return -EINVAL;
252
253         if (ap_addr->sa_family != ARPHRD_ETHER)
254                 return -EINVAL;
255
256         /* automatic mode */
257         if (is_zero_ether_addr(bssid) || is_broadcast_ether_addr(bssid))
258                 bssid = NULL;
259
260         cfg80211_lock_rdev(rdev);
261         mutex_lock(&rdev->devlist_mtx);
262         wdev_lock(wdev);
263
264         if (wdev->sme_state != CFG80211_SME_IDLE) {
265                 err = 0;
266                 /* both automatic */
267                 if (!bssid && !wdev->wext.connect.bssid)
268                         goto out;
269
270                 /* fixed already - and no change */
271                 if (wdev->wext.connect.bssid && bssid &&
272                     compare_ether_addr(bssid, wdev->wext.connect.bssid) == 0)
273                         goto out;
274
275                 err = __cfg80211_disconnect(rdev, dev,
276                                             WLAN_REASON_DEAUTH_LEAVING, false);
277                 if (err)
278                         goto out;
279         }
280
281         if (bssid) {
282                 memcpy(wdev->wext.bssid, bssid, ETH_ALEN);
283                 wdev->wext.connect.bssid = wdev->wext.bssid;
284         } else
285                 wdev->wext.connect.bssid = NULL;
286
287         err = cfg80211_mgd_wext_connect(rdev, wdev);
288  out:
289         wdev_unlock(wdev);
290         mutex_unlock(&rdev->devlist_mtx);
291         cfg80211_unlock_rdev(rdev);
292         return err;
293 }
294
295 int cfg80211_mgd_wext_giwap(struct net_device *dev,
296                             struct iw_request_info *info,
297                             struct sockaddr *ap_addr, char *extra)
298 {
299         struct wireless_dev *wdev = dev->ieee80211_ptr;
300
301         /* call only for station! */
302         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
303                 return -EINVAL;
304
305         ap_addr->sa_family = ARPHRD_ETHER;
306
307         wdev_lock(wdev);
308         if (wdev->current_bss)
309                 memcpy(ap_addr->sa_data, wdev->current_bss->pub.bssid, ETH_ALEN);
310         else
311                 memset(ap_addr->sa_data, 0, ETH_ALEN);
312         wdev_unlock(wdev);
313
314         return 0;
315 }
316
317 int cfg80211_wext_siwgenie(struct net_device *dev,
318                            struct iw_request_info *info,
319                            struct iw_point *data, char *extra)
320 {
321         struct wireless_dev *wdev = dev->ieee80211_ptr;
322         struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
323         u8 *ie = extra;
324         int ie_len = data->length, err;
325
326         if (wdev->iftype != NL80211_IFTYPE_STATION)
327                 return -EOPNOTSUPP;
328
329         if (!ie_len)
330                 ie = NULL;
331
332         wdev_lock(wdev);
333
334         /* no change */
335         err = 0;
336         if (wdev->wext.ie_len == ie_len &&
337             memcmp(wdev->wext.ie, ie, ie_len) == 0)
338                 goto out;
339
340         if (ie_len) {
341                 ie = kmemdup(extra, ie_len, GFP_KERNEL);
342                 if (!ie) {
343                         err = -ENOMEM;
344                         goto out;
345                 }
346         } else
347                 ie = NULL;
348
349         kfree(wdev->wext.ie);
350         wdev->wext.ie = ie;
351         wdev->wext.ie_len = ie_len;
352
353         if (wdev->sme_state != CFG80211_SME_IDLE) {
354                 err = __cfg80211_disconnect(rdev, dev,
355                                             WLAN_REASON_DEAUTH_LEAVING, false);
356                 if (err)
357                         goto out;
358         }
359
360         /* userspace better not think we'll reconnect */
361         err = 0;
362  out:
363         wdev_unlock(wdev);
364         return err;
365 }
366 EXPORT_SYMBOL_GPL(cfg80211_wext_siwgenie);
367
368 int cfg80211_wext_siwmlme(struct net_device *dev,
369                           struct iw_request_info *info,
370                           struct iw_point *data, char *extra)
371 {
372         struct wireless_dev *wdev = dev->ieee80211_ptr;
373         struct iw_mlme *mlme = (struct iw_mlme *)extra;
374         struct cfg80211_registered_device *rdev;
375         int err;
376
377         if (!wdev)
378                 return -EOPNOTSUPP;
379
380         rdev = wiphy_to_dev(wdev->wiphy);
381
382         if (wdev->iftype != NL80211_IFTYPE_STATION)
383                 return -EINVAL;
384
385         if (mlme->addr.sa_family != ARPHRD_ETHER)
386                 return -EINVAL;
387
388         wdev_lock(wdev);
389         switch (mlme->cmd) {
390         case IW_MLME_DEAUTH:
391         case IW_MLME_DISASSOC:
392                 err = __cfg80211_disconnect(rdev, dev, mlme->reason_code,
393                                             true);
394                 break;
395         default:
396                 err = -EOPNOTSUPP;
397                 break;
398         }
399         wdev_unlock(wdev);
400
401         return err;
402 }
403 EXPORT_SYMBOL_GPL(cfg80211_wext_siwmlme);