root/dev/ic/if_wi_hostap.c

DEFINITIONS

1. take_hword
2. take_tlv
3. put_hword
4. put_tlv
5. put_rates
6. wihap_init
7. wihap_sta_disassoc
8. wihap_sta_deauth
9. wihap_shutdown
10. sta_hash_func
11. addr_cmp
12. wihap_sta_movetail
13. wihap_timeout
14. wihap_sta_timeout
15. wihap_sta_delete
16. wihap_sta_alloc
17. wihap_sta_find
18. wihap_check_rates
19. wihap_auth_req
20. wihap_assoc_req
21. wihap_deauth_req
22. wihap_disassoc_req
23. wihap_debug_frame_type
24. wihap_mgmt_input
25. wihap_sta_is_assoc
26. wihap_check_tx
27. wihap_data_input
28. wihap_ioctl
29. wihap_init
30. wihap_shutdown
31. wihap_mgmt_input
32. wihap_data_input
33. wihap_ioctl
34. wihap_check_tx

    1 /*      $OpenBSD: if_wi_hostap.c,v 1.37 2006/11/26 19:46:28 deraadt Exp $       */
    3 /*
    4  * Copyright (c) 2002
    5  *      Thomas Skibo <skibo@pacbell.net>.  All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 3. All advertising materials mentioning features or use of this software
   16  *    must display the following acknowledgement:
   17  *      This product includes software developed by Thomas Skibo.
   18  * 4. Neither the name of the author nor the names of any co-contributors
   19  *    may be used to endorse or promote products derived from this software
   20  *    without specific prior written permission.
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY Thomas Skibo AND CONTRIBUTORS ``AS IS'' AND
   23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   25  * ARE DISCLAIMED.  IN NO EVENT SHALL Thomas Skibo OR HIS DRINKING PALS
   26  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   27  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   28  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   29  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   30  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
   32  * THE POSSIBILITY OF SUCH DAMAGE.
   33  *
   34  */
   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  */
   42 #include <sys/param.h>
   43 #include <sys/systm.h>
   44 #include <sys/sockio.h>
   45 #include <sys/mbuf.h>
   46 #include <sys/malloc.h>
   47 #include <sys/kernel.h>
   48 #include <sys/timeout.h>
   49 #include <sys/proc.h>
   50 #include <sys/ucred.h>
   51 #include <sys/socket.h>
   52 #include <sys/queue.h>
   53 #include <sys/syslog.h>
   54 #include <sys/sysctl.h>
   55 #include <sys/device.h>
   57 #include <machine/bus.h>
   59 #include <net/if.h>
   60 #include <net/if_arp.h>
   61 #include <net/if_dl.h>
   62 #include <net/if_media.h>
   63 #include <net/if_types.h>
   65 #include <netinet/in.h>
   66 #include <netinet/in_systm.h>
   67 #include <netinet/in_var.h>
   68 #include <netinet/ip.h>
   69 #include <netinet/if_ether.h>
   71 #include <net80211/ieee80211_var.h>
   72 #include <net80211/ieee80211_ioctl.h>
   74 #include <dev/rndvar.h>
   76 #include <dev/ic/if_wireg.h>
   77 #include <dev/ic/if_wi_ieee.h>
   78 #include <dev/ic/if_wivar.h>
   80 void wihap_timeout(void *v);
   81 void wihap_sta_timeout(void *v);
   82 struct wihap_sta_info *wihap_sta_alloc(struct wi_softc *sc, u_int8_t *addr);
   83 void wihap_sta_delete(struct wihap_sta_info *sta);
   84 struct wihap_sta_info *wihap_sta_find(struct wihap_info *whi, u_int8_t *addr);
   85 int wihap_sta_is_assoc(struct wihap_info *whi, u_int8_t addr[]);
   86 void wihap_auth_req(struct wi_softc *sc, struct wi_frame *rxfrm,
caddr_t pkt, int len);
   88 void wihap_sta_deauth(struct wi_softc *sc, u_int8_t sta_addr[],
u_int16_t reason);
   90 void wihap_deauth_req(struct wi_softc *sc, struct wi_frame *rxfrm,
caddr_t pkt, int len);
   92 void wihap_assoc_req(struct wi_softc *sc, struct wi_frame *rxfrm,
caddr_t pkt, int len);
   94 void wihap_sta_disassoc(struct wi_softc *sc, u_int8_t sta_addr[],
u_int16_t reason);
   96 void wihap_disassoc_req(struct wi_softc *sc, struct wi_frame *rxfrm,
caddr_t pkt, int len);
   99 #ifndef SMALL_KERNEL
  100 /*
  101  * take_hword()
  102  *
  103  *      Used for parsing management frames.  The pkt pointer and length
  104  *      variables are updated after the value is removed.
  105  */
  106 static __inline u_int16_t
take_hword(caddr_t *ppkt, int *plen)
  108 {
u_int16_t s = letoh16(* (u_int16_t *) *ppkt);
  110         *ppkt += sizeof(u_int16_t);
  111         *plen -= sizeof(u_int16_t);
  112         return s;
  113 }
  115 /* take_tlv()
  116  *
  117  *      Parse out TLV element from a packet, check for underflow of packet
  118  *      or overflow of buffer, update pkt/len.
  119  */
  120 static int
take_tlv(caddr_t *ppkt, int *plen, int id_expect, void *dst, int maxlen)
  122 {
u_int8_t id, len;
  125         if (*plen < 2)
  126                 return -1;
id = ((u_int8_t *)*ppkt)[0];
len = ((u_int8_t *)*ppkt)[1];
  131         if (id != id_expect || *plen < len+2 || maxlen < len)
  132                 return -1;
bcopy(*ppkt + 2, dst, len);
  135         *plen -= 2 + len;
  136         *ppkt += 2 + len;
  138         return (len);
  139 }
  141 /* put_hword()
  142  *      Put half-word element into management frames.
  143  */
  144 static __inline void
put_hword(caddr_t *ppkt, u_int16_t s)
  146 {
  147         * (u_int16_t *) *ppkt = htole16(s);
  148         *ppkt += sizeof(u_int16_t);
  149 }
  151 /* put_tlv()
  152  *      Put TLV elements into management frames.
  153  */
  154 static void
put_tlv(caddr_t *ppkt, u_int8_t id, void *src, u_int8_t len)
  156 {
  157         (*ppkt)[0] = id;
  158         (*ppkt)[1] = len;
bcopy(src, (*ppkt) + 2, len);
  160         *ppkt += 2 + len;
  161 }
  163 static int
