sys/netproto/802_11/wlan/ieee80211_input.c

   1 /*-
   2  * Copyright (c) 2001 Atsushi Onoe
   3  * Copyright (c) 2002-2009 Sam Leffler, Errno Consulting
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  *
  26  * $FreeBSD: head/sys/net80211/ieee80211_input.c 205986 2010-03-31 16:07:36Z rpaulo $
  27  */
  28
  29 #include "opt_wlan.h"
  30
  31 #include <sys/param.h>
  32 #include <sys/systm.h>
  33 #include <sys/mbuf.h>
  34 #include <sys/malloc.h>
  35 #include <sys/endian.h>
  36 #include <sys/kernel.h>
  37
  38 #include <sys/socket.h>
  39
  40 #include <net/ethernet.h>
  41 #include <net/if.h>
  42 #include <net/if_llc.h>
  43 #include <net/if_media.h>
  44 #include <net/route.h>
  45
  46 #include <netproto/802_11/ieee80211_var.h>
  47 #include <netproto/802_11/ieee80211_input.h>
  48 #ifdef IEEE80211_SUPPORT_MESH
  49 #include <netproto/802_11/ieee80211_mesh.h>
  50 #endif
  51
  52 #include <net/bpf.h>
  53
  54 #ifdef INET
  55 #include <netinet/in.h>
  56 #include <net/ethernet.h>
  57 #endif
  58
  59 int
  60 ieee80211_input_all(struct ieee80211com *ic, struct mbuf *m, int rssi, int nf)
  61 {
  62         struct ieee80211vap *vap;
  63         int type = -1;
  64
  65         m->m_flags |= M_BCAST;          /* NB: mark for bpf tap'ing */
  66
  67         /* XXX locking */
  68         TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
  69                 struct ieee80211_node *ni;
  70                 struct mbuf *mcopy;
  71
  72                 /* NB: could check for IFF_UP but this is cheaper */
  73                 if (vap->iv_state == IEEE80211_S_INIT)
  74                         continue;
  75                 /*
  76                  * WDS vap's only receive directed traffic from the
  77                  * station at the ``far end''.  That traffic should
  78                  * be passed through the AP vap the station is associated
  79                  * to--so don't spam them with mcast frames.
  80                  */
  81                 if (vap->iv_opmode == IEEE80211_M_WDS)
  82                         continue;
  83                 if (TAILQ_NEXT(vap, iv_next) != NULL) {
  84                         /*
  85                          * Packet contents are changed by ieee80211_decap
  86                          * so do a deep copy of the packet.
  87                          */
  88                         mcopy = m_dup(m, MB_DONTWAIT);
  89                         if (mcopy == NULL) {
  90                                 /* XXX stat+msg */
  91                                 continue;
  92                         }
  93                 } else {
  94                         mcopy = m;
  95                         m = NULL;
  96                 }
  97                 ni = ieee80211_ref_node(vap->iv_bss);
  98                 type = ieee80211_input(ni, mcopy, rssi, nf);
  99                 ieee80211_free_node(ni);
 100         }
 101         if (m != NULL)                  /* no vaps, reclaim mbuf */
 102                 m_freem(m);
 103         return type;
 104 }
 105
 106 /*
 107  * This function reassembles fragments.
 108  *
 109  * XXX should handle 3 concurrent reassemblies per-spec.
 110  */
 111 struct mbuf *
 112 ieee80211_defrag(struct ieee80211_node *ni, struct mbuf *m, int hdrspace)
 113 {
 114         struct ieee80211vap *vap = ni->ni_vap;
 115         struct ieee80211_frame *wh = mtod(m, struct ieee80211_frame *);
 116         struct ieee80211_frame *lwh;
 117         uint16_t rxseq;
 118         uint8_t fragno;
 119         uint8_t more_frag = wh->i_fc[1] & IEEE80211_FC1_MORE_FRAG;
 120         struct mbuf *mfrag;
 121
 122         KASSERT(!IEEE80211_IS_MULTICAST(wh->i_addr1), ("multicast fragm?"));
 123
 124         rxseq = le16toh(*(uint16_t *)wh->i_seq);
 125         fragno = rxseq & IEEE80211_SEQ_FRAG_MASK;
 126
 127         /* Quick way out, if there's nothing to defragment */
 128         if (!more_frag && fragno == 0 && ni->ni_rxfrag[0] == NULL)
 129                 return m;
 130
 131         /*
 132          * Remove frag to insure it doesn't get reaped by timer.
 133          */
 134         if (ni->ni_table == NULL) {
 135                 /*
 136                  * Should never happen.  If the node is orphaned (not in
 137                  * the table) then input packets should not reach here.
 138                  * Otherwise, a concurrent request that yanks the table
 139                  * should be blocked by other interlocking and/or by first
 140                  * shutting the driver down.  Regardless, be defensive
 141                  * here and just bail
 142                  */
 143                 /* XXX need msg+stat */
 144                 m_freem(m);
 145                 return NULL;
 146         }
 147         mfrag = ni->ni_rxfrag[0];
 148         ni->ni_rxfrag[0] = NULL;
 149
 150         /*
 151          * Validate new fragment is in order and
 152          * related to the previous ones.
 153          */
 154         if (mfrag != NULL) {
 155                 uint16_t last_rxseq;
 156
 157                 lwh = mtod(mfrag, struct ieee80211_frame *);
 158                 last_rxseq = le16toh(*(uint16_t *)lwh->i_seq);
 159                 /* NB: check seq # and frag together */
 160                 if (rxseq != last_rxseq+1 ||
 161                     !IEEE80211_ADDR_EQ(wh->i_addr1, lwh->i_addr1) ||
 162                     !IEEE80211_ADDR_EQ(wh->i_addr2, lwh->i_addr2)) {
 163                         /*
 164                          * Unrelated fragment or no space for it,
 165                          * clear current fragments.
 166                          */
 167                         m_freem(mfrag);
 168                         mfrag = NULL;
 169                 }
 170         }
 171
 172         if (mfrag == NULL) {
 173                 if (fragno != 0) {              /* !first fragment, discard */
 174                         vap->iv_stats.is_rx_defrag++;
 175                         IEEE80211_NODE_STAT(ni, rx_defrag);
 176                         m_freem(m);
 177                         return NULL;
 178                 }
 179                 mfrag = m;
 180         } else {                                /* concatenate */
 181                 m_adj(m, hdrspace);             /* strip header */
 182                 m_cat(mfrag, m);
 183                 /* NB: m_cat doesn't update the packet header */
 184                 mfrag->m_pkthdr.len += m->m_pkthdr.len;
 185                 /* track last seqnum and fragno */
 186                 lwh = mtod(mfrag, struct ieee80211_frame *);
 187                 *(uint16_t *) lwh->i_seq = *(uint16_t *) wh->i_seq;
 188         }
 189         if (more_frag) {                        /* more to come, save */
 190                 ni->ni_rxfragstamp = ticks;
 191                 ni->ni_rxfrag[0] = mfrag;
 192                 mfrag = NULL;
 193         }
 194         return mfrag;
 195 }
 196
 197 void
 198 ieee80211_deliver_data(struct ieee80211vap *vap,
 199         struct ieee80211_node *ni, struct mbuf *m)
 200 {
 201         struct ether_header *eh = mtod(m, struct ether_header *);
 202         struct ifnet *ifp = vap->iv_ifp;
 203
 204         /* clear driver/net80211 flags before passing up */
 205         m->m_flags &= ~(M_80211_RX | M_MCAST | M_BCAST);
 206
 207         /* NB: see hostap_deliver_data, this path doesn't handle hostap */
 208         KASSERT(vap->iv_opmode != IEEE80211_M_HOSTAP, ("gack, hostap"));
 209         /*
 210          * Do accounting.
 211          */
 212         ifp->if_ipackets++;
 213         IEEE80211_NODE_STAT(ni, rx_data);
 214         IEEE80211_NODE_STAT_ADD(ni, rx_bytes, m->m_pkthdr.len);
 215         if (ETHER_IS_MULTICAST(eh->ether_dhost)) {
 216                 m->m_flags |= M_MCAST;          /* XXX M_BCAST? */
 217                 IEEE80211_NODE_STAT(ni, rx_mcast);
 218         } else
 219                 IEEE80211_NODE_STAT(ni, rx_ucast);
 220         m->m_pkthdr.rcvif = ifp;
 221
 222         if (ni->ni_vlan != 0) {
 223                 /* attach vlan tag */
 224                 m->m_pkthdr.ether_vlantag = ni->ni_vlan;
 225                 m->m_flags |= M_VLANTAG;
 226         }
 227         ifp->if_input(ifp, m);
 228 }
 229
 230 struct mbuf *
 231 ieee80211_decap(struct ieee80211vap *vap, struct mbuf *m, int hdrlen)
 232 {
 233         struct ieee80211_qosframe_addr4 wh;
 234         struct ether_header *eh;
 235         struct llc *llc;
 236
 237         KASSERT(hdrlen <= sizeof(wh),
 238             ("hdrlen %d > max %zd", hdrlen, sizeof(wh)));
 239
 240         if (m->m_len < hdrlen + sizeof(*llc) &&
 241             (m = m_pullup(m, hdrlen + sizeof(*llc))) == NULL) {
 242                 vap->iv_stats.is_rx_tooshort++;
 243                 /* XXX msg */
 244                 return NULL;
 245         }
 246         memcpy(&wh, mtod(m, caddr_t), hdrlen);
 247         llc = (struct llc *)(mtod(m, caddr_t) + hdrlen);
 248         if (llc->llc_dsap == LLC_SNAP_LSAP && llc->llc_ssap == LLC_SNAP_LSAP &&
 249             llc->llc_control == LLC_UI && llc->llc_snap.org_code[0] == 0 &&
 250             llc->llc_snap.org_code[1] == 0 && llc->llc_snap.org_code[2] == 0 &&
 251             !(llc->llc_snap.ether_type == htons(ETHERTYPE_IPX))) {
 252                 m_adj(m, hdrlen + sizeof(struct llc) - sizeof(*eh));
 253                 llc = NULL;
 254         } else {
 255                 m_adj(m, hdrlen - sizeof(*eh));
 256         }
 257         eh = mtod(m, struct ether_header *);
 258         switch (wh.i_fc[1] & IEEE80211_FC1_DIR_MASK) {
 259         case IEEE80211_FC1_DIR_NODS:
 260                 IEEE80211_ADDR_COPY(eh->ether_dhost, wh.i_addr1);
 261                 IEEE80211_ADDR_COPY(eh->ether_shost, wh.i_addr2);
 262                 break;
 263         case IEEE80211_FC1_DIR_TODS:
 264                 IEEE80211_ADDR_COPY(eh->ether_dhost, wh.i_addr3);
 265                 IEEE80211_ADDR_COPY(eh->ether_shost, wh.i_addr2);
 266                 break;
 267         case IEEE80211_FC1_DIR_FROMDS:
 268                 IEEE80211_ADDR_COPY(eh->ether_dhost, wh.i_addr1);
 269                 IEEE80211_ADDR_COPY(eh->ether_shost, wh.i_addr3);
 270                 break;
 271         case IEEE80211_FC1_DIR_DSTODS:
 272                 IEEE80211_ADDR_COPY(eh->ether_dhost, wh.i_addr3);
 273                 IEEE80211_ADDR_COPY(eh->ether_shost, wh.i_addr4);
 274                 break;
 275         }
 276 #ifdef ALIGNED_POINTER
 277         if (!ALIGNED_POINTER(mtod(m, caddr_t) + sizeof(*eh), uint32_t)) {
 278                 m = ieee80211_realign(vap, m, sizeof(*eh));
 279                 if (m == NULL)
 280                         return NULL;
 281         }
 282 #endif /* ALIGNED_POINTER */
 283         if (llc != NULL) {
 284                 eh = mtod(m, struct ether_header *);
 285                 eh->ether_type = htons(m->m_pkthdr.len - sizeof(*eh));
 286         }
 287         return m;
 288 }
 289
 290 /*
 291  * Decap a frame encapsulated in a fast-frame/A-MSDU.
 292  */
 293 struct mbuf *
 294 ieee80211_decap1(struct mbuf *m, int *framelen)
 295 {
 296 #define FF_LLC_SIZE     (sizeof(struct ether_header) + sizeof(struct llc))
 297         struct ether_header *eh;
 298         struct llc *llc;
 299
 300         /*
 301          * The frame has an 802.3 header followed by an 802.2
 302          * LLC header.  The encapsulated frame length is in the
 303          * first header type field; save that and overwrite it
 304          * with the true type field found in the second.  Then
 305          * copy the 802.3 header up to where it belongs and
 306          * adjust the mbuf contents to remove the void.
 307          */
 308         if (m->m_len < FF_LLC_SIZE && (m = m_pullup(m, FF_LLC_SIZE)) == NULL)
 309                 return NULL;
 310         eh = mtod(m, struct ether_header *);    /* 802.3 header is first */
 311         llc = (struct llc *)&eh[1];             /* 802.2 header follows */
 312         *framelen = ntohs(eh->ether_type)       /* encap'd frame size */
 313                   + sizeof(struct ether_header) - sizeof(struct llc);
 314         eh->ether_type = llc->llc_un.type_snap.ether_type;
 315         ovbcopy(eh, mtod(m, uint8_t *) + sizeof(struct llc),
 316                 sizeof(struct ether_header));
 317         m_adj(m, sizeof(struct llc));
 318         return m;
 319 #undef FF_LLC_SIZE
 320 }
 321
 322 /*
 323  * Install received rate set information in the node's state block.
 324  */
 325 int
 326 ieee80211_setup_rates(struct ieee80211_node *ni,
 327         const uint8_t *rates, const uint8_t *xrates, int flags)
 328 {
 329         struct ieee80211vap *vap = ni->ni_vap;
 330         struct ieee80211_rateset *rs = &ni->ni_rates;
 331
 332         memset(rs, 0, sizeof(*rs));
 333         rs->rs_nrates = rates[1];
 334         memcpy(rs->rs_rates, rates + 2, rs->rs_nrates);
 335         if (xrates != NULL) {
 336                 uint8_t nxrates;
 337                 /*
 338                  * Tack on 11g extended supported rate element.
 339                  */
 340                 nxrates = xrates[1];
 341                 if (rs->rs_nrates + nxrates > IEEE80211_RATE_MAXSIZE) {
 342                         nxrates = IEEE80211_RATE_MAXSIZE - rs->rs_nrates;
 343                         IEEE80211_NOTE(vap, IEEE80211_MSG_XRATE, ni,
 344                             "extended rate set too large; only using "
 345                             "%u of %u rates", nxrates, xrates[1]);
 346                         vap->iv_stats.is_rx_rstoobig++;
 347                 }
 348                 memcpy(rs->rs_rates + rs->rs_nrates, xrates+2, nxrates);
 349                 rs->rs_nrates += nxrates;
 350         }
 351         return ieee80211_fix_rate(ni, rs, flags);
 352 }
 353
 354 /*
 355  * Send a management frame error response to the specified
 356  * station.  If ni is associated with the station then use
 357  * it; otherwise allocate a temporary node suitable for
 358  * transmitting the frame and then free the reference so
 359  * it will go away as soon as the frame has been transmitted.
 360  */
 361 void
 362 ieee80211_send_error(struct ieee80211_node *ni,
 363         const uint8_t mac[IEEE80211_ADDR_LEN], int subtype, int arg)
 364 {
 365         struct ieee80211vap *vap = ni->ni_vap;
 366         int istmp;
 367
 368         if (ni == vap->iv_bss) {
 369                 if (vap->iv_state != IEEE80211_S_RUN) {
 370                         /*
 371                          * XXX hack until we get rid of this routine.
 372                          * We can be called prior to the vap reaching
 373                          * run state under certain conditions in which
 374                          * case iv_bss->ni_chan will not be setup.
 375                          * Check for this explicitly and and just ignore
 376                          * the request.
 377                          */
 378                         return;
 379                 }
 380                 ni = ieee80211_tmp_node(vap, mac);
 381                 if (ni == NULL) {
 382                         /* XXX msg */
 383                         return;
 384                 }
 385                 istmp = 1;
 386         } else
 387                 istmp = 0;
 388         IEEE80211_SEND_MGMT(ni, subtype, arg);
 389         if (istmp)
 390                 ieee80211_free_node(ni);
 391 }
 392
 393 int
 394 ieee80211_alloc_challenge(struct ieee80211_node *ni)
 395 {
 396         if (ni->ni_challenge == NULL)
 397                 ni->ni_challenge = (uint32_t *) kmalloc(IEEE80211_CHALLENGE_LEN,
 398                     M_80211_NODE, M_INTWAIT);
 399         if (ni->ni_challenge == NULL) {
 400                 IEEE80211_NOTE(ni->ni_vap,
 401                     IEEE80211_MSG_DEBUG | IEEE80211_MSG_AUTH, ni,
 402                     "%s", "shared key challenge alloc failed");
 403                 /* XXX statistic */
 404         }
 405         return (ni->ni_challenge != NULL);
 406 }
 407
 408 /*
 409  * Parse a Beacon or ProbeResponse frame and return the
 410  * useful information in an ieee80211_scanparams structure.
 411  * Status is set to 0 if no problems were found; otherwise
 412  * a bitmask of IEEE80211_BPARSE_* items is returned that
 413  * describes the problems detected.
 414  */
 415 int
 416 ieee80211_parse_beacon(struct ieee80211_node *ni, struct mbuf *m,
 417         struct ieee80211_scanparams *scan)
 418 {
 419         struct ieee80211vap *vap = ni->ni_vap;
 420         struct ieee80211com *ic = ni->ni_ic;
 421         struct ieee80211_frame *wh;
 422         uint8_t *frm, *efrm;
 423
 424         wh = mtod(m, struct ieee80211_frame *);
 425         frm = (uint8_t *)&wh[1];
 426         efrm = mtod(m, uint8_t *) + m->m_len;
 427         scan->status = 0;
 428         /*
 429          * beacon/probe response frame format
 430          *      [8] time stamp
 431          *      [2] beacon interval
 432          *      [2] capability information
 433          *      [tlv] ssid
 434          *      [tlv] supported rates
 435          *      [tlv] country information
 436          *      [tlv] channel switch announcement (CSA)
 437          *      [tlv] parameter set (FH/DS)
 438          *      [tlv] erp information
 439          *      [tlv] extended supported rates
 440          *      [tlv] WME
 441          *      [tlv] WPA or RSN
 442          *      [tlv] HT capabilities
 443          *      [tlv] HT information
 444          *      [tlv] Atheros capabilities
 445          *      [tlv] Mesh ID
 446          *      [tlv] Mesh Configuration
 447          */
 448         IEEE80211_VERIFY_LENGTH(efrm - frm, 12,
 449             return (scan->status = IEEE80211_BPARSE_BADIELEN));
 450         memset(scan, 0, sizeof(*scan));
 451         scan->tstamp  = frm;                            frm += 8;
 452         scan->bintval = le16toh(*(uint16_t *)frm);      frm += 2;
 453         scan->capinfo = le16toh(*(uint16_t *)frm);      frm += 2;
 454         scan->bchan = ieee80211_chan2ieee(ic, ic->ic_curchan);
 455         scan->chan = scan->bchan;
 456         scan->ies = frm;
 457         scan->ies_len = efrm - frm;
 458
 459         while (efrm - frm > 1) {
 460                 IEEE80211_VERIFY_LENGTH(efrm - frm, frm[1] + 2,
 461                     return (scan->status = IEEE80211_BPARSE_BADIELEN));
 462                 switch (*frm) {
 463                 case IEEE80211_ELEMID_SSID:
 464                         scan->ssid = frm;
 465                         break;
 466                 case IEEE80211_ELEMID_RATES:
 467                         scan->rates = frm;
 468                         break;
 469                 case IEEE80211_ELEMID_COUNTRY:
 470                         scan->country = frm;
 471                         break;
 472                 case IEEE80211_ELEMID_CSA:
 473                         scan->csa = frm;
 474                         break;
 475                 case IEEE80211_ELEMID_FHPARMS:
 476                         if (ic->ic_phytype == IEEE80211_T_FH) {
 477                                 scan->fhdwell = LE_READ_2(&frm[2]);
 478                                 scan->chan = IEEE80211_FH_CHAN(frm[4], frm[5]);
 479                                 scan->fhindex = frm[6];
 480                         }
 481                         break;
 482                 case IEEE80211_ELEMID_DSPARMS:
 483                         /*
 484                          * XXX hack this since depending on phytype
 485                          * is problematic for multi-mode devices.
 486                          */
 487                         if (ic->ic_phytype != IEEE80211_T_FH)
 488                                 scan->chan = frm[2];
 489                         break;
 490                 case IEEE80211_ELEMID_TIM:
 491                         /* XXX ATIM? */
 492                         scan->tim = frm;
 493                         scan->timoff = frm - mtod(m, uint8_t *);
 494                         break;
 495                 case IEEE80211_ELEMID_IBSSPARMS:
 496                 case IEEE80211_ELEMID_CFPARMS:
 497                 case IEEE80211_ELEMID_PWRCNSTR:
 498                         /* NB: avoid debugging complaints */
 499                         break;
 500                 case IEEE80211_ELEMID_XRATES:
 501                         scan->xrates = frm;
 502                         break;
 503                 case IEEE80211_ELEMID_ERP:
 504                         if (frm[1] != 1) {
 505                                 IEEE80211_DISCARD_IE(vap,
 506                                     IEEE80211_MSG_ELEMID, wh, "ERP",
 507                                     "bad len %u", frm[1]);
 508                                 vap->iv_stats.is_rx_elem_toobig++;
 509                                 break;
 510                         }
 511                         scan->erp = frm[2] | 0x100;
 512                         break;
 513                 case IEEE80211_ELEMID_HTCAP:
 514                         scan->htcap = frm;
 515                         break;
 516                 case IEEE80211_ELEMID_RSN:
 517                         scan->rsn = frm;
 518                         break;
 519                 case IEEE80211_ELEMID_HTINFO:
 520                         scan->htinfo = frm;
 521                         break;
 522 #ifdef IEEE80211_SUPPORT_MESH
 523                 case IEEE80211_ELEMID_MESHID:
 524                         scan->meshid = frm;
 525                         break;
 526                 case IEEE80211_ELEMID_MESHCONF:
 527                         scan->meshconf = frm;
 528                         break;
 529 #endif
 530                 case IEEE80211_ELEMID_VENDOR:
 531                         if (iswpaoui(frm))
 532                                 scan->wpa = frm;
 533                         else if (iswmeparam(frm) || iswmeinfo(frm))
 534                                 scan->wme = frm;
 535 #ifdef IEEE80211_SUPPORT_SUPERG
 536                         else if (isatherosoui(frm))
 537                                 scan->ath = frm;
 538 #endif
 539 #ifdef IEEE80211_SUPPORT_TDMA
 540                         else if (istdmaoui(frm))
 541                                 scan->tdma = frm;
 542 #endif
 543                         else if (vap->iv_flags_ht & IEEE80211_FHT_HTCOMPAT) {
 544                                 /*
 545                                  * Accept pre-draft HT ie's if the
 546                                  * standard ones have not been seen.
 547                                  */
 548                                 if (ishtcapoui(frm)) {
 549                                         if (scan->htcap == NULL)
 550                                                 scan->htcap = frm;
 551                                 } else if (ishtinfooui(frm)) {
 552                                         if (scan->htinfo == NULL)
 553                                                 scan->htcap = frm;
 554                                 }
 555                         }
 556                         break;
 557                 default:
 558                         IEEE80211_DISCARD_IE(vap, IEEE80211_MSG_ELEMID,
 559                             wh, "unhandled",
 560                             "id %u, len %u", *frm, frm[1]);
 561                         vap->iv_stats.is_rx_elem_unknown++;
 562                         break;
 563                 }
 564                 frm += frm[1] + 2;
 565         }
 566         IEEE80211_VERIFY_ELEMENT(scan->rates, IEEE80211_RATE_MAXSIZE,
 567             scan->status |= IEEE80211_BPARSE_RATES_INVALID);
 568         if (scan->rates != NULL && scan->xrates != NULL) {
 569                 /*
 570                  * NB: don't process XRATES if RATES is missing.  This
 571                  * avoids a potential null ptr deref and should be ok
 572                  * as the return code will already note RATES is missing
 573                  * (so callers shouldn't otherwise process the frame).
 574                  */
 575                 IEEE80211_VERIFY_ELEMENT(scan->xrates,
 576                     IEEE80211_RATE_MAXSIZE - scan->rates[1],
 577                     scan->status |= IEEE80211_BPARSE_XRATES_INVALID);
 578         }
 579         IEEE80211_VERIFY_ELEMENT(scan->ssid, IEEE80211_NWID_LEN,
 580             scan->status |= IEEE80211_BPARSE_SSID_INVALID);
 581         if (scan->chan != scan->bchan && ic->ic_phytype != IEEE80211_T_FH) {
 582                 /*
 583                  * Frame was received on a channel different from the
 584                  * one indicated in the DS params element id;
 585                  * silently discard it.
 586                  *
 587                  * NB: this can happen due to signal leakage.
 588                  *     But we should take it for FH phy because
 589                  *     the rssi value should be correct even for
 590                  *     different hop pattern in FH.
 591                  */
 592                 IEEE80211_DISCARD(vap,
 593                     IEEE80211_MSG_ELEMID | IEEE80211_MSG_INPUT,
 594                     wh, NULL, "for off-channel %u", scan->chan);
 595                 vap->iv_stats.is_rx_chanmismatch++;
 596                 scan->status |= IEEE80211_BPARSE_OFFCHAN;
 597         }
 598         if (!(IEEE80211_BINTVAL_MIN <= scan->bintval &&
 599               scan->bintval <= IEEE80211_BINTVAL_MAX)) {
 600                 IEEE80211_DISCARD(vap,
 601                     IEEE80211_MSG_ELEMID | IEEE80211_MSG_INPUT,
 602                     wh, NULL, "bogus beacon interval %u", scan->bintval);
 603                 vap->iv_stats.is_rx_badbintval++;
 604                 scan->status |= IEEE80211_BPARSE_BINTVAL_INVALID;
 605         }
 606         if (scan->country != NULL) {
 607                 /*
 608                  * Validate we have at least enough data to extract
 609                  * the country code.  Not sure if we should return an
 610                  * error instead of discarding the IE; consider this
 611                  * being lenient as we don't depend on the data for
 612                  * correct operation.
 613                  */
 614                 IEEE80211_VERIFY_LENGTH(scan->country[1], 3 * sizeof(uint8_t),
 615                     scan->country = NULL);
 616         }
 617         if (scan->csa != NULL) {
 618                 /*
 619                  * Validate Channel Switch Announcement; this must
 620                  * be the correct length or we toss the frame.
 621                  */
 622                 IEEE80211_VERIFY_LENGTH(scan->csa[1], 3 * sizeof(uint8_t),
 623                     scan->status |= IEEE80211_BPARSE_CSA_INVALID);
 624         }
 625         /*
 626          * Process HT ie's.  This is complicated by our
 627          * accepting both the standard ie's and the pre-draft
 628          * vendor OUI ie's that some vendors still use/require.
 629          */
 630         if (scan->htcap != NULL) {
 631                 IEEE80211_VERIFY_LENGTH(scan->htcap[1],
 632                      scan->htcap[0] == IEEE80211_ELEMID_VENDOR ?
 633                          4 + sizeof(struct ieee80211_ie_htcap)-2 :
 634                          sizeof(struct ieee80211_ie_htcap)-2,
 635                      scan->htcap = NULL);
 636         }
 637         if (scan->htinfo != NULL) {
 638                 IEEE80211_VERIFY_LENGTH(scan->htinfo[1],
 639                      scan->htinfo[0] == IEEE80211_ELEMID_VENDOR ?
 640                          4 + sizeof(struct ieee80211_ie_htinfo)-2 :
 641                          sizeof(struct ieee80211_ie_htinfo)-2,
 642                      scan->htinfo = NULL);
 643         }
 644         return scan->status;
 645 }
 646
 647 /*
 648  * Parse an Action frame.  Return 0 on success, non-zero on failure.
 649  */
 650 int
 651 ieee80211_parse_action(struct ieee80211_node *ni, struct mbuf *m)
 652 {
 653         struct ieee80211vap *vap = ni->ni_vap;
 654         const struct ieee80211_action *ia;
 655         struct ieee80211_frame *wh;
 656         uint8_t *frm, *efrm;
 657
 658         /*
 659          * action frame format:
 660          *      [1] category
 661          *      [1] action
 662          *      [tlv] parameters
 663          */
 664         wh = mtod(m, struct ieee80211_frame *);
 665         frm = (u_int8_t *)&wh[1];
 666         efrm = mtod(m, u_int8_t *) + m->m_len;
 667         IEEE80211_VERIFY_LENGTH(efrm - frm,
 668                 sizeof(struct ieee80211_action), return EINVAL);
 669         ia = (const struct ieee80211_action *) frm;
 670
 671         vap->iv_stats.is_rx_action++;
 672         IEEE80211_NODE_STAT(ni, rx_action);
 673
 674         /* verify frame payloads but defer processing */
 675         /* XXX maybe push this to method */
 676         switch (ia->ia_category) {
 677         case IEEE80211_ACTION_CAT_BA:
 678                 switch (ia->ia_action) {
 679                 case IEEE80211_ACTION_BA_ADDBA_REQUEST:
 680                         IEEE80211_VERIFY_LENGTH(efrm - frm,
 681                             sizeof(struct ieee80211_action_ba_addbarequest),
 682                             return EINVAL);
 683                         break;
 684                 case IEEE80211_ACTION_BA_ADDBA_RESPONSE:
 685                         IEEE80211_VERIFY_LENGTH(efrm - frm,
 686                             sizeof(struct ieee80211_action_ba_addbaresponse),
 687                             return EINVAL);
 688                         break;
 689                 case IEEE80211_ACTION_BA_DELBA:
 690                         IEEE80211_VERIFY_LENGTH(efrm - frm,
 691                             sizeof(struct ieee80211_action_ba_delba),
 692                             return EINVAL);
 693                         break;
 694                 }
 695                 break;
 696         case IEEE80211_ACTION_CAT_HT:
 697                 switch (ia->ia_action) {
 698                 case IEEE80211_ACTION_HT_TXCHWIDTH:
 699                         IEEE80211_VERIFY_LENGTH(efrm - frm,
 700                             sizeof(struct ieee80211_action_ht_txchwidth),
 701                             return EINVAL);
 702                         break;
 703                 case IEEE80211_ACTION_HT_MIMOPWRSAVE:
 704                         IEEE80211_VERIFY_LENGTH(efrm - frm,
 705                             sizeof(struct ieee80211_action_ht_mimopowersave),
 706                             return EINVAL);
 707                         break;
 708                 }
 709                 break;
 710         }
 711         return 0;
 712 }
 713
 714 /*
 715  * Modules may be compiled with debugging even if wlan isn't
 716  */
 717 /*#ifdef IEEE80211_DEBUG*/
 718 #if 1
 719 /*
 720  * Debugging support.
 721  */
 722 void
 723 ieee80211_ssid_mismatch(struct ieee80211vap *vap, const char *tag,
 724         uint8_t mac[IEEE80211_ADDR_LEN], uint8_t *ssid)
 725 {
 726         char ethstr[ETHER_ADDRSTRLEN + 1];
 727
 728         kprintf("[%s] discard %s frame, ssid mismatch: ",
 729             kether_ntoa(mac, ethstr), tag);
 730         ieee80211_print_essid(ssid + 2, ssid[1]);
 731         kprintf("\n");
 732 }
 733
 734 /*
 735  * Return the bssid of a frame.
 736  */
 737 static const uint8_t *
 738 ieee80211_getbssid(const struct ieee80211vap *vap, const struct ieee80211_frame *wh)
 739 {
 740         if (vap->iv_opmode == IEEE80211_M_STA)
 741                 return wh->i_addr2;
 742         if ((wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) != IEEE80211_FC1_DIR_NODS)
 743                 return wh->i_addr1;
 744         if ((wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) == IEEE80211_FC0_SUBTYPE_PS_POLL)
 745                 return wh->i_addr1;
 746         return wh->i_addr3;
 747 }
 748
 749 #include <machine/stdarg.h>
 750
 751 void
 752 ieee80211_note(const struct ieee80211vap *vap, const char *fmt, ...)
 753 {
 754         char buf[128];          /* XXX */
 755         __va_list ap;
 756
 757         __va_start(ap, fmt);
 758         kvsnprintf(buf, sizeof(buf), fmt, ap);
 759         __va_end(ap);
 760
 761         if_printf(vap->iv_ifp, "%s", buf);      /* NB: no \n */
 762 }
 763
 764 void
 765 ieee80211_note_frame(const struct ieee80211vap *vap,
 766         const struct ieee80211_frame *wh,
 767         const char *fmt, ...)
 768 {
 769         char buf[128];          /* XXX */
 770         __va_list ap;
 771         char ethstr[ETHER_ADDRSTRLEN + 1];
 772
 773         __va_start(ap, fmt);
 774         kvsnprintf(buf, sizeof(buf), fmt, ap);
 775         __va_end(ap);
 776         if_printf(vap->iv_ifp, "[%s] %s\n",
 777             kether_ntoa(ieee80211_getbssid(vap, wh), ethstr), buf);
 778 }
 779
 780 void
 781 ieee80211_note_mac(const struct ieee80211vap *vap,
 782         const uint8_t mac[IEEE80211_ADDR_LEN],
 783         const char *fmt, ...)
 784 {
 785         char buf[128];          /* XXX */
 786         __va_list ap;
 787         char ethstr[ETHER_ADDRSTRLEN + 1];
 788
 789         __va_start(ap, fmt);
 790         kvsnprintf(buf, sizeof(buf), fmt, ap);
 791         __va_end(ap);
 792         if_printf(vap->iv_ifp, "[%s] %s\n", kether_ntoa(mac, ethstr), buf);
 793 }
 794
 795 void
 796 ieee80211_discard_frame(const struct ieee80211vap *vap,
 797         const struct ieee80211_frame *wh,
 798         const char *type, const char *fmt, ...)
 799 {
 800         __va_list ap;
 801         char ethstr[ETHER_ADDRSTRLEN + 1];
 802
 803         if_printf(vap->iv_ifp, "[%s] discard ",
 804             kether_ntoa(ieee80211_getbssid(vap, wh), ethstr));
 805         if (type == NULL) {
 806                 kprintf("%s frame, ", ieee80211_mgt_subtype_name[
 807                         (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) >>
 808                         IEEE80211_FC0_SUBTYPE_SHIFT]);
 809         } else
 810                 kprintf("%s frame, ", type);
 811         __va_start(ap, fmt);
 812         kvprintf(fmt, ap);
 813         __va_end(ap);
 814         kprintf("\n");
 815 }
 816
 817 void
 818 ieee80211_discard_ie(const struct ieee80211vap *vap,
 819         const struct ieee80211_frame *wh,
 820         const char *type, const char *fmt, ...)
 821 {
 822         __va_list ap;
 823         char ethstr[ETHER_ADDRSTRLEN + 1];
 824
 825         if_printf(vap->iv_ifp, "[%s] discard ",
 826             kether_ntoa(ieee80211_getbssid(vap, wh), ethstr));
 827         if (type != NULL)
 828                 kprintf("%s information element, ", type);
 829         else
 830                 kprintf("information element, ");
 831         __va_start(ap, fmt);
 832         kvprintf(fmt, ap);
 833         __va_end(ap);
 834         kprintf("\n");
 835 }
 836
 837 void
 838 ieee80211_discard_mac(const struct ieee80211vap *vap,
 839         const uint8_t mac[IEEE80211_ADDR_LEN],
 840         const char *type, const char *fmt, ...)
 841 {
 842         __va_list ap;
 843         char ethstr[ETHER_ADDRSTRLEN + 1];
 844
 845         if_printf(vap->iv_ifp, "[%s] discard ", kether_ntoa(mac, ethstr));
 846         if (type != NULL)
 847                 kprintf("%s frame, ", type);
 848         else
 849                 kprintf("frame, ");
 850         __va_start(ap, fmt);
 851         kvprintf(fmt, ap);
 852         __va_end(ap);
 853         kprintf("\n");
 854 }
 855 #endif /* IEEE80211_DEBUG */