sys/dev/netif/wi/wi_hostap.c

   1 /*
   2  * Copyright (c) 2002
   3  *      Thomas Skibo <skibo@pacbell.net>.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by Thomas Skibo.
  16  * 4. Neither the name of the author nor the names of any co-contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY Thomas Skibo AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL Thomas Skibo OR HIS DRINKING PALS
  24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  30  * THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  * $FreeBSD: src/sys/dev/wi/wi_hostap.c,v 1.7.2.4 2002/08/02 07:11:34 imp Exp $
  33  * $DragonFly: src/sys/dev/netif/wi/Attic/wi_hostap.c,v 1.8 2004/06/02 14:42:56 eirikn Exp $
  34  */
  35
  36 /* This is experimental Host AP software for Prism 2 802.11b interfaces.
  37  *
  38  * Much of this is based upon the "Linux Host AP driver Host AP driver
  39  * for Intersil Prism2" by Jouni Malinen <jkm@ssh.com> or <jkmaline@cc.hut.fi>.
  40  */
  41
  42 #include <sys/param.h>
  43 #include <sys/systm.h>
  44 #if defined(__FreeBSD__) && __FreeBSD_version >= 500033
  45 #include <sys/endian.h>
  46 #endif
  47 #include <sys/sockio.h>
  48 #include <sys/mbuf.h>
  49 #include <sys/malloc.h>
  50 #include <sys/kernel.h>
  51 #include <sys/proc.h>
  52 #include <sys/ucred.h>
  53 #include <sys/socket.h>
  54 #include <sys/module.h>
  55 #include <sys/queue.h>
  56 #include <sys/bus.h>
  57 #include <sys/syslog.h>
  58 #include <sys/sysctl.h>
  59
  60 #include <machine/bus.h>
  61 #include <machine/resource.h>
  62 #include <machine/clock.h>
  63 #include <machine/md_var.h>
  64 #include <machine/bus_pio.h>
  65 #include <sys/rman.h>
  66
  67 #include <net/if.h>
  68 #include <net/if_arp.h>
  69 #include <net/ethernet.h>
  70 #include <net/if_dl.h>
  71 #include <net/if_media.h>
  72 #include <net/if_types.h>
  73 #include <net/if_ieee80211.h>
  74
  75 #include <netinet/in.h>
  76 #include <netinet/in_systm.h>
  77 #include <netinet/in_var.h>
  78 #include <netinet/ip.h>
  79 #include <netinet/if_ether.h>
  80
  81 #include "if_wavelan_ieee.h"
  82 #include "wi_hostap.h"
  83 #include "if_wivar.h"
  84 #include "if_wireg.h"
  85
  86 MALLOC_DEFINE(M_HAP_STA, "hostap_sta", "if_wi host AP mode station entry");
  87
  88 static void wihap_sta_timeout(void *v);
  89 static struct wihap_sta_info *wihap_sta_alloc(struct wi_softc *sc,
  90     u_int8_t *addr);
  91 static void wihap_sta_delete(struct wihap_sta_info *sta);
  92 static struct wihap_sta_info *wihap_sta_find(struct wihap_info *whi,
  93     u_int8_t *addr);
  94 static int wihap_sta_is_assoc(struct wihap_info *whi, u_int8_t addr[]);
  95 static void wihap_auth_req(struct wi_softc *sc, struct wi_frame *rxfrm,
  96     caddr_t pkt, int len);
  97 static void wihap_sta_deauth(struct wi_softc *sc, u_int8_t sta_addr[],
  98     u_int16_t reason);
  99 static void wihap_deauth_req(struct wi_softc *sc, struct wi_frame *rxfrm,
 100     caddr_t pkt, int len);
 101 static void wihap_assoc_req(struct wi_softc *sc, struct wi_frame *rxfrm,
 102     caddr_t pkt, int len);
 103 static void wihap_sta_disassoc(struct wi_softc *sc, u_int8_t sta_addr[],
 104     u_int16_t reason);
 105 static void wihap_disassoc_req(struct wi_softc *sc, struct wi_frame *rxfrm,
 106     caddr_t pkt, int len);
 107
 108 /*
 109  * Spl use in this driver.
 110  *
 111  * splnet is used everywhere here to block timeouts when we need to do
 112  * so.
 113  */
 114
 115 /*
 116  * take_hword()
 117  *
 118  *      Used for parsing management frames.  The pkt pointer and length
 119  *      variables are updated after the value is removed.
 120  */
 121 static __inline u_int16_t
 122 take_hword(caddr_t *ppkt, int *plen)
 123 {
 124         u_int16_t s = le16toh(* (u_int16_t *) *ppkt);
 125         *ppkt += sizeof(u_int16_t);
 126         *plen -= sizeof(u_int16_t);
 127         return s;
 128 }
 129
 130 /* take_tlv()
 131  *
 132  *      Parse out TLV element from a packet, check for underflow of packet
 133  *      or overflow of buffer, update pkt/len.
 134  */
 135 static int
 136 take_tlv(caddr_t *ppkt, int *plen, int id_expect, void *dst, int maxlen)
 137 {
 138         u_int8_t id, len;
 139
 140         if (*plen < 2)
 141                 return -1;
 142
 143         id = ((u_int8_t *)*ppkt)[0];
 144         len = ((u_int8_t *)*ppkt)[1];
 145
 146         if (id != id_expect || *plen < len+2 || maxlen < len)
 147                 return -1;
 148
 149         bcopy(*ppkt + 2, dst, len);
 150         *plen -= 2 + len;
 151         *ppkt += 2 + len;
 152
 153         return (len);
 154 }
 155
 156 /* put_hword()
 157  *      Put half-word element into management frames.
 158  */
 159 static __inline void
 160 put_hword(caddr_t *ppkt, u_int16_t s)
 161 {
 162         * (u_int16_t *) *ppkt = htole16(s);
 163         *ppkt += sizeof(u_int16_t);
 164 }
 165
 166 /* put_tlv()
 167  *      Put TLV elements into management frames.
 168  */
 169 static void
 170 put_tlv(caddr_t *ppkt, u_int8_t id, void *src, u_int8_t len)
 171 {
 172         (*ppkt)[0] = id;
 173         (*ppkt)[1] = len;
 174         bcopy(src, (*ppkt) + 2, len);
 175         *ppkt += 2 + len;
 176 }
 177
 178 static int
 179 put_rates(caddr_t *ppkt, u_int16_t rates)
 180 {
 181         u_int8_t ratebuf[8];
 182         int len = 0;
 183
 184         if (rates & WI_SUPPRATES_1M)
 185                 ratebuf[len++] = 0x82;
 186         if (rates & WI_SUPPRATES_2M)
 187                 ratebuf[len++] = 0x84;
 188         if (rates & WI_SUPPRATES_5M)
 189                 ratebuf[len++] = 0x8b;
 190         if (rates & WI_SUPPRATES_11M)
 191                 ratebuf[len++] = 0x96;
 192
 193         put_tlv(ppkt, IEEE80211_ELEMID_RATES, ratebuf, len);
 194         return len;
 195 }
 196
 197 /* wihap_init()
 198  *
 199  *      Initialize host AP data structures.  Called even if port type is
 200  *      not AP.
 201  */
 202 void
 203 wihap_init(struct wi_softc *sc)
 204 {
 205         int i;
 206         struct wihap_info *whi = &sc->wi_hostap_info;
 207
 208         if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 209                 printf("wihap_init: sc=0x%x whi=0x%x\n", (int)sc, (int)whi);
 210
 211         bzero(whi, sizeof(struct wihap_info));
 212
 213         if (sc->wi_ptype != WI_PORTTYPE_AP)
 214                 return;
 215
 216         whi->apflags = WIHAPFL_ACTIVE;
 217
 218         LIST_INIT(&whi->sta_list);
 219         for (i = 0; i < WI_STA_HASH_SIZE; i++)
 220                 LIST_INIT(&whi->sta_hash[i]);
 221
 222         whi->inactivity_time = WIHAP_DFLT_INACTIVITY_TIME;
 223 }
 224
 225 /* wihap_sta_disassoc()
 226  *
 227  *      Send a disassociation frame to a specified station.
 228  */
 229 static void
 230 wihap_sta_disassoc(struct wi_softc *sc, u_int8_t sta_addr[], u_int16_t reason)
 231 {
 232         struct wi_80211_hdr     *resp_hdr;
 233         caddr_t                 pkt;
 234
 235         if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 236                 printf("Sending disassoc to sta %6D\n", sta_addr, ":");
 237
 238         /* Send disassoc packet. */
 239         resp_hdr = (struct wi_80211_hdr *) sc->wi_txbuf;
 240         bzero(resp_hdr, sizeof(struct wi_80211_hdr));
 241         resp_hdr->frame_ctl = WI_FTYPE_MGMT | WI_STYPE_MGMT_DISAS;
 242         pkt = sc->wi_txbuf + sizeof(struct wi_80211_hdr);
 243
 244         bcopy(sta_addr, resp_hdr->addr1, ETHER_ADDR_LEN);
 245         bcopy(sc->arpcom.ac_enaddr, resp_hdr->addr2, ETHER_ADDR_LEN);
 246         bcopy(sc->arpcom.ac_enaddr, resp_hdr->addr3, ETHER_ADDR_LEN);
 247
 248         put_hword(&pkt, reason);
 249
 250         wi_mgmt_xmit(sc, sc->wi_txbuf, 2 + sizeof(struct wi_80211_hdr));
 251 }
 252
 253 /* wihap_sta_deauth()
 254  *
 255  *      Send a deauthentication message to a specified station.
 256  */
 257 static void
 258 wihap_sta_deauth(struct wi_softc *sc, u_int8_t sta_addr[], u_int16_t reason)
 259 {
 260         struct wi_80211_hdr     *resp_hdr;
 261         caddr_t                 pkt;
 262
 263         if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 264                 printf("Sending deauth to sta %6D\n", sta_addr, ":");
 265
 266         /* Send deauth packet. */
 267         resp_hdr = (struct wi_80211_hdr *) sc->wi_txbuf;
 268         bzero(resp_hdr, sizeof(struct wi_80211_hdr));
 269         resp_hdr->frame_ctl = htole16(WI_FTYPE_MGMT | WI_STYPE_MGMT_DEAUTH);
 270         pkt = sc->wi_txbuf + sizeof(struct wi_80211_hdr);
 271
 272         bcopy(sta_addr, resp_hdr->addr1, ETHER_ADDR_LEN);
 273         bcopy(sc->arpcom.ac_enaddr, resp_hdr->addr2, ETHER_ADDR_LEN);
 274         bcopy(sc->arpcom.ac_enaddr, resp_hdr->addr3, ETHER_ADDR_LEN);
 275
 276         put_hword(&pkt, reason);
 277
 278         wi_mgmt_xmit(sc, sc->wi_txbuf, 2 + sizeof(struct wi_80211_hdr));
 279 }
 280
 281 /* wihap_shutdown()
 282  *
 283  *      Disassociate all stations and free up data structures.
 284  */
 285 void
 286 wihap_shutdown(struct wi_softc *sc)
 287 {
 288         struct wihap_info       *whi = &sc->wi_hostap_info;
 289         struct wihap_sta_info   *sta, *next;
 290         int s;
 291
 292         if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 293                 printf("wihap_shutdown: sc=0x%x whi=0x%x\n",
 294                     (int)sc, (int)whi);
 295
 296         if (!(whi->apflags & WIHAPFL_ACTIVE))
 297                 return;
 298
 299         /* XXX: I read somewhere you can deauth all the stations with
 300          * a single broadcast.  Maybe try that someday.
 301          */
 302
 303         s = splnet();
 304         sta = LIST_FIRST(&whi->sta_list);
 305         while (sta) {
 306                 untimeout(wihap_sta_timeout, sta, sta->tmo);
 307                 if (!sc->wi_gone) {
 308                         /* Disassociate station. */
 309                         if (sta->flags & WI_SIFLAGS_ASSOC)
 310                                 wihap_sta_disassoc(sc, sta->addr,
 311                                     IEEE80211_REASON_ASSOC_LEAVE);
 312                         /* Deauth station. */
 313                         if (sta->flags & WI_SIFLAGS_AUTHEN)
 314                                 wihap_sta_deauth(sc, sta->addr,
 315                                     IEEE80211_REASON_AUTH_LEAVE);
 316                 }
 317
 318                 /* Delete the structure. */
 319                 if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 320                         printf("wihap_shutdown: FREE(sta=0x%x)\n", (int)sta);
 321                 next = LIST_NEXT(sta, list);
 322                 FREE(sta, M_HAP_STA);
 323                 sta = next;
 324         }
 325
 326         whi->apflags = 0;
 327         splx(s);
 328 }
 329
 330 /* sta_hash_func()
 331  * Hash function for finding stations from ethernet address.
 332  */
 333 static __inline int
 334 sta_hash_func(u_int8_t addr[])
 335 {
 336         return ((addr[3] + addr[4] + addr[5]) % WI_STA_HASH_SIZE);
 337 }
 338
 339 /* addr_cmp():  Maybe this is a faster way to compare addresses? */
 340 static __inline int
 341 addr_cmp(u_int8_t a[], u_int8_t b[])
 342 {
 343         return (*(u_int16_t *)(a + 4) == *(u_int16_t *)(b + 4) &&
 344                 *(u_int32_t *)(a    ) == *(u_int32_t *)(b));
 345 }
 346
 347 void
 348 wihap_sta_timeout(void *v)
 349 {
 350         struct wihap_sta_info   *sta = v;
 351         struct wi_softc         *sc = sta->sc;
 352         struct wihap_info       *whi = &sc->wi_hostap_info;
 353         int     s;
 354
 355         s = splnet();
 356         if (sta->flags & WI_SIFLAGS_ASSOC) {
 357                 if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 358                         device_printf(sc->dev, "inactivity disassoc: %6D\n",
 359                             sta->addr, ":");
 360
 361                 /* Disassoc station. */
 362                 wihap_sta_disassoc(sc, sta->addr,
 363                     IEEE80211_REASON_ASSOC_EXPIRE);
 364                 sta->flags &= ~WI_SIFLAGS_ASSOC;
 365
 366                 sta->tmo = timeout(wihap_sta_timeout, sta,
 367                     hz * whi->inactivity_time);
 368
 369         } else if (sta->flags & WI_SIFLAGS_AUTHEN) {
 370
 371                 if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 372                         device_printf(sc->dev, "inactivity disassoc: %6D\n",
 373                             sta->addr, ":");
 374
 375                 /* Deauthenticate station. */
 376                 wihap_sta_deauth(sc, sta->addr, IEEE80211_REASON_AUTH_EXPIRE);
 377                 sta->flags &= ~WI_SIFLAGS_AUTHEN;
 378
 379                 /* Delete the station if it's not permanent. */
 380                 if (!(sta->flags & WI_SIFLAGS_PERM))
 381                         wihap_sta_delete(sta);
 382         }
 383         splx(s);
 384 }
 385
 386 /* wihap_sta_delete()
 387  * Delete a single station and free up its data structure.
 388  */
 389 static void
 390 wihap_sta_delete(struct wihap_sta_info *sta)
 391 {
 392         struct wi_softc         *sc = sta->sc;
 393         struct wihap_info       *whi = &sc->wi_hostap_info;
 394         int i = sta->asid - 0xc001;
 395
 396         untimeout(wihap_sta_timeout, sta, sta->tmo);
 397
 398         whi->asid_inuse_mask[i >> 4] &= ~(1UL << (i & 0xf));
 399
 400         LIST_REMOVE(sta, list);
 401         LIST_REMOVE(sta, hash);
 402         if (sta->challenge)
 403                 FREE(sta->challenge, M_TEMP);
 404         FREE(sta, M_HAP_STA);
 405         whi->n_stations--;
 406 }
 407
 408 /* wihap_sta_alloc()
 409  *
 410  *      Create a new station data structure and put it in the list
 411  *      and hash table.
 412  */
 413 static struct wihap_sta_info *
 414 wihap_sta_alloc(struct wi_softc *sc, u_int8_t *addr)
 415 {
 416         struct wihap_info       *whi = &sc->wi_hostap_info;
 417         struct wihap_sta_info   *sta;
 418         int i, hash = sta_hash_func(addr);
 419
 420         /* Allocate structure. */
 421         MALLOC(sta, struct wihap_sta_info *, sizeof(struct wihap_sta_info),
 422             M_HAP_STA, M_INTWAIT);
 423         if (sta == NULL)
 424                 return(NULL);
 425
 426         bzero(sta, sizeof(struct wihap_sta_info));
 427
 428         /* Allocate an ASID. */
 429         i=hash<<4;
 430         while (whi->asid_inuse_mask[i >> 4] & (1UL << (i & 0xf)))
 431                 i = (i == (WI_STA_HASH_SIZE << 4) - 1) ? 0 : (i + 1);
 432         whi->asid_inuse_mask[i >> 4] |= (1UL << (i & 0xf));
 433         sta->asid = 0xc001 + i;
 434
 435         /* Insert in list and hash list. */
 436         LIST_INSERT_HEAD(&whi->sta_list, sta, list);
 437         LIST_INSERT_HEAD(&whi->sta_hash[hash], sta, hash);
 438
 439         sta->sc = sc;
 440         whi->n_stations++;
 441         bcopy(addr, &sta->addr, ETHER_ADDR_LEN);
 442
 443         return(sta);
 444 }
 445
 446 /* wihap_sta_find()
 447  *
 448  *      Find station structure given address.
 449  */
 450 static struct wihap_sta_info *
 451 wihap_sta_find(struct wihap_info *whi, u_int8_t *addr)
 452 {
 453         int i;
 454         struct wihap_sta_info *sta;
 455
 456         i = sta_hash_func(addr);
 457         LIST_FOREACH(sta, &whi->sta_hash[i], hash)
 458                 if (addr_cmp(addr,sta->addr))
 459                         return sta;
 460
 461         return (NULL);
 462 }
 463
 464 static int
 465 wihap_check_rates(struct wihap_sta_info *sta, u_int8_t rates[], int rates_len)
 466 {
 467         struct wi_softc *sc = sta->sc;
 468         int     i;
 469
 470         sta->rates = 0;
 471         sta->tx_max_rate = 0;
 472         for (i=0; i<rates_len; i++)
 473                 switch (rates[i] & 0x7f) {
 474                 case 0x02:
 475                         sta->rates |= WI_SUPPRATES_1M;
 476                         break;
 477                 case 0x04:
 478                         sta->rates |= WI_SUPPRATES_2M;
 479                         if (sta->tx_max_rate<1)
 480                                 sta->tx_max_rate = 1;
 481                         break;
 482                 case 0x0b:
 483                         sta->rates |= WI_SUPPRATES_5M;
 484                         if (sta->tx_max_rate<2)
 485                                 sta->tx_max_rate = 2;
 486                         break;
 487                 case 0x16:
 488                         sta->rates |= WI_SUPPRATES_11M;
 489                         sta->tx_max_rate = 3;
 490                         break;
 491                 }
 492
 493         sta->rates &= sc->wi_supprates;
 494         sta->tx_curr_rate = sta->tx_max_rate;
 495
 496         return (sta->rates == 0 ? -1 : 0);
 497 }
 498
 499
 500 /* wihap_auth_req()
 501  *
 502  *      Handle incoming authentication request.  Only handle OPEN
 503  *      requests.
 504  */
 505 static void
 506 wihap_auth_req(struct wi_softc *sc, struct wi_frame *rxfrm,
 507     caddr_t pkt, int len)
 508 {
 509         struct wihap_info       *whi = &sc->wi_hostap_info;
 510         struct wihap_sta_info   *sta;
 511
 512         u_int16_t               algo;
 513         u_int16_t               seq;
 514         u_int16_t               status;
 515         int                     i, challenge_len;
 516         u_int32_t               challenge[32];
 517
 518         struct wi_80211_hdr     *resp_hdr;
 519
 520         if (len < 6)
 521                 return;
 522
 523         /* Break open packet. */
 524         algo = take_hword(&pkt, &len);
 525         seq = take_hword(&pkt, &len);
 526         status = take_hword(&pkt, &len);
 527         challenge_len = 0;
 528         if (len > 0 && (challenge_len = take_tlv(&pkt, &len,
 529             IEEE80211_ELEMID_CHALLENGE, challenge, sizeof(challenge))) < 0)
 530                 return;
 531
 532         if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 533                 printf("wihap_auth_req: station %6D algo=0x%x seq=0x%x\n",
 534                        rxfrm->wi_addr2, ":", algo, seq);
 535
 536         /* Find or create station info. */
 537         sta = wihap_sta_find(whi, rxfrm->wi_addr2);
 538         if (sta == NULL) {
 539
 540                 /* Are we allowing new stations?
 541                  */
 542                 if (whi->apflags & WIHAPFL_MAC_FILT) {
 543                         status = IEEE80211_STATUS_OTHER; /* XXX */
 544                         goto fail;
 545                 }
 546
 547                 /* Check for too many stations.
 548                  */
 549                 if (whi->n_stations >= WIHAP_MAX_STATIONS) {
 550                         status = IEEE80211_STATUS_TOO_MANY_STATIONS;
 551                         goto fail;
 552                 }
 553
 554                 if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 555                         printf("wihap_auth_req: new station\n");
 556
 557                 /* Create new station. */
 558                 sta = wihap_sta_alloc(sc, rxfrm->wi_addr2);
 559                 if (sta == NULL) {
 560                         /* Out of memory! */
 561                         status = IEEE80211_STATUS_TOO_MANY_STATIONS;
 562                         goto fail;
 563                 }
 564         }
 565
 566         /* Note: it's okay to leave the station info structure around
 567          * if the authen fails.  It'll be timed out eventually.
 568          */
 569         switch (algo) {
 570         case IEEE80211_AUTH_ALG_OPEN:
 571                 if (sc->wi_authmode != IEEE80211_AUTH_OPEN) {
 572                         seq = 2;
 573                         status = IEEE80211_STATUS_ALG;
 574                         goto fail;
 575                 }
 576                 if (seq != 1) {
 577                         seq = 2;
 578                         status = IEEE80211_STATUS_SEQUENCE;
 579                         goto fail;
 580                 }
 581                 challenge_len = 0;
 582                 seq = 2;
 583                 sta->flags |= WI_SIFLAGS_AUTHEN;
 584                 break;
 585         case IEEE80211_AUTH_ALG_SHARED:
 586                 if (sc->wi_authmode != IEEE80211_AUTH_SHARED) {
 587                         seq = 2;
 588                         status = IEEE80211_STATUS_ALG;
 589                         goto fail;
 590                 }
 591                 switch (seq) {
 592                 case 1:
 593                         /* Create a challenge frame. */
 594                         if (!sta->challenge) {
 595                                 MALLOC(sta->challenge, u_int32_t *, 128,
 596                                        M_TEMP, M_INTWAIT);
 597                                 if (!sta->challenge)
 598                                         return;
 599                         }
 600                         for (i = 0; i < 32; i++)
 601                                 challenge[i] = sta->challenge[i] =
 602                                         arc4random();
 603                         challenge_len = 128;
 604                         seq = 2;
 605                         break;
 606                 case 3:
 607                         if (challenge_len != 128 || !sta->challenge ||
 608                             !(le16toh(rxfrm->wi_frame_ctl) & WI_FCTL_WEP)) {
 609                                 status = IEEE80211_STATUS_CHALLENGE;
 610                                 goto fail;
 611                         }
 612                         challenge_len = 0;
 613                         seq = 4;
 614
 615                         /* Check the challenge text.  (Was decrypted by
 616                          * the adapter.)
 617                          */
 618                         for (i=0; i<32; i++)
 619                                 if (sta->challenge[i] != challenge[i]) {
 620                                         status = IEEE80211_STATUS_CHALLENGE;
 621                                         FREE(sta->challenge, M_TEMP);
 622                                         sta->challenge = NULL;
 623                                         goto fail;
 624                                 }
 625
 626                         sta->flags |= WI_SIFLAGS_AUTHEN;
 627                         FREE(sta->challenge, M_TEMP);
 628                         sta->challenge = NULL;
 629                         break;
 630                 default:
 631                         seq = 2;
 632                         status = IEEE80211_STATUS_SEQUENCE;
 633                         goto fail;
 634                 } /* switch (seq) */
 635                 break;
 636         default:
 637                 if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 638                         printf("wihap_auth_req: algorithm unsupported: 0x%x\n",
 639                                algo);
 640                 status = IEEE80211_STATUS_ALG;
 641                 goto fail;
 642         } /* switch (algo) */
 643
 644         status = IEEE80211_STATUS_SUCCESS;
 645
 646 fail:
 647         if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 648                 printf("wihap_auth_req: returns status=0x%x\n", status);
 649
 650         /* Send response. */
 651         resp_hdr = (struct wi_80211_hdr *) sc->wi_txbuf;
 652         bzero(resp_hdr, sizeof(struct wi_80211_hdr));
 653         resp_hdr->frame_ctl = htole16(WI_FTYPE_MGMT | WI_STYPE_MGMT_AUTH);
 654         bcopy(rxfrm->wi_addr2, resp_hdr->addr1, ETHER_ADDR_LEN);
 655         bcopy(sc->arpcom.ac_enaddr, resp_hdr->addr2, ETHER_ADDR_LEN);
 656         bcopy(sc->arpcom.ac_enaddr, resp_hdr->addr3, ETHER_ADDR_LEN);
 657         pkt = &sc->wi_txbuf[sizeof(struct wi_80211_hdr)];
 658         put_hword(&pkt, algo);
 659         put_hword(&pkt, seq);
 660         put_hword(&pkt, status);
 661         if (challenge_len > 0)
 662                 put_tlv(&pkt, IEEE80211_ELEMID_CHALLENGE,
 663                     challenge, challenge_len);
 664         wi_mgmt_xmit(sc, sc->wi_txbuf, (char *) pkt - (char *) sc->wi_txbuf);
 665 }
 666
 667 /* wihap_assoc_req()
 668  *
 669  *      Handle incoming association and reassociation requests.
 670  */
 671 static void
 672 wihap_assoc_req(struct wi_softc *sc, struct wi_frame *rxfrm,
 673                 caddr_t pkt, int len)
 674 {
 675         struct wihap_info       *whi = &sc->wi_hostap_info;
 676         struct wihap_sta_info   *sta;
 677         struct wi_80211_hdr     *resp_hdr;
 678         u_int16_t               capinfo;
 679         u_int16_t               lstintvl;
 680         u_int8_t                rates[8];
 681         int                     ssid_len, rates_len;
 682         char                    ssid[33];
 683         u_int16_t               status;
 684         u_int16_t               asid = 0;
 685
 686         if (len < 8)
 687                 return;
 688
 689         /* Pull out request parameters. */
 690         capinfo = take_hword(&pkt, &len);
 691         lstintvl = take_hword(&pkt, &len);
 692
 693         if ((rxfrm->wi_frame_ctl & htole16(WI_FCTL_STYPE)) ==
 694             htole16(WI_STYPE_MGMT_REASREQ)) {
 695                 if (len < 6)
 696                         return;
 697                 /* Eat the MAC address of the current AP */
 698                 take_hword(&pkt, &len);
 699                 take_hword(&pkt, &len);
 700                 take_hword(&pkt, &len);
 701         }
 702
 703         if ((ssid_len = take_tlv(&pkt, &len, IEEE80211_ELEMID_SSID,
 704             ssid, sizeof(ssid) - 1))<0)
 705                 return;
 706         ssid[ssid_len] = '\0';
 707         if ((rates_len = take_tlv(&pkt, &len, IEEE80211_ELEMID_RATES,
 708             rates, sizeof(rates)))<0)
 709                 return;
 710
 711         if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 712                 printf("wihap_assoc_req: from station %6D\n",
 713                     rxfrm->wi_addr2, ":");
 714
 715         /* If SSID doesn't match, simply drop. */
 716         if (strcmp(sc->wi_net_name, ssid) != 0) {
 717                 if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 718                         printf("wihap_assoc_req: bad ssid: '%s' != '%s'\n",
 719                             ssid, sc->wi_net_name);
 720                 return;
 721         }
 722
 723         /* Is this station authenticated yet? */
 724         sta = wihap_sta_find(whi, rxfrm->wi_addr2);
 725         if (sta == NULL || !(sta->flags & WI_SIFLAGS_AUTHEN)) {
 726                 wihap_sta_deauth(sc, rxfrm->wi_addr2,
 727                     IEEE80211_REASON_NOT_AUTHED);
 728                 return;
 729         }
 730
 731         /* Check supported rates against ours. */
 732         if (wihap_check_rates(sta, rates, rates_len) < 0) {
 733                 status = IEEE80211_STATUS_RATES;
 734                 goto fail;
 735         }
 736
 737         /* Check capinfo.
 738          * Check for ESS, not IBSS.
 739          * Check WEP/PRIVACY flags match.
 740          * Refuse stations requesting to be put on CF-polling list.
 741          */
 742         sta->capinfo = capinfo;
 743         status = IEEE80211_STATUS_CAPINFO;
 744         if ((capinfo & (IEEE80211_CAPINFO_ESS | IEEE80211_CAPINFO_IBSS)) !=
 745             IEEE80211_CAPINFO_ESS) {
 746                 if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 747                         printf("wihap_assoc_req: capinfo mismatch: "
 748                             "client using IBSS mode\n");
 749                 goto fail;
 750
 751         }
 752         if ((sc->wi_use_wep && !(capinfo & IEEE80211_CAPINFO_PRIVACY)) ||
 753             (!sc->wi_use_wep && (capinfo & IEEE80211_CAPINFO_PRIVACY))) {
 754                 if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 755                         printf("wihap_assoc_req: capinfo mismatch: client "
 756                             "%susing WEP\n", sc->wi_use_wep ? "not " : "");
 757                 goto fail;
 758         }
 759         if ((capinfo & (IEEE80211_CAPINFO_CF_POLLABLE |
 760             IEEE80211_CAPINFO_CF_POLLREQ)) == IEEE80211_CAPINFO_CF_POLLABLE) {
 761                 if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 762                         printf("wihap_assoc_req: capinfo mismatch: "
 763                             "client requested CF polling\n");
 764                 goto fail;
 765         }
 766
 767         /* Use ASID is allocated by whi_sta_alloc(). */
 768         asid = sta->asid;
 769
 770         if (sta->flags & WI_SIFLAGS_ASSOC) {
 771                 if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 772                         printf("wihap_assoc_req: already assoc'ed?\n");
 773         }
 774
 775         sta->flags |= WI_SIFLAGS_ASSOC;
 776         sta->inactivity_timer = whi->inactivity_time;
 777         status = IEEE80211_STATUS_SUCCESS;
 778
 779 fail:
 780         if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 781                 printf("wihap_assoc_req: returns status=0x%x\n", status);
 782
 783         /* Send response. */
 784         resp_hdr = (struct wi_80211_hdr *) sc->wi_txbuf;
 785         bzero(resp_hdr, sizeof(struct wi_80211_hdr));
 786         resp_hdr->frame_ctl = htole16(WI_FTYPE_MGMT | WI_STYPE_MGMT_ASRESP);
 787         pkt = sc->wi_txbuf + sizeof(struct wi_80211_hdr);
 788
 789         bcopy(rxfrm->wi_addr2, resp_hdr->addr1, ETHER_ADDR_LEN);
 790         bcopy(sc->arpcom.ac_enaddr, resp_hdr->addr2, ETHER_ADDR_LEN);
 791         bcopy(sc->arpcom.ac_enaddr, resp_hdr->addr3, ETHER_ADDR_LEN);
 792
 793         put_hword(&pkt, capinfo);
 794         put_hword(&pkt, status);
 795         put_hword(&pkt, asid);
 796         rates_len = put_rates(&pkt, sc->wi_supprates);
 797
 798         wi_mgmt_xmit(sc, sc->wi_txbuf,
 799             8 + rates_len + sizeof(struct wi_80211_hdr));
 800 }
 801
 802 /* wihap_deauth_req()
 803  *
 804  *      Handle deauthentication requests.  Delete the station.
 805  */
 806 static void
 807 wihap_deauth_req(struct wi_softc *sc, struct wi_frame *rxfrm,
 808                  caddr_t pkt, int len)
 809 {
 810         struct wihap_info       *whi = &sc->wi_hostap_info;
 811         struct wihap_sta_info   *sta;
 812         u_int16_t               reason;
 813
 814         if (len<2)
 815                 return;
 816
 817         reason = take_hword(&pkt, &len);
 818
 819         sta = wihap_sta_find(whi, rxfrm->wi_addr2);
 820         if (sta == NULL) {
 821                 if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 822                         printf("wihap_deauth_req: unknown station: %6D\n",
 823                             rxfrm->wi_addr2, ":");
 824         }
 825         else
 826                 wihap_sta_delete(sta);
 827 }
 828
 829 /* wihap_disassoc_req()
 830  *
 831  *      Handle disassociation requests.  Just reset the assoc flag.
 832  *      We'll free up the station resources when we get a deauth
 833  *      request or when it times out.
 834  */
 835 static void
 836 wihap_disassoc_req(struct wi_softc *sc, struct wi_frame *rxfrm,
 837     caddr_t pkt, int len)
 838 {
 839         struct wihap_info       *whi = &sc->wi_hostap_info;
 840         struct wihap_sta_info   *sta;
 841         u_int16_t               reason;
 842
 843         if (len < 2)
 844                 return;
 845
 846         reason = take_hword(&pkt, &len);
 847
 848         sta = wihap_sta_find(whi, rxfrm->wi_addr2);
 849         if (sta == NULL) {
 850                 if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 851                         printf("wihap_disassoc_req: unknown station: %6D\n",
 852                             rxfrm->wi_addr2, ":");
 853         }
 854         else if (!(sta->flags & WI_SIFLAGS_AUTHEN)) {
 855                 /*
 856                  * If station is not authenticated, send deauthentication
 857                  * frame.
 858                  */
 859                 wihap_sta_deauth(sc, rxfrm->wi_addr2,
 860                     IEEE80211_REASON_NOT_AUTHED);
 861                 return;
 862         }
 863         else
 864                 sta->flags &= ~WI_SIFLAGS_ASSOC;
 865 }
 866
 867 /* wihap_debug_frame_type()
 868  *
 869  * Print out frame type.  Used in early debugging.
 870  */
 871 static __inline void
 872 wihap_debug_frame_type(struct wi_frame *rxfrm)
 873 {
 874         printf("wihap_mgmt_input: len=%d ", le16toh(rxfrm->wi_dat_len));
 875
 876         if ((rxfrm->wi_frame_ctl & htole16(WI_FCTL_FTYPE)) ==
 877             htole16(WI_FTYPE_MGMT)) {
 878
 879                 printf("MGMT: ");
 880
 881                 switch (le16toh(rxfrm->wi_frame_ctl) & WI_FCTL_STYPE) {
 882                 case WI_STYPE_MGMT_ASREQ:
 883                         printf("assoc req: \n");
 884                         break;
 885                 case WI_STYPE_MGMT_ASRESP:
 886                         printf("assoc resp: \n");
 887                         break;
 888                 case WI_STYPE_MGMT_REASREQ:
 889                         printf("reassoc req: \n");
 890                         break;
 891                 case WI_STYPE_MGMT_REASRESP:
 892                         printf("reassoc resp: \n");
 893                         break;
 894                 case WI_STYPE_MGMT_PROBEREQ:
 895                         printf("probe req: \n");
 896                         break;
 897                 case WI_STYPE_MGMT_PROBERESP:
 898                         printf("probe resp: \n");
 899                         break;
 900                 case WI_STYPE_MGMT_BEACON:
 901                         printf("beacon: \n");
 902                         break;
 903                 case WI_STYPE_MGMT_ATIM:
 904                         printf("ann traf ind \n");
 905                         break;
 906                 case WI_STYPE_MGMT_DISAS:
 907                         printf("disassociation: \n");
 908                         break;
 909                 case WI_STYPE_MGMT_AUTH:
 910                         printf("auth: \n");
 911                         break;
 912                 case WI_STYPE_MGMT_DEAUTH:
 913                         printf("deauth: \n");
 914                         break;
 915                 default:
 916                         printf("unknown (stype=0x%x)\n",
 917                             le16toh(rxfrm->wi_frame_ctl) & WI_FCTL_STYPE);
 918                 }
 919
 920         }
 921         else {
 922                 printf("ftype=0x%x (ctl=0x%x)\n",
 923                     le16toh(rxfrm->wi_frame_ctl) & WI_FCTL_FTYPE,
 924                     le16toh(rxfrm->wi_frame_ctl));
 925         }
 926 }
 927
 928 /* wihap_mgmt_input:
 929  *
 930  *      Called for each management frame received in host ap mode.
 931  *      wihap_mgmt_input() is expected to free the mbuf.
 932  */
 933 void
 934 wihap_mgmt_input(struct wi_softc *sc, struct wi_frame *rxfrm, struct mbuf *m)
 935 {
 936         caddr_t pkt;
 937         int     s, len;
 938
 939         if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 940                 wihap_debug_frame_type(rxfrm);
 941
 942         pkt = mtod(m, caddr_t) + WI_802_11_OFFSET_RAW;
 943         len = m->m_len - WI_802_11_OFFSET_RAW;
 944
 945         if ((rxfrm->wi_frame_ctl & htole16(WI_FCTL_FTYPE)) ==
 946             htole16(WI_FTYPE_MGMT)) {
 947
 948                 /* any of the following will mess w/ the station list */
 949                 s = splnet();
 950                 switch (le16toh(rxfrm->wi_frame_ctl) & WI_FCTL_STYPE) {
 951                 case WI_STYPE_MGMT_ASREQ:
 952                         wihap_assoc_req(sc, rxfrm, pkt, len);
 953                         break;
 954                 case WI_STYPE_MGMT_ASRESP:
 955                         break;
 956                 case WI_STYPE_MGMT_REASREQ:
 957                         wihap_assoc_req(sc, rxfrm, pkt, len);
 958                         break;
 959                 case WI_STYPE_MGMT_REASRESP:
 960                         break;
 961                 case WI_STYPE_MGMT_PROBEREQ:
 962                         break;
 963                 case WI_STYPE_MGMT_PROBERESP:
 964                         break;
 965                 case WI_STYPE_MGMT_BEACON:
 966                         break;
 967                 case WI_STYPE_MGMT_ATIM:
 968                         break;
 969                 case WI_STYPE_MGMT_DISAS:
 970                         wihap_disassoc_req(sc, rxfrm, pkt, len);
 971                         break;
 972                 case WI_STYPE_MGMT_AUTH:
 973                         wihap_auth_req(sc, rxfrm, pkt, len);
 974                         break;
 975                 case WI_STYPE_MGMT_DEAUTH:
 976                         wihap_deauth_req(sc, rxfrm, pkt, len);
 977                         break;
 978                 }
 979                 splx(s);
 980         }
 981
 982         m_freem(m);
 983 }
 984
 985 /* wihap_sta_is_assoc()
 986  *
 987  *      Determine if a station is assoc'ed.  Update its activity
 988  *      counter as a side-effect.
 989  */
 990 static int
 991 wihap_sta_is_assoc(struct wihap_info *whi, u_int8_t addr[])
 992 {
 993         struct wihap_sta_info *sta;
 994         int retval, s;
 995
 996         s = splnet();
 997         retval = 0;
 998         sta = wihap_sta_find(whi, addr);
 999         if (sta != NULL && (sta->flags & WI_SIFLAGS_ASSOC)) {
1000                 /* Keep it active. */
1001                 untimeout(wihap_sta_timeout, sta, sta->tmo);
1002                 sta->tmo = timeout(wihap_sta_timeout, sta,
1003                     hz * whi->inactivity_time);
1004                 retval = 1;
1005         }
1006         splx(s);
1007         return (retval);
1008 }
1009
1010 /* wihap_check_tx()
1011  *
1012  *      Determine if a station is assoc'ed, get its tx rate, and update
1013  *      its activity.
1014  */
1015 int
1016 wihap_check_tx(struct wihap_info *whi, u_int8_t addr[], u_int8_t *txrate)
1017 {
1018         struct wihap_sta_info *sta;
1019         static u_int8_t txratetable[] = { 10, 20, 55, 110 };
1020         int s;
1021
1022         if (addr[0] & 0x01) {
1023                 *txrate = 0; /* XXX: multicast rate? */
1024                 return(1);
1025         }
1026         s = splnet();
1027         sta = wihap_sta_find(whi, addr);
1028         if (sta != NULL && (sta->flags & WI_SIFLAGS_ASSOC)) {
1029                 /* Keep it active. */
1030                 untimeout(wihap_sta_timeout, sta, sta->tmo);
1031                 sta->tmo = timeout(wihap_sta_timeout, sta,
1032                     hz * whi->inactivity_time);
1033                 *txrate = txratetable[ sta->tx_curr_rate ];
1034                 splx(s);
1035                 return(1);
1036         }
1037         splx(s);
1038
1039         return(0);
1040 }
1041
1042 /*
1043  * wihap_data_input()
1044  *
1045  *      Handle all data input on interface when in Host AP mode.
1046  *      Some packets are destined for this machine, others are
1047  *      repeated to other stations.
1048  *
1049  *      If wihap_data_input() returns a non-zero, it has processed
1050  *      the packet and will free the mbuf.
1051  */
1052 int
1053 wihap_data_input(struct wi_softc *sc, struct wi_frame *rxfrm, struct mbuf *m)
1054 {
1055         struct ifnet            *ifp = &sc->arpcom.ac_if;
1056         struct wihap_info       *whi = &sc->wi_hostap_info;
1057         struct wihap_sta_info   *sta;
1058         int                     mcast, s;
1059
1060         /* TODS flag must be set. */
1061         if (!(rxfrm->wi_frame_ctl & htole16(WI_FCTL_TODS))) {
1062                 if (ifp->if_flags & IFF_DEBUG)
1063                         printf("wihap_data_input: no TODS src=%6D\n",
1064                             rxfrm->wi_addr2, ":");
1065                 m_freem(m);
1066                 return(1);
1067         }
1068
1069         /* Check BSSID. (Is this necessary?) */
1070         if (!addr_cmp(rxfrm->wi_addr1, sc->arpcom.ac_enaddr)) {
1071                 if (ifp->if_flags & IFF_DEBUG)
1072                         printf("wihap_data_input: incorrect bss: %6D\n",
1073                                 rxfrm->wi_addr1, ":");
1074                 m_freem(m);
1075                 return (1);
1076         }
1077
1078         s = splnet();
1079
1080         /* Find source station. */
1081         sta = wihap_sta_find(whi, rxfrm->wi_addr2);
1082
1083         /* Source station must be associated. */
1084         if (sta == NULL || !(sta->flags & WI_SIFLAGS_ASSOC)) {
1085                 if (ifp->if_flags & IFF_DEBUG)
1086                         printf("wihap_data_input: dropping unassoc src %6D\n",
1087                             rxfrm->wi_addr2, ":");
1088                 wihap_sta_disassoc(sc, rxfrm->wi_addr2,
1089                     IEEE80211_REASON_ASSOC_LEAVE);
1090                 splx(s);
1091                 m_freem(m);
1092                 return(1);
1093         }
1094
1095         untimeout(wihap_sta_timeout, sta, sta->tmo);
1096         sta->tmo = timeout(wihap_sta_timeout, sta,
1097             hz * whi->inactivity_time);
1098         sta->sig_info = le16toh(rxfrm->wi_q_info);
1099
1100         splx(s);
1101
1102         /* Repeat this packet to BSS? */
1103         mcast = (rxfrm->wi_addr3[0] & 0x01) != 0;
1104         if (mcast || wihap_sta_is_assoc(whi, rxfrm->wi_addr3)) {
1105
1106                 /* If it's multicast, make a copy.
1107                  */
1108                 if (mcast) {
1109                         m = m_copym(m, 0, M_COPYALL, MB_DONTWAIT);
1110                         if (m == NULL)
1111                                 return(0);
1112                         m->m_flags |= M_MCAST; /* XXX */
1113                 }
1114
1115                 /* Queue up for repeating.
1116                  */
1117                 IF_HANDOFF(&ifp->if_snd, m, ifp);
1118                 return (!mcast);
1119         }
1120
1121         return(0);
1122 }
1123
1124 /* wihap_ioctl()
1125  *
1126  *      Handle Host AP specific ioctls.  Called from wi_ioctl().
1127  */
1128 int
1129 wihap_ioctl(struct wi_softc *sc, u_long command, caddr_t data)
1130 {
1131         struct ifreq            *ifr = (struct ifreq *) data;
1132         struct wihap_info       *whi = &sc->wi_hostap_info;
1133         struct wihap_sta_info   *sta;
1134         struct hostap_getall    reqall;
1135         struct hostap_sta       reqsta;
1136         struct hostap_sta       stabuf;
1137         int                     s, error = 0, n, flag;
1138         struct thread           *td = curthread;
1139
1140         if (!(sc->arpcom.ac_if.if_flags & IFF_RUNNING))
1141                 return ENODEV;
1142
1143         switch (command) {
1144         case SIOCHOSTAP_DEL:
1145                 if ((error = suser(td)))
1146                         break;
1147                 if ((error = copyin(ifr->ifr_data, &reqsta, sizeof(reqsta))))
1148                         break;
1149                 s = splnet();
1150                 sta = wihap_sta_find(whi, reqsta.addr);
1151                 if (sta == NULL)
1152                         error = ENOENT;
1153                 else {
1154                         /* Disassociate station. */
1155                         if (sta->flags & WI_SIFLAGS_ASSOC)
1156                                 wihap_sta_disassoc(sc, sta->addr,
1157                                     IEEE80211_REASON_ASSOC_LEAVE);
1158                         /* Deauth station. */
1159                         if (sta->flags & WI_SIFLAGS_AUTHEN)
1160                                 wihap_sta_deauth(sc, sta->addr,
1161                                     IEEE80211_REASON_AUTH_LEAVE);
1162
1163                         wihap_sta_delete(sta);
1164                 }
1165                 splx(s);
1166                 break;
1167
1168         case SIOCHOSTAP_GET:
1169                 if ((error = copyin(ifr->ifr_data, &reqsta, sizeof(reqsta))))
1170                         break;
1171                 s = splnet();
1172                 sta = wihap_sta_find(whi, reqsta.addr);
1173                 if (sta == NULL) {
1174                         error = ENOENT;
1175                         splx(s);
1176                 } else {
1177                         reqsta.flags = sta->flags;
1178                         reqsta.asid = sta->asid;
1179                         reqsta.capinfo = sta->capinfo;
1180                         reqsta.sig_info = sta->sig_info;
1181                         reqsta.rates = sta->rates;
1182                         splx(s);
1183                         error = copyout(&reqsta, ifr->ifr_data,
1184                             sizeof(reqsta));
1185                 }
1186                 break;
1187
1188         case SIOCHOSTAP_ADD:
1189                 if ((error = suser(td)))
1190                         break;
1191                 if ((error = copyin(ifr->ifr_data, &reqsta, sizeof(reqsta))))
1192                         break;
1193                 s = splnet();
1194                 sta = wihap_sta_find(whi, reqsta.addr);
1195                 if (sta != NULL) {
1196                         error = EEXIST;
1197                         splx(s);
1198                         break;
1199                 }
1200                 if (whi->n_stations >= WIHAP_MAX_STATIONS) {
1201                         error = ENOSPC;
1202                         splx(s);
1203                         break;
1204                 }
1205                 sta = wihap_sta_alloc(sc, reqsta.addr);
1206                 sta->flags = reqsta.flags;
1207                 sta->tmo = timeout(wihap_sta_timeout, sta,
1208                     hz * whi->inactivity_time);
1209                 splx(s);
1210                 break;
1211
1212         case SIOCHOSTAP_SFLAGS:
1213                 if ((error = suser(td)))
1214                         break;
1215                 if ((error = copyin(ifr->ifr_data, &flag, sizeof(int))))
1216                         break;
1217
1218                 whi->apflags = (whi->apflags & WIHAPFL_CANTCHANGE) |
1219                     (flag & ~WIHAPFL_CANTCHANGE);
1220                 break;
1221
1222         case SIOCHOSTAP_GFLAGS:
1223                 flag = (int) whi->apflags;
1224                 error = copyout(&flag, ifr->ifr_data, sizeof(int));
1225                 break;
1226
1227         case SIOCHOSTAP_GETALL:
1228                 if ((error = copyin(ifr->ifr_data, &reqall, sizeof(reqall))))
1229                         break;
1230
1231                 reqall.nstations = whi->n_stations;
1232                 n = 0;
1233                 s = splnet();
1234                 sta = LIST_FIRST(&whi->sta_list);
1235                 while (sta && reqall.size >= n+sizeof(struct hostap_sta)) {
1236
1237                         bcopy(sta->addr, stabuf.addr, ETHER_ADDR_LEN);
1238                         stabuf.asid = sta->asid;
1239                         stabuf.flags = sta->flags;
1240                         stabuf.capinfo = sta->capinfo;
1241                         stabuf.sig_info = sta->sig_info;
1242                         stabuf.rates = sta->rates;
1243
1244                         error = copyout(&stabuf, (caddr_t) reqall.addr + n,
1245                             sizeof(struct hostap_sta));
1246                         if (error)
1247                                 break;
1248
1249                         sta = LIST_NEXT(sta, list);
1250                         n += sizeof(struct hostap_sta);
1251                 }
1252                 splx(s);
1253
1254                 if (!error)
1255                         error = copyout(&reqall, ifr->ifr_data,
1256                             sizeof(reqall));
1257                 break;
1258         default:
1259                 printf("wihap_ioctl: i shouldn't get other ioctls!\n");
1260                 error = EINVAL;
1261         }
1262
1263         return(error);
1264 }