put_rates(caddr_t *ppkt, u_int16_t rates)
  165 {
u_int8_t ratebuf[8];
  167         int len = 0;
  169         if (rates & WI_SUPPRATES_1M)
ratebuf[len++] = 0x82;
  171         if (rates & WI_SUPPRATES_2M)
ratebuf[len++] = 0x84;
  173         if (rates & WI_SUPPRATES_5M)
ratebuf[len++] = 0x8b;
  175         if (rates & WI_SUPPRATES_11M)
ratebuf[len++] = 0x96;
put_tlv(ppkt, IEEE80211_ELEMID_RATES, ratebuf, len);
  179         return len;
  180 }
  182 /* wihap_init()
  183  *
  184  *      Initialize host AP data structures.  Called even if port type is
  185  *      not AP.  Caller MUST raise to splnet().
  186  */
  187 void
wihap_init(struct wi_softc *sc)
  189 {
  190         int i;
  191         struct wihap_info *whi = &sc->wi_hostap_info;
  193         if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_init: sc=%p whi=%p\n", sc, whi);
bzero(whi, sizeof(struct wihap_info));
  198         if (sc->wi_ptype != WI_PORTTYPE_HOSTAP)
  199                 return;
whi->apflags = WIHAPFL_ACTIVE;
TAILQ_INIT(&whi->sta_list);
  204         for (i = 0; i < WI_STA_HASH_SIZE; i++)
LIST_INIT(&whi->sta_hash[i]);
whi->inactivity_time = WIHAP_DFLT_INACTIVITY_TIME;
timeout_set(&whi->tmo, wihap_timeout, sc);
  209 }
  211 /* wihap_sta_disassoc()
  212  *
  213  *      Send a disassociation frame to a specified station.
  214  */
  215 void
wihap_sta_disassoc(struct wi_softc *sc, u_int8_t sta_addr[], u_int16_t reason)
  217 {
  218         struct wi_80211_hdr     *resp_hdr;
caddr_t                 pkt;
  221         if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("Sending disassoc to sta %s\n", ether_sprintf(sta_addr));
  224         /* Send disassoc packet. */
resp_hdr = (struct wi_80211_hdr *)sc->wi_txbuf;
bzero(resp_hdr, sizeof(struct wi_80211_hdr));
resp_hdr->frame_ctl = WI_FTYPE_MGMT | WI_STYPE_MGMT_DISAS;
pkt = (caddr_t)&sc->wi_txbuf + sizeof(struct wi_80211_hdr);
bcopy(sta_addr, resp_hdr->addr1, ETHER_ADDR_LEN);
bcopy(sc->sc_ic.ic_myaddr, resp_hdr->addr2, IEEE80211_ADDR_LEN);
bcopy(sc->sc_ic.ic_myaddr, resp_hdr->addr3, IEEE80211_ADDR_LEN);
put_hword(&pkt, reason);
wi_mgmt_xmit(sc, (caddr_t)&sc->wi_txbuf,
  237             2 + sizeof(struct wi_80211_hdr));
  238 }
  240 /* wihap_sta_deauth()
  241  *
  242  *      Send a deauthentication message to a specified station.
  243  */
  244 void
wihap_sta_deauth(struct wi_softc *sc, u_int8_t sta_addr[], u_int16_t reason)
  246 {
  247         struct wi_80211_hdr     *resp_hdr;
caddr_t                 pkt;
  250         if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("Sending deauth to sta %s\n", ether_sprintf(sta_addr));
  253         /* Send deauth packet. */
resp_hdr = (struct wi_80211_hdr *)sc->wi_txbuf;
bzero(resp_hdr, sizeof(struct wi_80211_hdr));
resp_hdr->frame_ctl = htole16(WI_FTYPE_MGMT | WI_STYPE_MGMT_DEAUTH);
pkt = (caddr_t)&sc->wi_txbuf + sizeof(struct wi_80211_hdr);
bcopy(sta_addr, resp_hdr->addr1, ETHER_ADDR_LEN);
bcopy(sc->sc_ic.ic_myaddr, resp_hdr->addr2, IEEE80211_ADDR_LEN);
bcopy(sc->sc_ic.ic_myaddr, resp_hdr->addr3, IEEE80211_ADDR_LEN);
put_hword(&pkt, reason);
wi_mgmt_xmit(sc, (caddr_t)&sc->wi_txbuf,
  266             2 + sizeof(struct wi_80211_hdr));
  267 }
  269 /* wihap_shutdown()
  270  *
  271  *      Disassociate all stations and free up data structures.
  272  */
  273 void
wihap_shutdown(struct wi_softc *sc)
  275 {
  276         struct wihap_info       *whi = &sc->wi_hostap_info;
  277         struct wihap_sta_info   *sta, *next;
  278         int i, s;
  280         if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_shutdown: sc=%p whi=%p\n", sc, whi);
  283         if (!(whi->apflags & WIHAPFL_ACTIVE))
  284                 return;
whi->apflags = 0;
s = splnet();
  289         /* Disable wihap inactivity timer. */
timeout_del(&whi->tmo);
  292         /* Delete all stations from the list. */
  293         for (sta = TAILQ_FIRST(&whi->sta_list);
sta != TAILQ_END(&whi->sta_list); sta = next) {
timeout_del(&sta->tmo);
  296                 if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_shutdown: FREE(sta=%p)\n", sta);
next = TAILQ_NEXT(sta, list);
  299                 if (sta->challenge)
FREE(sta->challenge, M_TEMP);
FREE(sta, M_DEVBUF);
  302         }
TAILQ_INIT(&whi->sta_list);
  305         /* Broadcast disassoc and deauth to all the stations. */
  306         if (sc->wi_flags & WI_FLAGS_ATTACHED) {
  307                 for (i = 0; i < 5; i++) {
wihap_sta_disassoc(sc, etherbroadcastaddr,
IEEE80211_REASON_ASSOC_LEAVE);
wihap_sta_deauth(sc, etherbroadcastaddr,
IEEE80211_REASON_AUTH_LEAVE);
DELAY(50);
  313                 }
  314         }
splx(s);
  317 }
  319 /* sta_hash_func()
  320  * Hash function for finding stations from ethernet address.
  321  */
  322 static __inline int
sta_hash_func(u_int8_t addr[])
  324 {
  325         return ((addr[3] + addr[4] + addr[5]) % WI_STA_HASH_SIZE);
  326 }
  328 /* addr_cmp():  Maybe this is a faster way to compare addresses? */
  329 static __inline int
addr_cmp(u_int8_t a[], u_int8_t b[])
  331 {
  332         return (*(u_int16_t *)(a + 4) == *(u_int16_t *)(b + 4) &&
  333                 *(u_int16_t *)(a + 2) == *(u_int16_t *)(b + 2) &&
  334                 *(u_int16_t *)(a    ) == *(u_int16_t *)(b));
  335 }
  337 /* wihap_sta_movetail(): move sta to the tail of the station list in whi */
  338 static __inline void
