if_wtap.c revision 243857
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: head/sys/dev/wtap/if_wtap.c 243857 2012-12-04 09:32:43Z glebius $ 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 */ 52static d_open_t wtap_node_open; 53static d_close_t wtap_node_close; 54static d_write_t wtap_node_write; 55static d_ioctl_t wtap_node_ioctl; 56 57static 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 67static int 68wtap_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 76static int 77wtap_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 84static int 85wtap_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_NOWAIT, 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 126int 127wtap_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 140static int wtap_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, 141 const struct ieee80211_bpf_params *params); 142 143static int 144wtap_medium_enqueue(struct wtap_vap *avp, struct mbuf *m) 145{ 146 147 return medium_transmit(avp->av_md, avp->id, m); 148} 149 150static int 151wtap_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 */ 164static void 165wtap_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 175static int 176wtap_reset_vap(struct ieee80211vap *vap, u_long cmd) 177{ 178 179 DWTAP_PRINTF("%s\n", __func__); 180 return 0; 181} 182 183static void 184wtap_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 */ 195static int 196wtap_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 219static void 220wtap_beacon_config(struct wtap_softc *sc, struct ieee80211vap *vap) 221{ 222 223 DWTAP_PRINTF("%s\n", __func__); 224} 225 226static void 227wtap_beacon_intrp(void *arg) 228{ 229 struct wtap_vap *avp = arg; 230 struct ieee80211vap *vap = arg; 231 struct mbuf *m; 232 233 if (vap->iv_state < IEEE80211_S_RUN) { 234 DWTAP_PRINTF("Skip beacon, not running, state %d", vap->iv_state); 235 return ; 236 } 237 DWTAP_PRINTF("[%d] beacon intrp\n", avp->id); //burst mode 238 /* 239 * Update dynamic beacon contents. If this returns 240 * non-zero then we need to remap the memory because 241 * the beacon frame changed size (probably because 242 * of the TIM bitmap). 243 */ 244 m = m_dup(avp->beacon, M_NOWAIT); 245 if (ieee80211_beacon_update(avp->bf_node, &avp->av_boff, m, 0)) { 246 printf("%s, need to remap the memory because the beacon frame" 247 " changed size.\n",__func__); 248 } 249 250 if (ieee80211_radiotap_active_vap(vap)) 251 ieee80211_radiotap_tx(vap, m); 252 253#if 0 254 medium_transmit(avp->av_md, avp->id, m); 255#endif 256 wtap_medium_enqueue(avp, m); 257 callout_schedule(&avp->av_swba, avp->av_bcinterval); 258} 259 260static int 261wtap_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 262{ 263 struct ieee80211com *ic = vap->iv_ic; 264 struct wtap_softc *sc = ic->ic_ifp->if_softc; 265 struct wtap_vap *avp = WTAP_VAP(vap); 266 struct ieee80211_node *ni = NULL; 267 int error; 268 269 DWTAP_PRINTF("%s\n", __func__); 270 271 ni = ieee80211_ref_node(vap->iv_bss); 272 /* 273 * Invoke the parent method to do net80211 work. 274 */ 275 error = avp->av_newstate(vap, nstate, arg); 276 if (error != 0) 277 goto bad; 278 279 if (nstate == IEEE80211_S_RUN) { 280 /* NB: collect bss node again, it may have changed */ 281 ieee80211_free_node(ni); 282 ni = ieee80211_ref_node(vap->iv_bss); 283 switch (vap->iv_opmode) { 284 case IEEE80211_M_MBSS: 285 error = wtap_beacon_alloc(sc, ni); 286 if (error != 0) 287 goto bad; 288 wtap_beacon_config(sc, vap); 289 callout_reset(&avp->av_swba, avp->av_bcinterval, 290 wtap_beacon_intrp, vap); 291 break; 292 default: 293 goto bad; 294 } 295 } else if (nstate == IEEE80211_S_INIT) { 296 callout_stop(&avp->av_swba); 297 } 298 ieee80211_free_node(ni); 299 return 0; 300bad: 301 printf("%s: bad\n", __func__); 302 ieee80211_free_node(ni); 303 return error; 304} 305 306static void 307wtap_bmiss(struct ieee80211vap *vap) 308{ 309 struct wtap_vap *avp = (struct wtap_vap *)vap; 310 311 DWTAP_PRINTF("%s\n", __func__); 312 avp->av_bmiss(vap); 313} 314 315static struct ieee80211vap * 316wtap_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], 317 int unit, enum ieee80211_opmode opmode, int flags, 318 const uint8_t bssid[IEEE80211_ADDR_LEN], 319 const uint8_t mac[IEEE80211_ADDR_LEN]) 320{ 321 struct wtap_softc *sc = ic->ic_ifp->if_softc; 322 struct ieee80211vap *vap; 323 struct wtap_vap *avp; 324 int error; 325 struct ieee80211_node *ni; 326 327 DWTAP_PRINTF("%s\n", __func__); 328 329 avp = (struct wtap_vap *) malloc(sizeof(struct wtap_vap), 330 M_80211_VAP, M_NOWAIT | M_ZERO); 331 avp->id = sc->id; 332 avp->av_md = sc->sc_md; 333 avp->av_bcinterval = msecs_to_ticks(BEACON_INTRERVAL + 100*sc->id); 334 vap = (struct ieee80211vap *) avp; 335 error = ieee80211_vap_setup(ic, vap, name, unit, IEEE80211_M_MBSS, 336 flags | IEEE80211_CLONE_NOBEACONS, bssid, mac); 337 338 /* override various methods */ 339 avp->av_recv_mgmt = vap->iv_recv_mgmt; 340 vap->iv_recv_mgmt = wtap_recv_mgmt; 341 vap->iv_reset = wtap_reset_vap; 342 vap->iv_update_beacon = wtap_beacon_update; 343 avp->av_newstate = vap->iv_newstate; 344 vap->iv_newstate = wtap_newstate; 345 avp->av_bmiss = vap->iv_bmiss; 346 vap->iv_bmiss = wtap_bmiss; 347 348 /* complete setup */ 349 ieee80211_vap_attach(vap, wtap_media_change, ieee80211_media_status); 350 avp->av_dev = make_dev(&wtap_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600, 351 (const char *)ic->ic_ifp->if_xname); 352 353 /* TODO this is a hack to force it to choose the rate we want */ 354 ni = ieee80211_ref_node(vap->iv_bss); 355 ni->ni_txrate = 130; 356 ieee80211_free_node(ni); 357 return vap; 358} 359 360static void 361wtap_vap_delete(struct ieee80211vap *vap) 362{ 363 struct wtap_vap *avp = WTAP_VAP(vap); 364 365 DWTAP_PRINTF("%s\n", __func__); 366 destroy_dev(avp->av_dev); 367 callout_stop(&avp->av_swba); 368 ieee80211_vap_detach(vap); 369 free((struct wtap_vap*) vap, M_80211_VAP); 370} 371 372/* NB: This function is not used. 373 * I had the problem of the queue 374 * being empty all the time. 375 * Maybe I am setting the queue wrong? 376 */ 377static void 378wtap_start(struct ifnet *ifp) 379{ 380 struct ieee80211com *ic = ifp->if_l2com; 381 struct ifnet *icifp = ic->ic_ifp; 382 struct wtap_softc *sc = icifp->if_softc; 383 struct ieee80211_node *ni; 384 struct mbuf *m; 385 386 DWTAP_PRINTF("my_start, with id=%u\n", sc->id); 387 388 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 || sc->up == 0) 389 return; 390 for (;;) { 391 if(IFQ_IS_EMPTY(&ifp->if_snd)){ 392 printf("queue empty, just trying to see " 393 "if the other queue is empty\n"); 394#if 0 395 printf("queue for id=1, %u\n", 396 IFQ_IS_EMPTY(&global_mscs[1]->ifp->if_snd)); 397 printf("queue for id=0, %u\n", 398 IFQ_IS_EMPTY(&global_mscs[0]->ifp->if_snd)); 399#endif 400 break; 401 } 402 IFQ_DEQUEUE(&ifp->if_snd, m); 403 if (m == NULL) { 404 printf("error dequeueing from ifp->snd\n"); 405 break; 406 } 407 ni = (struct ieee80211_node *) m->m_pkthdr.rcvif; 408 /* 409 * Check for fragmentation. If this frame 410 * has been broken up verify we have enough 411 * buffers to send all the fragments so all 412 * go out or none... 413 */ 414#if 0 415 STAILQ_INIT(&frags); 416#endif 417 if ((m->m_flags & M_FRAG)){ 418 printf("dont support frags\n"); 419 ifp->if_oerrors++; 420 return; 421 } 422 ifp->if_opackets++; 423 if(wtap_raw_xmit(ni, m, NULL) < 0){ 424 printf("error raw_xmiting\n"); 425 ifp->if_oerrors++; 426 return; 427 } 428 } 429} 430 431static int 432wtap_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 433{ 434#if 0 435 DWTAP_PRINTF("%s\n", __func__); 436 uprintf("%s, command %lu\n", __func__, cmd); 437#endif 438#define IS_RUNNING(ifp) \ 439 ((ifp->if_flags & IFF_UP) && (ifp->if_drv_flags & IFF_DRV_RUNNING)) 440 struct ieee80211com *ic = ifp->if_l2com; 441 struct wtap_softc *sc = ifp->if_softc; 442 struct ifreq *ifr = (struct ifreq *)data; 443 int error = 0; 444 445 switch (cmd) { 446 case SIOCSIFFLAGS: 447 //printf("%s: %s\n", __func__, "SIOCSIFFLAGS"); 448 if (IS_RUNNING(ifp)) { 449 DWTAP_PRINTF("running\n"); 450#if 0 451 /* 452 * To avoid rescanning another access point, 453 * do not call ath_init() here. Instead, 454 * only reflect promisc mode settings. 455 */ 456 //ath_mode_init(sc); 457#endif 458 } else if (ifp->if_flags & IFF_UP) { 459 DWTAP_PRINTF("up\n"); 460 sc->up = 1; 461#if 0 462 /* 463 * Beware of being called during attach/detach 464 * to reset promiscuous mode. In that case we 465 * will still be marked UP but not RUNNING. 466 * However trying to re-init the interface 467 * is the wrong thing to do as we've already 468 * torn down much of our state. There's 469 * probably a better way to deal with this. 470 */ 471 //if (!sc->sc_invalid) 472 // ath_init(sc); /* XXX lose error */ 473#endif 474 ifp->if_drv_flags |= IFF_DRV_RUNNING; 475 ieee80211_start_all(ic); 476 } else { 477 DWTAP_PRINTF("stoping\n"); 478#if 0 479 ath_stop_locked(ifp); 480#ifdef notyet 481 /* XXX must wakeup in places like ath_vap_delete */ 482 if (!sc->sc_invalid) 483 ath_hal_setpower(sc->sc_ah, HAL_PM_FULL_SLEEP); 484#endif 485#endif 486 } 487 break; 488 case SIOCGIFMEDIA: 489 case SIOCSIFMEDIA: 490#if 0 491 DWTAP_PRINTF("%s: %s\n", __func__, "SIOCGIFMEDIA|SIOCSIFMEDIA"); 492#endif 493 error = ifmedia_ioctl(ifp, ifr, &ic->ic_media, cmd); 494 break; 495 case SIOCGIFADDR: 496#if 0 497 DWTAP_PRINTF("%s: %s\n", __func__, "SIOCGIFADDR"); 498#endif 499 error = ether_ioctl(ifp, cmd, data); 500 break; 501 default: 502 DWTAP_PRINTF("%s: %s [%lu]\n", __func__, "EINVAL", cmd); 503 error = EINVAL; 504 break; 505 } 506 return error; 507#undef IS_RUNNING 508} 509 510static void 511wtap_init(void *arg){ 512 513 DWTAP_PRINTF("%s\n", __func__); 514} 515 516static void 517wtap_scan_start(struct ieee80211com *ic) 518{ 519 520#if 0 521 DWTAP_PRINTF("%s\n", __func__); 522#endif 523} 524 525static void 526wtap_scan_end(struct ieee80211com *ic) 527{ 528 529#if 0 530 DWTAP_PRINTF("%s\n", __func__); 531#endif 532} 533 534static void 535wtap_set_channel(struct ieee80211com *ic) 536{ 537 538#if 0 539 DWTAP_PRINTF("%s\n", __func__); 540#endif 541} 542 543static int 544wtap_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, 545 const struct ieee80211_bpf_params *params) 546{ 547#if 0 548 DWTAP_PRINTF("%s, %p\n", __func__, m); 549#endif 550 struct ieee80211vap *vap = ni->ni_vap; 551 struct wtap_vap *avp = WTAP_VAP(vap); 552 553 if (ieee80211_radiotap_active_vap(vap)) { 554 ieee80211_radiotap_tx(vap, m); 555 } 556 if (m->m_flags & M_TXCB) 557 ieee80211_process_callback(ni, m, 0); 558 ieee80211_free_node(ni); 559 return wtap_medium_enqueue(avp, m); 560} 561 562void 563wtap_inject(struct wtap_softc *sc, struct mbuf *m) 564{ 565 struct wtap_buf *bf = (struct wtap_buf *)malloc(sizeof(struct wtap_buf), 566 M_WTAP_RXBUF, M_NOWAIT | M_ZERO); 567 KASSERT(bf != NULL, ("could not allocated a new wtap_buf\n")); 568 bf->m = m; 569 570 mtx_lock(&sc->sc_mtx); 571 STAILQ_INSERT_TAIL(&sc->sc_rxbuf, bf, bf_list); 572 taskqueue_enqueue(sc->sc_tq, &sc->sc_rxtask); 573 mtx_unlock(&sc->sc_mtx); 574} 575 576void 577wtap_rx_deliver(struct wtap_softc *sc, struct mbuf *m) 578{ 579 struct ifnet *ifp = sc->sc_ifp; 580 struct ieee80211com *ic = ifp->if_l2com; 581 struct ieee80211_node *ni; 582 int type; 583#if 0 584 DWTAP_PRINTF("%s\n", __func__); 585#endif 586 587 DWTAP_PRINTF("[%d] receiving m=%p\n", sc->id, m); 588 if (m == NULL) { /* NB: shouldn't happen */ 589 if_printf(ifp, "%s: no mbuf!\n", __func__); 590 } 591 592 ifp->if_ipackets++; 593 594 ieee80211_dump_pkt(ic, mtod(m, caddr_t), 0,0,0); 595 596 /* 597 * Locate the node for sender, track state, and then 598 * pass the (referenced) node up to the 802.11 layer 599 * for its use. 600 */ 601 ni = ieee80211_find_rxnode_withkey(ic, 602 mtod(m, const struct ieee80211_frame_min *),IEEE80211_KEYIX_NONE); 603 if (ni != NULL) { 604 /* 605 * Sending station is known, dispatch directly. 606 */ 607 type = ieee80211_input(ni, m, 1<<7, 10); 608 ieee80211_free_node(ni); 609 } else { 610 type = ieee80211_input_all(ic, m, 1<<7, 10); 611 } 612} 613 614static void 615wtap_rx_proc(void *arg, int npending) 616{ 617 struct wtap_softc *sc = (struct wtap_softc *)arg; 618 struct ifnet *ifp = sc->sc_ifp; 619 struct ieee80211com *ic = ifp->if_l2com; 620 struct mbuf *m; 621 struct ieee80211_node *ni; 622 int type; 623 struct wtap_buf *bf; 624 625#if 0 626 DWTAP_PRINTF("%s\n", __func__); 627#endif 628 629 for(;;) { 630 mtx_lock(&sc->sc_mtx); 631 bf = STAILQ_FIRST(&sc->sc_rxbuf); 632 if (bf == NULL) { 633 mtx_unlock(&sc->sc_mtx); 634 return; 635 } 636 STAILQ_REMOVE_HEAD(&sc->sc_rxbuf, bf_list); 637 mtx_unlock(&sc->sc_mtx); 638 KASSERT(bf != NULL, ("wtap_buf is NULL\n")); 639 m = bf->m; 640 DWTAP_PRINTF("[%d] receiving m=%p\n", sc->id, bf->m); 641 if (m == NULL) { /* NB: shouldn't happen */ 642 if_printf(ifp, "%s: no mbuf!\n", __func__); 643 free(bf, M_WTAP_RXBUF); 644 return; 645 } 646 647 ifp->if_ipackets++; 648#if 0 649 ieee80211_dump_pkt(ic, mtod(m, caddr_t), 0,0,0); 650#endif 651 652 /* 653 * Locate the node for sender, track state, and then 654 * pass the (referenced) node up to the 802.11 layer 655 * for its use. 656 */ 657 ni = ieee80211_find_rxnode_withkey(ic, 658 mtod(m, const struct ieee80211_frame_min *), 659 IEEE80211_KEYIX_NONE); 660 if (ni != NULL) { 661 /* 662 * Sending station is known, dispatch directly. 663 */ 664#if 0 665 ieee80211_radiotap_rx(ni->ni_vap, m); 666#endif 667 type = ieee80211_input(ni, m, 1<<7, 10); 668 ieee80211_free_node(ni); 669 } else { 670#if 0 671 ieee80211_radiotap_rx_all(ic, m); 672#endif 673 type = ieee80211_input_all(ic, m, 1<<7, 10); 674 } 675 676 /* The mbufs are freed by the Net80211 stack */ 677 free(bf, M_WTAP_RXBUF); 678 } 679} 680 681static void 682wtap_newassoc(struct ieee80211_node *ni, int isnew) 683{ 684 685 DWTAP_PRINTF("%s\n", __func__); 686} 687 688/* 689 * Callback from the 802.11 layer to update WME parameters. 690 */ 691static int 692wtap_wme_update(struct ieee80211com *ic) 693{ 694 695 DWTAP_PRINTF("%s\n", __func__); 696 return 0; 697} 698 699static void 700wtap_update_mcast(struct ifnet *ifp) 701{ 702 703 DWTAP_PRINTF("%s\n", __func__); 704} 705 706static void 707wtap_update_promisc(struct ifnet *ifp) 708{ 709 710 DWTAP_PRINTF("%s\n", __func__); 711} 712 713static int 714wtap_if_transmit(struct ifnet *ifp, struct mbuf *m) 715{ 716 struct ieee80211_node *ni = 717 (struct ieee80211_node *) m->m_pkthdr.rcvif; 718 struct ieee80211vap *vap = ni->ni_vap; 719 struct wtap_vap *avp = WTAP_VAP(vap); 720 721 if(ni == NULL){ 722 printf("m->m_pkthdr.rcvif is NULL we cant radiotap_tx\n"); 723 }else{ 724 if (ieee80211_radiotap_active_vap(vap)) 725 ieee80211_radiotap_tx(vap, m); 726 } 727 if (m->m_flags & M_TXCB) 728 ieee80211_process_callback(ni, m, 0); 729 ieee80211_free_node(ni); 730 return wtap_medium_enqueue(avp, m); 731} 732 733static struct ieee80211_node * 734wtap_node_alloc(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN]) 735{ 736 struct ieee80211_node *ni; 737 738 DWTAP_PRINTF("%s\n", __func__); 739 740 ni = malloc(sizeof(struct ieee80211_node), M_80211_NODE, 741 M_NOWAIT|M_ZERO); 742 743 ni->ni_txrate = 130; 744 return ni; 745} 746 747static void 748wtap_node_free(struct ieee80211_node *ni) 749{ 750 struct ieee80211com *ic = ni->ni_ic; 751 struct wtap_softc *sc = ic->ic_ifp->if_softc; 752 753 DWTAP_PRINTF("%s\n", __func__); 754 sc->sc_node_free(ni); 755} 756 757int32_t 758wtap_attach(struct wtap_softc *sc, const uint8_t *macaddr) 759{ 760 struct ifnet *ifp; 761 struct ieee80211com *ic; 762 char wtap_name[] = {'w','T','a','p',sc->id, 763 '_','t','a','s','k','q','\0'}; 764 765 DWTAP_PRINTF("%s\n", __func__); 766 767 ifp = if_alloc(IFT_IEEE80211); 768 if (ifp == NULL) { 769 printf("can not if_alloc()\n"); 770 return -1; 771 } 772 ic = ifp->if_l2com; 773 if_initname(ifp, "wtap", sc->id); 774 775 sc->sc_ifp = ifp; 776 sc->up = 0; 777 778 STAILQ_INIT(&sc->sc_rxbuf); 779 sc->sc_tq = taskqueue_create(wtap_name, M_NOWAIT | M_ZERO, 780 taskqueue_thread_enqueue, &sc->sc_tq); 781 taskqueue_start_threads(&sc->sc_tq, 1, PI_SOFT, "%s taskQ", 782 ifp->if_xname); 783 TASK_INIT(&sc->sc_rxtask, 0, wtap_rx_proc, sc); 784 785 ifp->if_softc = sc; 786 ifp->if_flags = IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST; 787 ifp->if_start = wtap_start; 788 ifp->if_ioctl = wtap_ioctl; 789 ifp->if_init = wtap_init; 790 IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen); 791 ifp->if_snd.ifq_drv_maxlen = ifqmaxlen; 792 IFQ_SET_READY(&ifp->if_snd); 793 794 ic->ic_ifp = ifp; 795 ic->ic_phytype = IEEE80211_T_DS; 796 ic->ic_opmode = IEEE80211_M_MBSS; 797 ic->ic_caps = IEEE80211_C_MBSS; 798 799 ic->ic_max_keyix = 128; /* A value read from Atheros ATH_KEYMAX */ 800 801 ic->ic_regdomain.regdomain = SKU_ETSI; 802 ic->ic_regdomain.country = CTRY_SWEDEN; 803 ic->ic_regdomain.location = 1; /* Indoors */ 804 ic->ic_regdomain.isocc[0] = 'S'; 805 ic->ic_regdomain.isocc[1] = 'E'; 806 /* 807 * Indicate we need the 802.11 header padded to a 808 * 32-bit boundary for 4-address and QoS frames. 809 */ 810 ic->ic_flags |= IEEE80211_F_DATAPAD; 811 ic->ic_nchans = 1; 812 ic->ic_channels[0].ic_flags = IEEE80211_CHAN_B; 813 ic->ic_channels[0].ic_freq = 2412; 814 815 ieee80211_ifattach(ic, macaddr); 816 817#if 0 818 /* new prototype hook-ups */ 819 msc->if_input = ifp->if_input; 820 ifp->if_input = myath_if_input; 821 msc->if_output = ifp->if_output; 822 ifp->if_output = myath_if_output; 823#endif 824 sc->if_transmit = ifp->if_transmit; 825 ifp->if_transmit = wtap_if_transmit; 826 827 /* override default methods */ 828 ic->ic_newassoc = wtap_newassoc; 829#if 0 830 ic->ic_updateslot = myath_updateslot; 831#endif 832 ic->ic_wme.wme_update = wtap_wme_update; 833 ic->ic_vap_create = wtap_vap_create; 834 ic->ic_vap_delete = wtap_vap_delete; 835 ic->ic_raw_xmit = wtap_raw_xmit; 836 ic->ic_update_mcast = wtap_update_mcast; 837 ic->ic_update_promisc = wtap_update_promisc; 838 839 sc->sc_node_alloc = ic->ic_node_alloc; 840 ic->ic_node_alloc = wtap_node_alloc; 841 sc->sc_node_free = ic->ic_node_free; 842 ic->ic_node_free = wtap_node_free; 843 844#if 0 845 ic->ic_node_getsignal = myath_node_getsignal; 846#endif 847 ic->ic_scan_start = wtap_scan_start; 848 ic->ic_scan_end = wtap_scan_end; 849 ic->ic_set_channel = wtap_set_channel; 850 851 ieee80211_radiotap_attach(ic, 852 &sc->sc_tx_th.wt_ihdr, sizeof(sc->sc_tx_th), 853 WTAP_TX_RADIOTAP_PRESENT, 854 &sc->sc_rx_th.wr_ihdr, sizeof(sc->sc_rx_th), 855 WTAP_RX_RADIOTAP_PRESENT); 856 857 /* Work here, we must find a way to populate the rate table */ 858#if 0 859 if(ic->ic_rt == NULL){ 860 printf("no table for ic_curchan\n"); 861 ic->ic_rt = ieee80211_get_ratetable(&ic->ic_channels[0]); 862 } 863 printf("ic->ic_rt =%p\n", ic->ic_rt); 864 printf("rate count %d\n", ic->ic_rt->rateCount); 865 866 uint8_t code = ic->ic_rt->info[0].dot11Rate; 867 uint8_t cix = ic->ic_rt->info[0].ctlRateIndex; 868 uint8_t ctl_rate = ic->ic_rt->info[cix].dot11Rate; 869 printf("code=%d, cix=%d, ctl_rate=%d\n", code, cix, ctl_rate); 870 871 uint8_t rix0 = ic->ic_rt->rateCodeToIndex[130]; 872 uint8_t rix1 = ic->ic_rt->rateCodeToIndex[132]; 873 uint8_t rix2 = ic->ic_rt->rateCodeToIndex[139]; 874 uint8_t rix3 = ic->ic_rt->rateCodeToIndex[150]; 875 printf("rix0 %u,rix1 %u,rix2 %u,rix3 %u\n", rix0,rix1,rix2,rix3); 876 printf("lpAckDuration=%u\n", ic->ic_rt->info[0].lpAckDuration); 877 printf("rate=%d\n", ic->ic_rt->info[0].rateKbps); 878#endif 879 return 0; 880} 881 882int32_t 883wtap_detach(struct wtap_softc *sc) 884{ 885 struct ifnet *ifp = sc->sc_ifp; 886 struct ieee80211com *ic = ifp->if_l2com; 887 888 DWTAP_PRINTF("%s\n", __func__); 889 ieee80211_ageq_drain(&ic->ic_stageq); 890 ieee80211_ifdetach(ic); 891 if_free(ifp); 892 return 0; 893} 894 895void 896wtap_resume(struct wtap_softc *sc) 897{ 898 899 DWTAP_PRINTF("%s\n", __func__); 900} 901 902void 903wtap_suspend(struct wtap_softc *sc) 904{ 905 906 DWTAP_PRINTF("%s\n", __func__); 907} 908 909void 910wtap_shutdown(struct wtap_softc *sc) 911{ 912 913 DWTAP_PRINTF("%s\n", __func__); 914} 915 916void 917wtap_intr(struct wtap_softc *sc) 918{ 919 920 DWTAP_PRINTF("%s\n", __func__); 921} 922