sys/dev/wtap/if_wtap.c

   1 /*-
   2  * Copyright (c) 2010-2011 Monthadar Al Jaberi, TerraNet AB
   3  * All rights reserved.
   4  *
   5  * Copyright (c) 2002-2009 Sam Leffler, Errno Consulting
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer,
  13  *    without modification.
  14  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  15  *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
  16  *    redistribution must be conditioned upon including a substantially
  17  *    similar Disclaimer requirement for further binary redistribution.
  18  *
  19  * NO WARRANTY
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
  23  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
  24  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
  25  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  28  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  30  * THE POSSIBILITY OF SUCH DAMAGES.
  31  *
  32  * $FreeBSD$
  33  */
  34 #include "if_wtapvar.h"
  35 #include <sys/uio.h>    /* uio struct */
  36 #include <sys/jail.h>
  37 #include <net/if_var.h>
  38 #include <net/vnet.h>
  39
  40 #include <net80211/ieee80211_ratectl.h>
  41 #include "if_medium.h"
  42
  43 /*
  44  * This _requires_ vimage to be useful.
  45  */
  46 #ifndef VIMAGE
  47 #error  if_wtap requires VIMAGE.
  48 #endif  /* VIMAGE */
  49
  50 /* device for IOCTL and read/write for debuggin purposes */
  51 /* Function prototypes */
  52 static  d_open_t        wtap_node_open;
  53 static  d_close_t       wtap_node_close;
  54 static  d_write_t       wtap_node_write;
  55 static  d_ioctl_t       wtap_node_ioctl;
  56
  57 static struct cdevsw wtap_cdevsw = {
  58         .d_version =    D_VERSION,
  59         .d_flags =      0,
  60         .d_open =       wtap_node_open,
  61         .d_close =      wtap_node_close,
  62         .d_write =      wtap_node_write,
  63         .d_ioctl =      wtap_node_ioctl,
  64         .d_name =       "wtapnode",
  65 };
  66
  67 static int
  68 wtap_node_open(struct cdev *dev, int oflags, int devtype, struct thread *p)
  69 {
  70
  71         int err = 0;
  72         uprintf("Opened device \"echo\" successfully.\n");
  73         return(err);
  74 }
  75
  76 static int
  77 wtap_node_close(struct cdev *dev, int fflag, int devtype, struct thread *p)
  78 {
  79
  80         uprintf("Closing device \"echo.\"\n");
  81         return(0);
  82 }
  83
  84 static int
  85 wtap_node_write(struct cdev *dev, struct uio *uio, int ioflag)
  86 {
  87         int err = 0;
  88         struct mbuf *m;
  89         struct ifnet *ifp;
  90         struct wtap_softc *sc;
  91         uint8_t buf[1024];
  92         int buf_len;
  93
  94         uprintf("write device %s \"echo.\"\n", devtoname(dev));
  95         buf_len = MIN(uio->uio_iov->iov_len, 1024);
  96         err = copyin(uio->uio_iov->iov_base, buf, buf_len);
  97
  98         if (err != 0) {
  99                 uprintf("Write failed: bad address!\n");
 100                 return (err);
 101         }
 102
 103         MGETHDR(m, M_DONTWAIT, MT_DATA);
 104         m_copyback(m, 0, buf_len, buf);
 105
 106         CURVNET_SET(TD_TO_VNET(curthread));
 107         IFNET_RLOCK_NOSLEEP();
 108
 109         TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
 110                 printf("ifp->if_xname = %s\n", ifp->if_xname);
 111                 if(strcmp(devtoname(dev), ifp->if_xname) == 0){
 112                         printf("found match, correspoding wtap = %s\n",
 113                             ifp->if_xname);
 114                         sc = (struct wtap_softc *)ifp->if_softc;
 115                         printf("wtap id = %d\n", sc->id);
 116                         wtap_inject(sc, m);
 117                 }
 118         }
 119
 120         IFNET_RUNLOCK_NOSLEEP();
 121         CURVNET_RESTORE();
 122
 123         return(err);
 124 }
 125
 126 int
 127 wtap_node_ioctl(struct cdev *dev, u_long cmd, caddr_t data,
 128     int fflag, struct thread *td)
 129 {
 130         int error = 0;
 131
 132         switch(cmd) {
 133         default:
 134                 DWTAP_PRINTF("Unkown WTAP IOCTL\n");
 135                 error = EINVAL;
 136         }
 137         return error;
 138 }
 139
 140 static int wtap_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
 141         const struct ieee80211_bpf_params *params);
 142
 143 static int
 144 wtap_medium_enqueue(struct wtap_vap *avp, struct mbuf *m)
 145 {
 146
 147         return medium_transmit(avp->av_md, avp->id, m);
 148 }
 149
 150 static int
 151 wtap_media_change(struct ifnet *ifp)
 152 {
 153
 154         DWTAP_PRINTF("%s\n", __func__);
 155         int error = ieee80211_media_change(ifp);
 156         /* NB: only the fixed rate can change and that doesn't need a reset */
 157         return (error == ENETRESET ? 0 : error);
 158 }
 159
 160 /*
 161  * Intercept management frames to collect beacon rssi data
 162  * and to do ibss merges.
 163  */
 164 static void
 165 wtap_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m,
 166     int subtype, int rssi, int nf)
 167 {
 168         struct ieee80211vap *vap = ni->ni_vap;
 169 #if 0
 170         DWTAP_PRINTF("[%d] %s\n", myath_id(ni), __func__);
 171 #endif
 172         WTAP_VAP(vap)->av_recv_mgmt(ni, m, subtype, rssi, nf);
 173 }
 174
 175 static int
 176 wtap_reset_vap(struct ieee80211vap *vap, u_long cmd)
 177 {
 178
 179         DWTAP_PRINTF("%s\n", __func__);
 180         return 0;
 181 }
 182
 183 static void
 184 wtap_beacon_update(struct ieee80211vap *vap, int item)
 185 {
 186         struct ieee80211_beacon_offsets *bo = &WTAP_VAP(vap)->av_boff;
 187
 188         DWTAP_PRINTF("%s\n", __func__);
 189         setbit(bo->bo_flags, item);
 190 }
 191
 192 /*
 193  * Allocate and setup an initial beacon frame.
 194  */
 195 static int
 196 wtap_beacon_alloc(struct wtap_softc *sc, struct ieee80211_node *ni)
 197 {
 198         struct ieee80211vap *vap = ni->ni_vap;
 199         struct wtap_vap *avp = WTAP_VAP(vap);
 200
 201         DWTAP_PRINTF("[%s] %s\n", ether_sprintf(ni->ni_macaddr), __func__);
 202
 203         /*
 204          * NB: the beacon data buffer must be 32-bit aligned;
 205          * we assume the mbuf routines will return us something
 206          * with this alignment (perhaps should assert).
 207          */
 208         avp->beacon = ieee80211_beacon_alloc(ni, &avp->av_boff);
 209         if (avp->beacon == NULL) {
 210                 printf("%s: cannot get mbuf\n", __func__);
 211                 return ENOMEM;
 212         }
 213         callout_init(&avp->av_swba, 0);
 214         avp->bf_node = ieee80211_ref_node(ni);
 215
 216         return 0;
 217 }
 218
 219 static void
 220 wtap_beacon_config(struct wtap_softc *sc, struct ieee80211vap *vap)
 221 {
 222
 223         DWTAP_PRINTF("%s\n", __func__);
 224 }
 225
 226 static void
 227 wtap_beacon_intrp(void *arg)
 228 {
 229         struct wtap_vap *avp = arg;
 230         struct ieee80211vap *vap = arg;
 231         struct mbuf *m;
 232
 233         KASSERT(vap->iv_state >= IEEE80211_S_RUN,
 234             ("not running, state %d", vap->iv_state));
 235         DWTAP_PRINTF("[%d] beacon intrp\n", avp->id);   //burst mode
 236         /*
 237          * Update dynamic beacon contents.  If this returns
 238          * non-zero then we need to remap the memory because
 239          * the beacon frame changed size (probably because
 240          * of the TIM bitmap).
 241          */
 242         m = m_dup(avp->beacon, M_DONTWAIT);
 243         if (ieee80211_beacon_update(avp->bf_node, &avp->av_boff, m, 0)) {
 244                 printf("%s, need to remap the memory because the beacon frame"
 245                     " changed size.\n",__func__);
 246         }
 247
 248         if (ieee80211_radiotap_active_vap(vap))
 249             ieee80211_radiotap_tx(vap, m);
 250
 251 #if 0
 252         medium_transmit(avp->av_md, avp->id, m);
 253 #endif
 254         wtap_medium_enqueue(avp, m);
 255         callout_schedule(&avp->av_swba, avp->av_bcinterval);
 256 }
 257
 258 static int
 259 wtap_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
 260 {
 261         struct ieee80211com *ic = vap->iv_ic;
 262         struct wtap_softc *sc = ic->ic_ifp->if_softc;
 263         struct wtap_vap *avp = WTAP_VAP(vap);
 264         struct ieee80211_node *ni = NULL;
 265         int error;
 266
 267         DWTAP_PRINTF("%s\n", __func__);
 268
 269         ni = vap->iv_bss;
 270         /*
 271          * Invoke the parent method to do net80211 work.
 272          */
 273         error = avp->av_newstate(vap, nstate, arg);
 274         if (error != 0)
 275                 goto bad;
 276
 277         if (nstate == IEEE80211_S_RUN) {
 278                 /* NB: collect bss node again, it may have changed */
 279                 ni = vap->iv_bss;
 280                 switch (vap->iv_opmode) {
 281                 case IEEE80211_M_MBSS:
 282                         error = wtap_beacon_alloc(sc, ni);
 283                         if (error != 0)
 284                                 goto bad;
 285                         wtap_beacon_config(sc, vap);
 286                         callout_reset(&avp->av_swba, avp->av_bcinterval,
 287                             wtap_beacon_intrp, vap);
 288                         break;
 289                 default:
 290                         goto bad;
 291                 }
 292         }
 293         return 0;
 294 bad:
 295         printf("%s: bad\n", __func__);
 296         return error;
 297 }
 298
 299 static void
 300 wtap_bmiss(struct ieee80211vap *vap)
 301 {
 302         struct wtap_vap *avp = (struct wtap_vap *)vap;
 303
 304         DWTAP_PRINTF("%s\n", __func__);
 305         avp->av_bmiss(vap);
 306 }
 307
 308 static struct ieee80211vap *
 309 wtap_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ],
 310     int unit, enum ieee80211_opmode opmode, int flags,
 311     const uint8_t bssid[IEEE80211_ADDR_LEN],
 312     const uint8_t mac[IEEE80211_ADDR_LEN])
 313 {
 314          struct wtap_softc *sc = ic->ic_ifp->if_softc;
 315          struct ieee80211vap *vap;
 316          struct wtap_vap *avp;
 317          int error;
 318
 319          DWTAP_PRINTF("%s\n", __func__);
 320
 321         avp = (struct wtap_vap *) malloc(sizeof(struct wtap_vap),
 322             M_80211_VAP, M_NOWAIT | M_ZERO);
 323         avp->id = sc->id;
 324         avp->av_md = sc->sc_md;
 325         avp->av_bcinterval = BEACON_INTRERVAL + 100*sc->id;
 326         vap = (struct ieee80211vap *) avp;
 327         error = ieee80211_vap_setup(ic, vap, name, unit, IEEE80211_M_MBSS,
 328             flags | IEEE80211_CLONE_NOBEACONS, bssid, mac);
 329
 330         /* override various methods */
 331         avp->av_recv_mgmt = vap->iv_recv_mgmt;
 332         vap->iv_recv_mgmt = wtap_recv_mgmt;
 333         vap->iv_reset = wtap_reset_vap;
 334         vap->iv_update_beacon = wtap_beacon_update;
 335         avp->av_newstate = vap->iv_newstate;
 336         vap->iv_newstate = wtap_newstate;
 337         avp->av_bmiss = vap->iv_bmiss;
 338         vap->iv_bmiss = wtap_bmiss;
 339
 340         /* complete setup */
 341         ieee80211_vap_attach(vap, wtap_media_change, ieee80211_media_status);
 342         avp->av_dev = make_dev(&wtap_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600,
 343             (const char *)ic->ic_ifp->if_xname);
 344
 345         /* TODO this is a hack to force it to choose the rate we want */
 346         vap->iv_bss->ni_txrate = 130;
 347         return vap;
 348 }
 349
 350 static void
 351 wtap_vap_delete(struct ieee80211vap *vap)
 352 {
 353         struct wtap_vap *avp = WTAP_VAP(vap);
 354
 355         DWTAP_PRINTF("%s\n", __func__);
 356         destroy_dev(avp->av_dev);
 357         callout_stop(&avp->av_swba);
 358         ieee80211_vap_detach(vap);
 359         free((struct wtap_vap*) vap, M_80211_VAP);
 360 }
 361
 362 /* NB: This function is not used.
 363  * I had the problem of the queue
 364  * being empty all the time.
 365  * Maybe I am setting the queue wrong?
 366  */
 367 static void
 368 wtap_start(struct ifnet *ifp)
 369 {
 370         struct ieee80211com *ic = ifp->if_l2com;
 371         struct ifnet *icifp = ic->ic_ifp;
 372         struct wtap_softc *sc = icifp->if_softc;
 373         struct ieee80211_node *ni;
 374         struct mbuf *m;
 375
 376         DWTAP_PRINTF("my_start, with id=%u\n", sc->id);
 377
 378         if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 || sc->up == 0)
 379                 return;
 380         for (;;) {
 381                 if(IFQ_IS_EMPTY(&ifp->if_snd)){
 382                     printf("queue empty, just trying to see "
 383                         "if the other queue is empty\n");
 384 #if 0
 385                     printf("queue for id=1, %u\n",
 386                         IFQ_IS_EMPTY(&global_mscs[1]->ifp->if_snd));
 387                     printf("queue for id=0, %u\n",
 388                         IFQ_IS_EMPTY(&global_mscs[0]->ifp->if_snd));
 389 #endif
 390                     break;
 391                 }
 392                 IFQ_DEQUEUE(&ifp->if_snd, m);
 393                 if (m == NULL) {
 394                         printf("error dequeueing from ifp->snd\n");
 395                         break;
 396                 }
 397                 ni = (struct ieee80211_node *) m->m_pkthdr.rcvif;
 398                 /*
 399                  * Check for fragmentation.  If this frame
 400                  * has been broken up verify we have enough
 401                  * buffers to send all the fragments so all
 402                  * go out or none...
 403                  */
 404 #if 0
 405                 STAILQ_INIT(&frags);
 406 #endif
 407                 if ((m->m_flags & M_FRAG)){
 408                         printf("dont support frags\n");
 409                         ifp->if_oerrors++;
 410                         return;
 411                 }
 412                 ifp->if_opackets++;
 413                 if(wtap_raw_xmit(ni, m, NULL) < 0){
 414                         printf("error raw_xmiting\n");
 415                         ifp->if_oerrors++;
 416                         return;
 417                 }
 418         }
 419 }
 420
 421 static int
 422 wtap_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
 423 {
 424 #if 0
 425         DWTAP_PRINTF("%s\n", __func__);
 426         uprintf("%s, command %lu\n", __func__, cmd);
 427 #endif
 428 #define IS_RUNNING(ifp) \
 429         ((ifp->if_flags & IFF_UP) && (ifp->if_drv_flags & IFF_DRV_RUNNING))
 430         struct ieee80211com *ic = ifp->if_l2com;
 431         struct wtap_softc *sc = ifp->if_softc;
 432         struct ifreq *ifr = (struct ifreq *)data;
 433         int error = 0;
 434
 435         switch (cmd) {
 436         case SIOCSIFFLAGS:
 437                 //printf("%s: %s\n", __func__, "SIOCSIFFLAGS");
 438                 if (IS_RUNNING(ifp)) {
 439                         DWTAP_PRINTF("running\n");
 440 #if 0
 441                         /*
 442                          * To avoid rescanning another access point,
 443                          * do not call ath_init() here.  Instead,
 444                          * only reflect promisc mode settings.
 445                          */
 446                         //ath_mode_init(sc);
 447 #endif
 448                         } else if (ifp->if_flags & IFF_UP) {
 449                         DWTAP_PRINTF("up\n");
 450                         sc->up = 1;
 451 #if 0
 452                         /*
 453                          * Beware of being called during attach/detach
 454                          * to reset promiscuous mode.  In that case we
 455                          * will still be marked UP but not RUNNING.
 456                          * However trying to re-init the interface
 457                          * is the wrong thing to do as we've already
 458                          * torn down much of our state.  There's
 459                          * probably a better way to deal with this.
 460                          */
 461                         //if (!sc->sc_invalid)
 462                         //      ath_init(sc);   /* XXX lose error */
 463 #endif
 464                         ifp->if_drv_flags |= IFF_DRV_RUNNING;
 465                         ieee80211_start_all(ic);
 466                 } else {
 467                         DWTAP_PRINTF("stoping\n");
 468 #if 0
 469                         ath_stop_locked(ifp);
 470 #ifdef notyet
 471                         /* XXX must wakeup in places like ath_vap_delete */
 472                         if (!sc->sc_invalid)
 473                                 ath_hal_setpower(sc->sc_ah, HAL_PM_FULL_SLEEP);
 474 #endif
 475 #endif
 476                 }
 477                 break;
 478         case SIOCGIFMEDIA:
 479         case SIOCSIFMEDIA:
 480 #if 0
 481                 DWTAP_PRINTF("%s: %s\n", __func__, "SIOCGIFMEDIA|SIOCSIFMEDIA");
 482 #endif
 483                 error = ifmedia_ioctl(ifp, ifr, &ic->ic_media, cmd);
 484                 break;
 485         case SIOCGIFADDR:
 486 #if 0
 487                 DWTAP_PRINTF("%s: %s\n", __func__, "SIOCGIFADDR");
 488 #endif
 489                 error = ether_ioctl(ifp, cmd, data);
 490                 break;
 491         default:
 492                 DWTAP_PRINTF("%s: %s [%lu]\n", __func__, "EINVAL", cmd);
 493                 error = EINVAL;
 494                 break;
 495         }
 496         return error;
 497 #undef IS_RUNNING
 498 }
 499
 500 static void
 501 wtap_init(void *arg){
 502
 503         DWTAP_PRINTF("%s\n", __func__);
 504 }
 505
 506 static void
 507 wtap_scan_start(struct ieee80211com *ic)
 508 {
 509
 510 #if 0
 511         DWTAP_PRINTF("%s\n", __func__);
 512 #endif
 513 }
 514
 515 static void
 516 wtap_scan_end(struct ieee80211com *ic)
 517 {
 518
 519 #if 0
 520         DWTAP_PRINTF("%s\n", __func__);
 521 #endif
 522 }
 523
 524 static void
 525 wtap_set_channel(struct ieee80211com *ic)
 526 {
 527
 528 #if 0
 529         DWTAP_PRINTF("%s\n", __func__);
 530 #endif
 531 }
 532
 533 static int
 534 wtap_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
 535         const struct ieee80211_bpf_params *params)
 536 {
 537 #if 0
 538         DWTAP_PRINTF("%s, %p\n", __func__, m);
 539 #endif
 540         struct ieee80211vap     *vap = ni->ni_vap;
 541         struct wtap_vap         *avp = WTAP_VAP(vap);
 542
 543         if (ieee80211_radiotap_active_vap(vap)) {
 544                 ieee80211_radiotap_tx(vap, m);
 545         }
 546         if (m->m_flags & M_TXCB)
 547                 ieee80211_process_callback(ni, m, 0);
 548         ieee80211_free_node(ni);
 549         return wtap_medium_enqueue(avp, m);
 550 }
 551
 552 void
 553 wtap_inject(struct wtap_softc *sc, struct mbuf *m)
 554 {
 555       struct wtap_buf *bf = (struct wtap_buf *)malloc(sizeof(struct wtap_buf),
 556           M_WTAP_RXBUF, M_NOWAIT | M_ZERO);
 557       KASSERT(bf != NULL, ("could not allocated a new wtap_buf\n"));
 558       bf->m = m;
 559
 560       mtx_lock(&sc->sc_mtx);
 561       STAILQ_INSERT_TAIL(&sc->sc_rxbuf, bf, bf_list);
 562       taskqueue_enqueue(sc->sc_tq, &sc->sc_rxtask);
 563       mtx_unlock(&sc->sc_mtx);
 564 }
 565
 566 void
 567 wtap_rx_deliver(struct wtap_softc *sc, struct mbuf *m)
 568 {
 569         struct ifnet *ifp = sc->sc_ifp;
 570         struct ieee80211com *ic = ifp->if_l2com;
 571         struct ieee80211_node *ni;
 572         int type;
 573 #if 0
 574         DWTAP_PRINTF("%s\n", __func__);
 575 #endif
 576
 577         DWTAP_PRINTF("[%d] receiving m=%p\n", sc->id, m);
 578         if (m == NULL) {                /* NB: shouldn't happen */
 579                 if_printf(ifp, "%s: no mbuf!\n", __func__);
 580         }
 581
 582         ifp->if_ipackets++;
 583
 584         ieee80211_dump_pkt(ic, mtod(m, caddr_t), 0,0,0);
 585
 586         /*
 587           * Locate the node for sender, track state, and then
 588           * pass the (referenced) node up to the 802.11 layer
 589           * for its use.
 590           */
 591         ni = ieee80211_find_rxnode_withkey(ic,
 592             mtod(m, const struct ieee80211_frame_min *),IEEE80211_KEYIX_NONE);
 593         if (ni != NULL) {
 594                 /*
 595                  * Sending station is known, dispatch directly.
 596                  */
 597                 type = ieee80211_input(ni, m, 1<<7, 10);
 598                 ieee80211_free_node(ni);
 599         } else {
 600                 type = ieee80211_input_all(ic, m, 1<<7, 10);
 601         }
 602 }
 603
 604 static void
 605 wtap_rx_proc(void *arg, int npending)
 606 {
 607         struct wtap_softc *sc = (struct wtap_softc *)arg;
 608         struct ifnet *ifp = sc->sc_ifp;
 609         struct ieee80211com *ic = ifp->if_l2com;
 610         struct mbuf *m;
 611         struct ieee80211_node *ni;
 612         int type;
 613         struct wtap_buf *bf;
 614
 615 #if 0
 616         DWTAP_PRINTF("%s\n", __func__);
 617 #endif
 618
 619         for(;;) {
 620                 mtx_lock(&sc->sc_mtx);
 621                 bf = STAILQ_FIRST(&sc->sc_rxbuf);
 622                 if (bf == NULL) {
 623                         mtx_unlock(&sc->sc_mtx);
 624                         return;
 625                 }
 626                 STAILQ_REMOVE_HEAD(&sc->sc_rxbuf, bf_list);
 627                 mtx_unlock(&sc->sc_mtx);
 628                 KASSERT(bf != NULL, ("wtap_buf is NULL\n"));
 629                 m = bf->m;
 630                 DWTAP_PRINTF("[%d] receiving m=%p\n", sc->id, bf->m);
 631                 if (m == NULL) {                /* NB: shouldn't happen */
 632                         if_printf(ifp, "%s: no mbuf!\n", __func__);
 633                         free(bf, M_WTAP_RXBUF);
 634                         return;
 635                 }
 636
 637                 ifp->if_ipackets++;
 638 #if 0
 639                 ieee80211_dump_pkt(ic, mtod(m, caddr_t), 0,0,0);
 640 #endif
 641
 642                 /*
 643                  * Locate the node for sender, track state, and then
 644                  * pass the (referenced) node up to the 802.11 layer
 645                  * for its use.
 646                  */
 647                 ni = ieee80211_find_rxnode_withkey(ic,
 648                     mtod(m, const struct ieee80211_frame_min *),
 649                     IEEE80211_KEYIX_NONE);
 650                 if (ni != NULL) {
 651                         /*
 652                          * Sending station is known, dispatch directly.
 653                          */
 654 #if 0
 655                         ieee80211_radiotap_rx(ni->ni_vap, m);
 656 #endif
 657                         type = ieee80211_input(ni, m, 1<<7, 10);
 658                         ieee80211_free_node(ni);
 659                 } else {
 660 #if 0
 661                         ieee80211_radiotap_rx_all(ic, m);
 662 #endif
 663                         type = ieee80211_input_all(ic, m, 1<<7, 10);
 664                 }
 665
 666                 /* The mbufs are freed by the Net80211 stack */
 667                 free(bf, M_WTAP_RXBUF);
 668         }
 669 }
 670
 671 static void
 672 wtap_newassoc(struct ieee80211_node *ni, int isnew)
 673 {
 674
 675         DWTAP_PRINTF("%s\n", __func__);
 676 }
 677
 678 /*
 679  * Callback from the 802.11 layer to update WME parameters.
 680  */
 681 static int
 682 wtap_wme_update(struct ieee80211com *ic)
 683 {
 684
 685         DWTAP_PRINTF("%s\n", __func__);
 686         return 0;
 687 }
 688
 689 static void
 690 wtap_update_mcast(struct ifnet *ifp)
 691 {
 692
 693         DWTAP_PRINTF("%s\n", __func__);
 694 }
 695
 696 static void
 697 wtap_update_promisc(struct ifnet *ifp)
 698 {
 699
 700         DWTAP_PRINTF("%s\n", __func__);
 701 }
 702
 703 static int
 704 wtap_if_transmit(struct ifnet *ifp, struct mbuf *m)
 705 {
 706         struct ieee80211_node *ni =
 707             (struct ieee80211_node *) m->m_pkthdr.rcvif;
 708         struct ieee80211vap *vap = ni->ni_vap;
 709         struct wtap_vap *avp = WTAP_VAP(vap);
 710
 711         if(ni == NULL){
 712                 printf("m->m_pkthdr.rcvif is NULL we cant radiotap_tx\n");
 713         }else{
 714                 if (ieee80211_radiotap_active_vap(vap))
 715                         ieee80211_radiotap_tx(vap, m);
 716         }
 717         if (m->m_flags & M_TXCB)
 718                 ieee80211_process_callback(ni, m, 0);
 719         ieee80211_free_node(ni);
 720         return wtap_medium_enqueue(avp, m);
 721 }
 722
 723 static struct ieee80211_node *
 724 wtap_node_alloc(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN])
 725 {
 726         struct ieee80211_node *ni;
 727
 728         DWTAP_PRINTF("%s\n", __func__);
 729
 730         ni = malloc(sizeof(struct ieee80211_node), M_80211_NODE,
 731             M_NOWAIT|M_ZERO);
 732
 733         ni->ni_txrate = 130;
 734         return ni;
 735 }
 736
 737 static void
 738 wtap_node_free(struct ieee80211_node *ni)
 739 {
 740         struct ieee80211com *ic = ni->ni_ic;
 741         struct wtap_softc *sc = ic->ic_ifp->if_softc;
 742
 743         DWTAP_PRINTF("%s\n", __func__);
 744         sc->sc_node_free(ni);
 745 }
 746
 747 int32_t
 748 wtap_attach(struct wtap_softc *sc, const uint8_t *macaddr)
 749 {
 750         struct ifnet *ifp;
 751         struct ieee80211com *ic;
 752         char wtap_name[] = {'w','T','a','p',sc->id,
 753             '_','t','a','s','k','q','\0'};
 754
 755         DWTAP_PRINTF("%s\n", __func__);
 756
 757         ifp = if_alloc(IFT_IEEE80211);
 758         if (ifp == NULL) {
 759                 printf("can not if_alloc()\n");
 760                 return -1;
 761         }
 762         ic = ifp->if_l2com;
 763         if_initname(ifp, "wtap", sc->id);
 764
 765         sc->sc_ifp = ifp;
 766         sc->up = 0;
 767
 768         STAILQ_INIT(&sc->sc_rxbuf);
 769         sc->sc_tq = taskqueue_create(wtap_name, M_NOWAIT | M_ZERO,
 770             taskqueue_thread_enqueue, &sc->sc_tq);
 771         taskqueue_start_threads(&sc->sc_tq, 1, PI_SOFT, "%s taskQ",
 772             ifp->if_xname);
 773         TASK_INIT(&sc->sc_rxtask, 0, wtap_rx_proc, sc);
 774
 775         ifp->if_softc = sc;
 776         ifp->if_flags = IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST;
 777         ifp->if_start = wtap_start;
 778         ifp->if_ioctl = wtap_ioctl;
 779         ifp->if_init = wtap_init;
 780         IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
 781         ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;
 782         IFQ_SET_READY(&ifp->if_snd);
 783
 784         ic->ic_ifp = ifp;
 785         ic->ic_phytype = IEEE80211_T_DS;
 786         ic->ic_opmode = IEEE80211_M_MBSS;
 787         ic->ic_caps = IEEE80211_C_MBSS;
 788
 789         ic->ic_max_keyix = 128; /* A value read from Atheros ATH_KEYMAX */
 790
 791         ic->ic_regdomain.regdomain = SKU_ETSI;
 792         ic->ic_regdomain.country = CTRY_SWEDEN;
 793         ic->ic_regdomain.location = 1; /* Indoors */
 794         ic->ic_regdomain.isocc[0] = 'S';
 795         ic->ic_regdomain.isocc[1] = 'E';
 796         /*
 797          * Indicate we need the 802.11 header padded to a
 798          * 32-bit boundary for 4-address and QoS frames.
 799          */
 800         ic->ic_flags |= IEEE80211_F_DATAPAD;
 801         ic->ic_nchans = 1;
 802         ic->ic_channels[0].ic_flags = IEEE80211_CHAN_B;
 803         ic->ic_channels[0].ic_freq = 2412;
 804
 805         ieee80211_ifattach(ic, macaddr);
 806
 807 #if 0
 808         /* new prototype hook-ups */
 809         msc->if_input = ifp->if_input;
 810         ifp->if_input = myath_if_input;
 811         msc->if_output = ifp->if_output;
 812         ifp->if_output = myath_if_output;
 813 #endif
 814         sc->if_transmit = ifp->if_transmit;
 815         ifp->if_transmit = wtap_if_transmit;
 816
 817         /* override default methods */
 818         ic->ic_newassoc = wtap_newassoc;
 819 #if 0
 820         ic->ic_updateslot = myath_updateslot;
 821 #endif
 822         ic->ic_wme.wme_update = wtap_wme_update;
 823         ic->ic_vap_create = wtap_vap_create;
 824         ic->ic_vap_delete = wtap_vap_delete;
 825         ic->ic_raw_xmit = wtap_raw_xmit;
 826         ic->ic_update_mcast = wtap_update_mcast;
 827         ic->ic_update_promisc = wtap_update_promisc;
 828
 829         sc->sc_node_alloc = ic->ic_node_alloc;
 830         ic->ic_node_alloc = wtap_node_alloc;
 831         sc->sc_node_free = ic->ic_node_free;
 832         ic->ic_node_free = wtap_node_free;
 833
 834 #if 0
 835         ic->ic_node_getsignal = myath_node_getsignal;
 836 #endif
 837         ic->ic_scan_start = wtap_scan_start;
 838         ic->ic_scan_end = wtap_scan_end;
 839         ic->ic_set_channel = wtap_set_channel;
 840
 841         ieee80211_radiotap_attach(ic,
 842             &sc->sc_tx_th.wt_ihdr, sizeof(sc->sc_tx_th),
 843             WTAP_TX_RADIOTAP_PRESENT,
 844             &sc->sc_rx_th.wr_ihdr, sizeof(sc->sc_rx_th),
 845             WTAP_RX_RADIOTAP_PRESENT);
 846
 847         /* Work here, we must find a way to populate the rate table */
 848 #if 0
 849         if(ic->ic_rt == NULL){
 850                 printf("no table for ic_curchan\n");
 851                 ic->ic_rt = ieee80211_get_ratetable(&ic->ic_channels[0]);
 852         }
 853         printf("ic->ic_rt =%p\n", ic->ic_rt);
 854         printf("rate count %d\n", ic->ic_rt->rateCount);
 855
 856         uint8_t code = ic->ic_rt->info[0].dot11Rate;
 857         uint8_t cix = ic->ic_rt->info[0].ctlRateIndex;
 858         uint8_t ctl_rate = ic->ic_rt->info[cix].dot11Rate;
 859         printf("code=%d, cix=%d, ctl_rate=%d\n", code, cix, ctl_rate);
 860
 861         uint8_t rix0 = ic->ic_rt->rateCodeToIndex[130];
 862         uint8_t rix1 = ic->ic_rt->rateCodeToIndex[132];
 863         uint8_t rix2 = ic->ic_rt->rateCodeToIndex[139];
 864         uint8_t rix3 = ic->ic_rt->rateCodeToIndex[150];
 865         printf("rix0 %u,rix1 %u,rix2 %u,rix3 %u\n", rix0,rix1,rix2,rix3);
 866         printf("lpAckDuration=%u\n", ic->ic_rt->info[0].lpAckDuration);
 867         printf("rate=%d\n", ic->ic_rt->info[0].rateKbps);
 868 #endif
 869         return 0;
 870 }
 871
 872 int32_t
 873 wtap_detach(struct wtap_softc *sc)
 874 {
 875         struct ifnet *ifp = sc->sc_ifp;
 876         struct ieee80211com *ic = ifp->if_l2com;
 877
 878         DWTAP_PRINTF("%s\n", __func__);
 879         ieee80211_ageq_drain(&ic->ic_stageq);
 880         ieee80211_ifdetach(ic);
 881         if_free(ifp);
 882         return 0;
 883 }
 884
 885 void
 886 wtap_resume(struct wtap_softc *sc)
 887 {
 888
 889         DWTAP_PRINTF("%s\n", __func__);
 890 }
 891
 892 void
 893 wtap_suspend(struct wtap_softc *sc)
 894 {
 895
 896         DWTAP_PRINTF("%s\n", __func__);
 897 }
 898
 899 void
 900 wtap_shutdown(struct wtap_softc *sc)
 901 {
 902
 903         DWTAP_PRINTF("%s\n", __func__);
 904 }
 905
 906 void
 907 wtap_intr(struct wtap_softc *sc)
 908 {
 909
 910         DWTAP_PRINTF("%s\n", __func__);
 911 }