wihap_sta_movetail(struct wihap_info *whi, struct wihap_sta_info *sta)
  340 {
TAILQ_REMOVE(&whi->sta_list, sta, list);
sta->flags &= ~WI_SIFLAGS_DEAD;
TAILQ_INSERT_TAIL(&whi->sta_list, sta, list);
  344 }
  346 void
wihap_timeout(void *v)
  348 {
  349         struct wi_softc         *sc = v;
  350         struct wihap_info       *whi = &sc->wi_hostap_info;
  351         struct wihap_sta_info   *sta, *next;
  352         int     i, s;
s = splnet();
  356         for (i = 10, sta = TAILQ_FIRST(&whi->sta_list);
i != 0 && sta != TAILQ_END(&whi->sta_list) &&
  358             (sta->flags & WI_SIFLAGS_DEAD); i--, sta = next) {
next = TAILQ_NEXT(sta, list);
  360                 if (timeout_pending(&sta->tmo)) {
  361                         /* Became alive again, move to end of list. */
wihap_sta_movetail(whi, sta);
  363                 } else if (sta->flags & WI_SIFLAGS_ASSOC) {
  364                         if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_timeout: disassoc due to inactivity: %s\n",
ether_sprintf(sta->addr));
  368                         /* Disassoc station. */
wihap_sta_disassoc(sc, sta->addr,
IEEE80211_REASON_ASSOC_EXPIRE);
sta->flags &= ~WI_SIFLAGS_ASSOC;
  373                         /*
  374                          * Move to end of the list and reset station timeout.
  375                          * We do this to make sure we don't get deauthed
  376                          * until inactivity_time seconds have passed.
  377                          */
wihap_sta_movetail(whi, sta);
timeout_add(&sta->tmo, hz * whi->inactivity_time);
  380                 } else if (sta->flags & WI_SIFLAGS_AUTHEN) {
  381                         if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_timeout: deauth due to inactivity: %s\n",
ether_sprintf(sta->addr));
  385                         /* Deauthenticate station. */
wihap_sta_deauth(sc, sta->addr,
IEEE80211_REASON_AUTH_EXPIRE);
sta->flags &= ~WI_SIFLAGS_AUTHEN;
  390                         /* Delete the station if it's not permanent. */
  391                         if (sta->flags & WI_SIFLAGS_PERM)
wihap_sta_movetail(whi, sta);
  393                         else
wihap_sta_delete(sta);
  395                 }
  396         }
  398         /* Restart the timeout if there are still dead stations left. */
sta = TAILQ_FIRST(&whi->sta_list);
  400         if (sta != NULL && (sta->flags & WI_SIFLAGS_DEAD))
timeout_add(&whi->tmo, 1);      /* still work left, requeue */
splx(s);
  404 }
  406 void
wihap_sta_timeout(void *v)
  408 {
  409         struct wihap_sta_info   *sta = v;
  410         struct wi_softc         *sc = sta->sc;
  411         struct wihap_info       *whi = &sc->wi_hostap_info;
  412         int     s;
s = splnet();
  416         /* Mark sta as dead and move it to the head of the list. */
TAILQ_REMOVE(&whi->sta_list, sta, list);
sta->flags |= WI_SIFLAGS_DEAD;
TAILQ_INSERT_HEAD(&whi->sta_list, sta, list);
  421         /* Add wihap timeout if we have not already done so. */
  422         if (!timeout_pending(&whi->tmo))
timeout_add(&whi->tmo, hz / 10);
splx(s);
  426 }
  428 /* wihap_sta_delete()
  429  * Delete a single station and free up its data structure.
  430  * Caller must raise to splnet().
  431  */
  432 void
wihap_sta_delete(struct wihap_sta_info *sta)
  434 {
  435         struct wi_softc         *sc = sta->sc;
  436         struct wihap_info       *whi = &sc->wi_hostap_info;
  437         int i = sta->asid - 0xc001;
timeout_del(&sta->tmo);
whi->asid_inuse_mask[i >> 4] &= ~(1UL << (i & 0xf));
TAILQ_REMOVE(&whi->sta_list, sta, list);
LIST_REMOVE(sta, hash);
  445         if (sta->challenge)
FREE(sta->challenge, M_TEMP);
FREE(sta, M_DEVBUF);
whi->n_stations--;
  449 }
  451 /* wihap_sta_alloc()
  452  *
  453  *      Create a new station data structure and put it in the list
  454  *      and hash table.
  455  */
  456 struct wihap_sta_info *
wihap_sta_alloc(struct wi_softc *sc, u_int8_t *addr)
  458 {
  459         struct wihap_info       *whi = &sc->wi_hostap_info;
  460         struct wihap_sta_info   *sta;
  461         int i, hash = sta_hash_func(addr);
  463         /* Allocate structure. */
MALLOC(sta, struct wihap_sta_info *, sizeof(struct wihap_sta_info),
M_DEVBUF, M_NOWAIT);
  466         if (sta == NULL)
  467                 return (NULL);
bzero(sta, sizeof(struct wihap_sta_info));
  471         /* Allocate an ASID. */
i=hash<<4;
  473         while (whi->asid_inuse_mask[i >> 4] & (1UL << (i & 0xf)))
i = (i == (WI_STA_HASH_SIZE << 4) - 1) ? 0 : (i + 1);
whi->asid_inuse_mask[i >> 4] |= (1UL << (i & 0xf));
sta->asid = 0xc001 + i;
  478         /* Insert in list and hash list. */
TAILQ_INSERT_TAIL(&whi->sta_list, sta, list);
LIST_INSERT_HEAD(&whi->sta_hash[hash], sta, hash);
sta->sc = sc;
whi->n_stations++;
bcopy(addr, &sta->addr, ETHER_ADDR_LEN);
timeout_set(&sta->tmo, wihap_sta_timeout, sta);
timeout_add(&sta->tmo, hz * whi->inactivity_time);
  488         return (sta);
  489 }
  491 /* wihap_sta_find()
  492  *
  493  *      Find station structure given address.
  494  */
  495 struct wihap_sta_info *
wihap_sta_find(struct wihap_info *whi, u_int8_t *addr)
  497 {
  498         int i;
  499         struct wihap_sta_info *sta;
i = sta_hash_func(addr);
LIST_FOREACH(sta, &whi->sta_hash[i], hash)
  503                 if (addr_cmp(addr, sta->addr))
  504                         return sta;
  506         return (NULL);
  507 }
  509 static __inline int
