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