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