wihap_check_rates(struct wihap_sta_info *sta, u_int8_t rates[], int rates_len)
  511 {
  512         struct wi_softc *sc = sta->sc;
  513         int     i;
sta->rates = 0;
sta->tx_max_rate = 0;
  517         for (i = 0; i < rates_len; i++)
  518                 switch (rates[i] & 0x7f) {
  519                 case 0x02:
sta->rates |= WI_SUPPRATES_1M;
  521                         break;
  522                 case 0x04:
sta->rates |= WI_SUPPRATES_2M;
  524                         if (sta->tx_max_rate < 1)
sta->tx_max_rate = 1;
  526                         break;
  527                 case 0x0b:
sta->rates |= WI_SUPPRATES_5M;
  529                         if (sta->tx_max_rate < 2)
sta->tx_max_rate = 2;
  531                         break;
  532                 case 0x16:
sta->rates |= WI_SUPPRATES_11M;
sta->tx_max_rate = 3;
  535                         break;
  536                 }
sta->rates &= sc->wi_supprates;
sta->tx_curr_rate = sta->tx_max_rate;
  541         return (sta->rates == 0 ? -1 : 0);
  542 }
  545 /* wihap_auth_req()
  546  *
  547  *      Handle incoming authentication request.
  548  */
  549 void
wihap_auth_req(struct wi_softc *sc, struct wi_frame *rxfrm,
caddr_t pkt, int len)
  552 {
  553         struct wihap_info       *whi = &sc->wi_hostap_info;
  554         struct wihap_sta_info   *sta;
  555         int                     i, s;
u_int16_t               algo;
u_int16_t               seq;
u_int16_t               status;
  560         int                     challenge_len;
u_int32_t               challenge[32];
  563         struct wi_80211_hdr     *resp_hdr;
  565         if (len < 6) {
  566                 if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_auth_req: station %s short request\n",
ether_sprintf(rxfrm->wi_addr2));
  569                 return;
  570         }
  572         /* Break open packet. */
algo = take_hword(&pkt, &len);
seq = take_hword(&pkt, &len);
status = take_hword(&pkt, &len);
  576         if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_auth_req: station %s algo=0x%x seq=0x%x\n",
ether_sprintf(rxfrm->wi_addr2), algo, seq);
  580         /* Ignore vendor private tlv (if any). */
  581         (void)take_tlv(&pkt, &len, IEEE80211_ELEMID_VENDOR, challenge,
  582             sizeof(challenge));
challenge_len = 0;
  585         if (len > 0 && (challenge_len = take_tlv(&pkt, &len,
IEEE80211_ELEMID_CHALLENGE, challenge, sizeof(challenge))) < 0) {
status = IEEE80211_STATUS_CHALLENGE;
  588                 goto fail;
  589         }
  591         /* Find or create station info. */
sta = wihap_sta_find(whi, rxfrm->wi_addr2);
  593         if (sta == NULL) {
  595                 /* Are we allowing new stations?
  596                  */
  597                 if (whi->apflags & WIHAPFL_MAC_FILT) {
status = IEEE80211_STATUS_OTHER; /* XXX */
  599                         goto fail;
  600                 }
  602                 /* Check for too many stations.
  603                  */
  604                 if (whi->n_stations >= WIHAP_MAX_STATIONS) {
status = IEEE80211_STATUS_TOOMANY;
  606                         goto fail;
  607                 }
  609                 if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_auth_req: new station\n");
  612                 /* Create new station. */
s = splnet();
sta = wihap_sta_alloc(sc, rxfrm->wi_addr2);
splx(s);
  616                 if (sta == NULL) {
  617                         /* Out of memory! */
status = IEEE80211_STATUS_TOOMANY;
  619                         goto fail;
  620                 }
  621         }
timeout_add(&sta->tmo, hz * whi->inactivity_time);
  624         /* Note: it's okay to leave the station info structure around
  625          * if the authen fails.  It'll be timed out eventually.
  626          */
  627         switch (algo) {
  628         case IEEE80211_AUTH_ALG_OPEN:
  629                 if (sc->wi_authtype != IEEE80211_AUTH_OPEN) {
status = IEEE80211_STATUS_ALG;
  631                         goto fail;
  632                 }
  633                 if (seq != 1) {
status = IEEE80211_STATUS_SEQUENCE;
  635                         goto fail;
  636                 }
challenge_len = 0;
sta->flags |= WI_SIFLAGS_AUTHEN;
  639                 break;
  640         case IEEE80211_AUTH_ALG_SHARED:
  641                 if (sc->wi_authtype != IEEE80211_AUTH_SHARED) {
status = IEEE80211_STATUS_ALG;
  643                         goto fail;
  644                 }
  645                 switch (seq) {
  646                 case 1:
  647                         /* Create a challenge frame. */
  648                         if (!sta->challenge) {
MALLOC(sta->challenge, u_int32_t *, 128,
M_TEMP, M_NOWAIT);
  651                                 if (!sta->challenge)
  652                                         return;
  653                         }
  654                         for (i = 0; i < 32; i++)
challenge[i] = sta->challenge[i] =
arc4random();
  658                         if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("\tchallenge: 0x%x 0x%x ...\n",
challenge[0], challenge[1]);
challenge_len = 128;
  662                         break;
  663                 case 3:
  664                         if (challenge_len != 128 || !sta->challenge ||
  665                             !(letoh16(rxfrm->wi_frame_ctl) & WI_FCTL_WEP)) {
status = IEEE80211_STATUS_CHALLENGE;
  667                                 goto fail;
  668                         }
  670                         for (i=0; i<32; i++)
  671                                 if (sta->challenge[i] != challenge[i]) {
status = IEEE80211_STATUS_CHALLENGE;
  673                                         goto fail;
  674                                 }
sta->flags |= WI_SIFLAGS_AUTHEN;
FREE(sta->challenge, M_TEMP);
sta->challenge = NULL;
challenge_len = 0;
  680                         break;
  681                 default:
status = IEEE80211_STATUS_SEQUENCE;
  683                         goto fail;
  684                 } /* switch (seq) */
  685                 break;
  686         default:
  687                 if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_auth_req: algorithm unsupported: 0x%x\n",
algo);
status = IEEE80211_STATUS_ALG;
  691                 goto fail;
  692         } /* switch (algo) */
status = IEEE80211_STATUS_SUCCESS;
fail:
  697         if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_auth_req: returns status=0x%x\n", status);
  700         /* Send response. */
resp_hdr = (struct wi_80211_hdr *)&sc->wi_txbuf;
bzero(resp_hdr, sizeof(struct wi_80211_hdr));
resp_hdr->frame_ctl = htole16(WI_FTYPE_MGMT | WI_STYPE_MGMT_AUTH);
bcopy(rxfrm->wi_addr2, resp_hdr->addr1, ETHER_ADDR_LEN);
bcopy(sc->sc_ic.ic_myaddr, resp_hdr->addr2, IEEE80211_ADDR_LEN);
bcopy(sc->sc_ic.ic_myaddr, resp_hdr->addr3, IEEE80211_ADDR_LEN);
pkt = (caddr_t)&sc->wi_txbuf + sizeof(struct wi_80211_hdr);
put_hword(&pkt, algo);
put_hword(&pkt, seq + 1);
put_hword(&pkt, status);
  712         if (challenge_len > 0)
