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_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 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, const struct ieee80211_rx_stats *stats, 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, stats, 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 = &vap->iv_bcn_off; 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); 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 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, 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 260 static int 261 wtap_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_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; 300 bad: 301 printf("%s: bad\n", __func__); 302 ieee80211_free_node(ni); 303 return error; 304 } 305 306 static void 307 wtap_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 315 static struct ieee80211vap * 316 wtap_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_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 = malloc(sizeof(struct wtap_vap), M_80211_VAP, M_WAITOK | M_ZERO); 330 avp->id = sc->id; 331 avp->av_md = sc->sc_md; 332 avp->av_bcinterval = msecs_to_ticks(BEACON_INTRERVAL + 100*sc->id); 333 vap = (struct ieee80211vap *) avp; 334 error = ieee80211_vap_setup(ic, vap, name, unit, IEEE80211_M_MBSS, 335 flags | IEEE80211_CLONE_NOBEACONS, bssid); 336 if (error) { 337 free(avp, M_80211_VAP); 338 return (NULL); 339 } 340 341 /* override various methods */ 342 avp->av_recv_mgmt = vap->iv_recv_mgmt; 343 vap->iv_recv_mgmt = wtap_recv_mgmt; 344 vap->iv_reset = wtap_reset_vap; 345 vap->iv_update_beacon = wtap_beacon_update; 346 avp->av_newstate = vap->iv_newstate; 347 vap->iv_newstate = wtap_newstate; 348 avp->av_bmiss = vap->iv_bmiss; 349 vap->iv_bmiss = wtap_bmiss; 350 351 /* complete setup */ 352 ieee80211_vap_attach(vap, wtap_media_change, ieee80211_media_status, 353 mac); 354 avp->av_dev = make_dev(&wtap_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600, 355 "%s", (const char *)sc->name); 356 357 /* TODO this is a hack to force it to choose the rate we want */ 358 ni = ieee80211_ref_node(vap->iv_bss); 359 ni->ni_txrate = 130; 360 ieee80211_free_node(ni); 361 return vap; 362 } 363 364 static void 365 wtap_vap_delete(struct ieee80211vap *vap) 366 { 367 struct wtap_vap *avp = WTAP_VAP(vap); 368 369 DWTAP_PRINTF("%s\n", __func__); 370 destroy_dev(avp->av_dev); 371 callout_stop(&avp->av_swba); 372 ieee80211_vap_detach(vap); 373 free((struct wtap_vap*) vap, M_80211_VAP); 374 } 375 376 static void 377 wtap_parent(struct ieee80211com *ic) 378 { 379 struct wtap_softc *sc = ic->ic_softc; 380 381 if (ic->ic_nrunning > 0) { 382 sc->up = 1; 383 ieee80211_start_all(ic); 384 } else 385 sc->up = 0; 386 } 387 388 static void 389 wtap_scan_start(struct ieee80211com *ic) 390 { 391 392 #if 0 393 DWTAP_PRINTF("%s\n", __func__); 394 #endif 395 } 396 397 static void 398 wtap_scan_end(struct ieee80211com *ic) 399 { 400 401 #if 0 402 DWTAP_PRINTF("%s\n", __func__); 403 #endif 404 } 405 406 static void 407 wtap_set_channel(struct ieee80211com *ic) 408 { 409 410 #if 0 411 DWTAP_PRINTF("%s\n", __func__); 412 #endif 413 } 414 415 static int 416 wtap_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, 417 const struct ieee80211_bpf_params *params) 418 { 419 #if 0 420 DWTAP_PRINTF("%s, %p\n", __func__, m); 421 #endif 422 struct ieee80211vap *vap = ni->ni_vap; 423 struct wtap_vap *avp = WTAP_VAP(vap); 424 425 if (ieee80211_radiotap_active_vap(vap)) { 426 ieee80211_radiotap_tx(vap, m); 427 } 428 if (m->m_flags & M_TXCB) 429 ieee80211_process_callback(ni, m, 0); 430 ieee80211_free_node(ni); 431 return wtap_medium_enqueue(avp, m); 432 } 433 434 void 435 wtap_inject(struct wtap_softc *sc, struct mbuf *m) 436 { 437 struct wtap_buf *bf = (struct wtap_buf *)malloc(sizeof(struct wtap_buf), 438 M_WTAP_RXBUF, M_NOWAIT | M_ZERO); 439 KASSERT(bf != NULL, ("could not allocated a new wtap_buf\n")); 440 bf->m = m; 441 442 mtx_lock(&sc->sc_mtx); 443 STAILQ_INSERT_TAIL(&sc->sc_rxbuf, bf, bf_list); 444 taskqueue_enqueue(sc->sc_tq, &sc->sc_rxtask); 445 mtx_unlock(&sc->sc_mtx); 446 } 447 448 void 449 wtap_rx_deliver(struct wtap_softc *sc, struct mbuf *m) 450 { 451 struct ieee80211com *ic = &sc->sc_ic; 452 struct ieee80211_node *ni; 453 int type; 454 #if 0 455 DWTAP_PRINTF("%s\n", __func__); 456 #endif 457 458 DWTAP_PRINTF("[%d] receiving m=%p\n", sc->id, m); 459 if (m == NULL) { /* NB: shouldn't happen */ 460 ic_printf(ic, "%s: no mbuf!\n", __func__); 461 } 462 463 ieee80211_dump_pkt(ic, mtod(m, caddr_t), 0,0,0); 464 465 /* 466 * Locate the node for sender, track state, and then 467 * pass the (referenced) node up to the 802.11 layer 468 * for its use. 469 */ 470 ni = ieee80211_find_rxnode_withkey(ic, 471 mtod(m, const struct ieee80211_frame_min *),IEEE80211_KEYIX_NONE); 472 if (ni != NULL) { 473 /* 474 * Sending station is known, dispatch directly. 475 */ 476 type = ieee80211_input(ni, m, 1<<7, 10); 477 ieee80211_free_node(ni); 478 } else { 479 type = ieee80211_input_all(ic, m, 1<<7, 10); 480 } 481 } 482 483 static void 484 wtap_rx_proc(void *arg, int npending) 485 { 486 struct wtap_softc *sc = (struct wtap_softc *)arg; 487 struct ieee80211com *ic = &sc->sc_ic; 488 struct mbuf *m; 489 struct ieee80211_node *ni; 490 int type; 491 struct wtap_buf *bf; 492 493 #if 0 494 DWTAP_PRINTF("%s\n", __func__); 495 #endif 496 497 for(;;) { 498 mtx_lock(&sc->sc_mtx); 499 bf = STAILQ_FIRST(&sc->sc_rxbuf); 500 if (bf == NULL) { 501 mtx_unlock(&sc->sc_mtx); 502 return; 503 } 504 STAILQ_REMOVE_HEAD(&sc->sc_rxbuf, bf_list); 505 mtx_unlock(&sc->sc_mtx); 506 KASSERT(bf != NULL, ("wtap_buf is NULL\n")); 507 m = bf->m; 508 DWTAP_PRINTF("[%d] receiving m=%p\n", sc->id, bf->m); 509 if (m == NULL) { /* NB: shouldn't happen */ 510 ic_printf(ic, "%s: no mbuf!\n", __func__); 511 free(bf, M_WTAP_RXBUF); 512 return; 513 } 514 #if 0 515 ieee80211_dump_pkt(ic, mtod(m, caddr_t), 0,0,0); 516 #endif 517 518 /* 519 * Locate the node for sender, track state, and then 520 * pass the (referenced) node up to the 802.11 layer 521 * for its use. 522 */ 523 ni = ieee80211_find_rxnode_withkey(ic, 524 mtod(m, const struct ieee80211_frame_min *), 525 IEEE80211_KEYIX_NONE); 526 if (ni != NULL) { 527 /* 528 * Sending station is known, dispatch directly. 529 */ 530 type = ieee80211_input(ni, m, 1<<7, 10); 531 ieee80211_free_node(ni); 532 } else { 533 type = ieee80211_input_all(ic, m, 1<<7, 10); 534 } 535 536 /* The mbufs are freed by the Net80211 stack */ 537 free(bf, M_WTAP_RXBUF); 538 } 539 } 540 541 static void 542 wtap_newassoc(struct ieee80211_node *ni, int isnew) 543 { 544 545 DWTAP_PRINTF("%s\n", __func__); 546 } 547 548 /* 549 * Callback from the 802.11 layer to update WME parameters. 550 */ 551 static int 552 wtap_wme_update(struct ieee80211com *ic) 553 { 554 555 DWTAP_PRINTF("%s\n", __func__); 556 return 0; 557 } 558 559 static void 560 wtap_update_mcast(struct ieee80211com *ic) 561 { 562 563 DWTAP_PRINTF("%s\n", __func__); 564 } 565 566 static void 567 wtap_update_promisc(struct ieee80211com *ic) 568 { 569 570 DWTAP_PRINTF("%s\n", __func__); 571 } 572 573 static int 574 wtap_transmit(struct ieee80211com *ic, struct mbuf *m) 575 { 576 struct ieee80211_node *ni = 577 (struct ieee80211_node *) m->m_pkthdr.rcvif; 578 struct ieee80211vap *vap = ni->ni_vap; 579 struct wtap_vap *avp = WTAP_VAP(vap); 580 581 if(ni == NULL){ 582 printf("m->m_pkthdr.rcvif is NULL we cant radiotap_tx\n"); 583 }else{ 584 if (ieee80211_radiotap_active_vap(vap)) 585 ieee80211_radiotap_tx(vap, m); 586 } 587 if (m->m_flags & M_TXCB) 588 ieee80211_process_callback(ni, m, 0); 589 ieee80211_free_node(ni); 590 return wtap_medium_enqueue(avp, m); 591 } 592 593 static struct ieee80211_node * 594 wtap_node_alloc(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN]) 595 { 596 struct ieee80211_node *ni; 597 598 DWTAP_PRINTF("%s\n", __func__); 599 600 ni = malloc(sizeof(struct ieee80211_node), M_80211_NODE, 601 M_NOWAIT|M_ZERO); 602 603 ni->ni_txrate = 130; 604 return ni; 605 } 606 607 static void 608 wtap_node_free(struct ieee80211_node *ni) 609 { 610 struct ieee80211com *ic = ni->ni_ic; 611 struct wtap_softc *sc = ic->ic_softc; 612 613 DWTAP_PRINTF("%s\n", __func__); 614 sc->sc_node_free(ni); 615 } 616 617 int32_t 618 wtap_attach(struct wtap_softc *sc, const uint8_t *macaddr) 619 { 620 struct ieee80211com *ic = &sc->sc_ic; 621 622 DWTAP_PRINTF("%s\n", __func__); 623 624 sc->up = 0; 625 STAILQ_INIT(&sc->sc_rxbuf); 626 sc->sc_tq = taskqueue_create("wtap_taskq", M_NOWAIT | M_ZERO, 627 taskqueue_thread_enqueue, &sc->sc_tq); 628 taskqueue_start_threads(&sc->sc_tq, 1, PI_SOFT, "%s taskQ", sc->name); 629 TASK_INIT(&sc->sc_rxtask, 0, wtap_rx_proc, sc); 630 631 ic->ic_softc = sc; 632 ic->ic_name = sc->name; 633 ic->ic_phytype = IEEE80211_T_DS; 634 ic->ic_opmode = IEEE80211_M_MBSS; 635 ic->ic_caps = IEEE80211_C_MBSS; 636 637 ic->ic_max_keyix = 128; /* A value read from Atheros ATH_KEYMAX */ 638 639 ic->ic_regdomain.regdomain = SKU_ETSI; 640 ic->ic_regdomain.country = CTRY_SWEDEN; 641 ic->ic_regdomain.location = 1; /* Indoors */ 642 ic->ic_regdomain.isocc[0] = 'S'; 643 ic->ic_regdomain.isocc[1] = 'E'; 644 645 ic->ic_nchans = 1; 646 ic->ic_channels[0].ic_flags = IEEE80211_CHAN_B; 647 ic->ic_channels[0].ic_freq = 2412; 648 649 IEEE80211_ADDR_COPY(ic->ic_macaddr, macaddr); 650 ieee80211_ifattach(ic); 651 652 /* override default methods */ 653 ic->ic_newassoc = wtap_newassoc; 654 ic->ic_wme.wme_update = wtap_wme_update; 655 ic->ic_vap_create = wtap_vap_create; 656 ic->ic_vap_delete = wtap_vap_delete; 657 ic->ic_raw_xmit = wtap_raw_xmit; 658 ic->ic_update_mcast = wtap_update_mcast; 659 ic->ic_update_promisc = wtap_update_promisc; 660 ic->ic_transmit = wtap_transmit; 661 ic->ic_parent = wtap_parent; 662 663 sc->sc_node_alloc = ic->ic_node_alloc; 664 ic->ic_node_alloc = wtap_node_alloc; 665 sc->sc_node_free = ic->ic_node_free; 666 ic->ic_node_free = wtap_node_free; 667 668 ic->ic_scan_start = wtap_scan_start; 669 ic->ic_scan_end = wtap_scan_end; 670 ic->ic_set_channel = wtap_set_channel; 671 672 ieee80211_radiotap_attach(ic, 673 &sc->sc_tx_th.wt_ihdr, sizeof(sc->sc_tx_th), 674 WTAP_TX_RADIOTAP_PRESENT, 675 &sc->sc_rx_th.wr_ihdr, sizeof(sc->sc_rx_th), 676 WTAP_RX_RADIOTAP_PRESENT); 677 678 /* Work here, we must find a way to populate the rate table */ 679 #if 0 680 if(ic->ic_rt == NULL){ 681 printf("no table for ic_curchan\n"); 682 ic->ic_rt = ieee80211_get_ratetable(&ic->ic_channels[0]); 683 } 684 printf("ic->ic_rt =%p\n", ic->ic_rt); 685 printf("rate count %d\n", ic->ic_rt->rateCount); 686 687 uint8_t code = ic->ic_rt->info[0].dot11Rate; 688 uint8_t cix = ic->ic_rt->info[0].ctlRateIndex; 689 uint8_t ctl_rate = ic->ic_rt->info[cix].dot11Rate; 690 printf("code=%d, cix=%d, ctl_rate=%d\n", code, cix, ctl_rate); 691 692 uint8_t rix0 = ic->ic_rt->rateCodeToIndex[130]; 693 uint8_t rix1 = ic->ic_rt->rateCodeToIndex[132]; 694 uint8_t rix2 = ic->ic_rt->rateCodeToIndex[139]; 695 uint8_t rix3 = ic->ic_rt->rateCodeToIndex[150]; 696 printf("rix0 %u,rix1 %u,rix2 %u,rix3 %u\n", rix0,rix1,rix2,rix3); 697 printf("lpAckDuration=%u\n", ic->ic_rt->info[0].lpAckDuration); 698 printf("rate=%d\n", ic->ic_rt->info[0].rateKbps); 699 #endif 700 return 0; 701 } 702 703 int32_t 704 wtap_detach(struct wtap_softc *sc) 705 { 706 struct ieee80211com *ic = &sc->sc_ic; 707 708 DWTAP_PRINTF("%s\n", __func__); 709 ieee80211_ageq_drain(&ic->ic_stageq); 710 ieee80211_ifdetach(ic); 711 return 0; 712 } 713 714 void 715 wtap_resume(struct wtap_softc *sc) 716 { 717 718 DWTAP_PRINTF("%s\n", __func__); 719 } 720 721 void 722 wtap_suspend(struct wtap_softc *sc) 723 { 724 725 DWTAP_PRINTF("%s\n", __func__); 726 } 727 728 void 729 wtap_shutdown(struct wtap_softc *sc) 730 { 731 732 DWTAP_PRINTF("%s\n", __func__); 733 } 734 735 void 736 wtap_intr(struct wtap_softc *sc) 737 { 738 739 DWTAP_PRINTF("%s\n", __func__); 740 } 741