]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/net/wireless/hostap/hostap_ap.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'timers-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[mirror_ubuntu-bionic-kernel.git] / drivers / net / wireless / hostap / hostap_ap.c
1 /*
2 * Intersil Prism2 driver with Host AP (software access point) support
3 * Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen
4 * <j@w1.fi>
5 * Copyright (c) 2002-2005, Jouni Malinen <j@w1.fi>
6 *
7 * This file is to be included into hostap.c when S/W AP functionality is
8 * compiled.
9 *
10 * AP: FIX:
11 * - if unicast Class 2 (assoc,reassoc,disassoc) frame received from
12 * unauthenticated STA, send deauth. frame (8802.11: 5.5)
13 * - if unicast Class 3 (data with to/from DS,deauth,pspoll) frame received
14 * from authenticated, but unassoc STA, send disassoc frame (8802.11: 5.5)
15 * - if unicast Class 3 received from unauthenticated STA, send deauth. frame
16 * (8802.11: 5.5)
17 */
18
19 #include <linux/proc_fs.h>
20 #include <linux/delay.h>
21 #include <linux/random.h>
22
23 #include "hostap_wlan.h"
24 #include "hostap.h"
25 #include "hostap_ap.h"
26
27 static int other_ap_policy[MAX_PARM_DEVICES] = { AP_OTHER_AP_SKIP_ALL,
28 DEF_INTS };
29 module_param_array(other_ap_policy, int, NULL, 0444);
30 MODULE_PARM_DESC(other_ap_policy, "Other AP beacon monitoring policy (0-3)");
31
32 static int ap_max_inactivity[MAX_PARM_DEVICES] = { AP_MAX_INACTIVITY_SEC,
33 DEF_INTS };
34 module_param_array(ap_max_inactivity, int, NULL, 0444);
35 MODULE_PARM_DESC(ap_max_inactivity, "AP timeout (in seconds) for station "
36 "inactivity");
37
38 static int ap_bridge_packets[MAX_PARM_DEVICES] = { 1, DEF_INTS };
39 module_param_array(ap_bridge_packets, int, NULL, 0444);
40 MODULE_PARM_DESC(ap_bridge_packets, "Bridge packets directly between "
41 "stations");
42
43 static int autom_ap_wds[MAX_PARM_DEVICES] = { 0, DEF_INTS };
44 module_param_array(autom_ap_wds, int, NULL, 0444);
45 MODULE_PARM_DESC(autom_ap_wds, "Add WDS connections to other APs "
46 "automatically");
47
48
49 static struct sta_info* ap_get_sta(struct ap_data *ap, u8 *sta);
50 static void hostap_event_expired_sta(struct net_device *dev,
51 struct sta_info *sta);
52 static void handle_add_proc_queue(struct work_struct *work);
53
54 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
55 static void handle_wds_oper_queue(struct work_struct *work);
56 static void prism2_send_mgmt(struct net_device *dev,
57 u16 type_subtype, char *body,
58 int body_len, u8 *addr, u16 tx_cb_idx);
59 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
60
61
62 #ifndef PRISM2_NO_PROCFS_DEBUG
63 static int ap_debug_proc_read(char *page, char **start, off_t off,
64 int count, int *eof, void *data)
65 {
66 char *p = page;
67 struct ap_data *ap = (struct ap_data *) data;
68
69 if (off != 0) {
70 *eof = 1;
71 return 0;
72 }
73
74 p += sprintf(p, "BridgedUnicastFrames=%u\n", ap->bridged_unicast);
75 p += sprintf(p, "BridgedMulticastFrames=%u\n", ap->bridged_multicast);
76 p += sprintf(p, "max_inactivity=%u\n", ap->max_inactivity / HZ);
77 p += sprintf(p, "bridge_packets=%u\n", ap->bridge_packets);
78 p += sprintf(p, "nullfunc_ack=%u\n", ap->nullfunc_ack);
79 p += sprintf(p, "autom_ap_wds=%u\n", ap->autom_ap_wds);
80 p += sprintf(p, "auth_algs=%u\n", ap->local->auth_algs);
81 p += sprintf(p, "tx_drop_nonassoc=%u\n", ap->tx_drop_nonassoc);
82
83 return (p - page);
84 }
85 #endif /* PRISM2_NO_PROCFS_DEBUG */
86
87
88 static void ap_sta_hash_add(struct ap_data *ap, struct sta_info *sta)
89 {
90 sta->hnext = ap->sta_hash[STA_HASH(sta->addr)];
91 ap->sta_hash[STA_HASH(sta->addr)] = sta;
92 }
93
94 static void ap_sta_hash_del(struct ap_data *ap, struct sta_info *sta)
95 {
96 struct sta_info *s;
97 DECLARE_MAC_BUF(mac);
98
99 s = ap->sta_hash[STA_HASH(sta->addr)];
100 if (s == NULL) return;
101 if (memcmp(s->addr, sta->addr, ETH_ALEN) == 0) {
102 ap->sta_hash[STA_HASH(sta->addr)] = s->hnext;
103 return;
104 }
105
106 while (s->hnext != NULL && memcmp(s->hnext->addr, sta->addr, ETH_ALEN)
107 != 0)
108 s = s->hnext;
109 if (s->hnext != NULL)
110 s->hnext = s->hnext->hnext;
111 else
112 printk("AP: could not remove STA %s"
113 " from hash table\n",
114 print_mac(mac, sta->addr));
115 }
116
117 static void ap_free_sta(struct ap_data *ap, struct sta_info *sta)
118 {
119 DECLARE_MAC_BUF(mac);
120 if (sta->ap && sta->local)
121 hostap_event_expired_sta(sta->local->dev, sta);
122
123 if (ap->proc != NULL) {
124 char name[20];
125 sprintf(name, "%s", print_mac(mac, sta->addr));
126 remove_proc_entry(name, ap->proc);
127 }
128
129 if (sta->crypt) {
130 sta->crypt->ops->deinit(sta->crypt->priv);
131 kfree(sta->crypt);
132 sta->crypt = NULL;
133 }
134
135 skb_queue_purge(&sta->tx_buf);
136
137 ap->num_sta--;
138 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
139 if (sta->aid > 0)
140 ap->sta_aid[sta->aid - 1] = NULL;
141
142 if (!sta->ap && sta->u.sta.challenge)
143 kfree(sta->u.sta.challenge);
144 del_timer(&sta->timer);
145 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
146
147 kfree(sta);
148 }
149
150
151 static void hostap_set_tim(local_info_t *local, int aid, int set)
152 {
153 if (local->func->set_tim)
154 local->func->set_tim(local->dev, aid, set);
155 }
156
157
158 static void hostap_event_new_sta(struct net_device *dev, struct sta_info *sta)
159 {
160 union iwreq_data wrqu;
161 memset(&wrqu, 0, sizeof(wrqu));
162 memcpy(wrqu.addr.sa_data, sta->addr, ETH_ALEN);
163 wrqu.addr.sa_family = ARPHRD_ETHER;
164 wireless_send_event(dev, IWEVREGISTERED, &wrqu, NULL);
165 }
166
167
168 static void hostap_event_expired_sta(struct net_device *dev,
169 struct sta_info *sta)
170 {
171 union iwreq_data wrqu;
172 memset(&wrqu, 0, sizeof(wrqu));
173 memcpy(wrqu.addr.sa_data, sta->addr, ETH_ALEN);
174 wrqu.addr.sa_family = ARPHRD_ETHER;
175 wireless_send_event(dev, IWEVEXPIRED, &wrqu, NULL);
176 }
177
178
179 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
180
181 static void ap_handle_timer(unsigned long data)
182 {
183 struct sta_info *sta = (struct sta_info *) data;
184 local_info_t *local;
185 struct ap_data *ap;
186 unsigned long next_time = 0;
187 int was_assoc;
188 DECLARE_MAC_BUF(mac);
189
190 if (sta == NULL || sta->local == NULL || sta->local->ap == NULL) {
191 PDEBUG(DEBUG_AP, "ap_handle_timer() called with NULL data\n");
192 return;
193 }
194
195 local = sta->local;
196 ap = local->ap;
197 was_assoc = sta->flags & WLAN_STA_ASSOC;
198
199 if (atomic_read(&sta->users) != 0)
200 next_time = jiffies + HZ;
201 else if ((sta->flags & WLAN_STA_PERM) && !(sta->flags & WLAN_STA_AUTH))
202 next_time = jiffies + ap->max_inactivity;
203
204 if (time_before(jiffies, sta->last_rx + ap->max_inactivity)) {
205 /* station activity detected; reset timeout state */
206 sta->timeout_next = STA_NULLFUNC;
207 next_time = sta->last_rx + ap->max_inactivity;
208 } else if (sta->timeout_next == STA_DISASSOC &&
209 !(sta->flags & WLAN_STA_PENDING_POLL)) {
210 /* STA ACKed data nullfunc frame poll */
211 sta->timeout_next = STA_NULLFUNC;
212 next_time = jiffies + ap->max_inactivity;
213 }
214
215 if (next_time) {
216 sta->timer.expires = next_time;
217 add_timer(&sta->timer);
218 return;
219 }
220
221 if (sta->ap)
222 sta->timeout_next = STA_DEAUTH;
223
224 if (sta->timeout_next == STA_DEAUTH && !(sta->flags & WLAN_STA_PERM)) {
225 spin_lock(&ap->sta_table_lock);
226 ap_sta_hash_del(ap, sta);
227 list_del(&sta->list);
228 spin_unlock(&ap->sta_table_lock);
229 sta->flags &= ~(WLAN_STA_AUTH | WLAN_STA_ASSOC);
230 } else if (sta->timeout_next == STA_DISASSOC)
231 sta->flags &= ~WLAN_STA_ASSOC;
232
233 if (was_assoc && !(sta->flags & WLAN_STA_ASSOC) && !sta->ap)
234 hostap_event_expired_sta(local->dev, sta);
235
236 if (sta->timeout_next == STA_DEAUTH && sta->aid > 0 &&
237 !skb_queue_empty(&sta->tx_buf)) {
238 hostap_set_tim(local, sta->aid, 0);
239 sta->flags &= ~WLAN_STA_TIM;
240 }
241
242 if (sta->ap) {
243 if (ap->autom_ap_wds) {
244 PDEBUG(DEBUG_AP, "%s: removing automatic WDS "
245 "connection to AP %s\n",
246 local->dev->name, print_mac(mac, sta->addr));
247 hostap_wds_link_oper(local, sta->addr, WDS_DEL);
248 }
249 } else if (sta->timeout_next == STA_NULLFUNC) {
250 /* send data frame to poll STA and check whether this frame
251 * is ACKed */
252 /* FIX: IEEE80211_STYPE_NULLFUNC would be more appropriate, but
253 * it is apparently not retried so TX Exc events are not
254 * received for it */
255 sta->flags |= WLAN_STA_PENDING_POLL;
256 prism2_send_mgmt(local->dev, IEEE80211_FTYPE_DATA |
257 IEEE80211_STYPE_DATA, NULL, 0,
258 sta->addr, ap->tx_callback_poll);
259 } else {
260 int deauth = sta->timeout_next == STA_DEAUTH;
261 __le16 resp;
262 PDEBUG(DEBUG_AP, "%s: sending %s info to STA %s"
263 "(last=%lu, jiffies=%lu)\n",
264 local->dev->name,
265 deauth ? "deauthentication" : "disassociation",
266 print_mac(mac, sta->addr), sta->last_rx, jiffies);
267
268 resp = cpu_to_le16(deauth ? WLAN_REASON_PREV_AUTH_NOT_VALID :
269 WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY);
270 prism2_send_mgmt(local->dev, IEEE80211_FTYPE_MGMT |
271 (deauth ? IEEE80211_STYPE_DEAUTH :
272 IEEE80211_STYPE_DISASSOC),
273 (char *) &resp, 2, sta->addr, 0);
274 }
275
276 if (sta->timeout_next == STA_DEAUTH) {
277 if (sta->flags & WLAN_STA_PERM) {
278 PDEBUG(DEBUG_AP, "%s: STA %s"
279 " would have been removed, "
280 "but it has 'perm' flag\n",
281 local->dev->name, print_mac(mac, sta->addr));
282 } else
283 ap_free_sta(ap, sta);
284 return;
285 }
286
287 if (sta->timeout_next == STA_NULLFUNC) {
288 sta->timeout_next = STA_DISASSOC;
289 sta->timer.expires = jiffies + AP_DISASSOC_DELAY;
290 } else {
291 sta->timeout_next = STA_DEAUTH;
292 sta->timer.expires = jiffies + AP_DEAUTH_DELAY;
293 }
294
295 add_timer(&sta->timer);
296 }
297
298
299 void hostap_deauth_all_stas(struct net_device *dev, struct ap_data *ap,
300 int resend)
301 {
302 u8 addr[ETH_ALEN];
303 __le16 resp;
304 int i;
305
306 PDEBUG(DEBUG_AP, "%s: Deauthenticate all stations\n", dev->name);
307 memset(addr, 0xff, ETH_ALEN);
308
309 resp = cpu_to_le16(WLAN_REASON_PREV_AUTH_NOT_VALID);
310
311 /* deauth message sent; try to resend it few times; the message is
312 * broadcast, so it may be delayed until next DTIM; there is not much
313 * else we can do at this point since the driver is going to be shut
314 * down */
315 for (i = 0; i < 5; i++) {
316 prism2_send_mgmt(dev, IEEE80211_FTYPE_MGMT |
317 IEEE80211_STYPE_DEAUTH,
318 (char *) &resp, 2, addr, 0);
319
320 if (!resend || ap->num_sta <= 0)
321 return;
322
323 mdelay(50);
324 }
325 }
326
327
328 static int ap_control_proc_read(char *page, char **start, off_t off,
329 int count, int *eof, void *data)
330 {
331 char *p = page;
332 struct ap_data *ap = (struct ap_data *) data;
333 char *policy_txt;
334 struct mac_entry *entry;
335 DECLARE_MAC_BUF(mac);
336
337 if (off != 0) {
338 *eof = 1;
339 return 0;
340 }
341
342 switch (ap->mac_restrictions.policy) {
343 case MAC_POLICY_OPEN:
344 policy_txt = "open";
345 break;
346 case MAC_POLICY_ALLOW:
347 policy_txt = "allow";
348 break;
349 case MAC_POLICY_DENY:
350 policy_txt = "deny";
351 break;
352 default:
353 policy_txt = "unknown";
354 break;
355 };
356 p += sprintf(p, "MAC policy: %s\n", policy_txt);
357 p += sprintf(p, "MAC entries: %u\n", ap->mac_restrictions.entries);
358 p += sprintf(p, "MAC list:\n");
359 spin_lock_bh(&ap->mac_restrictions.lock);
360 list_for_each_entry(entry, &ap->mac_restrictions.mac_list, list) {
361 if (p - page > PAGE_SIZE - 80) {
362 p += sprintf(p, "All entries did not fit one page.\n");
363 break;
364 }
365
366 p += sprintf(p, "%s\n", print_mac(mac, entry->addr));
367 }
368 spin_unlock_bh(&ap->mac_restrictions.lock);
369
370 return (p - page);
371 }
372
373
374 int ap_control_add_mac(struct mac_restrictions *mac_restrictions, u8 *mac)
375 {
376 struct mac_entry *entry;
377
378 entry = kmalloc(sizeof(struct mac_entry), GFP_KERNEL);
379 if (entry == NULL)
380 return -1;
381
382 memcpy(entry->addr, mac, ETH_ALEN);
383
384 spin_lock_bh(&mac_restrictions->lock);
385 list_add_tail(&entry->list, &mac_restrictions->mac_list);
386 mac_restrictions->entries++;
387 spin_unlock_bh(&mac_restrictions->lock);
388
389 return 0;
390 }
391
392
393 int ap_control_del_mac(struct mac_restrictions *mac_restrictions, u8 *mac)
394 {
395 struct list_head *ptr;
396 struct mac_entry *entry;
397
398 spin_lock_bh(&mac_restrictions->lock);
399 for (ptr = mac_restrictions->mac_list.next;
400 ptr != &mac_restrictions->mac_list; ptr = ptr->next) {
401 entry = list_entry(ptr, struct mac_entry, list);
402
403 if (memcmp(entry->addr, mac, ETH_ALEN) == 0) {
404 list_del(ptr);
405 kfree(entry);
406 mac_restrictions->entries--;
407 spin_unlock_bh(&mac_restrictions->lock);
408 return 0;
409 }
410 }
411 spin_unlock_bh(&mac_restrictions->lock);
412 return -1;
413 }
414
415
416 static int ap_control_mac_deny(struct mac_restrictions *mac_restrictions,
417 u8 *mac)
418 {
419 struct mac_entry *entry;
420 int found = 0;
421
422 if (mac_restrictions->policy == MAC_POLICY_OPEN)
423 return 0;
424
425 spin_lock_bh(&mac_restrictions->lock);
426 list_for_each_entry(entry, &mac_restrictions->mac_list, list) {
427 if (memcmp(entry->addr, mac, ETH_ALEN) == 0) {
428 found = 1;
429 break;
430 }
431 }
432 spin_unlock_bh(&mac_restrictions->lock);
433
434 if (mac_restrictions->policy == MAC_POLICY_ALLOW)
435 return !found;
436 else
437 return found;
438 }
439
440
441 void ap_control_flush_macs(struct mac_restrictions *mac_restrictions)
442 {
443 struct list_head *ptr, *n;
444 struct mac_entry *entry;
445
446 if (mac_restrictions->entries == 0)
447 return;
448
449 spin_lock_bh(&mac_restrictions->lock);
450 for (ptr = mac_restrictions->mac_list.next, n = ptr->next;
451 ptr != &mac_restrictions->mac_list;
452 ptr = n, n = ptr->next) {
453 entry = list_entry(ptr, struct mac_entry, list);
454 list_del(ptr);
455 kfree(entry);
456 }
457 mac_restrictions->entries = 0;
458 spin_unlock_bh(&mac_restrictions->lock);
459 }
460
461
462 int ap_control_kick_mac(struct ap_data *ap, struct net_device *dev, u8 *mac)
463 {
464 struct sta_info *sta;
465 __le16 resp;
466
467 spin_lock_bh(&ap->sta_table_lock);
468 sta = ap_get_sta(ap, mac);
469 if (sta) {
470 ap_sta_hash_del(ap, sta);
471 list_del(&sta->list);
472 }
473 spin_unlock_bh(&ap->sta_table_lock);
474
475 if (!sta)
476 return -EINVAL;
477
478 resp = cpu_to_le16(WLAN_REASON_PREV_AUTH_NOT_VALID);
479 prism2_send_mgmt(dev, IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_DEAUTH,
480 (char *) &resp, 2, sta->addr, 0);
481
482 if ((sta->flags & WLAN_STA_ASSOC) && !sta->ap)
483 hostap_event_expired_sta(dev, sta);
484
485 ap_free_sta(ap, sta);
486
487 return 0;
488 }
489
490 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
491
492
493 void ap_control_kickall(struct ap_data *ap)
494 {
495 struct list_head *ptr, *n;
496 struct sta_info *sta;
497
498 spin_lock_bh(&ap->sta_table_lock);
499 for (ptr = ap->sta_list.next, n = ptr->next; ptr != &ap->sta_list;
500 ptr = n, n = ptr->next) {
501 sta = list_entry(ptr, struct sta_info, list);
502 ap_sta_hash_del(ap, sta);
503 list_del(&sta->list);
504 if ((sta->flags & WLAN_STA_ASSOC) && !sta->ap && sta->local)
505 hostap_event_expired_sta(sta->local->dev, sta);
506 ap_free_sta(ap, sta);
507 }
508 spin_unlock_bh(&ap->sta_table_lock);
509 }
510
511
512 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
513
514 #define PROC_LIMIT (PAGE_SIZE - 80)
515
516 static int prism2_ap_proc_read(char *page, char **start, off_t off,
517 int count, int *eof, void *data)
518 {
519 char *p = page;
520 struct ap_data *ap = (struct ap_data *) data;
521 struct sta_info *sta;
522 int i;
523 DECLARE_MAC_BUF(mac);
524
525 if (off > PROC_LIMIT) {
526 *eof = 1;
527 return 0;
528 }
529
530 p += sprintf(p, "# BSSID CHAN SIGNAL NOISE RATE SSID FLAGS\n");
531 spin_lock_bh(&ap->sta_table_lock);
532 list_for_each_entry(sta, &ap->sta_list, list) {
533 if (!sta->ap)
534 continue;
535
536 p += sprintf(p, "%s %d %d %d %d '",
537 print_mac(mac, sta->addr),
538 sta->u.ap.channel, sta->last_rx_signal,
539 sta->last_rx_silence, sta->last_rx_rate);
540 for (i = 0; i < sta->u.ap.ssid_len; i++)
541 p += sprintf(p, ((sta->u.ap.ssid[i] >= 32 &&
542 sta->u.ap.ssid[i] < 127) ?
543 "%c" : "<%02x>"),
544 sta->u.ap.ssid[i]);
545 p += sprintf(p, "'");
546 if (sta->capability & WLAN_CAPABILITY_ESS)
547 p += sprintf(p, " [ESS]");
548 if (sta->capability & WLAN_CAPABILITY_IBSS)
549 p += sprintf(p, " [IBSS]");
550 if (sta->capability & WLAN_CAPABILITY_PRIVACY)
551 p += sprintf(p, " [WEP]");
552 p += sprintf(p, "\n");
553
554 if ((p - page) > PROC_LIMIT) {
555 printk(KERN_DEBUG "hostap: ap proc did not fit\n");
556 break;
557 }
558 }
559 spin_unlock_bh(&ap->sta_table_lock);
560
561 if ((p - page) <= off) {
562 *eof = 1;
563 return 0;
564 }
565
566 *start = page + off;
567
568 return (p - page - off);
569 }
570 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
571
572
573 void hostap_check_sta_fw_version(struct ap_data *ap, int sta_fw_ver)
574 {
575 if (!ap)
576 return;
577
578 if (sta_fw_ver == PRISM2_FW_VER(0,8,0)) {
579 PDEBUG(DEBUG_AP, "Using data::nullfunc ACK workaround - "
580 "firmware upgrade recommended\n");
581 ap->nullfunc_ack = 1;
582 } else
583 ap->nullfunc_ack = 0;
584
585 if (sta_fw_ver == PRISM2_FW_VER(1,4,2)) {
586 printk(KERN_WARNING "%s: Warning: secondary station firmware "
587 "version 1.4.2 does not seem to work in Host AP mode\n",
588 ap->local->dev->name);
589 }
590 }
591
592
593 /* Called only as a tasklet (software IRQ) */
594 static void hostap_ap_tx_cb(struct sk_buff *skb, int ok, void *data)
595 {
596 struct ap_data *ap = data;
597 u16 fc;
598 struct ieee80211_hdr_4addr *hdr;
599
600 if (!ap->local->hostapd || !ap->local->apdev) {
601 dev_kfree_skb(skb);
602 return;
603 }
604
605 hdr = (struct ieee80211_hdr_4addr *) skb->data;
606 fc = le16_to_cpu(hdr->frame_ctl);
607
608 /* Pass the TX callback frame to the hostapd; use 802.11 header version
609 * 1 to indicate failure (no ACK) and 2 success (frame ACKed) */
610
611 fc &= ~IEEE80211_FCTL_VERS;
612 fc |= ok ? BIT(1) : BIT(0);
613 hdr->frame_ctl = cpu_to_le16(fc);
614
615 skb->dev = ap->local->apdev;
616 skb_pull(skb, hostap_80211_get_hdrlen(fc));
617 skb->pkt_type = PACKET_OTHERHOST;
618 skb->protocol = __constant_htons(ETH_P_802_2);
619 memset(skb->cb, 0, sizeof(skb->cb));
620 netif_rx(skb);
621 }
622
623
624 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
625 /* Called only as a tasklet (software IRQ) */
626 static void hostap_ap_tx_cb_auth(struct sk_buff *skb, int ok, void *data)
627 {
628 struct ap_data *ap = data;
629 struct net_device *dev = ap->local->dev;
630 struct ieee80211_hdr_4addr *hdr;
631 u16 fc, auth_alg, auth_transaction, status;
632 __le16 *pos;
633 struct sta_info *sta = NULL;
634 char *txt = NULL;
635
636 if (ap->local->hostapd) {
637 dev_kfree_skb(skb);
638 return;
639 }
640
641 hdr = (struct ieee80211_hdr_4addr *) skb->data;
642 fc = le16_to_cpu(hdr->frame_ctl);
643 if (WLAN_FC_GET_TYPE(fc) != IEEE80211_FTYPE_MGMT ||
644 WLAN_FC_GET_STYPE(fc) != IEEE80211_STYPE_AUTH ||
645 skb->len < IEEE80211_MGMT_HDR_LEN + 6) {
646 printk(KERN_DEBUG "%s: hostap_ap_tx_cb_auth received invalid "
647 "frame\n", dev->name);
648 dev_kfree_skb(skb);
649 return;
650 }
651
652 pos = (__le16 *) (skb->data + IEEE80211_MGMT_HDR_LEN);
653 auth_alg = le16_to_cpu(*pos++);
654 auth_transaction = le16_to_cpu(*pos++);
655 status = le16_to_cpu(*pos++);
656
657 if (!ok) {
658 txt = "frame was not ACKed";
659 goto done;
660 }
661
662 spin_lock(&ap->sta_table_lock);
663 sta = ap_get_sta(ap, hdr->addr1);
664 if (sta)
665 atomic_inc(&sta->users);
666 spin_unlock(&ap->sta_table_lock);
667
668 if (!sta) {
669 txt = "STA not found";
670 goto done;
671 }
672
673 if (status == WLAN_STATUS_SUCCESS &&
674 ((auth_alg == WLAN_AUTH_OPEN && auth_transaction == 2) ||
675 (auth_alg == WLAN_AUTH_SHARED_KEY && auth_transaction == 4))) {
676 txt = "STA authenticated";
677 sta->flags |= WLAN_STA_AUTH;
678 sta->last_auth = jiffies;
679 } else if (status != WLAN_STATUS_SUCCESS)
680 txt = "authentication failed";
681
682 done:
683 if (sta)
684 atomic_dec(&sta->users);
685 if (txt) {
686 PDEBUG(DEBUG_AP, "%s: " MAC_FMT " auth_cb - alg=%d "
687 "trans#=%d status=%d - %s\n",
688 dev->name,
689 hdr->addr1[0], hdr->addr1[1], hdr->addr1[2],
690 hdr->addr1[3], hdr->addr1[4], hdr->addr1[5],
691 auth_alg, auth_transaction, status, txt);
692 }
693 dev_kfree_skb(skb);
694 }
695
696
697 /* Called only as a tasklet (software IRQ) */
698 static void hostap_ap_tx_cb_assoc(struct sk_buff *skb, int ok, void *data)
699 {
700 struct ap_data *ap = data;
701 struct net_device *dev = ap->local->dev;
702 struct ieee80211_hdr_4addr *hdr;
703 u16 fc, status;
704 __le16 *pos;
705 struct sta_info *sta = NULL;
706 char *txt = NULL;
707
708 if (ap->local->hostapd) {
709 dev_kfree_skb(skb);
710 return;
711 }
712
713 hdr = (struct ieee80211_hdr_4addr *) skb->data;
714 fc = le16_to_cpu(hdr->frame_ctl);
715 if (WLAN_FC_GET_TYPE(fc) != IEEE80211_FTYPE_MGMT ||
716 (WLAN_FC_GET_STYPE(fc) != IEEE80211_STYPE_ASSOC_RESP &&
717 WLAN_FC_GET_STYPE(fc) != IEEE80211_STYPE_REASSOC_RESP) ||
718 skb->len < IEEE80211_MGMT_HDR_LEN + 4) {
719 printk(KERN_DEBUG "%s: hostap_ap_tx_cb_assoc received invalid "
720 "frame\n", dev->name);
721 dev_kfree_skb(skb);
722 return;
723 }
724
725 if (!ok) {
726 txt = "frame was not ACKed";
727 goto done;
728 }
729
730 spin_lock(&ap->sta_table_lock);
731 sta = ap_get_sta(ap, hdr->addr1);
732 if (sta)
733 atomic_inc(&sta->users);
734 spin_unlock(&ap->sta_table_lock);
735
736 if (!sta) {
737 txt = "STA not found";
738 goto done;
739 }
740
741 pos = (__le16 *) (skb->data + IEEE80211_MGMT_HDR_LEN);
742 pos++;
743 status = le16_to_cpu(*pos++);
744 if (status == WLAN_STATUS_SUCCESS) {
745 if (!(sta->flags & WLAN_STA_ASSOC))
746 hostap_event_new_sta(dev, sta);
747 txt = "STA associated";
748 sta->flags |= WLAN_STA_ASSOC;
749 sta->last_assoc = jiffies;
750 } else
751 txt = "association failed";
752
753 done:
754 if (sta)
755 atomic_dec(&sta->users);
756 if (txt) {
757 PDEBUG(DEBUG_AP, "%s: " MAC_FMT " assoc_cb - %s\n",
758 dev->name,
759 hdr->addr1[0], hdr->addr1[1], hdr->addr1[2],
760 hdr->addr1[3], hdr->addr1[4], hdr->addr1[5],
761 txt);
762 }
763 dev_kfree_skb(skb);
764 }
765
766 /* Called only as a tasklet (software IRQ); TX callback for poll frames used
767 * in verifying whether the STA is still present. */
768 static void hostap_ap_tx_cb_poll(struct sk_buff *skb, int ok, void *data)
769 {
770 struct ap_data *ap = data;
771 struct ieee80211_hdr_4addr *hdr;
772 struct sta_info *sta;
773
774 if (skb->len < 24)
775 goto fail;
776 hdr = (struct ieee80211_hdr_4addr *) skb->data;
777 if (ok) {
778 spin_lock(&ap->sta_table_lock);
779 sta = ap_get_sta(ap, hdr->addr1);
780 if (sta)
781 sta->flags &= ~WLAN_STA_PENDING_POLL;
782 spin_unlock(&ap->sta_table_lock);
783 } else {
784 PDEBUG(DEBUG_AP, "%s: STA " MAC_FMT
785 " did not ACK activity poll frame\n",
786 ap->local->dev->name,
787 hdr->addr1[0], hdr->addr1[1], hdr->addr1[2],
788 hdr->addr1[3], hdr->addr1[4], hdr->addr1[5]);
789 }
790
791 fail:
792 dev_kfree_skb(skb);
793 }
794 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
795
796
797 void hostap_init_data(local_info_t *local)
798 {
799 struct ap_data *ap = local->ap;
800
801 if (ap == NULL) {
802 printk(KERN_WARNING "hostap_init_data: ap == NULL\n");
803 return;
804 }
805 memset(ap, 0, sizeof(struct ap_data));
806 ap->local = local;
807
808 ap->ap_policy = GET_INT_PARM(other_ap_policy, local->card_idx);
809 ap->bridge_packets = GET_INT_PARM(ap_bridge_packets, local->card_idx);
810 ap->max_inactivity =
811 GET_INT_PARM(ap_max_inactivity, local->card_idx) * HZ;
812 ap->autom_ap_wds = GET_INT_PARM(autom_ap_wds, local->card_idx);
813
814 spin_lock_init(&ap->sta_table_lock);
815 INIT_LIST_HEAD(&ap->sta_list);
816
817 /* Initialize task queue structure for AP management */
818 INIT_WORK(&local->ap->add_sta_proc_queue, handle_add_proc_queue);
819
820 ap->tx_callback_idx =
821 hostap_tx_callback_register(local, hostap_ap_tx_cb, ap);
822 if (ap->tx_callback_idx == 0)
823 printk(KERN_WARNING "%s: failed to register TX callback for "
824 "AP\n", local->dev->name);
825 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
826 INIT_WORK(&local->ap->wds_oper_queue, handle_wds_oper_queue);
827
828 ap->tx_callback_auth =
829 hostap_tx_callback_register(local, hostap_ap_tx_cb_auth, ap);
830 ap->tx_callback_assoc =
831 hostap_tx_callback_register(local, hostap_ap_tx_cb_assoc, ap);
832 ap->tx_callback_poll =
833 hostap_tx_callback_register(local, hostap_ap_tx_cb_poll, ap);
834 if (ap->tx_callback_auth == 0 || ap->tx_callback_assoc == 0 ||
835 ap->tx_callback_poll == 0)
836 printk(KERN_WARNING "%s: failed to register TX callback for "
837 "AP\n", local->dev->name);
838
839 spin_lock_init(&ap->mac_restrictions.lock);
840 INIT_LIST_HEAD(&ap->mac_restrictions.mac_list);
841 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
842
843 ap->initialized = 1;
844 }
845
846
847 void hostap_init_ap_proc(local_info_t *local)
848 {
849 struct ap_data *ap = local->ap;
850
851 ap->proc = local->proc;
852 if (ap->proc == NULL)
853 return;
854
855 #ifndef PRISM2_NO_PROCFS_DEBUG
856 create_proc_read_entry("ap_debug", 0, ap->proc,
857 ap_debug_proc_read, ap);
858 #endif /* PRISM2_NO_PROCFS_DEBUG */
859
860 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
861 create_proc_read_entry("ap_control", 0, ap->proc,
862 ap_control_proc_read, ap);
863 create_proc_read_entry("ap", 0, ap->proc,
864 prism2_ap_proc_read, ap);
865 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
866
867 }
868
869
870 void hostap_free_data(struct ap_data *ap)
871 {
872 struct sta_info *n, *sta;
873
874 if (ap == NULL || !ap->initialized) {
875 printk(KERN_DEBUG "hostap_free_data: ap has not yet been "
876 "initialized - skip resource freeing\n");
877 return;
878 }
879
880 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
881 if (ap->crypt)
882 ap->crypt->deinit(ap->crypt_priv);
883 ap->crypt = ap->crypt_priv = NULL;
884 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
885
886 list_for_each_entry_safe(sta, n, &ap->sta_list, list) {
887 ap_sta_hash_del(ap, sta);
888 list_del(&sta->list);
889 if ((sta->flags & WLAN_STA_ASSOC) && !sta->ap && sta->local)
890 hostap_event_expired_sta(sta->local->dev, sta);
891 ap_free_sta(ap, sta);
892 }
893
894 #ifndef PRISM2_NO_PROCFS_DEBUG
895 if (ap->proc != NULL) {
896 remove_proc_entry("ap_debug", ap->proc);
897 }
898 #endif /* PRISM2_NO_PROCFS_DEBUG */
899
900 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
901 if (ap->proc != NULL) {
902 remove_proc_entry("ap", ap->proc);
903 remove_proc_entry("ap_control", ap->proc);
904 }
905 ap_control_flush_macs(&ap->mac_restrictions);
906 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
907
908 ap->initialized = 0;
909 }
910
911
912 /* caller should have mutex for AP STA list handling */
913 static struct sta_info* ap_get_sta(struct ap_data *ap, u8 *sta)
914 {
915 struct sta_info *s;
916
917 s = ap->sta_hash[STA_HASH(sta)];
918 while (s != NULL && memcmp(s->addr, sta, ETH_ALEN) != 0)
919 s = s->hnext;
920 return s;
921 }
922
923
924 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
925
926 /* Called from timer handler and from scheduled AP queue handlers */
927 static void prism2_send_mgmt(struct net_device *dev,
928 u16 type_subtype, char *body,
929 int body_len, u8 *addr, u16 tx_cb_idx)
930 {
931 struct hostap_interface *iface;
932 local_info_t *local;
933 struct ieee80211_hdr_4addr *hdr;
934 u16 fc;
935 struct sk_buff *skb;
936 struct hostap_skb_tx_data *meta;
937 int hdrlen;
938
939 iface = netdev_priv(dev);
940 local = iface->local;
941 dev = local->dev; /* always use master radio device */
942 iface = netdev_priv(dev);
943
944 if (!(dev->flags & IFF_UP)) {
945 PDEBUG(DEBUG_AP, "%s: prism2_send_mgmt - device is not UP - "
946 "cannot send frame\n", dev->name);
947 return;
948 }
949
950 skb = dev_alloc_skb(sizeof(*hdr) + body_len);
951 if (skb == NULL) {
952 PDEBUG(DEBUG_AP, "%s: prism2_send_mgmt failed to allocate "
953 "skb\n", dev->name);
954 return;
955 }
956
957 fc = type_subtype;
958 hdrlen = hostap_80211_get_hdrlen(fc);
959 hdr = (struct ieee80211_hdr_4addr *) skb_put(skb, hdrlen);
960 if (body)
961 memcpy(skb_put(skb, body_len), body, body_len);
962
963 memset(hdr, 0, hdrlen);
964
965 /* FIX: ctrl::ack sending used special HFA384X_TX_CTRL_802_11
966 * tx_control instead of using local->tx_control */
967
968
969 memcpy(hdr->addr1, addr, ETH_ALEN); /* DA / RA */
970 if (WLAN_FC_GET_TYPE(fc) == IEEE80211_FTYPE_DATA) {
971 fc |= IEEE80211_FCTL_FROMDS;
972 memcpy(hdr->addr2, dev->dev_addr, ETH_ALEN); /* BSSID */
973 memcpy(hdr->addr3, dev->dev_addr, ETH_ALEN); /* SA */
974 } else if (WLAN_FC_GET_TYPE(fc) == IEEE80211_FTYPE_CTL) {
975 /* control:ACK does not have addr2 or addr3 */
976 memset(hdr->addr2, 0, ETH_ALEN);
977 memset(hdr->addr3, 0, ETH_ALEN);
978 } else {
979 memcpy(hdr->addr2, dev->dev_addr, ETH_ALEN); /* SA */
980 memcpy(hdr->addr3, dev->dev_addr, ETH_ALEN); /* BSSID */
981 }
982
983 hdr->frame_ctl = cpu_to_le16(fc);
984
985 meta = (struct hostap_skb_tx_data *) skb->cb;
986 memset(meta, 0, sizeof(*meta));
987 meta->magic = HOSTAP_SKB_TX_DATA_MAGIC;
988 meta->iface = iface;
989 meta->tx_cb_idx = tx_cb_idx;
990
991 skb->dev = dev;
992 skb_reset_mac_header(skb);
993 skb_reset_network_header(skb);
994 dev_queue_xmit(skb);
995 }
996 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
997
998
999 static int prism2_sta_proc_read(char *page, char **start, off_t off,
1000 int count, int *eof, void *data)
1001 {
1002 char *p = page;
1003 struct sta_info *sta = (struct sta_info *) data;
1004 int i;
1005 DECLARE_MAC_BUF(mac);
1006
1007 /* FIX: possible race condition.. the STA data could have just expired,
1008 * but proc entry was still here so that the read could have started;
1009 * some locking should be done here.. */
1010
1011 if (off != 0) {
1012 *eof = 1;
1013 return 0;
1014 }
1015
1016 p += sprintf(p, "%s=%s\nusers=%d\naid=%d\n"
1017 "flags=0x%04x%s%s%s%s%s%s%s\n"
1018 "capability=0x%02x\nlisten_interval=%d\nsupported_rates=",
1019 sta->ap ? "AP" : "STA",
1020 print_mac(mac, sta->addr), atomic_read(&sta->users), sta->aid,
1021 sta->flags,
1022 sta->flags & WLAN_STA_AUTH ? " AUTH" : "",
1023 sta->flags & WLAN_STA_ASSOC ? " ASSOC" : "",
1024 sta->flags & WLAN_STA_PS ? " PS" : "",
1025 sta->flags & WLAN_STA_TIM ? " TIM" : "",
1026 sta->flags & WLAN_STA_PERM ? " PERM" : "",
1027 sta->flags & WLAN_STA_AUTHORIZED ? " AUTHORIZED" : "",
1028 sta->flags & WLAN_STA_PENDING_POLL ? " POLL" : "",
1029 sta->capability, sta->listen_interval);
1030 /* supported_rates: 500 kbit/s units with msb ignored */
1031 for (i = 0; i < sizeof(sta->supported_rates); i++)
1032 if (sta->supported_rates[i] != 0)
1033 p += sprintf(p, "%d%sMbps ",
1034 (sta->supported_rates[i] & 0x7f) / 2,
1035 sta->supported_rates[i] & 1 ? ".5" : "");
1036 p += sprintf(p, "\njiffies=%lu\nlast_auth=%lu\nlast_assoc=%lu\n"
1037 "last_rx=%lu\nlast_tx=%lu\nrx_packets=%lu\n"
1038 "tx_packets=%lu\n"
1039 "rx_bytes=%lu\ntx_bytes=%lu\nbuffer_count=%d\n"
1040 "last_rx: silence=%d dBm signal=%d dBm rate=%d%s Mbps\n"
1041 "tx_rate=%d\ntx[1M]=%d\ntx[2M]=%d\ntx[5.5M]=%d\n"
1042 "tx[11M]=%d\n"
1043 "rx[1M]=%d\nrx[2M]=%d\nrx[5.5M]=%d\nrx[11M]=%d\n",
1044 jiffies, sta->last_auth, sta->last_assoc, sta->last_rx,
1045 sta->last_tx,
1046 sta->rx_packets, sta->tx_packets, sta->rx_bytes,
1047 sta->tx_bytes, skb_queue_len(&sta->tx_buf),
1048 sta->last_rx_silence,
1049 sta->last_rx_signal, sta->last_rx_rate / 10,
1050 sta->last_rx_rate % 10 ? ".5" : "",
1051 sta->tx_rate, sta->tx_count[0], sta->tx_count[1],
1052 sta->tx_count[2], sta->tx_count[3], sta->rx_count[0],
1053 sta->rx_count[1], sta->rx_count[2], sta->rx_count[3]);
1054 if (sta->crypt && sta->crypt->ops && sta->crypt->ops->print_stats)
1055 p = sta->crypt->ops->print_stats(p, sta->crypt->priv);
1056 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
1057 if (sta->ap) {
1058 if (sta->u.ap.channel >= 0)
1059 p += sprintf(p, "channel=%d\n", sta->u.ap.channel);
1060 p += sprintf(p, "ssid=");
1061 for (i = 0; i < sta->u.ap.ssid_len; i++)
1062 p += sprintf(p, ((sta->u.ap.ssid[i] >= 32 &&
1063 sta->u.ap.ssid[i] < 127) ?
1064 "%c" : "<%02x>"),
1065 sta->u.ap.ssid[i]);
1066 p += sprintf(p, "\n");
1067 }
1068 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
1069
1070 return (p - page);
1071 }
1072
1073
1074 static void handle_add_proc_queue(struct work_struct *work)
1075 {
1076 struct ap_data *ap = container_of(work, struct ap_data,
1077 add_sta_proc_queue);
1078 struct sta_info *sta;
1079 char name[20];
1080 struct add_sta_proc_data *entry, *prev;
1081 DECLARE_MAC_BUF(mac);
1082
1083 entry = ap->add_sta_proc_entries;
1084 ap->add_sta_proc_entries = NULL;
1085
1086 while (entry) {
1087 spin_lock_bh(&ap->sta_table_lock);
1088 sta = ap_get_sta(ap, entry->addr);
1089 if (sta)
1090 atomic_inc(&sta->users);
1091 spin_unlock_bh(&ap->sta_table_lock);
1092
1093 if (sta) {
1094 sprintf(name, "%s", print_mac(mac, sta->addr));
1095 sta->proc = create_proc_read_entry(
1096 name, 0, ap->proc,
1097 prism2_sta_proc_read, sta);
1098
1099 atomic_dec(&sta->users);
1100 }
1101
1102 prev = entry;
1103 entry = entry->next;
1104 kfree(prev);
1105 }
1106 }
1107
1108
1109 static struct sta_info * ap_add_sta(struct ap_data *ap, u8 *addr)
1110 {
1111 struct sta_info *sta;
1112
1113 sta = kzalloc(sizeof(struct sta_info), GFP_ATOMIC);
1114 if (sta == NULL) {
1115 PDEBUG(DEBUG_AP, "AP: kmalloc failed\n");
1116 return NULL;
1117 }
1118
1119 /* initialize STA info data */
1120 sta->local = ap->local;
1121 skb_queue_head_init(&sta->tx_buf);
1122 memcpy(sta->addr, addr, ETH_ALEN);
1123
1124 atomic_inc(&sta->users);
1125 spin_lock_bh(&ap->sta_table_lock);
1126 list_add(&sta->list, &ap->sta_list);
1127 ap->num_sta++;
1128 ap_sta_hash_add(ap, sta);
1129 spin_unlock_bh(&ap->sta_table_lock);
1130
1131 if (ap->proc) {
1132 struct add_sta_proc_data *entry;
1133 /* schedule a non-interrupt context process to add a procfs
1134 * entry for the STA since procfs code use GFP_KERNEL */
1135 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
1136 if (entry) {
1137 memcpy(entry->addr, sta->addr, ETH_ALEN);
1138 entry->next = ap->add_sta_proc_entries;
1139 ap->add_sta_proc_entries = entry;
1140 schedule_work(&ap->add_sta_proc_queue);
1141 } else
1142 printk(KERN_DEBUG "Failed to add STA proc data\n");
1143 }
1144
1145 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
1146 init_timer(&sta->timer);
1147 sta->timer.expires = jiffies + ap->max_inactivity;
1148 sta->timer.data = (unsigned long) sta;
1149 sta->timer.function = ap_handle_timer;
1150 if (!ap->local->hostapd)
1151 add_timer(&sta->timer);
1152 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
1153
1154 return sta;
1155 }
1156
1157
1158 static int ap_tx_rate_ok(int rateidx, struct sta_info *sta,
1159 local_info_t *local)
1160 {
1161 if (rateidx > sta->tx_max_rate ||
1162 !(sta->tx_supp_rates & (1 << rateidx)))
1163 return 0;
1164
1165 if (local->tx_rate_control != 0 &&
1166 !(local->tx_rate_control & (1 << rateidx)))
1167 return 0;
1168
1169 return 1;
1170 }
1171
1172
1173 static void prism2_check_tx_rates(struct sta_info *sta)
1174 {
1175 int i;
1176
1177 sta->tx_supp_rates = 0;
1178 for (i = 0; i < sizeof(sta->supported_rates); i++) {
1179 if ((sta->supported_rates[i] & 0x7f) == 2)
1180 sta->tx_supp_rates |= WLAN_RATE_1M;
1181 if ((sta->supported_rates[i] & 0x7f) == 4)
1182 sta->tx_supp_rates |= WLAN_RATE_2M;
1183 if ((sta->supported_rates[i] & 0x7f) == 11)
1184 sta->tx_supp_rates |= WLAN_RATE_5M5;
1185 if ((sta->supported_rates[i] & 0x7f) == 22)
1186 sta->tx_supp_rates |= WLAN_RATE_11M;
1187 }
1188 sta->tx_max_rate = sta->tx_rate = sta->tx_rate_idx = 0;
1189 if (sta->tx_supp_rates & WLAN_RATE_1M) {
1190 sta->tx_max_rate = 0;
1191 if (ap_tx_rate_ok(0, sta, sta->local)) {
1192 sta->tx_rate = 10;
1193 sta->tx_rate_idx = 0;
1194 }
1195 }
1196 if (sta->tx_supp_rates & WLAN_RATE_2M) {
1197 sta->tx_max_rate = 1;
1198 if (ap_tx_rate_ok(1, sta, sta->local)) {
1199 sta->tx_rate = 20;
1200 sta->tx_rate_idx = 1;
1201 }
1202 }
1203 if (sta->tx_supp_rates & WLAN_RATE_5M5) {
1204 sta->tx_max_rate = 2;
1205 if (ap_tx_rate_ok(2, sta, sta->local)) {
1206 sta->tx_rate = 55;
1207 sta->tx_rate_idx = 2;
1208 }
1209 }
1210 if (sta->tx_supp_rates & WLAN_RATE_11M) {
1211 sta->tx_max_rate = 3;
1212 if (ap_tx_rate_ok(3, sta, sta->local)) {
1213 sta->tx_rate = 110;
1214 sta->tx_rate_idx = 3;
1215 }
1216 }
1217 }
1218
1219
1220 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
1221
1222 static void ap_crypt_init(struct ap_data *ap)
1223 {
1224 ap->crypt = ieee80211_get_crypto_ops("WEP");
1225
1226 if (ap->crypt) {
1227 if (ap->crypt->init) {
1228 ap->crypt_priv = ap->crypt->init(0);
1229 if (ap->crypt_priv == NULL)
1230 ap->crypt = NULL;
1231 else {
1232 u8 key[WEP_KEY_LEN];
1233 get_random_bytes(key, WEP_KEY_LEN);
1234 ap->crypt->set_key(key, WEP_KEY_LEN, NULL,
1235 ap->crypt_priv);
1236 }
1237 }
1238 }
1239
1240 if (ap->crypt == NULL) {
1241 printk(KERN_WARNING "AP could not initialize WEP: load module "
1242 "ieee80211_crypt_wep.ko\n");
1243 }
1244 }
1245
1246
1247 /* Generate challenge data for shared key authentication. IEEE 802.11 specifies
1248 * that WEP algorithm is used for generating challange. This should be unique,
1249 * but otherwise there is not really need for randomness etc. Initialize WEP
1250 * with pseudo random key and then use increasing IV to get unique challenge
1251 * streams.
1252 *
1253 * Called only as a scheduled task for pending AP frames.
1254 */
1255 static char * ap_auth_make_challenge(struct ap_data *ap)
1256 {
1257 char *tmpbuf;
1258 struct sk_buff *skb;
1259
1260 if (ap->crypt == NULL) {
1261 ap_crypt_init(ap);
1262 if (ap->crypt == NULL)
1263 return NULL;
1264 }
1265
1266 tmpbuf = kmalloc(WLAN_AUTH_CHALLENGE_LEN, GFP_ATOMIC);
1267 if (tmpbuf == NULL) {
1268 PDEBUG(DEBUG_AP, "AP: kmalloc failed for challenge\n");
1269 return NULL;
1270 }
1271
1272 skb = dev_alloc_skb(WLAN_AUTH_CHALLENGE_LEN +
1273 ap->crypt->extra_mpdu_prefix_len +
1274 ap->crypt->extra_mpdu_postfix_len);
1275 if (skb == NULL) {
1276 kfree(tmpbuf);
1277 return NULL;
1278 }
1279
1280 skb_reserve(skb, ap->crypt->extra_mpdu_prefix_len);
1281 memset(skb_put(skb, WLAN_AUTH_CHALLENGE_LEN), 0,
1282 WLAN_AUTH_CHALLENGE_LEN);
1283 if (ap->crypt->encrypt_mpdu(skb, 0, ap->crypt_priv)) {
1284 dev_kfree_skb(skb);
1285 kfree(tmpbuf);
1286 return NULL;
1287 }
1288
1289 skb_copy_from_linear_data_offset(skb, ap->crypt->extra_mpdu_prefix_len,
1290 tmpbuf, WLAN_AUTH_CHALLENGE_LEN);
1291 dev_kfree_skb(skb);
1292
1293 return tmpbuf;
1294 }
1295
1296
1297 /* Called only as a scheduled task for pending AP frames. */
1298 static void handle_authen(local_info_t *local, struct sk_buff *skb,
1299 struct hostap_80211_rx_status *rx_stats)
1300 {
1301 struct net_device *dev = local->dev;
1302 struct ieee80211_hdr_4addr *hdr = (struct ieee80211_hdr_4addr *) skb->data;
1303 size_t hdrlen;
1304 struct ap_data *ap = local->ap;
1305 char body[8 + WLAN_AUTH_CHALLENGE_LEN], *challenge = NULL;
1306 int len, olen;
1307 u16 auth_alg, auth_transaction, status_code;
1308 __le16 *pos;
1309 u16 resp = WLAN_STATUS_SUCCESS, fc;
1310 struct sta_info *sta = NULL;
1311 struct ieee80211_crypt_data *crypt;
1312 char *txt = "";
1313
1314 len = skb->len - IEEE80211_MGMT_HDR_LEN;
1315
1316 fc = le16_to_cpu(hdr->frame_ctl);
1317 hdrlen = hostap_80211_get_hdrlen(fc);
1318
1319 if (len < 6) {
1320 PDEBUG(DEBUG_AP, "%s: handle_authen - too short payload "
1321 "(len=%d) from " MAC_FMT "\n", dev->name, len,
1322 hdr->addr2[0], hdr->addr2[1], hdr->addr2[2],
1323 hdr->addr2[3], hdr->addr2[4], hdr->addr2[5]);
1324 return;
1325 }
1326
1327 spin_lock_bh(&local->ap->sta_table_lock);
1328 sta = ap_get_sta(local->ap, hdr->addr2);
1329 if (sta)
1330 atomic_inc(&sta->users);
1331 spin_unlock_bh(&local->ap->sta_table_lock);
1332
1333 if (sta && sta->crypt)
1334 crypt = sta->crypt;
1335 else {
1336 int idx = 0;
1337 if (skb->len >= hdrlen + 3)
1338 idx = skb->data[hdrlen + 3] >> 6;
1339 crypt = local->crypt[idx];
1340 }
1341
1342 pos = (__le16 *) (skb->data + IEEE80211_MGMT_HDR_LEN);
1343 auth_alg = __le16_to_cpu(*pos);
1344 pos++;
1345 auth_transaction = __le16_to_cpu(*pos);
1346 pos++;
1347 status_code = __le16_to_cpu(*pos);
1348 pos++;
1349
1350 if (memcmp(dev->dev_addr, hdr->addr2, ETH_ALEN) == 0 ||
1351 ap_control_mac_deny(&ap->mac_restrictions, hdr->addr2)) {
1352 txt = "authentication denied";
1353 resp = WLAN_STATUS_UNSPECIFIED_FAILURE;
1354 goto fail;
1355 }
1356
1357 if (((local->auth_algs & PRISM2_AUTH_OPEN) &&
1358 auth_alg == WLAN_AUTH_OPEN) ||
1359 ((local->auth_algs & PRISM2_AUTH_SHARED_KEY) &&
1360 crypt && auth_alg == WLAN_AUTH_SHARED_KEY)) {
1361 } else {
1362 txt = "unsupported algorithm";
1363 resp = WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG;
1364 goto fail;
1365 }
1366
1367 if (len >= 8) {
1368 u8 *u = (u8 *) pos;
1369 if (*u == WLAN_EID_CHALLENGE) {
1370 if (*(u + 1) != WLAN_AUTH_CHALLENGE_LEN) {
1371 txt = "invalid challenge len";
1372 resp = WLAN_STATUS_CHALLENGE_FAIL;
1373 goto fail;
1374 }
1375 if (len - 8 < WLAN_AUTH_CHALLENGE_LEN) {
1376 txt = "challenge underflow";
1377 resp = WLAN_STATUS_CHALLENGE_FAIL;
1378 goto fail;
1379 }
1380 challenge = (char *) (u + 2);
1381 }
1382 }
1383
1384 if (sta && sta->ap) {
1385 if (time_after(jiffies, sta->u.ap.last_beacon +
1386 (10 * sta->listen_interval * HZ) / 1024)) {
1387 PDEBUG(DEBUG_AP, "%s: no beacons received for a while,"
1388 " assuming AP " MAC_FMT " is now STA\n",
1389 dev->name,
1390 sta->addr[0], sta->addr[1], sta->addr[2],
1391 sta->addr[3], sta->addr[4], sta->addr[5]);
1392 sta->ap = 0;
1393 sta->flags = 0;
1394 sta->u.sta.challenge = NULL;
1395 } else {
1396 txt = "AP trying to authenticate?";
1397 resp = WLAN_STATUS_UNSPECIFIED_FAILURE;
1398 goto fail;
1399 }
1400 }
1401
1402 if ((auth_alg == WLAN_AUTH_OPEN && auth_transaction == 1) ||
1403 (auth_alg == WLAN_AUTH_SHARED_KEY &&
1404 (auth_transaction == 1 ||
1405 (auth_transaction == 3 && sta != NULL &&
1406 sta->u.sta.challenge != NULL)))) {
1407 } else {
1408 txt = "unknown authentication transaction number";
1409 resp = WLAN_STATUS_UNKNOWN_AUTH_TRANSACTION;
1410 goto fail;
1411 }
1412
1413 if (sta == NULL) {
1414 txt = "new STA";
1415
1416 if (local->ap->num_sta >= MAX_STA_COUNT) {
1417 /* FIX: might try to remove some old STAs first? */
1418 txt = "no more room for new STAs";
1419 resp = WLAN_STATUS_UNSPECIFIED_FAILURE;
1420 goto fail;
1421 }
1422
1423 sta = ap_add_sta(local->ap, hdr->addr2);
1424 if (sta == NULL) {
1425 txt = "ap_add_sta failed";
1426 resp = WLAN_STATUS_UNSPECIFIED_FAILURE;
1427 goto fail;
1428 }
1429 }
1430
1431 switch (auth_alg) {
1432 case WLAN_AUTH_OPEN:
1433 txt = "authOK";
1434 /* IEEE 802.11 standard is not completely clear about
1435 * whether STA is considered authenticated after
1436 * authentication OK frame has been send or after it
1437 * has been ACKed. In order to reduce interoperability
1438 * issues, mark the STA authenticated before ACK. */
1439 sta->flags |= WLAN_STA_AUTH;
1440 break;
1441
1442 case WLAN_AUTH_SHARED_KEY:
1443 if (auth_transaction == 1) {
1444 if (sta->u.sta.challenge == NULL) {
1445 sta->u.sta.challenge =
1446 ap_auth_make_challenge(local->ap);
1447 if (sta->u.sta.challenge == NULL) {
1448 resp = WLAN_STATUS_UNSPECIFIED_FAILURE;
1449 goto fail;
1450 }
1451 }
1452 } else {
1453 if (sta->u.sta.challenge == NULL ||
1454 challenge == NULL ||
1455 memcmp(sta->u.sta.challenge, challenge,
1456 WLAN_AUTH_CHALLENGE_LEN) != 0 ||
1457 !(fc & IEEE80211_FCTL_PROTECTED)) {
1458 txt = "challenge response incorrect";
1459 resp = WLAN_STATUS_CHALLENGE_FAIL;
1460 goto fail;
1461 }
1462
1463 txt = "challenge OK - authOK";
1464 /* IEEE 802.11 standard is not completely clear about
1465 * whether STA is considered authenticated after
1466 * authentication OK frame has been send or after it
1467 * has been ACKed. In order to reduce interoperability
1468 * issues, mark the STA authenticated before ACK. */
1469 sta->flags |= WLAN_STA_AUTH;
1470 kfree(sta->u.sta.challenge);
1471 sta->u.sta.challenge = NULL;
1472 }
1473 break;
1474 }
1475
1476 fail:
1477 pos = (__le16 *) body;
1478 *pos = cpu_to_le16(auth_alg);
1479 pos++;
1480 *pos = cpu_to_le16(auth_transaction + 1);
1481 pos++;
1482 *pos = cpu_to_le16(resp); /* status_code */
1483 pos++;
1484 olen = 6;
1485
1486 if (resp == WLAN_STATUS_SUCCESS && sta != NULL &&
1487 sta->u.sta.challenge != NULL &&
1488 auth_alg == WLAN_AUTH_SHARED_KEY && auth_transaction == 1) {
1489 u8 *tmp = (u8 *) pos;
1490 *tmp++ = WLAN_EID_CHALLENGE;
1491 *tmp++ = WLAN_AUTH_CHALLENGE_LEN;
1492 pos++;
1493 memcpy(pos, sta->u.sta.challenge, WLAN_AUTH_CHALLENGE_LEN);
1494 olen += 2 + WLAN_AUTH_CHALLENGE_LEN;
1495 }
1496
1497 prism2_send_mgmt(dev, IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_AUTH,
1498 body, olen, hdr->addr2, ap->tx_callback_auth);
1499
1500 if (sta) {
1501 sta->last_rx = jiffies;
1502 atomic_dec(&sta->users);
1503 }
1504
1505 if (resp) {
1506 PDEBUG(DEBUG_AP, "%s: " MAC_FMT " auth (alg=%d "
1507 "trans#=%d stat=%d len=%d fc=%04x) ==> %d (%s)\n",
1508 dev->name,
1509 hdr->addr2[0], hdr->addr2[1], hdr->addr2[2],
1510 hdr->addr2[3], hdr->addr2[4], hdr->addr2[5],
1511 auth_alg, auth_transaction, status_code, len,
1512 fc, resp, txt);
1513 }
1514 }
1515
1516
1517 /* Called only as a scheduled task for pending AP frames. */
1518 static void handle_assoc(local_info_t *local, struct sk_buff *skb,
1519 struct hostap_80211_rx_status *rx_stats, int reassoc)
1520 {
1521 struct net_device *dev = local->dev;
1522 struct ieee80211_hdr_4addr *hdr = (struct ieee80211_hdr_4addr *) skb->data;
1523 char body[12], *p, *lpos;
1524 int len, left;
1525 __le16 *pos;
1526 u16 resp = WLAN_STATUS_SUCCESS;
1527 struct sta_info *sta = NULL;
1528 int send_deauth = 0;
1529 char *txt = "";
1530 u8 prev_ap[ETH_ALEN];
1531
1532 left = len = skb->len - IEEE80211_MGMT_HDR_LEN;
1533
1534 if (len < (reassoc ? 10 : 4)) {
1535 PDEBUG(DEBUG_AP, "%s: handle_assoc - too short payload "
1536 "(len=%d, reassoc=%d) from " MAC_FMT "\n",
1537 dev->name, len, reassoc,
1538 hdr->addr2[0], hdr->addr2[1], hdr->addr2[2],
1539 hdr->addr2[3], hdr->addr2[4], hdr->addr2[5]);
1540 return;
1541 }
1542
1543 spin_lock_bh(&local->ap->sta_table_lock);
1544 sta = ap_get_sta(local->ap, hdr->addr2);
1545 if (sta == NULL || (sta->flags & WLAN_STA_AUTH) == 0) {
1546 spin_unlock_bh(&local->ap->sta_table_lock);
1547 txt = "trying to associate before authentication";
1548 send_deauth = 1;
1549 resp = WLAN_STATUS_UNSPECIFIED_FAILURE;
1550 sta = NULL; /* do not decrement sta->users */
1551 goto fail;
1552 }
1553 atomic_inc(&sta->users);
1554 spin_unlock_bh(&local->ap->sta_table_lock);
1555
1556 pos = (__le16 *) (skb->data + IEEE80211_MGMT_HDR_LEN);
1557 sta->capability = __le16_to_cpu(*pos);
1558 pos++; left -= 2;
1559 sta->listen_interval = __le16_to_cpu(*pos);
1560 pos++; left -= 2;
1561
1562 if (reassoc) {
1563 memcpy(prev_ap, pos, ETH_ALEN);
1564 pos++; pos++; pos++; left -= 6;
1565 } else
1566 memset(prev_ap, 0, ETH_ALEN);
1567
1568 if (left >= 2) {
1569 unsigned int ileft;
1570 unsigned char *u = (unsigned char *) pos;
1571
1572 if (*u == WLAN_EID_SSID) {
1573 u++; left--;
1574 ileft = *u;
1575 u++; left--;
1576
1577 if (ileft > left || ileft > MAX_SSID_LEN) {
1578 txt = "SSID overflow";
1579 resp = WLAN_STATUS_UNSPECIFIED_FAILURE;
1580 goto fail;
1581 }
1582
1583 if (ileft != strlen(local->essid) ||
1584 memcmp(local->essid, u, ileft) != 0) {
1585 txt = "not our SSID";
1586 resp = WLAN_STATUS_ASSOC_DENIED_UNSPEC;
1587 goto fail;
1588 }
1589
1590 u += ileft;
1591 left -= ileft;
1592 }
1593
1594 if (left >= 2 && *u == WLAN_EID_SUPP_RATES) {
1595 u++; left--;
1596 ileft = *u;
1597 u++; left--;
1598
1599 if (ileft > left || ileft == 0 ||
1600 ileft > WLAN_SUPP_RATES_MAX) {
1601 txt = "SUPP_RATES len error";
1602 resp = WLAN_STATUS_UNSPECIFIED_FAILURE;
1603 goto fail;
1604 }
1605
1606 memset(sta->supported_rates, 0,
1607 sizeof(sta->supported_rates));
1608 memcpy(sta->supported_rates, u, ileft);
1609 prism2_check_tx_rates(sta);
1610
1611 u += ileft;
1612 left -= ileft;
1613 }
1614
1615 if (left > 0) {
1616 PDEBUG(DEBUG_AP, "%s: assoc from " MAC_FMT
1617 " with extra data (%d bytes) [",
1618 dev->name,
1619 hdr->addr2[0], hdr->addr2[1], hdr->addr2[2],
1620 hdr->addr2[3], hdr->addr2[4], hdr->addr2[5],
1621 left);
1622 while (left > 0) {
1623 PDEBUG2(DEBUG_AP, "<%02x>", *u);
1624 u++; left--;
1625 }
1626 PDEBUG2(DEBUG_AP, "]\n");
1627 }
1628 } else {
1629 txt = "frame underflow";
1630 resp = WLAN_STATUS_UNSPECIFIED_FAILURE;
1631 goto fail;
1632 }
1633
1634 /* get a unique AID */
1635 if (sta->aid > 0)
1636 txt = "OK, old AID";
1637 else {
1638 spin_lock_bh(&local->ap->sta_table_lock);
1639 for (sta->aid = 1; sta->aid <= MAX_AID_TABLE_SIZE; sta->aid++)
1640 if (local->ap->sta_aid[sta->aid - 1] == NULL)
1641 break;
1642 if (sta->aid > MAX_AID_TABLE_SIZE) {
1643 sta->aid = 0;
1644 spin_unlock_bh(&local->ap->sta_table_lock);
1645 resp = WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA;
1646 txt = "no room for more AIDs";
1647 } else {
1648 local->ap->sta_aid[sta->aid - 1] = sta;
1649 spin_unlock_bh(&local->ap->sta_table_lock);
1650 txt = "OK, new AID";
1651 }
1652 }
1653
1654 fail:
1655 pos = (__le16 *) body;
1656
1657 if (send_deauth) {
1658 *pos = cpu_to_le16(WLAN_REASON_STA_REQ_ASSOC_WITHOUT_AUTH);
1659 pos++;
1660 } else {
1661 /* FIX: CF-Pollable and CF-PollReq should be set to match the
1662 * values in beacons/probe responses */
1663 /* FIX: how about privacy and WEP? */
1664 /* capability */
1665 *pos = cpu_to_le16(WLAN_CAPABILITY_ESS);
1666 pos++;
1667
1668 /* status_code */
1669 *pos = cpu_to_le16(resp);
1670 pos++;
1671
1672 *pos = cpu_to_le16((sta && sta->aid > 0 ? sta->aid : 0) |
1673 BIT(14) | BIT(15)); /* AID */
1674 pos++;
1675
1676 /* Supported rates (Information element) */
1677 p = (char *) pos;
1678 *p++ = WLAN_EID_SUPP_RATES;
1679 lpos = p;
1680 *p++ = 0; /* len */
1681 if (local->tx_rate_control & WLAN_RATE_1M) {
1682 *p++ = local->basic_rates & WLAN_RATE_1M ? 0x82 : 0x02;
1683 (*lpos)++;
1684 }
1685 if (local->tx_rate_control & WLAN_RATE_2M) {
1686 *p++ = local->basic_rates & WLAN_RATE_2M ? 0x84 : 0x04;
1687 (*lpos)++;
1688 }
1689 if (local->tx_rate_control & WLAN_RATE_5M5) {
1690 *p++ = local->basic_rates & WLAN_RATE_5M5 ?
1691 0x8b : 0x0b;
1692 (*lpos)++;
1693 }
1694 if (local->tx_rate_control & WLAN_RATE_11M) {
1695 *p++ = local->basic_rates & WLAN_RATE_11M ?
1696 0x96 : 0x16;
1697 (*lpos)++;
1698 }
1699 pos = (__le16 *) p;
1700 }
1701
1702 prism2_send_mgmt(dev, IEEE80211_FTYPE_MGMT |
1703 (send_deauth ? IEEE80211_STYPE_DEAUTH :
1704 (reassoc ? IEEE80211_STYPE_REASSOC_RESP :
1705 IEEE80211_STYPE_ASSOC_RESP)),
1706 body, (u8 *) pos - (u8 *) body,
1707 hdr->addr2,
1708 send_deauth ? 0 : local->ap->tx_callback_assoc);
1709
1710 if (sta) {
1711 if (resp == WLAN_STATUS_SUCCESS) {
1712 sta->last_rx = jiffies;
1713 /* STA will be marked associated from TX callback, if
1714 * AssocResp is ACKed */
1715 }
1716 atomic_dec(&sta->users);
1717 }
1718
1719 #if 0
1720 PDEBUG(DEBUG_AP, "%s: " MAC_FMT" %sassoc (len=%d "
1721 "prev_ap=" MAC_FMT") => %d(%d) (%s)\n",
1722 dev->name,
1723 hdr->addr2[0], hdr->addr2[1], hdr->addr2[2],
1724 hdr->addr2[3], hdr->addr2[4], hdr->addr2[5],
1725 reassoc ? "re" : "", len,
1726 prev_ap[0], prev_ap[1], prev_ap[2],
1727 prev_ap[3], prev_ap[4], prev_ap[5],
1728 resp, send_deauth, txt);
1729 #endif
1730 }
1731
1732
1733 /* Called only as a scheduled task for pending AP frames. */
1734 static void handle_deauth(local_info_t *local, struct sk_buff *skb,
1735 struct hostap_80211_rx_status *rx_stats)
1736 {
1737 struct net_device *dev = local->dev;
1738 struct ieee80211_hdr_4addr *hdr = (struct ieee80211_hdr_4addr *) skb->data;
1739 char *body = (char *) (skb->data + IEEE80211_MGMT_HDR_LEN);
1740 int len;
1741 u16 reason_code;
1742 __le16 *pos;
1743 struct sta_info *sta = NULL;
1744 DECLARE_MAC_BUF(mac);
1745
1746 len = skb->len - IEEE80211_MGMT_HDR_LEN;
1747
1748 if (len < 2) {
1749 printk("handle_deauth - too short payload (len=%d)\n", len);
1750 return;
1751 }
1752
1753 pos = (__le16 *) body;
1754 reason_code = le16_to_cpu(*pos);
1755
1756 PDEBUG(DEBUG_AP, "%s: deauthentication: " MAC_FMT " len=%d, "
1757 "reason_code=%d\n", dev->name,
1758 hdr->addr2[0], hdr->addr2[1], hdr->addr2[2],
1759 hdr->addr2[3], hdr->addr2[4], hdr->addr2[5],
1760 len, reason_code);
1761
1762 spin_lock_bh(&local->ap->sta_table_lock);
1763 sta = ap_get_sta(local->ap, hdr->addr2);
1764 if (sta != NULL) {
1765 if ((sta->flags & WLAN_STA_ASSOC) && !sta->ap)
1766 hostap_event_expired_sta(local->dev, sta);
1767 sta->flags &= ~(WLAN_STA_AUTH | WLAN_STA_ASSOC);
1768 }
1769 spin_unlock_bh(&local->ap->sta_table_lock);
1770 if (sta == NULL) {
1771 printk("%s: deauthentication from " MAC_FMT ", "
1772 "reason_code=%d, but STA not authenticated\n", dev->name,
1773 hdr->addr2[0], hdr->addr2[1], hdr->addr2[2],
1774 hdr->addr2[3], hdr->addr2[4], hdr->addr2[5],
1775 reason_code);
1776 }
1777 }
1778
1779
1780 /* Called only as a scheduled task for pending AP frames. */
1781 static void handle_disassoc(local_info_t *local, struct sk_buff *skb,
1782 struct hostap_80211_rx_status *rx_stats)
1783 {
1784 struct net_device *dev = local->dev;
1785 struct ieee80211_hdr_4addr *hdr = (struct ieee80211_hdr_4addr *) skb->data;
1786 char *body = skb->data + IEEE80211_MGMT_HDR_LEN;
1787 int len;
1788 u16 reason_code;
1789 __le16 *pos;
1790 struct sta_info *sta = NULL;
1791
1792 len = skb->len - IEEE80211_MGMT_HDR_LEN;
1793
1794 if (len < 2) {
1795 printk("handle_disassoc - too short payload (len=%d)\n", len);
1796 return;
1797 }
1798
1799 pos = (__le16 *) body;
1800 reason_code = le16_to_cpu(*pos);
1801
1802 PDEBUG(DEBUG_AP, "%s: disassociation: " MAC_FMT " len=%d, "
1803 "reason_code=%d\n", dev->name,
1804 hdr->addr2[0], hdr->addr2[1], hdr->addr2[2],
1805 hdr->addr2[3], hdr->addr2[4], hdr->addr2[5],
1806 len, reason_code);
1807
1808 spin_lock_bh(&local->ap->sta_table_lock);
1809 sta = ap_get_sta(local->ap, hdr->addr2);
1810 if (sta != NULL) {
1811 if ((sta->flags & WLAN_STA_ASSOC) && !sta->ap)
1812 hostap_event_expired_sta(local->dev, sta);
1813 sta->flags &= ~WLAN_STA_ASSOC;
1814 }
1815 spin_unlock_bh(&local->ap->sta_table_lock);
1816 if (sta == NULL) {
1817 printk("%s: disassociation from " MAC_FMT ", "
1818 "reason_code=%d, but STA not authenticated\n",
1819 dev->name,
1820 hdr->addr2[0], hdr->addr2[1], hdr->addr2[2],
1821 hdr->addr2[3], hdr->addr2[4], hdr->addr2[5],
1822 reason_code);
1823 }
1824 }
1825
1826
1827 /* Called only as a scheduled task for pending AP frames. */
1828 static void ap_handle_data_nullfunc(local_info_t *local,
1829 struct ieee80211_hdr_4addr *hdr)
1830 {
1831 struct net_device *dev = local->dev;
1832
1833 /* some STA f/w's seem to require control::ACK frame for
1834 * data::nullfunc, but at least Prism2 station f/w version 0.8.0 does
1835 * not send this..
1836 * send control::ACK for the data::nullfunc */
1837
1838 printk(KERN_DEBUG "Sending control::ACK for data::nullfunc\n");
1839 prism2_send_mgmt(dev, IEEE80211_FTYPE_CTL | IEEE80211_STYPE_ACK,
1840 NULL, 0, hdr->addr2, 0);
1841 }
1842
1843
1844 /* Called only as a scheduled task for pending AP frames. */
1845 static void ap_handle_dropped_data(local_info_t *local,
1846 struct ieee80211_hdr_4addr *hdr)
1847 {
1848 struct net_device *dev = local->dev;
1849 struct sta_info *sta;
1850 __le16 reason;
1851
1852 spin_lock_bh(&local->ap->sta_table_lock);
1853 sta = ap_get_sta(local->ap, hdr->addr2);
1854 if (sta)
1855 atomic_inc(&sta->users);
1856 spin_unlock_bh(&local->ap->sta_table_lock);
1857
1858 if (sta != NULL && (sta->flags & WLAN_STA_ASSOC)) {
1859 PDEBUG(DEBUG_AP, "ap_handle_dropped_data: STA is now okay?\n");
1860 atomic_dec(&sta->users);
1861 return;
1862 }
1863
1864 reason = cpu_to_le16(WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA);
1865 prism2_send_mgmt(dev, IEEE80211_FTYPE_MGMT |
1866 ((sta == NULL || !(sta->flags & WLAN_STA_ASSOC)) ?
1867 IEEE80211_STYPE_DEAUTH : IEEE80211_STYPE_DISASSOC),
1868 (char *) &reason, sizeof(reason), hdr->addr2, 0);
1869
1870 if (sta)
1871 atomic_dec(&sta->users);
1872 }
1873
1874 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
1875
1876
1877 /* Called only as a scheduled task for pending AP frames. */
1878 static void pspoll_send_buffered(local_info_t *local, struct sta_info *sta,
1879 struct sk_buff *skb)
1880 {
1881 struct hostap_skb_tx_data *meta;
1882
1883 if (!(sta->flags & WLAN_STA_PS)) {
1884 /* Station has moved to non-PS mode, so send all buffered
1885 * frames using normal device queue. */
1886 dev_queue_xmit(skb);
1887 return;
1888 }
1889
1890 /* add a flag for hostap_handle_sta_tx() to know that this skb should
1891 * be passed through even though STA is using PS */
1892 meta = (struct hostap_skb_tx_data *) skb->cb;
1893 meta->flags |= HOSTAP_TX_FLAGS_BUFFERED_FRAME;
1894 if (!skb_queue_empty(&sta->tx_buf)) {
1895 /* indicate to STA that more frames follow */
1896 meta->flags |= HOSTAP_TX_FLAGS_ADD_MOREDATA;
1897 }
1898 dev_queue_xmit(skb);
1899 }
1900
1901
1902 /* Called only as a scheduled task for pending AP frames. */
1903 static void handle_pspoll(local_info_t *local,
1904 struct ieee80211_hdr_4addr *hdr,
1905 struct hostap_80211_rx_status *rx_stats)
1906 {
1907 struct net_device *dev = local->dev;
1908 struct sta_info *sta;
1909 u16 aid;
1910 struct sk_buff *skb;
1911
1912 PDEBUG(DEBUG_PS2, "handle_pspoll: BSSID=" MAC_FMT
1913 ", TA=" MAC_FMT " PWRMGT=%d\n",
1914 hdr->addr1[0], hdr->addr1[1], hdr->addr1[2],
1915 hdr->addr1[3], hdr->addr1[4], hdr->addr1[5],
1916 hdr->addr2[0], hdr->addr2[1], hdr->addr2[2],
1917 hdr->addr2[3], hdr->addr2[4], hdr->addr2[5],
1918 !!(le16_to_cpu(hdr->frame_ctl) & IEEE80211_FCTL_PM));
1919
1920 if (memcmp(hdr->addr1, dev->dev_addr, ETH_ALEN)) {
1921 PDEBUG(DEBUG_AP, "handle_pspoll - addr1(BSSID)=" MAC_FMT
1922 " not own MAC\n",
1923 hdr->addr1[0], hdr->addr1[1], hdr->addr1[2],
1924 hdr->addr1[3], hdr->addr1[4], hdr->addr1[5]);
1925 return;
1926 }
1927
1928 aid = le16_to_cpu(hdr->duration_id);
1929 if ((aid & (BIT(15) | BIT(14))) != (BIT(15) | BIT(14))) {
1930 PDEBUG(DEBUG_PS, " PSPOLL and AID[15:14] not set\n");
1931 return;
1932 }
1933 aid &= ~(BIT(15) | BIT(14));
1934 if (aid == 0 || aid > MAX_AID_TABLE_SIZE) {
1935 PDEBUG(DEBUG_PS, " invalid aid=%d\n", aid);
1936 return;
1937 }
1938 PDEBUG(DEBUG_PS2, " aid=%d\n", aid);
1939
1940 spin_lock_bh(&local->ap->sta_table_lock);
1941 sta = ap_get_sta(local->ap, hdr->addr2);
1942 if (sta)
1943 atomic_inc(&sta->users);
1944 spin_unlock_bh(&local->ap->sta_table_lock);
1945
1946 if (sta == NULL) {
1947 PDEBUG(DEBUG_PS, " STA not found\n");
1948 return;
1949 }
1950 if (sta->aid != aid) {
1951 PDEBUG(DEBUG_PS, " received aid=%i does not match with "
1952 "assoc.aid=%d\n", aid, sta->aid);
1953 return;
1954 }
1955
1956 /* FIX: todo:
1957 * - add timeout for buffering (clear aid in TIM vector if buffer timed
1958 * out (expiry time must be longer than ListenInterval for
1959 * the corresponding STA; "8802-11: 11.2.1.9 AP aging function"
1960 * - what to do, if buffered, pspolled, and sent frame is not ACKed by
1961 * sta; store buffer for later use and leave TIM aid bit set? use
1962 * TX event to check whether frame was ACKed?
1963 */
1964
1965 while ((skb = skb_dequeue(&sta->tx_buf)) != NULL) {
1966 /* send buffered frame .. */
1967 PDEBUG(DEBUG_PS2, "Sending buffered frame to STA after PS POLL"
1968 " (buffer_count=%d)\n", skb_queue_len(&sta->tx_buf));
1969
1970 pspoll_send_buffered(local, sta, skb);
1971
1972 if (sta->flags & WLAN_STA_PS) {
1973 /* send only one buffered packet per PS Poll */
1974 /* FIX: should ignore further PS Polls until the
1975 * buffered packet that was just sent is acknowledged
1976 * (Tx or TxExc event) */
1977 break;
1978 }
1979 }
1980
1981 if (skb_queue_empty(&sta->tx_buf)) {
1982 /* try to clear aid from TIM */
1983 if (!(sta->flags & WLAN_STA_TIM))
1984 PDEBUG(DEBUG_PS2, "Re-unsetting TIM for aid %d\n",
1985 aid);
1986 hostap_set_tim(local, aid, 0);
1987 sta->flags &= ~WLAN_STA_TIM;
1988 }
1989
1990 atomic_dec(&sta->users);
1991 }
1992
1993
1994 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
1995
1996 static void handle_wds_oper_queue(struct work_struct *work)
1997 {
1998 struct ap_data *ap = container_of(work, struct ap_data,
1999 wds_oper_queue);
2000 local_info_t *local = ap->local;
2001 struct wds_oper_data *entry, *prev;
2002
2003 spin_lock_bh(&local->lock);
2004 entry = local->ap->wds_oper_entries;
2005 local->ap->wds_oper_entries = NULL;
2006 spin_unlock_bh(&local->lock);
2007
2008 while (entry) {
2009 PDEBUG(DEBUG_AP, "%s: %s automatic WDS connection "
2010 "to AP " MAC_FMT "\n",
2011 local->dev->name,
2012 entry->type == WDS_ADD ? "adding" : "removing",
2013 entry->addr[0], entry->addr[1], entry->addr[2],
2014 entry->addr[3], entry->addr[4], entry->addr[5]);
2015 if (entry->type == WDS_ADD)
2016 prism2_wds_add(local, entry->addr, 0);
2017 else if (entry->type == WDS_DEL)
2018 prism2_wds_del(local, entry->addr, 0, 1);
2019
2020 prev = entry;
2021 entry = entry->next;
2022 kfree(prev);
2023 }
2024 }
2025
2026
2027 /* Called only as a scheduled task for pending AP frames. */
2028 static void handle_beacon(local_info_t *local, struct sk_buff *skb,
2029 struct hostap_80211_rx_status *rx_stats)
2030 {
2031 struct ieee80211_hdr_4addr *hdr = (struct ieee80211_hdr_4addr *) skb->data;
2032 char *body = skb->data + IEEE80211_MGMT_HDR_LEN;
2033 int len, left;
2034 u16 beacon_int, capability;
2035 __le16 *pos;
2036 char *ssid = NULL;
2037 unsigned char *supp_rates = NULL;
2038 int ssid_len = 0, supp_rates_len = 0;
2039 struct sta_info *sta = NULL;
2040 int new_sta = 0, channel = -1;
2041
2042 len = skb->len - IEEE80211_MGMT_HDR_LEN;
2043
2044 if (len < 8 + 2 + 2) {
2045 printk(KERN_DEBUG "handle_beacon - too short payload "
2046 "(len=%d)\n", len);
2047 return;
2048 }
2049
2050 pos = (__le16 *) body;
2051 left = len;
2052
2053 /* Timestamp (8 octets) */
2054 pos += 4; left -= 8;
2055 /* Beacon interval (2 octets) */
2056 beacon_int = le16_to_cpu(*pos);
2057 pos++; left -= 2;
2058 /* Capability information (2 octets) */
2059 capability = le16_to_cpu(*pos);
2060 pos++; left -= 2;
2061
2062 if (local->ap->ap_policy != AP_OTHER_AP_EVEN_IBSS &&
2063 capability & WLAN_CAPABILITY_IBSS)
2064 return;
2065
2066 if (left >= 2) {
2067 unsigned int ileft;
2068 unsigned char *u = (unsigned char *) pos;
2069
2070 if (*u == WLAN_EID_SSID) {
2071 u++; left--;
2072 ileft = *u;
2073 u++; left--;
2074
2075 if (ileft > left || ileft > MAX_SSID_LEN) {
2076 PDEBUG(DEBUG_AP, "SSID: overflow\n");
2077 return;
2078 }
2079
2080 if (local->ap->ap_policy == AP_OTHER_AP_SAME_SSID &&
2081 (ileft != strlen(local->essid) ||
2082 memcmp(local->essid, u, ileft) != 0)) {
2083 /* not our SSID */
2084 return;
2085 }
2086
2087 ssid = u;
2088 ssid_len = ileft;
2089
2090 u += ileft;
2091 left -= ileft;
2092 }
2093
2094 if (*u == WLAN_EID_SUPP_RATES) {
2095 u++; left--;
2096 ileft = *u;
2097 u++; left--;
2098
2099 if (ileft > left || ileft == 0 || ileft > 8) {
2100 PDEBUG(DEBUG_AP, " - SUPP_RATES len error\n");
2101 return;
2102 }
2103
2104 supp_rates = u;
2105 supp_rates_len = ileft;
2106
2107 u += ileft;
2108 left -= ileft;
2109 }
2110
2111 if (*u == WLAN_EID_DS_PARAMS) {
2112 u++; left--;
2113 ileft = *u;
2114 u++; left--;
2115
2116 if (ileft > left || ileft != 1) {
2117 PDEBUG(DEBUG_AP, " - DS_PARAMS len error\n");
2118 return;
2119 }
2120
2121 channel = *u;
2122
2123 u += ileft;
2124 left -= ileft;
2125 }
2126 }
2127
2128 spin_lock_bh(&local->ap->sta_table_lock);
2129 sta = ap_get_sta(local->ap, hdr->addr2);
2130 if (sta != NULL)
2131 atomic_inc(&sta->users);
2132 spin_unlock_bh(&local->ap->sta_table_lock);
2133
2134 if (sta == NULL) {
2135 /* add new AP */
2136 new_sta = 1;
2137 sta = ap_add_sta(local->ap, hdr->addr2);
2138 if (sta == NULL) {
2139 printk(KERN_INFO "prism2: kmalloc failed for AP "
2140 "data structure\n");
2141 return;
2142 }
2143 hostap_event_new_sta(local->dev, sta);
2144
2145 /* mark APs authentication and associated for pseudo ad-hoc
2146 * style communication */
2147 sta->flags = WLAN_STA_AUTH | WLAN_STA_ASSOC;
2148
2149 if (local->ap->autom_ap_wds) {
2150 hostap_wds_link_oper(local, sta->addr, WDS_ADD);
2151 }
2152 }
2153
2154 sta->ap = 1;
2155 if (ssid) {
2156 sta->u.ap.ssid_len = ssid_len;
2157 memcpy(sta->u.ap.ssid, ssid, ssid_len);
2158 sta->u.ap.ssid[ssid_len] = '\0';
2159 } else {
2160 sta->u.ap.ssid_len = 0;
2161 sta->u.ap.ssid[0] = '\0';
2162 }
2163 sta->u.ap.channel = channel;
2164 sta->rx_packets++;
2165 sta->rx_bytes += len;
2166 sta->u.ap.last_beacon = sta->last_rx = jiffies;
2167 sta->capability = capability;
2168 sta->listen_interval = beacon_int;
2169
2170 atomic_dec(&sta->users);
2171
2172 if (new_sta) {
2173 memset(sta->supported_rates, 0, sizeof(sta->supported_rates));
2174 memcpy(sta->supported_rates, supp_rates, supp_rates_len);
2175 prism2_check_tx_rates(sta);
2176 }
2177 }
2178
2179 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
2180
2181
2182 /* Called only as a tasklet. */
2183 static void handle_ap_item(local_info_t *local, struct sk_buff *skb,
2184 struct hostap_80211_rx_status *rx_stats)
2185 {
2186 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
2187 struct net_device *dev = local->dev;
2188 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
2189 u16 fc, type, stype;
2190 struct ieee80211_hdr_4addr *hdr;
2191
2192 /* FIX: should give skb->len to handler functions and check that the
2193 * buffer is long enough */
2194 hdr = (struct ieee80211_hdr_4addr *) skb->data;
2195 fc = le16_to_cpu(hdr->frame_ctl);
2196 type = WLAN_FC_GET_TYPE(fc);
2197 stype = WLAN_FC_GET_STYPE(fc);
2198
2199 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
2200 if (!local->hostapd && type == IEEE80211_FTYPE_DATA) {
2201 PDEBUG(DEBUG_AP, "handle_ap_item - data frame\n");
2202
2203 if (!(fc & IEEE80211_FCTL_TODS) ||
2204 (fc & IEEE80211_FCTL_FROMDS)) {
2205 if (stype == IEEE80211_STYPE_NULLFUNC) {
2206 /* no ToDS nullfunc seems to be used to check
2207 * AP association; so send reject message to
2208 * speed up re-association */
2209 ap_handle_dropped_data(local, hdr);
2210 goto done;
2211 }
2212 PDEBUG(DEBUG_AP, " not ToDS frame (fc=0x%04x)\n",
2213 fc);
2214 goto done;
2215 }
2216
2217 if (memcmp(hdr->addr1, dev->dev_addr, ETH_ALEN)) {
2218 PDEBUG(DEBUG_AP, "handle_ap_item - addr1(BSSID)="
2219 MAC_FMT " not own MAC\n",
2220 hdr->addr1[0], hdr->addr1[1], hdr->addr1[2],
2221 hdr->addr1[3], hdr->addr1[4], hdr->addr1[5]);
2222 goto done;
2223 }
2224
2225 if (local->ap->nullfunc_ack &&
2226 stype == IEEE80211_STYPE_NULLFUNC)
2227 ap_handle_data_nullfunc(local, hdr);
2228 else
2229 ap_handle_dropped_data(local, hdr);
2230 goto done;
2231 }
2232
2233 if (type == IEEE80211_FTYPE_MGMT && stype == IEEE80211_STYPE_BEACON) {
2234 handle_beacon(local, skb, rx_stats);
2235 goto done;
2236 }
2237 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
2238
2239 if (type == IEEE80211_FTYPE_CTL && stype == IEEE80211_STYPE_PSPOLL) {
2240 handle_pspoll(local, hdr, rx_stats);
2241 goto done;
2242 }
2243
2244 if (local->hostapd) {
2245 PDEBUG(DEBUG_AP, "Unknown frame in AP queue: type=0x%02x "
2246 "subtype=0x%02x\n", type, stype);
2247 goto done;
2248 }
2249
2250 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
2251 if (type != IEEE80211_FTYPE_MGMT) {
2252 PDEBUG(DEBUG_AP, "handle_ap_item - not a management frame?\n");
2253 goto done;
2254 }
2255
2256 if (memcmp(hdr->addr1, dev->dev_addr, ETH_ALEN)) {
2257 PDEBUG(DEBUG_AP, "handle_ap_item - addr1(DA)=" MAC_FMT
2258 " not own MAC\n",
2259 hdr->addr1[0], hdr->addr1[1], hdr->addr1[2],
2260 hdr->addr1[3], hdr->addr1[4], hdr->addr1[5]);
2261 goto done;
2262 }
2263
2264 if (memcmp(hdr->addr3, dev->dev_addr, ETH_ALEN)) {
2265 PDEBUG(DEBUG_AP, "handle_ap_item - addr3(BSSID)=" MAC_FMT
2266 " not own MAC\n",
2267 hdr->addr3[0], hdr->addr3[1], hdr->addr3[2],
2268 hdr->addr3[3], hdr->addr3[4], hdr->addr3[5]);
2269 goto done;
2270 }
2271
2272 switch (stype) {
2273 case IEEE80211_STYPE_ASSOC_REQ:
2274 handle_assoc(local, skb, rx_stats, 0);
2275 break;
2276 case IEEE80211_STYPE_ASSOC_RESP:
2277 PDEBUG(DEBUG_AP, "==> ASSOC RESP (ignored)\n");
2278 break;
2279 case IEEE80211_STYPE_REASSOC_REQ:
2280 handle_assoc(local, skb, rx_stats, 1);
2281 break;
2282 case IEEE80211_STYPE_REASSOC_RESP:
2283 PDEBUG(DEBUG_AP, "==> REASSOC RESP (ignored)\n");
2284 break;
2285 case IEEE80211_STYPE_ATIM:
2286 PDEBUG(DEBUG_AP, "==> ATIM (ignored)\n");
2287 break;
2288 case IEEE80211_STYPE_DISASSOC:
2289 handle_disassoc(local, skb, rx_stats);
2290 break;
2291 case IEEE80211_STYPE_AUTH:
2292 handle_authen(local, skb, rx_stats);
2293 break;
2294 case IEEE80211_STYPE_DEAUTH:
2295 handle_deauth(local, skb, rx_stats);
2296 break;
2297 default:
2298 PDEBUG(DEBUG_AP, "Unknown mgmt frame subtype 0x%02x\n",
2299 stype >> 4);
2300 break;
2301 }
2302 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
2303
2304 done:
2305 dev_kfree_skb(skb);
2306 }
2307
2308
2309 /* Called only as a tasklet (software IRQ) */
2310 void hostap_rx(struct net_device *dev, struct sk_buff *skb,
2311 struct hostap_80211_rx_status *rx_stats)
2312 {
2313 struct hostap_interface *iface;
2314 local_info_t *local;
2315 u16 fc;
2316 struct ieee80211_hdr_4addr *hdr;
2317
2318 iface = netdev_priv(dev);
2319 local = iface->local;
2320
2321 if (skb->len < 16)
2322 goto drop;
2323
2324 local->stats.rx_packets++;
2325
2326 hdr = (struct ieee80211_hdr_4addr *) skb->data;
2327 fc = le16_to_cpu(hdr->frame_ctl);
2328
2329 if (local->ap->ap_policy == AP_OTHER_AP_SKIP_ALL &&
2330 WLAN_FC_GET_TYPE(fc) == IEEE80211_FTYPE_MGMT &&
2331 WLAN_FC_GET_STYPE(fc) == IEEE80211_STYPE_BEACON)
2332 goto drop;
2333
2334 skb->protocol = __constant_htons(ETH_P_HOSTAP);
2335 handle_ap_item(local, skb, rx_stats);
2336 return;
2337
2338 drop:
2339 dev_kfree_skb(skb);
2340 }
2341
2342
2343 /* Called only as a tasklet (software IRQ) */
2344 static void schedule_packet_send(local_info_t *local, struct sta_info *sta)
2345 {
2346 struct sk_buff *skb;
2347 struct ieee80211_hdr_4addr *hdr;
2348 struct hostap_80211_rx_status rx_stats;
2349
2350 if (skb_queue_empty(&sta->tx_buf))
2351 return;
2352
2353 skb = dev_alloc_skb(16);
2354 if (skb == NULL) {
2355 printk(KERN_DEBUG "%s: schedule_packet_send: skb alloc "
2356 "failed\n", local->dev->name);
2357 return;
2358 }
2359
2360 hdr = (struct ieee80211_hdr_4addr *) skb_put(skb, 16);
2361
2362 /* Generate a fake pspoll frame to start packet delivery */
2363 hdr->frame_ctl = __constant_cpu_to_le16(
2364 IEEE80211_FTYPE_CTL | IEEE80211_STYPE_PSPOLL);
2365 memcpy(hdr->addr1, local->dev->dev_addr, ETH_ALEN);
2366 memcpy(hdr->addr2, sta->addr, ETH_ALEN);
2367 hdr->duration_id = cpu_to_le16(sta->aid | BIT(15) | BIT(14));
2368
2369 PDEBUG(DEBUG_PS2, "%s: Scheduling buffered packet delivery for STA "
2370 MAC_FMT "\n", local->dev->name,
2371 sta->addr[0], sta->addr[1], sta->addr[2],
2372 sta->addr[3], sta->addr[4], sta->addr[5]);
2373
2374 skb->dev = local->dev;
2375
2376 memset(&rx_stats, 0, sizeof(rx_stats));
2377 hostap_rx(local->dev, skb, &rx_stats);
2378 }
2379
2380
2381 int prism2_ap_get_sta_qual(local_info_t *local, struct sockaddr addr[],
2382 struct iw_quality qual[], int buf_size,
2383 int aplist)
2384 {
2385 struct ap_data *ap = local->ap;
2386 struct list_head *ptr;
2387 int count = 0;
2388
2389 spin_lock_bh(&ap->sta_table_lock);
2390
2391 for (ptr = ap->sta_list.next; ptr != NULL && ptr != &ap->sta_list;
2392 ptr = ptr->next) {
2393 struct sta_info *sta = (struct sta_info *) ptr;
2394
2395 if (aplist && !sta->ap)
2396 continue;
2397 addr[count].sa_family = ARPHRD_ETHER;
2398 memcpy(addr[count].sa_data, sta->addr, ETH_ALEN);
2399 if (sta->last_rx_silence == 0)
2400 qual[count].qual = sta->last_rx_signal < 27 ?
2401 0 : (sta->last_rx_signal - 27) * 92 / 127;
2402 else
2403 qual[count].qual = sta->last_rx_signal -
2404 sta->last_rx_silence - 35;
2405 qual[count].level = HFA384X_LEVEL_TO_dBm(sta->last_rx_signal);
2406 qual[count].noise = HFA384X_LEVEL_TO_dBm(sta->last_rx_silence);
2407 qual[count].updated = sta->last_rx_updated;
2408
2409 sta->last_rx_updated = IW_QUAL_DBM;
2410
2411 count++;
2412 if (count >= buf_size)
2413 break;
2414 }
2415 spin_unlock_bh(&ap->sta_table_lock);
2416
2417 return count;
2418 }
2419
2420
2421 /* Translate our list of Access Points & Stations to a card independant
2422 * format that the Wireless Tools will understand - Jean II */
2423 int prism2_ap_translate_scan(struct net_device *dev,
2424 struct iw_request_info *info, char *buffer)
2425 {
2426 struct hostap_interface *iface;
2427 local_info_t *local;
2428 struct ap_data *ap;
2429 struct list_head *ptr;
2430 struct iw_event iwe;
2431 char *current_ev = buffer;
2432 char *end_buf = buffer + IW_SCAN_MAX_DATA;
2433 #if !defined(PRISM2_NO_KERNEL_IEEE80211_MGMT)
2434 char buf[64];
2435 #endif
2436
2437 iface = netdev_priv(dev);
2438 local = iface->local;
2439 ap = local->ap;
2440
2441 spin_lock_bh(&ap->sta_table_lock);
2442
2443 for (ptr = ap->sta_list.next; ptr != NULL && ptr != &ap->sta_list;
2444 ptr = ptr->next) {
2445 struct sta_info *sta = (struct sta_info *) ptr;
2446
2447 /* First entry *MUST* be the AP MAC address */
2448 memset(&iwe, 0, sizeof(iwe));
2449 iwe.cmd = SIOCGIWAP;
2450 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
2451 memcpy(iwe.u.ap_addr.sa_data, sta->addr, ETH_ALEN);
2452 iwe.len = IW_EV_ADDR_LEN;
2453 current_ev = iwe_stream_add_event(info, current_ev, end_buf,
2454 &iwe, IW_EV_ADDR_LEN);
2455
2456 /* Use the mode to indicate if it's a station or
2457 * an Access Point */
2458 memset(&iwe, 0, sizeof(iwe));
2459 iwe.cmd = SIOCGIWMODE;
2460 if (sta->ap)
2461 iwe.u.mode = IW_MODE_MASTER;
2462 else
2463 iwe.u.mode = IW_MODE_INFRA;
2464 iwe.len = IW_EV_UINT_LEN;
2465 current_ev = iwe_stream_add_event(info, current_ev, end_buf,
2466 &iwe, IW_EV_UINT_LEN);
2467
2468 /* Some quality */
2469 memset(&iwe, 0, sizeof(iwe));
2470 iwe.cmd = IWEVQUAL;
2471 if (sta->last_rx_silence == 0)
2472 iwe.u.qual.qual = sta->last_rx_signal < 27 ?
2473 0 : (sta->last_rx_signal - 27) * 92 / 127;
2474 else
2475 iwe.u.qual.qual = sta->last_rx_signal -
2476 sta->last_rx_silence - 35;
2477 iwe.u.qual.level = HFA384X_LEVEL_TO_dBm(sta->last_rx_signal);
2478 iwe.u.qual.noise = HFA384X_LEVEL_TO_dBm(sta->last_rx_silence);
2479 iwe.u.qual.updated = sta->last_rx_updated;
2480 iwe.len = IW_EV_QUAL_LEN;
2481 current_ev = iwe_stream_add_event(info, current_ev, end_buf,
2482 &iwe, IW_EV_QUAL_LEN);
2483
2484 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
2485 if (sta->ap) {
2486 memset(&iwe, 0, sizeof(iwe));
2487 iwe.cmd = SIOCGIWESSID;
2488 iwe.u.data.length = sta->u.ap.ssid_len;
2489 iwe.u.data.flags = 1;
2490 current_ev = iwe_stream_add_point(info, current_ev,
2491 end_buf, &iwe,
2492 sta->u.ap.ssid);
2493
2494 memset(&iwe, 0, sizeof(iwe));
2495 iwe.cmd = SIOCGIWENCODE;
2496 if (sta->capability & WLAN_CAPABILITY_PRIVACY)
2497 iwe.u.data.flags =
2498 IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
2499 else
2500 iwe.u.data.flags = IW_ENCODE_DISABLED;
2501 current_ev = iwe_stream_add_point(info, current_ev,
2502 end_buf, &iwe,
2503 sta->u.ap.ssid);
2504
2505 if (sta->u.ap.channel > 0 &&
2506 sta->u.ap.channel <= FREQ_COUNT) {
2507 memset(&iwe, 0, sizeof(iwe));
2508 iwe.cmd = SIOCGIWFREQ;
2509 iwe.u.freq.m = freq_list[sta->u.ap.channel - 1]
2510 * 100000;
2511 iwe.u.freq.e = 1;
2512 current_ev = iwe_stream_add_event(
2513 info, current_ev, end_buf, &iwe,
2514 IW_EV_FREQ_LEN);
2515 }
2516
2517 memset(&iwe, 0, sizeof(iwe));
2518 iwe.cmd = IWEVCUSTOM;
2519 sprintf(buf, "beacon_interval=%d",
2520 sta->listen_interval);
2521 iwe.u.data.length = strlen(buf);
2522 current_ev = iwe_stream_add_point(info, current_ev,
2523 end_buf, &iwe, buf);
2524 }
2525 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
2526
2527 sta->last_rx_updated = IW_QUAL_DBM;
2528
2529 /* To be continued, we should make good use of IWEVCUSTOM */
2530 }
2531
2532 spin_unlock_bh(&ap->sta_table_lock);
2533
2534 return current_ev - buffer;
2535 }
2536
2537
2538 static int prism2_hostapd_add_sta(struct ap_data *ap,
2539 struct prism2_hostapd_param *param)
2540 {
2541 struct sta_info *sta;
2542
2543 spin_lock_bh(&ap->sta_table_lock);
2544 sta = ap_get_sta(ap, param->sta_addr);
2545 if (sta)
2546 atomic_inc(&sta->users);
2547 spin_unlock_bh(&ap->sta_table_lock);
2548
2549 if (sta == NULL) {
2550 sta = ap_add_sta(ap, param->sta_addr);
2551 if (sta == NULL)
2552 return -1;
2553 }
2554
2555 if (!(sta->flags & WLAN_STA_ASSOC) && !sta->ap && sta->local)
2556 hostap_event_new_sta(sta->local->dev, sta);
2557
2558 sta->flags |= WLAN_STA_AUTH | WLAN_STA_ASSOC;
2559 sta->last_rx = jiffies;
2560 sta->aid = param->u.add_sta.aid;
2561 sta->capability = param->u.add_sta.capability;
2562 sta->tx_supp_rates = param->u.add_sta.tx_supp_rates;
2563 if (sta->tx_supp_rates & WLAN_RATE_1M)
2564 sta->supported_rates[0] = 2;
2565 if (sta->tx_supp_rates & WLAN_RATE_2M)
2566 sta->supported_rates[1] = 4;
2567 if (sta->tx_supp_rates & WLAN_RATE_5M5)
2568 sta->supported_rates[2] = 11;
2569 if (sta->tx_supp_rates & WLAN_RATE_11M)
2570 sta->supported_rates[3] = 22;
2571 prism2_check_tx_rates(sta);
2572 atomic_dec(&sta->users);
2573 return 0;
2574 }
2575
2576
2577 static int prism2_hostapd_remove_sta(struct ap_data *ap,
2578 struct prism2_hostapd_param *param)
2579 {
2580 struct sta_info *sta;
2581
2582 spin_lock_bh(&ap->sta_table_lock);
2583 sta = ap_get_sta(ap, param->sta_addr);
2584 if (sta) {
2585 ap_sta_hash_del(ap, sta);
2586 list_del(&sta->list);
2587 }
2588 spin_unlock_bh(&ap->sta_table_lock);
2589
2590 if (!sta)
2591 return -ENOENT;
2592
2593 if ((sta->flags & WLAN_STA_ASSOC) && !sta->ap && sta->local)
2594 hostap_event_expired_sta(sta->local->dev, sta);
2595 ap_free_sta(ap, sta);
2596
2597 return 0;
2598 }
2599
2600
2601 static int prism2_hostapd_get_info_sta(struct ap_data *ap,
2602 struct prism2_hostapd_param *param)
2603 {
2604 struct sta_info *sta;
2605
2606 spin_lock_bh(&ap->sta_table_lock);
2607 sta = ap_get_sta(ap, param->sta_addr);
2608 if (sta)
2609 atomic_inc(&sta->users);
2610 spin_unlock_bh(&ap->sta_table_lock);
2611
2612 if (!sta)
2613 return -ENOENT;
2614
2615 param->u.get_info_sta.inactive_sec = (jiffies - sta->last_rx) / HZ;
2616
2617 atomic_dec(&sta->users);
2618
2619 return 1;
2620 }
2621
2622
2623 static int prism2_hostapd_set_flags_sta(struct ap_data *ap,
2624 struct prism2_hostapd_param *param)
2625 {
2626 struct sta_info *sta;
2627
2628 spin_lock_bh(&ap->sta_table_lock);
2629 sta = ap_get_sta(ap, param->sta_addr);
2630 if (sta) {
2631 sta->flags |= param->u.set_flags_sta.flags_or;
2632 sta->flags &= param->u.set_flags_sta.flags_and;
2633 }
2634 spin_unlock_bh(&ap->sta_table_lock);
2635
2636 if (!sta)
2637 return -ENOENT;
2638
2639 return 0;
2640 }
2641
2642
2643 static int prism2_hostapd_sta_clear_stats(struct ap_data *ap,
2644 struct prism2_hostapd_param *param)
2645 {
2646 struct sta_info *sta;
2647 int rate;
2648
2649 spin_lock_bh(&ap->sta_table_lock);
2650 sta = ap_get_sta(ap, param->sta_addr);
2651 if (sta) {
2652 sta->rx_packets = sta->tx_packets = 0;
2653 sta->rx_bytes = sta->tx_bytes = 0;
2654 for (rate = 0; rate < WLAN_RATE_COUNT; rate++) {
2655 sta->tx_count[rate] = 0;
2656 sta->rx_count[rate] = 0;
2657 }
2658 }
2659 spin_unlock_bh(&ap->sta_table_lock);
2660
2661 if (!sta)
2662 return -ENOENT;
2663
2664 return 0;
2665 }
2666
2667
2668 int prism2_hostapd(struct ap_data *ap, struct prism2_hostapd_param *param)
2669 {
2670 switch (param->cmd) {
2671 case PRISM2_HOSTAPD_FLUSH:
2672 ap_control_kickall(ap);
2673 return 0;
2674 case PRISM2_HOSTAPD_ADD_STA:
2675 return prism2_hostapd_add_sta(ap, param);
2676 case PRISM2_HOSTAPD_REMOVE_STA:
2677 return prism2_hostapd_remove_sta(ap, param);
2678 case PRISM2_HOSTAPD_GET_INFO_STA:
2679 return prism2_hostapd_get_info_sta(ap, param);
2680 case PRISM2_HOSTAPD_SET_FLAGS_STA:
2681 return prism2_hostapd_set_flags_sta(ap, param);
2682 case PRISM2_HOSTAPD_STA_CLEAR_STATS:
2683 return prism2_hostapd_sta_clear_stats(ap, param);
2684 default:
2685 printk(KERN_WARNING "prism2_hostapd: unknown cmd=%d\n",
2686 param->cmd);
2687 return -EOPNOTSUPP;
2688 }
2689 }
2690
2691
2692 /* Update station info for host-based TX rate control and return current
2693 * TX rate */
2694 static int ap_update_sta_tx_rate(struct sta_info *sta, struct net_device *dev)
2695 {
2696 int ret = sta->tx_rate;
2697 struct hostap_interface *iface;
2698 local_info_t *local;
2699
2700 iface = netdev_priv(dev);
2701 local = iface->local;
2702
2703 sta->tx_count[sta->tx_rate_idx]++;
2704 sta->tx_since_last_failure++;
2705 sta->tx_consecutive_exc = 0;
2706 if (sta->tx_since_last_failure >= WLAN_RATE_UPDATE_COUNT &&
2707 sta->tx_rate_idx < sta->tx_max_rate) {
2708 /* use next higher rate */
2709 int old_rate, new_rate;
2710 old_rate = new_rate = sta->tx_rate_idx;
2711 while (new_rate < sta->tx_max_rate) {
2712 new_rate++;
2713 if (ap_tx_rate_ok(new_rate, sta, local)) {
2714 sta->tx_rate_idx = new_rate;
2715 break;
2716 }
2717 }
2718 if (old_rate != sta->tx_rate_idx) {
2719 switch (sta->tx_rate_idx) {
2720 case 0: sta->tx_rate = 10; break;
2721 case 1: sta->tx_rate = 20; break;
2722 case 2: sta->tx_rate = 55; break;
2723 case 3: sta->tx_rate = 110; break;
2724 default: sta->tx_rate = 0; break;
2725 }
2726 PDEBUG(DEBUG_AP, "%s: STA " MAC_FMT
2727 " TX rate raised to %d\n",
2728 dev->name,
2729 sta->addr[0], sta->addr[1], sta->addr[2],
2730 sta->addr[3], sta->addr[4], sta->addr[5],
2731 sta->tx_rate);
2732 }
2733 sta->tx_since_last_failure = 0;
2734 }
2735
2736 return ret;
2737 }
2738
2739
2740 /* Called only from software IRQ. Called for each TX frame prior possible
2741 * encryption and transmit. */
2742 ap_tx_ret hostap_handle_sta_tx(local_info_t *local, struct hostap_tx_data *tx)
2743 {
2744 struct sta_info *sta = NULL;
2745 struct sk_buff *skb = tx->skb;
2746 int set_tim, ret;
2747 struct ieee80211_hdr_4addr *hdr;
2748 struct hostap_skb_tx_data *meta;
2749
2750 meta = (struct hostap_skb_tx_data *) skb->cb;
2751 ret = AP_TX_CONTINUE;
2752 if (local->ap == NULL || skb->len < 10 ||
2753 meta->iface->type == HOSTAP_INTERFACE_STA)
2754 goto out;
2755
2756 hdr = (struct ieee80211_hdr_4addr *) skb->data;
2757
2758 if (hdr->addr1[0] & 0x01) {
2759 /* broadcast/multicast frame - no AP related processing */
2760 if (local->ap->num_sta <= 0)
2761 ret = AP_TX_DROP;
2762 goto out;
2763 }
2764
2765 /* unicast packet - check whether destination STA is associated */
2766 spin_lock(&local->ap->sta_table_lock);
2767 sta = ap_get_sta(local->ap, hdr->addr1);
2768 if (sta)
2769 atomic_inc(&sta->users);
2770 spin_unlock(&local->ap->sta_table_lock);
2771
2772 if (local->iw_mode == IW_MODE_MASTER && sta == NULL &&
2773 !(meta->flags & HOSTAP_TX_FLAGS_WDS) &&
2774 meta->iface->type != HOSTAP_INTERFACE_MASTER &&
2775 meta->iface->type != HOSTAP_INTERFACE_AP) {
2776 #if 0
2777 /* This can happen, e.g., when wlan0 is added to a bridge and
2778 * bridging code does not know which port is the correct target
2779 * for a unicast frame. In this case, the packet is send to all
2780 * ports of the bridge. Since this is a valid scenario, do not
2781 * print out any errors here. */
2782 if (net_ratelimit()) {
2783 printk(KERN_DEBUG "AP: drop packet to non-associated "
2784 "STA " MAC_FMT "\n",
2785 hdr->addr1[0], hdr->addr1[1], hdr->addr1[2],
2786 hdr->addr1[3], hdr->addr1[4], hdr->addr1[5]);
2787 }
2788 #endif
2789 local->ap->tx_drop_nonassoc++;
2790 ret = AP_TX_DROP;
2791 goto out;
2792 }
2793
2794 if (sta == NULL)
2795 goto out;
2796
2797 if (!(sta->flags & WLAN_STA_AUTHORIZED))
2798 ret = AP_TX_CONTINUE_NOT_AUTHORIZED;
2799
2800 /* Set tx_rate if using host-based TX rate control */
2801 if (!local->fw_tx_rate_control)
2802 local->ap->last_tx_rate = meta->rate =
2803 ap_update_sta_tx_rate(sta, local->dev);
2804
2805 if (local->iw_mode != IW_MODE_MASTER)
2806 goto out;
2807
2808 if (!(sta->flags & WLAN_STA_PS))
2809 goto out;
2810
2811 if (meta->flags & HOSTAP_TX_FLAGS_ADD_MOREDATA) {
2812 /* indicate to STA that more frames follow */
2813 hdr->frame_ctl |=
2814 __constant_cpu_to_le16(IEEE80211_FCTL_MOREDATA);
2815 }
2816
2817 if (meta->flags & HOSTAP_TX_FLAGS_BUFFERED_FRAME) {
2818 /* packet was already buffered and now send due to
2819 * PS poll, so do not rebuffer it */
2820 goto out;
2821 }
2822
2823 if (skb_queue_len(&sta->tx_buf) >= STA_MAX_TX_BUFFER) {
2824 PDEBUG(DEBUG_PS, "%s: No more space in STA (" MAC_FMT
2825 ")'s PS mode buffer\n",
2826 local->dev->name,
2827 sta->addr[0], sta->addr[1], sta->addr[2],
2828 sta->addr[3], sta->addr[4], sta->addr[5]);
2829 /* Make sure that TIM is set for the station (it might not be
2830 * after AP wlan hw reset). */
2831 /* FIX: should fix hw reset to restore bits based on STA
2832 * buffer state.. */
2833 hostap_set_tim(local, sta->aid, 1);
2834 sta->flags |= WLAN_STA_TIM;
2835 ret = AP_TX_DROP;
2836 goto out;
2837 }
2838
2839 /* STA in PS mode, buffer frame for later delivery */
2840 set_tim = skb_queue_empty(&sta->tx_buf);
2841 skb_queue_tail(&sta->tx_buf, skb);
2842 /* FIX: could save RX time to skb and expire buffered frames after
2843 * some time if STA does not poll for them */
2844
2845 if (set_tim) {
2846 if (sta->flags & WLAN_STA_TIM)
2847 PDEBUG(DEBUG_PS2, "Re-setting TIM for aid %d\n",
2848 sta->aid);
2849 hostap_set_tim(local, sta->aid, 1);
2850 sta->flags |= WLAN_STA_TIM;
2851 }
2852
2853 ret = AP_TX_BUFFERED;
2854
2855 out:
2856 if (sta != NULL) {
2857 if (ret == AP_TX_CONTINUE ||
2858 ret == AP_TX_CONTINUE_NOT_AUTHORIZED) {
2859 sta->tx_packets++;
2860 sta->tx_bytes += skb->len;
2861 sta->last_tx = jiffies;
2862 }
2863
2864 if ((ret == AP_TX_CONTINUE ||
2865 ret == AP_TX_CONTINUE_NOT_AUTHORIZED) &&
2866 sta->crypt && tx->host_encrypt) {
2867 tx->crypt = sta->crypt;
2868 tx->sta_ptr = sta; /* hostap_handle_sta_release() will
2869 * be called to release sta info
2870 * later */
2871 } else
2872 atomic_dec(&sta->users);
2873 }
2874
2875 return ret;
2876 }
2877
2878
2879 void hostap_handle_sta_release(void *ptr)
2880 {
2881 struct sta_info *sta = ptr;
2882 atomic_dec(&sta->users);
2883 }
2884
2885
2886 /* Called only as a tasklet (software IRQ) */
2887 void hostap_handle_sta_tx_exc(local_info_t *local, struct sk_buff *skb)
2888 {
2889 struct sta_info *sta;
2890 struct ieee80211_hdr_4addr *hdr;
2891 struct hostap_skb_tx_data *meta;
2892
2893 hdr = (struct ieee80211_hdr_4addr *) skb->data;
2894 meta = (struct hostap_skb_tx_data *) skb->cb;
2895
2896 spin_lock(&local->ap->sta_table_lock);
2897 sta = ap_get_sta(local->ap, hdr->addr1);
2898 if (!sta) {
2899 spin_unlock(&local->ap->sta_table_lock);
2900 PDEBUG(DEBUG_AP, "%s: Could not find STA " MAC_FMT
2901 " for this TX error (@%lu)\n",
2902 local->dev->name,
2903 hdr->addr1[0], hdr->addr1[1], hdr->addr1[2],
2904 hdr->addr1[3], hdr->addr1[4], hdr->addr1[5],
2905 jiffies);
2906 return;
2907 }
2908
2909 sta->tx_since_last_failure = 0;
2910 sta->tx_consecutive_exc++;
2911
2912 if (sta->tx_consecutive_exc >= WLAN_RATE_DECREASE_THRESHOLD &&
2913 sta->tx_rate_idx > 0 && meta->rate <= sta->tx_rate) {
2914 /* use next lower rate */
2915 int old, rate;
2916 old = rate = sta->tx_rate_idx;
2917 while (rate > 0) {
2918 rate--;
2919 if (ap_tx_rate_ok(rate, sta, local)) {
2920 sta->tx_rate_idx = rate;
2921 break;
2922 }
2923 }
2924 if (old != sta->tx_rate_idx) {
2925 switch (sta->tx_rate_idx) {
2926 case 0: sta->tx_rate = 10; break;
2927 case 1: sta->tx_rate = 20; break;
2928 case 2: sta->tx_rate = 55; break;
2929 case 3: sta->tx_rate = 110; break;
2930 default: sta->tx_rate = 0; break;
2931 }
2932 PDEBUG(DEBUG_AP, "%s: STA " MAC_FMT
2933 " TX rate lowered to %d\n",
2934 local->dev->name,
2935 sta->addr[0], sta->addr[1], sta->addr[2],
2936 sta->addr[3], sta->addr[4], sta->addr[5],
2937 sta->tx_rate);
2938 }
2939 sta->tx_consecutive_exc = 0;
2940 }
2941 spin_unlock(&local->ap->sta_table_lock);
2942 }
2943
2944
2945 static void hostap_update_sta_ps2(local_info_t *local, struct sta_info *sta,
2946 int pwrmgt, int type, int stype)
2947 {
2948 DECLARE_MAC_BUF(mac);
2949 if (pwrmgt && !(sta->flags & WLAN_STA_PS)) {
2950 sta->flags |= WLAN_STA_PS;
2951 PDEBUG(DEBUG_PS2, "STA %s changed to use PS "
2952 "mode (type=0x%02X, stype=0x%02X)\n",
2953 print_mac(mac, sta->addr), type >> 2, stype >> 4);
2954 } else if (!pwrmgt && (sta->flags & WLAN_STA_PS)) {
2955 sta->flags &= ~WLAN_STA_PS;
2956 PDEBUG(DEBUG_PS2, "STA %s changed to not use "
2957 "PS mode (type=0x%02X, stype=0x%02X)\n",
2958 print_mac(mac, sta->addr), type >> 2, stype >> 4);
2959 if (type != IEEE80211_FTYPE_CTL ||
2960 stype != IEEE80211_STYPE_PSPOLL)
2961 schedule_packet_send(local, sta);
2962 }
2963 }
2964
2965
2966 /* Called only as a tasklet (software IRQ). Called for each RX frame to update
2967 * STA power saving state. pwrmgt is a flag from 802.11 frame_ctl field. */
2968 int hostap_update_sta_ps(local_info_t *local, struct ieee80211_hdr_4addr *hdr)
2969 {
2970 struct sta_info *sta;
2971 u16 fc;
2972
2973 spin_lock(&local->ap->sta_table_lock);
2974 sta = ap_get_sta(local->ap, hdr->addr2);
2975 if (sta)
2976 atomic_inc(&sta->users);
2977 spin_unlock(&local->ap->sta_table_lock);
2978
2979 if (!sta)
2980 return -1;
2981
2982 fc = le16_to_cpu(hdr->frame_ctl);
2983 hostap_update_sta_ps2(local, sta, fc & IEEE80211_FCTL_PM,
2984 WLAN_FC_GET_TYPE(fc), WLAN_FC_GET_STYPE(fc));
2985
2986 atomic_dec(&sta->users);
2987 return 0;
2988 }
2989
2990
2991 /* Called only as a tasklet (software IRQ). Called for each RX frame after
2992 * getting RX header and payload from hardware. */
2993 ap_rx_ret hostap_handle_sta_rx(local_info_t *local, struct net_device *dev,
2994 struct sk_buff *skb,
2995 struct hostap_80211_rx_status *rx_stats,
2996 int wds)
2997 {
2998 int ret;
2999 struct sta_info *sta;
3000 u16 fc, type, stype;
3001 struct ieee80211_hdr_4addr *hdr;
3002
3003 if (local->ap == NULL)
3004 return AP_RX_CONTINUE;
3005
3006 hdr = (struct ieee80211_hdr_4addr *) skb->data;
3007
3008 fc = le16_to_cpu(hdr->frame_ctl);
3009 type = WLAN_FC_GET_TYPE(fc);
3010 stype = WLAN_FC_GET_STYPE(fc);
3011
3012 spin_lock(&local->ap->sta_table_lock);
3013 sta = ap_get_sta(local->ap, hdr->addr2);
3014 if (sta)
3015 atomic_inc(&sta->users);
3016 spin_unlock(&local->ap->sta_table_lock);
3017
3018 if (sta && !(sta->flags & WLAN_STA_AUTHORIZED))
3019 ret = AP_RX_CONTINUE_NOT_AUTHORIZED;
3020 else
3021 ret = AP_RX_CONTINUE;
3022
3023
3024 if (fc & IEEE80211_FCTL_TODS) {
3025 if (!wds && (sta == NULL || !(sta->flags & WLAN_STA_ASSOC))) {
3026 if (local->hostapd) {
3027 prism2_rx_80211(local->apdev, skb, rx_stats,
3028 PRISM2_RX_NON_ASSOC);
3029 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
3030 } else {
3031 printk(KERN_DEBUG "%s: dropped received packet"
3032 " from non-associated STA "
3033 MAC_FMT
3034 " (type=0x%02x, subtype=0x%02x)\n",
3035 dev->name,
3036 hdr->addr2[0], hdr->addr2[1],
3037 hdr->addr2[2], hdr->addr2[3],
3038 hdr->addr2[4], hdr->addr2[5],
3039 type >> 2, stype >> 4);
3040 hostap_rx(dev, skb, rx_stats);
3041 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
3042 }
3043 ret = AP_RX_EXIT;
3044 goto out;
3045 }
3046 } else if (fc & IEEE80211_FCTL_FROMDS) {
3047 if (!wds) {
3048 /* FromDS frame - not for us; probably
3049 * broadcast/multicast in another BSS - drop */
3050 if (memcmp(hdr->addr1, dev->dev_addr, ETH_ALEN) == 0) {
3051 printk(KERN_DEBUG "Odd.. FromDS packet "
3052 "received with own BSSID\n");
3053 hostap_dump_rx_80211(dev->name, skb, rx_stats);
3054 }
3055 ret = AP_RX_DROP;
3056 goto out;
3057 }
3058 } else if (stype == IEEE80211_STYPE_NULLFUNC && sta == NULL &&
3059 memcmp(hdr->addr1, dev->dev_addr, ETH_ALEN) == 0) {
3060
3061 if (local->hostapd) {
3062 prism2_rx_80211(local->apdev, skb, rx_stats,
3063 PRISM2_RX_NON_ASSOC);
3064 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
3065 } else {
3066 /* At least Lucent f/w seems to send data::nullfunc
3067 * frames with no ToDS flag when the current AP returns
3068 * after being unavailable for some time. Speed up
3069 * re-association by informing the station about it not
3070 * being associated. */
3071 printk(KERN_DEBUG "%s: rejected received nullfunc "
3072 "frame without ToDS from not associated STA "
3073 MAC_FMT "\n",
3074 dev->name,
3075 hdr->addr2[0], hdr->addr2[1],
3076 hdr->addr2[2], hdr->addr2[3],
3077 hdr->addr2[4], hdr->addr2[5]);
3078 hostap_rx(dev, skb, rx_stats);
3079 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
3080 }
3081 ret = AP_RX_EXIT;
3082 goto out;
3083 } else if (stype == IEEE80211_STYPE_NULLFUNC) {
3084 /* At least Lucent cards seem to send periodic nullfunc
3085 * frames with ToDS. Let these through to update SQ
3086 * stats and PS state. Nullfunc frames do not contain
3087 * any data and they will be dropped below. */
3088 } else {
3089 /* If BSSID (Addr3) is foreign, this frame is a normal
3090 * broadcast frame from an IBSS network. Drop it silently.
3091 * If BSSID is own, report the dropping of this frame. */
3092 if (memcmp(hdr->addr3, dev->dev_addr, ETH_ALEN) == 0) {
3093 printk(KERN_DEBUG "%s: dropped received packet from "
3094 MAC_FMT " with no ToDS flag "
3095 "(type=0x%02x, subtype=0x%02x)\n", dev->name,
3096 hdr->addr2[0], hdr->addr2[1],
3097 hdr->addr2[2], hdr->addr2[3],
3098 hdr->addr2[4], hdr->addr2[5],
3099 type >> 2, stype >> 4);
3100 hostap_dump_rx_80211(dev->name, skb, rx_stats);
3101 }
3102 ret = AP_RX_DROP;
3103 goto out;
3104 }
3105
3106 if (sta) {
3107 hostap_update_sta_ps2(local, sta, fc & IEEE80211_FCTL_PM,
3108 type, stype);
3109
3110 sta->rx_packets++;
3111 sta->rx_bytes += skb->len;
3112 sta->last_rx = jiffies;
3113 }
3114
3115 if (local->ap->nullfunc_ack && stype == IEEE80211_STYPE_NULLFUNC &&
3116 fc & IEEE80211_FCTL_TODS) {
3117 if (local->hostapd) {
3118 prism2_rx_80211(local->apdev, skb, rx_stats,
3119 PRISM2_RX_NULLFUNC_ACK);
3120 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
3121 } else {
3122 /* some STA f/w's seem to require control::ACK frame
3123 * for data::nullfunc, but Prism2 f/w 0.8.0 (at least
3124 * from Compaq) does not send this.. Try to generate
3125 * ACK for these frames from the host driver to make
3126 * power saving work with, e.g., Lucent WaveLAN f/w */
3127 hostap_rx(dev, skb, rx_stats);
3128 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
3129 }
3130 ret = AP_RX_EXIT;
3131 goto out;
3132 }
3133
3134 out:
3135 if (sta)
3136 atomic_dec(&sta->users);
3137
3138 return ret;
3139 }
3140
3141
3142 /* Called only as a tasklet (software IRQ) */
3143 int hostap_handle_sta_crypto(local_info_t *local,
3144 struct ieee80211_hdr_4addr *hdr,
3145 struct ieee80211_crypt_data **crypt,
3146 void **sta_ptr)
3147 {
3148 struct sta_info *sta;
3149
3150 spin_lock(&local->ap->sta_table_lock);
3151 sta = ap_get_sta(local->ap, hdr->addr2);
3152 if (sta)
3153 atomic_inc(&sta->users);
3154 spin_unlock(&local->ap->sta_table_lock);
3155
3156 if (!sta)
3157 return -1;
3158
3159 if (sta->crypt) {
3160 *crypt = sta->crypt;
3161 *sta_ptr = sta;
3162 /* hostap_handle_sta_release() will be called to release STA
3163 * info */
3164 } else
3165 atomic_dec(&sta->users);
3166
3167 return 0;
3168 }
3169
3170
3171 /* Called only as a tasklet (software IRQ) */
3172 int hostap_is_sta_assoc(struct ap_data *ap, u8 *sta_addr)
3173 {
3174 struct sta_info *sta;
3175 int ret = 0;
3176
3177 spin_lock(&ap->sta_table_lock);
3178 sta = ap_get_sta(ap, sta_addr);
3179 if (sta != NULL && (sta->flags & WLAN_STA_ASSOC) && !sta->ap)
3180 ret = 1;
3181 spin_unlock(&ap->sta_table_lock);
3182
3183 return ret;
3184 }
3185
3186
3187 /* Called only as a tasklet (software IRQ) */
3188 int hostap_is_sta_authorized(struct ap_data *ap, u8 *sta_addr)
3189 {
3190 struct sta_info *sta;
3191 int ret = 0;
3192
3193 spin_lock(&ap->sta_table_lock);
3194 sta = ap_get_sta(ap, sta_addr);
3195 if (sta != NULL && (sta->flags & WLAN_STA_ASSOC) && !sta->ap &&
3196 ((sta->flags & WLAN_STA_AUTHORIZED) ||
3197 ap->local->ieee_802_1x == 0))
3198 ret = 1;
3199 spin_unlock(&ap->sta_table_lock);
3200
3201 return ret;
3202 }
3203
3204
3205 /* Called only as a tasklet (software IRQ) */
3206 int hostap_add_sta(struct ap_data *ap, u8 *sta_addr)
3207 {
3208 struct sta_info *sta;
3209 int ret = 1;
3210
3211 if (!ap)
3212 return -1;
3213
3214 spin_lock(&ap->sta_table_lock);
3215 sta = ap_get_sta(ap, sta_addr);
3216 if (sta)
3217 ret = 0;
3218 spin_unlock(&ap->sta_table_lock);
3219
3220 if (ret == 1) {
3221 sta = ap_add_sta(ap, sta_addr);
3222 if (!sta)
3223 return -1;
3224 sta->flags = WLAN_STA_AUTH | WLAN_STA_ASSOC;
3225 sta->ap = 1;
3226 memset(sta->supported_rates, 0, sizeof(sta->supported_rates));
3227 /* No way of knowing which rates are supported since we did not
3228 * get supported rates element from beacon/assoc req. Assume
3229 * that remote end supports all 802.11b rates. */
3230 sta->supported_rates[0] = 0x82;
3231 sta->supported_rates[1] = 0x84;
3232 sta->supported_rates[2] = 0x0b;
3233 sta->supported_rates[3] = 0x16;
3234 sta->tx_supp_rates = WLAN_RATE_1M | WLAN_RATE_2M |
3235 WLAN_RATE_5M5 | WLAN_RATE_11M;
3236 sta->tx_rate = 110;
3237 sta->tx_max_rate = sta->tx_rate_idx = 3;
3238 }
3239
3240 return ret;
3241 }
3242
3243
3244 /* Called only as a tasklet (software IRQ) */
3245 int hostap_update_rx_stats(struct ap_data *ap,
3246 struct ieee80211_hdr_4addr *hdr,
3247 struct hostap_80211_rx_status *rx_stats)
3248 {
3249 struct sta_info *sta;
3250
3251 if (!ap)
3252 return -1;
3253
3254 spin_lock(&ap->sta_table_lock);
3255 sta = ap_get_sta(ap, hdr->addr2);
3256 if (sta) {
3257 sta->last_rx_silence = rx_stats->noise;
3258 sta->last_rx_signal = rx_stats->signal;
3259 sta->last_rx_rate = rx_stats->rate;
3260 sta->last_rx_updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
3261 if (rx_stats->rate == 10)
3262 sta->rx_count[0]++;
3263 else if (rx_stats->rate == 20)
3264 sta->rx_count[1]++;
3265 else if (rx_stats->rate == 55)
3266 sta->rx_count[2]++;
3267 else if (rx_stats->rate == 110)
3268 sta->rx_count[3]++;
3269 }
3270 spin_unlock(&ap->sta_table_lock);
3271
3272 return sta ? 0 : -1;
3273 }
3274
3275
3276 void hostap_update_rates(local_info_t *local)
3277 {
3278 struct sta_info *sta;
3279 struct ap_data *ap = local->ap;
3280
3281 if (!ap)
3282 return;
3283
3284 spin_lock_bh(&ap->sta_table_lock);
3285 list_for_each_entry(sta, &ap->sta_list, list) {
3286 prism2_check_tx_rates(sta);
3287 }
3288 spin_unlock_bh(&ap->sta_table_lock);
3289 }
3290
3291
3292 void * ap_crypt_get_ptrs(struct ap_data *ap, u8 *addr, int permanent,
3293 struct ieee80211_crypt_data ***crypt)
3294 {
3295 struct sta_info *sta;
3296
3297 spin_lock_bh(&ap->sta_table_lock);
3298 sta = ap_get_sta(ap, addr);
3299 if (sta)
3300 atomic_inc(&sta->users);
3301 spin_unlock_bh(&ap->sta_table_lock);
3302
3303 if (!sta && permanent)
3304 sta = ap_add_sta(ap, addr);
3305
3306 if (!sta)
3307 return NULL;
3308
3309 if (permanent)
3310 sta->flags |= WLAN_STA_PERM;
3311
3312 *crypt = &sta->crypt;
3313
3314 return sta;
3315 }
3316
3317
3318 void hostap_add_wds_links(local_info_t *local)
3319 {
3320 struct ap_data *ap = local->ap;
3321 struct sta_info *sta;
3322
3323 spin_lock_bh(&ap->sta_table_lock);
3324 list_for_each_entry(sta, &ap->sta_list, list) {
3325 if (sta->ap)
3326 hostap_wds_link_oper(local, sta->addr, WDS_ADD);
3327 }
3328 spin_unlock_bh(&ap->sta_table_lock);
3329
3330 schedule_work(&local->ap->wds_oper_queue);
3331 }
3332
3333
3334 void hostap_wds_link_oper(local_info_t *local, u8 *addr, wds_oper_type type)
3335 {
3336 struct wds_oper_data *entry;
3337
3338 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
3339 if (!entry)
3340 return;
3341 memcpy(entry->addr, addr, ETH_ALEN);
3342 entry->type = type;
3343 spin_lock_bh(&local->lock);
3344 entry->next = local->ap->wds_oper_entries;
3345 local->ap->wds_oper_entries = entry;
3346 spin_unlock_bh(&local->lock);
3347
3348 schedule_work(&local->ap->wds_oper_queue);
3349 }
3350
3351
3352 EXPORT_SYMBOL(hostap_init_data);
3353 EXPORT_SYMBOL(hostap_init_ap_proc);
3354 EXPORT_SYMBOL(hostap_free_data);
3355 EXPORT_SYMBOL(hostap_check_sta_fw_version);
3356 EXPORT_SYMBOL(hostap_handle_sta_tx_exc);
3357 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
3358 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
ubuntu-bionic-kernel mirror