put_tlv(&pkt, IEEE80211_ELEMID_CHALLENGE,
challenge, challenge_len);
wi_mgmt_xmit(sc, (caddr_t)&sc->wi_txbuf,
  717             6 + sizeof(struct wi_80211_hdr) +
  718             (challenge_len > 0 ? challenge_len + 2 : 0));
  719 }
  722 /* wihap_assoc_req()
  723  *
  724  *      Handle incoming association and reassociation requests.
  725  */
  726 void
wihap_assoc_req(struct wi_softc *sc, struct wi_frame *rxfrm,
caddr_t pkt, int len)
  729 {
  730         struct wihap_info       *whi = &sc->wi_hostap_info;
  731         struct wihap_sta_info   *sta;
  732         struct wi_80211_hdr     *resp_hdr;
u_int16_t               capinfo;
u_int16_t               lstintvl;
u_int8_t                rates[12];
  736         int                     ssid_len, rates_len;
  737         struct ieee80211_nwid   ssid;
u_int16_t               status;
u_int16_t               asid = 0;
  741         if (len < 8)
  742                 return;
  744         /* Pull out request parameters. */
capinfo = take_hword(&pkt, &len);
lstintvl = take_hword(&pkt, &len);
  748         if ((rxfrm->wi_frame_ctl & htole16(WI_FCTL_STYPE)) ==
htole16(WI_STYPE_MGMT_REASREQ)) {
  750                 if (len < 6)
  751                         return;
  752                 /* Eat the MAC address of the current AP */
take_hword(&pkt, &len);
take_hword(&pkt, &len);
take_hword(&pkt, &len);
  756         }
  758         if ((ssid_len = take_tlv(&pkt, &len, IEEE80211_ELEMID_SSID,
ssid.i_nwid, sizeof(ssid))) < 0)
  760                 return;
ssid.i_len = ssid_len;
  762         if ((rates_len = take_tlv(&pkt, &len, IEEE80211_ELEMID_RATES,
rates, sizeof(rates))) < 0)
  764                 return;
  766         if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_assoc_req: from station %s\n",
ether_sprintf(rxfrm->wi_addr2));
  770         /* If SSID doesn't match, simply drop. */
  771         if (sc->wi_net_name.i_len != ssid.i_len ||
memcmp(sc->wi_net_name.i_nwid, ssid.i_nwid, ssid.i_len)) {
  774                 if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_assoc_req: bad ssid: '%.*s' != '%.*s'\n",
ssid.i_len, ssid.i_nwid, sc->wi_net_name.i_len,
sc->wi_net_name.i_nwid);
  778                 return;
  779         }
  781         /* Is this station authenticated yet? */
sta = wihap_sta_find(whi, rxfrm->wi_addr2);
  783         if (sta == NULL || !(sta->flags & WI_SIFLAGS_AUTHEN)) {
wihap_sta_deauth(sc, rxfrm->wi_addr2,
IEEE80211_REASON_NOT_AUTHED);
  786                 return;
  787         }
  789         /* Check supported rates against ours. */
  790         if (wihap_check_rates(sta, rates, rates_len) < 0) {
  791                 if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_assoc_req: rates mismatch.\n");
status = IEEE80211_STATUS_BASIC_RATE;
  794                 goto fail;
  795         }
  797         /* Check capinfo.
  798          * Check for ESS, not IBSS.
  799          * Check WEP/PRIVACY flags match.
  800          * Refuse stations requesting to be put on CF-polling list.
  801          */
sta->capinfo = capinfo;
status = IEEE80211_STATUS_CAPINFO;
  804         if ((capinfo & (IEEE80211_CAPINFO_ESS | IEEE80211_CAPINFO_IBSS)) !=
IEEE80211_CAPINFO_ESS) {
  806                 if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_assoc_req: capinfo: not ESS: "
  808                             "capinfo=0x%x\n", capinfo);
  809                 goto fail;
  811         }
  812         if ((sc->wi_use_wep && !(capinfo & IEEE80211_CAPINFO_PRIVACY)) ||
  813             (!sc->wi_use_wep && (capinfo & IEEE80211_CAPINFO_PRIVACY))) {
  814                 if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_assoc_req: WEP flag mismatch: "
  816                             "capinfo=0x%x\n", capinfo);
  817                 goto fail;
  818         }
  819         if ((capinfo & (IEEE80211_CAPINFO_CF_POLLABLE |
IEEE80211_CAPINFO_CF_POLLREQ)) == IEEE80211_CAPINFO_CF_POLLABLE) {
  821                 if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_assoc_req: polling not supported: "
  823                             "capinfo=0x%x\n", capinfo);
  824                 goto fail;
  825         }
  827         /* Use ASID is allocated by whi_sta_alloc(). */
asid = sta->asid;
  830         if (sta->flags & WI_SIFLAGS_ASSOC) {
  831                 if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_assoc_req: already assoc'ed?\n");
  833         }
sta->flags |= WI_SIFLAGS_ASSOC;
timeout_add(&sta->tmo, hz * whi->inactivity_time);
status = IEEE80211_STATUS_SUCCESS;
fail:
  840         if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_assoc_req: returns status=0x%x\n", status);
  843         /* Send response. */
resp_hdr = (struct wi_80211_hdr *)&sc->wi_txbuf;
bzero(resp_hdr, sizeof(struct wi_80211_hdr));
resp_hdr->frame_ctl = htole16(WI_FTYPE_MGMT | WI_STYPE_MGMT_ASRESP);
pkt = (caddr_t)&sc->wi_txbuf + sizeof(struct wi_80211_hdr);
bcopy(rxfrm->wi_addr2, resp_hdr->addr1, ETHER_ADDR_LEN);
bcopy(sc->sc_ic.ic_myaddr, resp_hdr->addr2, IEEE80211_ADDR_LEN);
bcopy(sc->sc_ic.ic_myaddr, resp_hdr->addr3, IEEE80211_ADDR_LEN);
put_hword(&pkt, capinfo);
put_hword(&pkt, status);
put_hword(&pkt, asid);
rates_len = put_rates(&pkt, sc->wi_supprates);
wi_mgmt_xmit(sc, (caddr_t)&sc->wi_txbuf,
  859             8 + rates_len + sizeof(struct wi_80211_hdr));
  860 }
  862 /* wihap_deauth_req()
  863  *
  864  *      Handle deauthentication requests.  Delete the station.
  865  */
  866 void
