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