The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/net80211/ieee80211_freebsd.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 2003-2009 Sam Leffler, Errno Consulting
    3  * 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  *
   14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   17  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   24  */
   25 
   26 #include <sys/cdefs.h>
   27 __FBSDID("$FreeBSD: releng/11.2/sys/net80211/ieee80211_freebsd.c 330466 2018-03-05 08:30:47Z eadler $");
   28 
   29 /*
   30  * IEEE 802.11 support (FreeBSD-specific code)
   31  */
   32 #include "opt_wlan.h"
   33 
   34 #include <sys/param.h>
   35 #include <sys/systm.h> 
   36 #include <sys/eventhandler.h>
   37 #include <sys/kernel.h>
   38 #include <sys/linker.h>
   39 #include <sys/malloc.h>
   40 #include <sys/mbuf.h>   
   41 #include <sys/module.h>
   42 #include <sys/proc.h>
   43 #include <sys/sysctl.h>
   44 
   45 #include <sys/socket.h>
   46 
   47 #include <net/bpf.h>
   48 #include <net/if.h>
   49 #include <net/if_var.h>
   50 #include <net/if_dl.h>
   51 #include <net/if_clone.h>
   52 #include <net/if_media.h>
   53 #include <net/if_types.h>
   54 #include <net/ethernet.h>
   55 #include <net/route.h>
   56 #include <net/vnet.h>
   57 
   58 #include <net80211/ieee80211_var.h>
   59 #include <net80211/ieee80211_input.h>
   60 
   61 SYSCTL_NODE(_net, OID_AUTO, wlan, CTLFLAG_RD, 0, "IEEE 80211 parameters");
   62 
   63 #ifdef IEEE80211_DEBUG
   64 static int      ieee80211_debug = 0;
   65 SYSCTL_INT(_net_wlan, OID_AUTO, debug, CTLFLAG_RW, &ieee80211_debug,
   66             0, "debugging printfs");
   67 #endif
   68 
   69 static MALLOC_DEFINE(M_80211_COM, "80211com", "802.11 com state");
   70 
   71 static const char wlanname[] = "wlan";
   72 static struct if_clone *wlan_cloner;
   73 
   74 static int
   75 wlan_clone_create(struct if_clone *ifc, int unit, caddr_t params)
   76 {
   77         struct ieee80211_clone_params cp;
   78         struct ieee80211vap *vap;
   79         struct ieee80211com *ic;
   80         int error;
   81 
   82         error = copyin(params, &cp, sizeof(cp));
   83         if (error)
   84                 return error;
   85         ic = ieee80211_find_com(cp.icp_parent);
   86         if (ic == NULL)
   87                 return ENXIO;
   88         if (cp.icp_opmode >= IEEE80211_OPMODE_MAX) {
   89                 ic_printf(ic, "%s: invalid opmode %d\n", __func__,
   90                     cp.icp_opmode);
   91                 return EINVAL;
   92         }
   93         if ((ic->ic_caps & ieee80211_opcap[cp.icp_opmode]) == 0) {
   94                 ic_printf(ic, "%s mode not supported\n",
   95                     ieee80211_opmode_name[cp.icp_opmode]);
   96                 return EOPNOTSUPP;
   97         }
   98         if ((cp.icp_flags & IEEE80211_CLONE_TDMA) &&
   99 #ifdef IEEE80211_SUPPORT_TDMA
  100             (ic->ic_caps & IEEE80211_C_TDMA) == 0
  101 #else
  102             (1)
  103 #endif
  104         ) {
  105                 ic_printf(ic, "TDMA not supported\n");
  106                 return EOPNOTSUPP;
  107         }
  108         vap = ic->ic_vap_create(ic, wlanname, unit,
  109                         cp.icp_opmode, cp.icp_flags, cp.icp_bssid,
  110                         cp.icp_flags & IEEE80211_CLONE_MACADDR ?
  111                             cp.icp_macaddr : ic->ic_macaddr);
  112 
  113         return (vap == NULL ? EIO : 0);
  114 }
  115 
  116 static void
  117 wlan_clone_destroy(struct ifnet *ifp)
  118 {
  119         struct ieee80211vap *vap = ifp->if_softc;
  120         struct ieee80211com *ic = vap->iv_ic;
  121 
  122         ic->ic_vap_delete(vap);
  123 }
  124 
  125 void
  126 ieee80211_vap_destroy(struct ieee80211vap *vap)
  127 {
  128         CURVNET_SET(vap->iv_ifp->if_vnet);
  129         if_clone_destroyif(wlan_cloner, vap->iv_ifp);
  130         CURVNET_RESTORE();
  131 }
  132 
  133 int
  134 ieee80211_sysctl_msecs_ticks(SYSCTL_HANDLER_ARGS)
  135 {
  136         int msecs = ticks_to_msecs(*(int *)arg1);
  137         int error, t;
  138 
  139         error = sysctl_handle_int(oidp, &msecs, 0, req);
  140         if (error || !req->newptr)
  141                 return error;
  142         t = msecs_to_ticks(msecs);
  143         *(int *)arg1 = (t < 1) ? 1 : t;
  144         return 0;
  145 }
  146 
  147 static int
  148 ieee80211_sysctl_inact(SYSCTL_HANDLER_ARGS)
  149 {
  150         int inact = (*(int *)arg1) * IEEE80211_INACT_WAIT;
  151         int error;
  152 
  153         error = sysctl_handle_int(oidp, &inact, 0, req);
  154         if (error || !req->newptr)
  155                 return error;
  156         *(int *)arg1 = inact / IEEE80211_INACT_WAIT;
  157         return 0;
  158 }
  159 
  160 static int
  161 ieee80211_sysctl_parent(SYSCTL_HANDLER_ARGS)
  162 {
  163         struct ieee80211com *ic = arg1;
  164 
  165         return SYSCTL_OUT_STR(req, ic->ic_name);
  166 }
  167 
  168 static int
  169 ieee80211_sysctl_radar(SYSCTL_HANDLER_ARGS)
  170 {
  171         struct ieee80211com *ic = arg1;
  172         int t = 0, error;
  173 
  174         error = sysctl_handle_int(oidp, &t, 0, req);
  175         if (error || !req->newptr)
  176                 return error;
  177         IEEE80211_LOCK(ic);
  178         ieee80211_dfs_notify_radar(ic, ic->ic_curchan);
  179         IEEE80211_UNLOCK(ic);
  180         return 0;
  181 }
  182 
  183 /*
  184  * For now, just restart everything.
  185  *
  186  * Later on, it'd be nice to have a separate VAP restart to
  187  * full-device restart.
  188  */
  189 static int
  190 ieee80211_sysctl_vap_restart(SYSCTL_HANDLER_ARGS)
  191 {
  192         struct ieee80211vap *vap = arg1;
  193         int t = 0, error;
  194 
  195         error = sysctl_handle_int(oidp, &t, 0, req);
  196         if (error || !req->newptr)
  197                 return error;
  198 
  199         ieee80211_restart_all(vap->iv_ic);
  200         return 0;
  201 }
  202 
  203 void
  204 ieee80211_sysctl_attach(struct ieee80211com *ic)
  205 {
  206 }
  207 
  208 void
  209 ieee80211_sysctl_detach(struct ieee80211com *ic)
  210 {
  211 }
  212 
  213 void
  214 ieee80211_sysctl_vattach(struct ieee80211vap *vap)
  215 {
  216         struct ifnet *ifp = vap->iv_ifp;
  217         struct sysctl_ctx_list *ctx;
  218         struct sysctl_oid *oid;
  219         char num[14];                   /* sufficient for 32 bits */
  220 
  221         ctx = (struct sysctl_ctx_list *) IEEE80211_MALLOC(sizeof(struct sysctl_ctx_list),
  222                 M_DEVBUF, IEEE80211_M_NOWAIT | IEEE80211_M_ZERO);
  223         if (ctx == NULL) {
  224                 if_printf(ifp, "%s: cannot allocate sysctl context!\n",
  225                         __func__);
  226                 return;
  227         }
  228         sysctl_ctx_init(ctx);
  229         snprintf(num, sizeof(num), "%u", ifp->if_dunit);
  230         oid = SYSCTL_ADD_NODE(ctx, &SYSCTL_NODE_CHILDREN(_net, wlan),
  231                 OID_AUTO, num, CTLFLAG_RD, NULL, "");
  232         SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
  233                 "%parent", CTLTYPE_STRING | CTLFLAG_RD, vap->iv_ic, 0,
  234                 ieee80211_sysctl_parent, "A", "parent device");
  235         SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
  236                 "driver_caps", CTLFLAG_RW, &vap->iv_caps, 0,
  237                 "driver capabilities");
  238 #ifdef IEEE80211_DEBUG
  239         vap->iv_debug = ieee80211_debug;
  240         SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
  241                 "debug", CTLFLAG_RW, &vap->iv_debug, 0,
  242                 "control debugging printfs");
  243 #endif
  244         SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
  245                 "bmiss_max", CTLFLAG_RW, &vap->iv_bmiss_max, 0,
  246                 "consecutive beacon misses before scanning");
  247         /* XXX inherit from tunables */
  248         SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
  249                 "inact_run", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_run, 0,
  250                 ieee80211_sysctl_inact, "I",
  251                 "station inactivity timeout (sec)");
  252         SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
  253                 "inact_probe", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_probe, 0,
  254                 ieee80211_sysctl_inact, "I",
  255                 "station inactivity probe timeout (sec)");
  256         SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
  257                 "inact_auth", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_auth, 0,
  258                 ieee80211_sysctl_inact, "I",
  259                 "station authentication timeout (sec)");
  260         SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
  261                 "inact_init", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_init, 0,
  262                 ieee80211_sysctl_inact, "I",
  263                 "station initial state timeout (sec)");
  264         if (vap->iv_htcaps & IEEE80211_HTC_HT) {
  265                 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
  266                         "ampdu_mintraffic_bk", CTLFLAG_RW,
  267                         &vap->iv_ampdu_mintraffic[WME_AC_BK], 0,
  268                         "BK traffic tx aggr threshold (pps)");
  269                 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
  270                         "ampdu_mintraffic_be", CTLFLAG_RW,
  271                         &vap->iv_ampdu_mintraffic[WME_AC_BE], 0,
  272                         "BE traffic tx aggr threshold (pps)");
  273                 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
  274                         "ampdu_mintraffic_vo", CTLFLAG_RW,
  275                         &vap->iv_ampdu_mintraffic[WME_AC_VO], 0,
  276                         "VO traffic tx aggr threshold (pps)");
  277                 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
  278                         "ampdu_mintraffic_vi", CTLFLAG_RW,
  279                         &vap->iv_ampdu_mintraffic[WME_AC_VI], 0,
  280                         "VI traffic tx aggr threshold (pps)");
  281         }
  282 
  283         SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
  284                 "force_restart", CTLTYPE_INT | CTLFLAG_RW, vap, 0,
  285                 ieee80211_sysctl_vap_restart, "I",
  286                 "force a VAP restart");
  287 
  288         if (vap->iv_caps & IEEE80211_C_DFS) {
  289                 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
  290                         "radar", CTLTYPE_INT | CTLFLAG_RW, vap->iv_ic, 0,
  291                         ieee80211_sysctl_radar, "I", "simulate radar event");
  292         }
  293         vap->iv_sysctl = ctx;
  294         vap->iv_oid = oid;
  295 }
  296 
  297 void
  298 ieee80211_sysctl_vdetach(struct ieee80211vap *vap)
  299 {
  300 
  301         if (vap->iv_sysctl != NULL) {
  302                 sysctl_ctx_free(vap->iv_sysctl);
  303                 IEEE80211_FREE(vap->iv_sysctl, M_DEVBUF);
  304                 vap->iv_sysctl = NULL;
  305         }
  306 }
  307 
  308 int
  309 ieee80211_node_dectestref(struct ieee80211_node *ni)
  310 {
  311         /* XXX need equivalent of atomic_dec_and_test */
  312         atomic_subtract_int(&ni->ni_refcnt, 1);
  313         return atomic_cmpset_int(&ni->ni_refcnt, 0, 1);
  314 }
  315 
  316 void
  317 ieee80211_drain_ifq(struct ifqueue *ifq)
  318 {
  319         struct ieee80211_node *ni;
  320         struct mbuf *m;
  321 
  322         for (;;) {
  323                 IF_DEQUEUE(ifq, m);
  324                 if (m == NULL)
  325                         break;
  326 
  327                 ni = (struct ieee80211_node *)m->m_pkthdr.rcvif;
  328                 KASSERT(ni != NULL, ("frame w/o node"));
  329                 ieee80211_free_node(ni);
  330                 m->m_pkthdr.rcvif = NULL;
  331 
  332                 m_freem(m);
  333         }
  334 }
  335 
  336 void
  337 ieee80211_flush_ifq(struct ifqueue *ifq, struct ieee80211vap *vap)
  338 {
  339         struct ieee80211_node *ni;
  340         struct mbuf *m, **mprev;
  341 
  342         IF_LOCK(ifq);
  343         mprev = &ifq->ifq_head;
  344         while ((m = *mprev) != NULL) {
  345                 ni = (struct ieee80211_node *)m->m_pkthdr.rcvif;
  346                 if (ni != NULL && ni->ni_vap == vap) {
  347                         *mprev = m->m_nextpkt;          /* remove from list */
  348                         ifq->ifq_len--;
  349 
  350                         m_freem(m);
  351                         ieee80211_free_node(ni);        /* reclaim ref */
  352                 } else
  353                         mprev = &m->m_nextpkt;
  354         }
  355         /* recalculate tail ptr */
  356         m = ifq->ifq_head;
  357         for (; m != NULL && m->m_nextpkt != NULL; m = m->m_nextpkt)
  358                 ;
  359         ifq->ifq_tail = m;
  360         IF_UNLOCK(ifq);
  361 }
  362 
  363 /*
  364  * As above, for mbufs allocated with m_gethdr/MGETHDR
  365  * or initialized by M_COPY_PKTHDR.
  366  */
  367 #define MC_ALIGN(m, len)                                                \
  368 do {                                                                    \
  369         (m)->m_data += rounddown2(MCLBYTES - (len), sizeof(long));      \
  370 } while (/* CONSTCOND */ 0)
  371 
  372 /*
  373  * Allocate and setup a management frame of the specified
  374  * size.  We return the mbuf and a pointer to the start
  375  * of the contiguous data area that's been reserved based
  376  * on the packet length.  The data area is forced to 32-bit
  377  * alignment and the buffer length to a multiple of 4 bytes.
  378  * This is done mainly so beacon frames (that require this)
  379  * can use this interface too.
  380  */
  381 struct mbuf *
  382 ieee80211_getmgtframe(uint8_t **frm, int headroom, int pktlen)
  383 {
  384         struct mbuf *m;
  385         u_int len;
  386 
  387         /*
  388          * NB: we know the mbuf routines will align the data area
  389          *     so we don't need to do anything special.
  390          */
  391         len = roundup2(headroom + pktlen, 4);
  392         KASSERT(len <= MCLBYTES, ("802.11 mgt frame too large: %u", len));
  393         if (len < MINCLSIZE) {
  394                 m = m_gethdr(M_NOWAIT, MT_DATA);
  395                 /*
  396                  * Align the data in case additional headers are added.
  397                  * This should only happen when a WEP header is added
  398                  * which only happens for shared key authentication mgt
  399                  * frames which all fit in MHLEN.
  400                  */
  401                 if (m != NULL)
  402                         M_ALIGN(m, len);
  403         } else {
  404                 m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
  405                 if (m != NULL)
  406                         MC_ALIGN(m, len);
  407         }
  408         if (m != NULL) {
  409                 m->m_data += headroom;
  410                 *frm = m->m_data;
  411         }
  412         return m;
  413 }
  414 
  415 #ifndef __NO_STRICT_ALIGNMENT
  416 /*
  417  * Re-align the payload in the mbuf.  This is mainly used (right now)
  418  * to handle IP header alignment requirements on certain architectures.
  419  */
  420 struct mbuf *
  421 ieee80211_realign(struct ieee80211vap *vap, struct mbuf *m, size_t align)
  422 {
  423         int pktlen, space;
  424         struct mbuf *n;
  425 
  426         pktlen = m->m_pkthdr.len;
  427         space = pktlen + align;
  428         if (space < MINCLSIZE)
  429                 n = m_gethdr(M_NOWAIT, MT_DATA);
  430         else {
  431                 n = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR,
  432                     space <= MCLBYTES ?     MCLBYTES :
  433 #if MJUMPAGESIZE != MCLBYTES
  434                     space <= MJUMPAGESIZE ? MJUMPAGESIZE :
  435 #endif
  436                     space <= MJUM9BYTES ?   MJUM9BYTES : MJUM16BYTES);
  437         }
  438         if (__predict_true(n != NULL)) {
  439                 m_move_pkthdr(n, m);
  440                 n->m_data = (caddr_t)(ALIGN(n->m_data + align) - align);
  441                 m_copydata(m, 0, pktlen, mtod(n, caddr_t));
  442                 n->m_len = pktlen;
  443         } else {
  444                 IEEE80211_DISCARD(vap, IEEE80211_MSG_ANY,
  445                     mtod(m, const struct ieee80211_frame *), NULL,
  446                     "%s", "no mbuf to realign");
  447                 vap->iv_stats.is_rx_badalign++;
  448         }
  449         m_freem(m);
  450         return n;
  451 }
  452 #endif /* !__NO_STRICT_ALIGNMENT */
  453 
  454 int
  455 ieee80211_add_callback(struct mbuf *m,
  456         void (*func)(struct ieee80211_node *, void *, int), void *arg)
  457 {
  458         struct m_tag *mtag;
  459         struct ieee80211_cb *cb;
  460 
  461         mtag = m_tag_alloc(MTAG_ABI_NET80211, NET80211_TAG_CALLBACK,
  462                         sizeof(struct ieee80211_cb), M_NOWAIT);
  463         if (mtag == NULL)
  464                 return 0;
  465 
  466         cb = (struct ieee80211_cb *)(mtag+1);
  467         cb->func = func;
  468         cb->arg = arg;
  469         m_tag_prepend(m, mtag);
  470         m->m_flags |= M_TXCB;
  471         return 1;
  472 }
  473 
  474 int
  475 ieee80211_add_xmit_params(struct mbuf *m,
  476     const struct ieee80211_bpf_params *params)
  477 {
  478         struct m_tag *mtag;
  479         struct ieee80211_tx_params *tx;
  480 
  481         mtag = m_tag_alloc(MTAG_ABI_NET80211, NET80211_TAG_XMIT_PARAMS,
  482             sizeof(struct ieee80211_tx_params), M_NOWAIT);
  483         if (mtag == NULL)
  484                 return (0);
  485 
  486         tx = (struct ieee80211_tx_params *)(mtag+1);
  487         memcpy(&tx->params, params, sizeof(struct ieee80211_bpf_params));
  488         m_tag_prepend(m, mtag);
  489         return (1);
  490 }
  491 
  492 int
  493 ieee80211_get_xmit_params(struct mbuf *m,
  494     struct ieee80211_bpf_params *params)
  495 {
  496         struct m_tag *mtag;
  497         struct ieee80211_tx_params *tx;
  498 
  499         mtag = m_tag_locate(m, MTAG_ABI_NET80211, NET80211_TAG_XMIT_PARAMS,
  500             NULL);
  501         if (mtag == NULL)
  502                 return (-1);
  503         tx = (struct ieee80211_tx_params *)(mtag + 1);
  504         memcpy(params, &tx->params, sizeof(struct ieee80211_bpf_params));
  505         return (0);
  506 }
  507 
  508 void
  509 ieee80211_process_callback(struct ieee80211_node *ni,
  510         struct mbuf *m, int status)
  511 {
  512         struct m_tag *mtag;
  513 
  514         mtag = m_tag_locate(m, MTAG_ABI_NET80211, NET80211_TAG_CALLBACK, NULL);
  515         if (mtag != NULL) {
  516                 struct ieee80211_cb *cb = (struct ieee80211_cb *)(mtag+1);
  517                 cb->func(ni, cb->arg, status);
  518         }
  519 }
  520 
  521 /*
  522  * Add RX parameters to the given mbuf.
  523  *
  524  * Returns 1 if OK, 0 on error.
  525  */
  526 int
  527 ieee80211_add_rx_params(struct mbuf *m, const struct ieee80211_rx_stats *rxs)
  528 {
  529         struct m_tag *mtag;
  530         struct ieee80211_rx_params *rx;
  531 
  532         mtag = m_tag_alloc(MTAG_ABI_NET80211, NET80211_TAG_RECV_PARAMS,
  533             sizeof(struct ieee80211_rx_stats), M_NOWAIT);
  534         if (mtag == NULL)
  535                 return (0);
  536 
  537         rx = (struct ieee80211_rx_params *)(mtag + 1);
  538         memcpy(&rx->params, rxs, sizeof(*rxs));
  539         m_tag_prepend(m, mtag);
  540         return (1);
  541 }
  542 
  543 int
  544 ieee80211_get_rx_params(struct mbuf *m, struct ieee80211_rx_stats *rxs)
  545 {
  546         struct m_tag *mtag;
  547         struct ieee80211_rx_params *rx;
  548 
  549         mtag = m_tag_locate(m, MTAG_ABI_NET80211, NET80211_TAG_RECV_PARAMS,
  550             NULL);
  551         if (mtag == NULL)
  552                 return (-1);
  553         rx = (struct ieee80211_rx_params *)(mtag + 1);
  554         memcpy(rxs, &rx->params, sizeof(*rxs));
  555         return (0);
  556 }
  557 
  558 /*
  559  * Transmit a frame to the parent interface.
  560  */
  561 int
  562 ieee80211_parent_xmitpkt(struct ieee80211com *ic, struct mbuf *m)
  563 {
  564         int error;
  565 
  566         /*
  567          * Assert the IC TX lock is held - this enforces the
  568          * processing -> queuing order is maintained
  569          */
  570         IEEE80211_TX_LOCK_ASSERT(ic);
  571         error = ic->ic_transmit(ic, m);
  572         if (error) {
  573                 struct ieee80211_node *ni;
  574 
  575                 ni = (struct ieee80211_node *)m->m_pkthdr.rcvif;
  576 
  577                 /* XXX number of fragments */
  578                 if_inc_counter(ni->ni_vap->iv_ifp, IFCOUNTER_OERRORS, 1);
  579                 ieee80211_free_node(ni);
  580                 ieee80211_free_mbuf(m);
  581         }
  582         return (error);
  583 }
  584 
  585 /*
  586  * Transmit a frame to the VAP interface.
  587  */
  588 int
  589 ieee80211_vap_xmitpkt(struct ieee80211vap *vap, struct mbuf *m)
  590 {
  591         struct ifnet *ifp = vap->iv_ifp;
  592 
  593         /*
  594          * When transmitting via the VAP, we shouldn't hold
  595          * any IC TX lock as the VAP TX path will acquire it.
  596          */
  597         IEEE80211_TX_UNLOCK_ASSERT(vap->iv_ic);
  598 
  599         return (ifp->if_transmit(ifp, m));
  600 
  601 }
  602 
  603 #include <sys/libkern.h>
  604 
  605 void
  606 get_random_bytes(void *p, size_t n)
  607 {
  608         uint8_t *dp = p;
  609 
  610         while (n > 0) {
  611                 uint32_t v = arc4random();
  612                 size_t nb = n > sizeof(uint32_t) ? sizeof(uint32_t) : n;
  613                 bcopy(&v, dp, n > sizeof(uint32_t) ? sizeof(uint32_t) : n);
  614                 dp += sizeof(uint32_t), n -= nb;
  615         }
  616 }
  617 
  618 /*
  619  * Helper function for events that pass just a single mac address.
  620  */
  621 static void
  622 notify_macaddr(struct ifnet *ifp, int op, const uint8_t mac[IEEE80211_ADDR_LEN])
  623 {
  624         struct ieee80211_join_event iev;
  625 
  626         CURVNET_SET(ifp->if_vnet);
  627         memset(&iev, 0, sizeof(iev));
  628         IEEE80211_ADDR_COPY(iev.iev_addr, mac);
  629         rt_ieee80211msg(ifp, op, &iev, sizeof(iev));
  630         CURVNET_RESTORE();
  631 }
  632 
  633 void
  634 ieee80211_notify_node_join(struct ieee80211_node *ni, int newassoc)
  635 {
  636         struct ieee80211vap *vap = ni->ni_vap;
  637         struct ifnet *ifp = vap->iv_ifp;
  638 
  639         CURVNET_SET_QUIET(ifp->if_vnet);
  640         IEEE80211_NOTE(vap, IEEE80211_MSG_NODE, ni, "%snode join",
  641             (ni == vap->iv_bss) ? "bss " : "");
  642 
  643         if (ni == vap->iv_bss) {
  644                 notify_macaddr(ifp, newassoc ?
  645                     RTM_IEEE80211_ASSOC : RTM_IEEE80211_REASSOC, ni->ni_bssid);
  646                 if_link_state_change(ifp, LINK_STATE_UP);
  647         } else {
  648                 notify_macaddr(ifp, newassoc ?
  649                     RTM_IEEE80211_JOIN : RTM_IEEE80211_REJOIN, ni->ni_macaddr);
  650         }
  651         CURVNET_RESTORE();
  652 }
  653 
  654 void
  655 ieee80211_notify_node_leave(struct ieee80211_node *ni)
  656 {
  657         struct ieee80211vap *vap = ni->ni_vap;
  658         struct ifnet *ifp = vap->iv_ifp;
  659 
  660         CURVNET_SET_QUIET(ifp->if_vnet);
  661         IEEE80211_NOTE(vap, IEEE80211_MSG_NODE, ni, "%snode leave",
  662             (ni == vap->iv_bss) ? "bss " : "");
  663 
  664         if (ni == vap->iv_bss) {
  665                 rt_ieee80211msg(ifp, RTM_IEEE80211_DISASSOC, NULL, 0);
  666                 if_link_state_change(ifp, LINK_STATE_DOWN);
  667         } else {
  668                 /* fire off wireless event station leaving */
  669                 notify_macaddr(ifp, RTM_IEEE80211_LEAVE, ni->ni_macaddr);
  670         }
  671         CURVNET_RESTORE();
  672 }
  673 
  674 void
  675 ieee80211_notify_scan_done(struct ieee80211vap *vap)
  676 {
  677         struct ifnet *ifp = vap->iv_ifp;
  678 
  679         IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, "%s\n", "notify scan done");
  680 
  681         /* dispatch wireless event indicating scan completed */
  682         CURVNET_SET(ifp->if_vnet);
  683         rt_ieee80211msg(ifp, RTM_IEEE80211_SCAN, NULL, 0);
  684         CURVNET_RESTORE();
  685 }
  686 
  687 void
  688 ieee80211_notify_replay_failure(struct ieee80211vap *vap,
  689         const struct ieee80211_frame *wh, const struct ieee80211_key *k,
  690         u_int64_t rsc, int tid)
  691 {
  692         struct ifnet *ifp = vap->iv_ifp;
  693 
  694         IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_CRYPTO, wh->i_addr2,
  695             "%s replay detected tid %d <rsc %ju, csc %ju, keyix %u rxkeyix %u>",
  696             k->wk_cipher->ic_name, tid, (intmax_t) rsc,
  697             (intmax_t) k->wk_keyrsc[tid],
  698             k->wk_keyix, k->wk_rxkeyix);
  699 
  700         if (ifp != NULL) {              /* NB: for cipher test modules */
  701                 struct ieee80211_replay_event iev;
  702 
  703                 IEEE80211_ADDR_COPY(iev.iev_dst, wh->i_addr1);
  704                 IEEE80211_ADDR_COPY(iev.iev_src, wh->i_addr2);
  705                 iev.iev_cipher = k->wk_cipher->ic_cipher;
  706                 if (k->wk_rxkeyix != IEEE80211_KEYIX_NONE)
  707                         iev.iev_keyix = k->wk_rxkeyix;
  708                 else
  709                         iev.iev_keyix = k->wk_keyix;
  710                 iev.iev_keyrsc = k->wk_keyrsc[tid];
  711                 iev.iev_rsc = rsc;
  712                 CURVNET_SET(ifp->if_vnet);
  713                 rt_ieee80211msg(ifp, RTM_IEEE80211_REPLAY, &iev, sizeof(iev));
  714                 CURVNET_RESTORE();
  715         }
  716 }
  717 
  718 void
  719 ieee80211_notify_michael_failure(struct ieee80211vap *vap,
  720         const struct ieee80211_frame *wh, u_int keyix)
  721 {
  722         struct ifnet *ifp = vap->iv_ifp;
  723 
  724         IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_CRYPTO, wh->i_addr2,
  725             "michael MIC verification failed <keyix %u>", keyix);
  726         vap->iv_stats.is_rx_tkipmic++;
  727 
  728         if (ifp != NULL) {              /* NB: for cipher test modules */
  729                 struct ieee80211_michael_event iev;
  730 
  731                 IEEE80211_ADDR_COPY(iev.iev_dst, wh->i_addr1);
  732                 IEEE80211_ADDR_COPY(iev.iev_src, wh->i_addr2);
  733                 iev.iev_cipher = IEEE80211_CIPHER_TKIP;
  734                 iev.iev_keyix = keyix;
  735                 CURVNET_SET(ifp->if_vnet);
  736                 rt_ieee80211msg(ifp, RTM_IEEE80211_MICHAEL, &iev, sizeof(iev));
  737                 CURVNET_RESTORE();
  738         }
  739 }
  740 
  741 void
  742 ieee80211_notify_wds_discover(struct ieee80211_node *ni)
  743 {
  744         struct ieee80211vap *vap = ni->ni_vap;
  745         struct ifnet *ifp = vap->iv_ifp;
  746 
  747         notify_macaddr(ifp, RTM_IEEE80211_WDS, ni->ni_macaddr);
  748 }
  749 
  750 void
  751 ieee80211_notify_csa(struct ieee80211com *ic,
  752         const struct ieee80211_channel *c, int mode, int count)
  753 {
  754         struct ieee80211_csa_event iev;
  755         struct ieee80211vap *vap;
  756         struct ifnet *ifp;
  757 
  758         memset(&iev, 0, sizeof(iev));
  759         iev.iev_flags = c->ic_flags;
  760         iev.iev_freq = c->ic_freq;
  761         iev.iev_ieee = c->ic_ieee;
  762         iev.iev_mode = mode;
  763         iev.iev_count = count;
  764         TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
  765                 ifp = vap->iv_ifp;
  766                 CURVNET_SET(ifp->if_vnet);
  767                 rt_ieee80211msg(ifp, RTM_IEEE80211_CSA, &iev, sizeof(iev));
  768                 CURVNET_RESTORE();
  769         }
  770 }
  771 
  772 void
  773 ieee80211_notify_radar(struct ieee80211com *ic,
  774         const struct ieee80211_channel *c)
  775 {
  776         struct ieee80211_radar_event iev;
  777         struct ieee80211vap *vap;
  778         struct ifnet *ifp;
  779 
  780         memset(&iev, 0, sizeof(iev));
  781         iev.iev_flags = c->ic_flags;
  782         iev.iev_freq = c->ic_freq;
  783         iev.iev_ieee = c->ic_ieee;
  784         TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
  785                 ifp = vap->iv_ifp;
  786                 CURVNET_SET(ifp->if_vnet);
  787                 rt_ieee80211msg(ifp, RTM_IEEE80211_RADAR, &iev, sizeof(iev));
  788                 CURVNET_RESTORE();
  789         }
  790 }
  791 
  792 void
  793 ieee80211_notify_cac(struct ieee80211com *ic,
  794         const struct ieee80211_channel *c, enum ieee80211_notify_cac_event type)
  795 {
  796         struct ieee80211_cac_event iev;
  797         struct ieee80211vap *vap;
  798         struct ifnet *ifp;
  799 
  800         memset(&iev, 0, sizeof(iev));
  801         iev.iev_flags = c->ic_flags;
  802         iev.iev_freq = c->ic_freq;
  803         iev.iev_ieee = c->ic_ieee;
  804         iev.iev_type = type;
  805         TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
  806                 ifp = vap->iv_ifp;
  807                 CURVNET_SET(ifp->if_vnet);
  808                 rt_ieee80211msg(ifp, RTM_IEEE80211_CAC, &iev, sizeof(iev));
  809                 CURVNET_RESTORE();
  810         }
  811 }
  812 
  813 void
  814 ieee80211_notify_node_deauth(struct ieee80211_node *ni)
  815 {
  816         struct ieee80211vap *vap = ni->ni_vap;
  817         struct ifnet *ifp = vap->iv_ifp;
  818 
  819         IEEE80211_NOTE(vap, IEEE80211_MSG_NODE, ni, "%s", "node deauth");
  820 
  821         notify_macaddr(ifp, RTM_IEEE80211_DEAUTH, ni->ni_macaddr);
  822 }
  823 
  824 void
  825 ieee80211_notify_node_auth(struct ieee80211_node *ni)
  826 {
  827         struct ieee80211vap *vap = ni->ni_vap;
  828         struct ifnet *ifp = vap->iv_ifp;
  829 
  830         IEEE80211_NOTE(vap, IEEE80211_MSG_NODE, ni, "%s", "node auth");
  831 
  832         notify_macaddr(ifp, RTM_IEEE80211_AUTH, ni->ni_macaddr);
  833 }
  834 
  835 void
  836 ieee80211_notify_country(struct ieee80211vap *vap,
  837         const uint8_t bssid[IEEE80211_ADDR_LEN], const uint8_t cc[2])
  838 {
  839         struct ifnet *ifp = vap->iv_ifp;
  840         struct ieee80211_country_event iev;
  841 
  842         memset(&iev, 0, sizeof(iev));
  843         IEEE80211_ADDR_COPY(iev.iev_addr, bssid);
  844         iev.iev_cc[0] = cc[0];
  845         iev.iev_cc[1] = cc[1];
  846         CURVNET_SET(ifp->if_vnet);
  847         rt_ieee80211msg(ifp, RTM_IEEE80211_COUNTRY, &iev, sizeof(iev));
  848         CURVNET_RESTORE();
  849 }
  850 
  851 void
  852 ieee80211_notify_radio(struct ieee80211com *ic, int state)
  853 {
  854         struct ieee80211_radio_event iev;
  855         struct ieee80211vap *vap;
  856         struct ifnet *ifp;
  857 
  858         memset(&iev, 0, sizeof(iev));
  859         iev.iev_state = state;
  860         TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
  861                 ifp = vap->iv_ifp;
  862                 CURVNET_SET(ifp->if_vnet);
  863                 rt_ieee80211msg(ifp, RTM_IEEE80211_RADIO, &iev, sizeof(iev));
  864                 CURVNET_RESTORE();
  865         }
  866 }
  867 
  868 void
  869 ieee80211_load_module(const char *modname)
  870 {
  871 
  872 #ifdef notyet
  873         (void)kern_kldload(curthread, modname, NULL);
  874 #else
  875         printf("%s: load the %s module by hand for now.\n", __func__, modname);
  876 #endif
  877 }
  878 
  879 static eventhandler_tag wlan_bpfevent;
  880 static eventhandler_tag wlan_ifllevent;
  881 
  882 static void
  883 bpf_track(void *arg, struct ifnet *ifp, int dlt, int attach)
  884 {
  885         /* NB: identify vap's by if_init */
  886         if (dlt == DLT_IEEE802_11_RADIO &&
  887             ifp->if_init == ieee80211_init) {
  888                 struct ieee80211vap *vap = ifp->if_softc;
  889                 /*
  890                  * Track bpf radiotap listener state.  We mark the vap
  891                  * to indicate if any listener is present and the com
  892                  * to indicate if any listener exists on any associated
  893                  * vap.  This flag is used by drivers to prepare radiotap
  894                  * state only when needed.
  895                  */
  896                 if (attach) {
  897                         ieee80211_syncflag_ext(vap, IEEE80211_FEXT_BPF);
  898                         if (vap->iv_opmode == IEEE80211_M_MONITOR)
  899                                 atomic_add_int(&vap->iv_ic->ic_montaps, 1);
  900                 } else if (!bpf_peers_present(vap->iv_rawbpf)) {
  901                         ieee80211_syncflag_ext(vap, -IEEE80211_FEXT_BPF);
  902                         if (vap->iv_opmode == IEEE80211_M_MONITOR)
  903                                 atomic_subtract_int(&vap->iv_ic->ic_montaps, 1);
  904                 }
  905         }
  906 }
  907 
  908 /*
  909  * Change MAC address on the vap (if was not started).
  910  */
  911 static void
  912 wlan_iflladdr(void *arg __unused, struct ifnet *ifp)
  913 {
  914         /* NB: identify vap's by if_init */
  915         if (ifp->if_init == ieee80211_init &&
  916             (ifp->if_flags & IFF_UP) == 0) {
  917                 struct ieee80211vap *vap = ifp->if_softc;
  918 
  919                 IEEE80211_ADDR_COPY(vap->iv_myaddr, IF_LLADDR(ifp));
  920         }
  921 }
  922 
  923 /*
  924  * Module glue.
  925  *
  926  * NB: the module name is "wlan" for compatibility with NetBSD.
  927  */
  928 static int
  929 wlan_modevent(module_t mod, int type, void *unused)
  930 {
  931         switch (type) {
  932         case MOD_LOAD:
  933                 if (bootverbose)
  934                         printf("wlan: <802.11 Link Layer>\n");
  935                 wlan_bpfevent = EVENTHANDLER_REGISTER(bpf_track,
  936                     bpf_track, 0, EVENTHANDLER_PRI_ANY);
  937                 wlan_ifllevent = EVENTHANDLER_REGISTER(iflladdr_event,
  938                     wlan_iflladdr, NULL, EVENTHANDLER_PRI_ANY);
  939                 wlan_cloner = if_clone_simple(wlanname, wlan_clone_create,
  940                     wlan_clone_destroy, 0);
  941                 return 0;
  942         case MOD_UNLOAD:
  943                 if_clone_detach(wlan_cloner);
  944                 EVENTHANDLER_DEREGISTER(bpf_track, wlan_bpfevent);
  945                 EVENTHANDLER_DEREGISTER(iflladdr_event, wlan_ifllevent);
  946                 return 0;
  947         }
  948         return EINVAL;
  949 }
  950 
  951 static moduledata_t wlan_mod = {
  952         wlanname,
  953         wlan_modevent,
  954         0
  955 };
  956 DECLARE_MODULE(wlan, wlan_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST);
  957 MODULE_VERSION(wlan, 1);
  958 MODULE_DEPEND(wlan, ether, 1, 1, 1);
  959 #ifdef  IEEE80211_ALQ
  960 MODULE_DEPEND(wlan, alq, 1, 1, 1);
  961 #endif  /* IEEE80211_ALQ */
  962 

Cache object: 105c84961a3e948131893685ffccf36b


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.