wihap_deauth_req(struct wi_softc *sc, struct wi_frame *rxfrm,
caddr_t pkt, int len)
  869 {
  870         struct wihap_info       *whi = &sc->wi_hostap_info;
  871         struct wihap_sta_info   *sta;
u_int16_t               reason;
  874         if (len<2)
  875                 return;
reason = take_hword(&pkt, &len);
sta = wihap_sta_find(whi, rxfrm->wi_addr2);
  880         if (sta == NULL) {
  881                 if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_deauth_req: unknown station: %s\n",
ether_sprintf(rxfrm->wi_addr2));
  884         }
  885         else
wihap_sta_delete(sta);
  887 }
  889 /* wihap_disassoc_req()
  890  *
  891  *      Handle disassociation requests.  Just reset the assoc flag.
  892  *      We'll free up the station resources when we get a deauth
  893  *      request or when it times out.
  894  */
  895 void
wihap_disassoc_req(struct wi_softc *sc, struct wi_frame *rxfrm,
caddr_t pkt, int len)
  898 {
  899         struct wihap_info       *whi = &sc->wi_hostap_info;
  900         struct wihap_sta_info   *sta;
u_int16_t               reason;
  903         if (len < 2)
  904                 return;
reason = take_hword(&pkt, &len);
sta = wihap_sta_find(whi, rxfrm->wi_addr2);
  909         if (sta == NULL) {
  910                 if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
printf("wihap_disassoc_req: unknown station: %s\n",
ether_sprintf(rxfrm->wi_addr2));
  913         }
  914         else if (!(sta->flags & WI_SIFLAGS_AUTHEN)) {
  915                 /*
  916                  * If station is not authenticated, send deauthentication
  917                  * frame.
  918                  */
wihap_sta_deauth(sc, rxfrm->wi_addr2,
IEEE80211_REASON_NOT_AUTHED);
  921                 return;
  922         }
  923         else
sta->flags &= ~WI_SIFLAGS_ASSOC;
  925 }
  927 /* wihap_debug_frame_type()
  928  *
  929  * Print out frame type.  Used in early debugging.
  930  */
  931 static __inline void
wihap_debug_frame_type(struct wi_frame *rxfrm)
  933 {
printf("wihap_mgmt_input: len=%d ", letoh16(rxfrm->wi_dat_len));
  936         if ((rxfrm->wi_frame_ctl & htole16(WI_FCTL_FTYPE)) ==
htole16(WI_FTYPE_MGMT)) {
printf("MGMT: ");
  941                 switch (letoh16(rxfrm->wi_frame_ctl) & WI_FCTL_STYPE) {
  942                 case WI_STYPE_MGMT_ASREQ:
printf("assoc req: \n");
  944                         break;
  945                 case WI_STYPE_MGMT_ASRESP:
printf("assoc resp: \n");
  947                         break;
  948                 case WI_STYPE_MGMT_REASREQ:
printf("reassoc req: \n");
  950                         break;
  951                 case WI_STYPE_MGMT_REASRESP:
printf("reassoc resp: \n");
  953                         break;
  954                 case WI_STYPE_MGMT_PROBEREQ:
printf("probe req: \n");
  956                         break;
  957                 case WI_STYPE_MGMT_PROBERESP:
printf("probe resp: \n");
  959                         break;
  960                 case WI_STYPE_MGMT_BEACON:
printf("beacon: \n");
  962                         break;
  963                 case WI_STYPE_MGMT_ATIM:
printf("ann traf ind \n");
  965                         break;
  966                 case WI_STYPE_MGMT_DISAS:
printf("disassociation: \n");
  968                         break;
  969                 case WI_STYPE_MGMT_AUTH:
printf("auth: \n");
  971                         break;
  972                 case WI_STYPE_MGMT_DEAUTH:
printf("deauth: \n");
  974                         break;
  975                 default:
printf("unknown (stype=0x%x)\n",
letoh16(rxfrm->wi_frame_ctl) & WI_FCTL_STYPE);
  978                 }
  980         }
  981         else {
printf("ftype=0x%x (ctl=0x%x)\n",
letoh16(rxfrm->wi_frame_ctl) & WI_FCTL_FTYPE,
letoh16(rxfrm->wi_frame_ctl));
  985         }
  986 }
  988 /*
  989  * wihap_mgmt_input:
  990  *
  991  *      Called for each management frame received in host ap mode.
  992  *      wihap_mgmt_input() is expected to free the mbuf.
  993  */
  994 void
wihap_mgmt_input(struct wi_softc *sc, struct wi_frame *rxfrm, struct mbuf *m)
  996 {
caddr_t pkt;
  998         int     s, len;
 1000         if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
wihap_debug_frame_type(rxfrm);
pkt = mtod(m, caddr_t) + WI_802_11_OFFSET_RAW;
len = m->m_len - WI_802_11_OFFSET_RAW;
 1006         if ((rxfrm->wi_frame_ctl & htole16(WI_FCTL_FTYPE)) ==
htole16(WI_FTYPE_MGMT)) {
 1009                 /* any of the following will mess w/ the station list */
s = splsoftclock();
 1011                 switch (letoh16(rxfrm->wi_frame_ctl) & WI_FCTL_STYPE) {
 1012                 case WI_STYPE_MGMT_ASREQ:
wihap_assoc_req(sc, rxfrm, pkt, len);
 1014                         break;
 1015                 case WI_STYPE_MGMT_ASRESP:
 1016                         break;
 1017                 case WI_STYPE_MGMT_REASREQ:
wihap_assoc_req(sc, rxfrm, pkt, len);
 1019                         break;
 1020                 case WI_STYPE_MGMT_REASRESP:
 1021                         break;
 1022                 case WI_STYPE_MGMT_PROBEREQ:
 1023                         break;
 1024                 case WI_STYPE_MGMT_PROBERESP:
 1025                         break;
 1026                 case WI_STYPE_MGMT_BEACON:
 1027                         break;
 1028                 case WI_STYPE_MGMT_ATIM:
 1029                         break;
 1030                 case WI_STYPE_MGMT_DISAS:
wihap_disassoc_req(sc, rxfrm, pkt, len);
 1032                         break;
 1033                 case WI_STYPE_MGMT_AUTH:
wihap_auth_req(sc, rxfrm, pkt, len);
 1035                         break;
 1036                 case WI_STYPE_MGMT_DEAUTH:
wihap_deauth_req(sc, rxfrm, pkt, len);
 1038                         break;
 1039                 }
splx(s);
 1041         }
m_freem(m);
 1044 }
 1046 /* wihap_sta_is_assoc()
 1047  *
 1048  *      Determine if a station is assoc'ed.  Update its activity
 1049  *      counter as a side-effect.
 1050  */
 1051 int
wihap_sta_is_assoc(struct wihap_info *whi, u_int8_t addr[])
 1053 {
 1054         struct wihap_sta_info *sta;
sta = wihap_sta_find(whi, addr);
 1057         if (sta != NULL && (sta->flags & WI_SIFLAGS_ASSOC)) {
 1058                 /* Keep it active. */
timeout_add(&sta->tmo, hz * whi->inactivity_time);
 1060                 return (1);
 1061         }
 1063         return (0);
 1064 }
 1066 /* wihap_check_tx()
 1067  *
 1068  *      Determine if a station is assoc'ed, get its tx rate, and update
 1069  *      its activity.
 1070  */
 1071 int
wihap_check_tx(struct wihap_info *whi, u_int8_t addr[], u_int8_t *txrate)
 1073 {
 1074         struct wihap_sta_info *sta;
 1075         static u_int8_t txratetable[] = { 10, 20, 55, 110 };
 1076         int s;
 1078         if (addr[0] & 0x01) {
 1079                 *txrate = 0; /* XXX: multicast rate? */
 1080                 return (1);
 1081         }
s = splsoftclock();
sta = wihap_sta_find(whi, addr);
 1085         if (sta != NULL && (sta->flags & WI_SIFLAGS_ASSOC)) {
 1086                 /* Keep it active. */
timeout_add(&sta->tmo, hz * whi->inactivity_time);
 1088                 *txrate = txratetable[sta->tx_curr_rate];
splx(s);
 1090                 return (1);
 1091         }
splx(s);
 1094         return (0);
 1095 }
 1097 /*
 1098  * wihap_data_input()
 1099  *
 1100  *      Handle all data input on interface when in Host AP mode.
 1101  *      Some packets are destined for this machine, others are
 1102  *      repeated to other stations.
 1103  *
 1104  *      If wihap_data_input() returns a non-zero, it has processed
 1105  *      the packet and will free the mbuf.
 1106  */
 1107 int
wihap_data_input(struct wi_softc *sc, struct wi_frame *rxfrm, struct mbuf *m)
 1109 {
 1110         struct ifnet            *ifp = &sc->sc_ic.ic_if;
 1111         struct wihap_info       *whi = &sc->wi_hostap_info;
 1112         struct wihap_sta_info   *sta;
 1113         int                     mcast, s;
u_int16_t               fctl;
 1116         /*
 1117          * TODS flag must be set.  However, Lucent cards set NULLFUNC but
 1118          * not TODS when probing an AP to see if it is alive after it has
 1119          * been down for a while.  We accept these probe packets and send a
 1120          * disassoc packet later on if the station is not already associated.
 1121          */
fctl = letoh16(rxfrm->wi_frame_ctl);
 1123         if (!(fctl & WI_FCTL_TODS) && !(fctl & WI_STYPE_NULLFUNC)) {
 1124                 if (ifp->if_flags & IFF_DEBUG)
printf("wihap_data_input: no TODS src=%s, fctl=0x%x\n",
ether_sprintf(rxfrm->wi_addr2), fctl);
m_freem(m);
 1128                 return (1);
 1129         }
 1131         /* Check BSSID. (Is this necessary?) */
 1132         if (!addr_cmp(rxfrm->wi_addr1, sc->sc_ic.ic_myaddr)) {
 1133                 if (ifp->if_flags & IFF_DEBUG)
printf("wihap_data_input: incorrect bss: %s\n",
ether_sprintf(rxfrm->wi_addr1));
m_freem(m);
 1137                 return (1);
 1138         }
s = splsoftclock();
 1142         /* Find source station. */
sta = wihap_sta_find(whi, rxfrm->wi_addr2);
 1145         /* Source station must be associated. */
 1146         if (sta == NULL || !(sta->flags & WI_SIFLAGS_ASSOC)) {
 1147                 if (ifp->if_flags & IFF_DEBUG)
printf("wihap_data_input: dropping unassoc src %s\n",
ether_sprintf(rxfrm->wi_addr2));
wihap_sta_disassoc(sc, rxfrm->wi_addr2,
IEEE80211_REASON_ASSOC_LEAVE);
splx(s);
m_freem(m);
 1154                 return (1);
 1155         }
timeout_add(&sta->tmo, hz * whi->inactivity_time);
sta->sig_info = letoh16(rxfrm->wi_q_info);
splx(s);
 1162         /* Repeat this packet to BSS? */
mcast = (rxfrm->wi_addr3[0] & 0x01) != 0;
 1164         if (mcast || wihap_sta_is_assoc(whi, rxfrm->wi_addr3)) {
 1166                 /* If it's multicast, make a copy.
 1167                  */
 1168                 if (mcast) {
m = m_copym(m, 0, M_COPYALL, M_DONTWAIT);
 1170                         if (m == NULL)
 1171                                 return (0);
m->m_flags |= M_MCAST; /* XXX */
 1173                 }
 1175                 /* Queue up for repeating.
 1176                  */
 1177                 if (IF_QFULL(&ifp->if_snd)) {
IF_DROP(&ifp->if_snd);
m_freem(m);
 1180                 }
 1181                 else {
ifp->if_obytes += m->m_pkthdr.len;
 1183                         if (m->m_flags & M_MCAST)
ifp->if_omcasts++;
IF_ENQUEUE(&ifp->if_snd, m);
 1186                         if ((ifp->if_flags & IFF_OACTIVE) == 0)
 1187                                 (*ifp->if_start)(ifp);
 1188                 }
 1189                 return (!mcast);
 1190         }
 1192         return (0);
 1193 }
 1195 /* wihap_ioctl()
 1196  *
 1197  *      Handle Host AP specific ioctls.  Called from wi_ioctl().
 1198  */
 1199 int
wihap_ioctl(struct wi_softc *sc, u_long command, caddr_t data)
 1201 {
 1202         struct proc             *p = curproc;
 1203         struct ifreq            *ifr = (struct ifreq *) data;
 1204         struct wihap_info       *whi = &sc->wi_hostap_info;
 1205         struct wihap_sta_info   *sta;
 1206         struct hostap_getall    reqall;
 1207         struct hostap_sta       reqsta;
 1208         struct hostap_sta       stabuf;
 1209         int                     s, error = 0, n, flag;
 1211         struct ieee80211_nodereq nr;
 1212         struct ieee80211_nodereq_all *na;
 1214         if (!(sc->sc_ic.ic_if.if_flags & IFF_RUNNING))
 1215                 return ENODEV;
 1217         switch (command) {
 1218         case SIOCHOSTAP_DEL:
 1219                 if ((error = suser(p, 0)))
 1220                         break;
 1221                 if ((error = copyin(ifr->ifr_data, &reqsta, sizeof(reqsta))))
 1222                         break;
s = splnet();
sta = wihap_sta_find(whi, reqsta.addr);
 1225                 if (sta == NULL)
error = ENOENT;
 1227                 else {
 1228                         /* Disassociate station. */
 1229                         if (sta->flags & WI_SIFLAGS_ASSOC)
wihap_sta_disassoc(sc, sta->addr,
IEEE80211_REASON_ASSOC_LEAVE);
 1232                         /* Deauth station. */
 1233                         if (sta->flags & WI_SIFLAGS_AUTHEN)
wihap_sta_deauth(sc, sta->addr,
IEEE80211_REASON_AUTH_LEAVE);
wihap_sta_delete(sta);
 1238                 }
splx(s);
 1240                 break;
 1242         case SIOCHOSTAP_GET:
 1243                 if ((error = copyin(ifr->ifr_data, &reqsta, sizeof(reqsta))))
 1244                         break;
s = splnet();
sta = wihap_sta_find(whi, reqsta.addr);
 1247                 if (sta == NULL)
error = ENOENT;
 1249                 else {
reqsta.flags = sta->flags;
reqsta.asid = sta->asid;
reqsta.capinfo = sta->capinfo;
reqsta.sig_info = sta->sig_info;
reqsta.rates = sta->rates;
error = copyout(&reqsta, ifr->ifr_data,
 1257                             sizeof(reqsta));
 1258                 }
splx(s);
 1260                 break;
 1262         case SIOCHOSTAP_ADD:
 1263                 if ((error = suser(p, 0)))
 1264                         break;
 1265                 if ((error = copyin(ifr->ifr_data, &reqsta, sizeof(reqsta))))
 1266                         break;
s = splnet();
sta = wihap_sta_find(whi, reqsta.addr);
 1269                 if (sta != NULL) {
error = EEXIST;
splx(s);
 1272                         break;
 1273                 }
 1274                 if (whi->n_stations >= WIHAP_MAX_STATIONS) {
error = ENOSPC;
splx(s);
 1277                         break;
 1278                 }
sta = wihap_sta_alloc(sc, reqsta.addr);
sta->flags = reqsta.flags;
timeout_add(&sta->tmo, hz * whi->inactivity_time);
splx(s);
 1283                 break;
 1285         case SIOCHOSTAP_SFLAGS:
 1286                 if ((error = suser(p, 0)))
 1287                         break;
 1288                 if ((error = copyin(ifr->ifr_data, &flag, sizeof(int))))
 1289                         break;
whi->apflags = (whi->apflags & WIHAPFL_CANTCHANGE) |
 1292                     (flag & ~WIHAPFL_CANTCHANGE);
 1293                 break;
 1295         case SIOCHOSTAP_GFLAGS:
flag = (int) whi->apflags;
error = copyout(&flag, ifr->ifr_data, sizeof(int));
 1298                 break;
 1300         case SIOCHOSTAP_GETALL:
 1301                 if ((error = copyin(ifr->ifr_data, &reqall, sizeof(reqall))))
 1302                         break;
reqall.nstations = whi->n_stations;
n = 0;
s = splnet();
sta = TAILQ_FIRST(&whi->sta_list);
 1308                 while (sta && reqall.size >= n+sizeof(struct hostap_sta)) {
bcopy(sta->addr, stabuf.addr, ETHER_ADDR_LEN);
stabuf.asid = sta->asid;
stabuf.flags = sta->flags;
stabuf.capinfo = sta->capinfo;
stabuf.sig_info = sta->sig_info;
stabuf.rates = sta->rates;
error = copyout(&stabuf, (caddr_t) reqall.addr + n,
 1318                             sizeof(struct hostap_sta));
 1319                         if (error)
 1320                                 break;
sta = TAILQ_NEXT(sta, list);
n += sizeof(struct hostap_sta);
 1324                 }
splx(s);
 1327                 if (!error)
error = copyout(&reqall, ifr->ifr_data,
 1329                             sizeof(reqall));
 1330                 break;
 1332         case SIOCG80211ALLNODES:
na = (struct ieee80211_nodereq_all *)data;
na->na_nodes = n = 0;
s = splnet();
sta = TAILQ_FIRST(&whi->sta_list);
 1337                 while (sta && na->na_size >=
n + sizeof(struct ieee80211_nodereq)) {
bzero(&nr, sizeof(nr));
IEEE80211_ADDR_COPY(nr.nr_macaddr, sta->addr);
IEEE80211_ADDR_COPY(nr.nr_bssid,
 1342                             &sc->sc_ic.ic_myaddr);
nr.nr_channel = sc->wi_channel;
nr.nr_chan_flags = IEEE80211_CHAN_B;
nr.nr_associd = sta->asid;
nr.nr_rssi = sta->sig_info >> 8;
nr.nr_max_rssi = 0;
nr.nr_capinfo = sta->capinfo;
nr.nr_nrates = 0;
 1350                         if (sta->rates & WI_SUPPRATES_1M)
nr.nr_rates[nr.nr_nrates++] = 2;
 1352                         if (sta->rates & WI_SUPPRATES_2M)
nr.nr_rates[nr.nr_nrates++] = 4;
 1354                         if (sta->rates & WI_SUPPRATES_5M)
nr.nr_rates[nr.nr_nrates++] = 11;
 1356                         if (sta->rates & WI_SUPPRATES_11M)
nr.nr_rates[nr.nr_nrates++] = 22;
error = copyout(&nr, (caddr_t)na->na_node + n,
 1360                             sizeof(struct ieee80211_nodereq));
 1361                         if (error)
 1362                                 break;
n += sizeof(struct ieee80211_nodereq);
na->na_nodes++;
sta = TAILQ_NEXT(sta, list);
 1366                 }
splx(s);
 1368                 break;
 1370         default:
printf("wihap_ioctl: i shouldn't get other ioctls!\n");
error = EINVAL;
 1373         }
 1375         return (error);
 1376 }
 1378 #else
 1379 void
wihap_init(struct wi_softc *sc)
 1381 {
 1382         return;
 1383 }
 1385 void
wihap_shutdown(struct wi_softc *sc)
 1387 {
 1388         return;
 1389 }
 1391 void
wihap_mgmt_input(struct wi_softc *sc, struct wi_frame *rxfrm, struct mbuf *m)
 1393 {
 1394         return;
 1395 }
 1397 int
wihap_data_input(struct wi_softc *sc, struct wi_frame *rxfrm, struct mbuf *m)
 1399 {
 1400         return (0);
 1401 }
 1403 int
wihap_ioctl(struct wi_softc *sc, u_long command, caddr_t data)
 1405 {
 1406         return (EINVAL);
 1407 }
 1409 int
wihap_check_tx(struct wihap_info *whi, u_int8_t addr[], u_int8_t *txrate)
 1411 {
 1412         return (0);
 1413 }
 1414 #endif