762 lines
19 KiB
C
762 lines
19 KiB
C
/*-
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*
|
|
* Copyright (c) 2010-2011 Monthadar Al Jaberi, TerraNet AB
|
|
* All rights reserved.
|
|
*
|
|
* Copyright (c) 2002-2009 Sam Leffler, Errno Consulting
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer,
|
|
* without modification.
|
|
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
|
|
* similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
|
|
* redistribution must be conditioned upon including a substantially
|
|
* similar Disclaimer requirement for further binary redistribution.
|
|
*
|
|
* NO WARRANTY
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
|
|
* AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
|
|
* THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
|
|
* OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
|
|
* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
|
* THE POSSIBILITY OF SUCH DAMAGES.
|
|
*/
|
|
#include "if_wtapvar.h"
|
|
#include <sys/uio.h> /* uio struct */
|
|
#include <sys/jail.h>
|
|
#include <net/if_var.h>
|
|
#include <net/vnet.h>
|
|
|
|
#include <net80211/ieee80211_ratectl.h>
|
|
#include "if_medium.h"
|
|
#include "wtap_hal/hal.h"
|
|
|
|
/*
|
|
* This _requires_ vimage to be useful.
|
|
*/
|
|
#ifndef VIMAGE
|
|
#error if_wtap requires VIMAGE.
|
|
#endif /* VIMAGE */
|
|
|
|
/* device for IOCTL and read/write for debuggin purposes */
|
|
/* Function prototypes */
|
|
static d_open_t wtap_node_open;
|
|
static d_close_t wtap_node_close;
|
|
static d_write_t wtap_node_write;
|
|
static d_ioctl_t wtap_node_ioctl;
|
|
|
|
static struct cdevsw wtap_cdevsw = {
|
|
.d_version = D_VERSION,
|
|
.d_flags = 0,
|
|
.d_open = wtap_node_open,
|
|
.d_close = wtap_node_close,
|
|
.d_write = wtap_node_write,
|
|
.d_ioctl = wtap_node_ioctl,
|
|
.d_name = "wtapnode",
|
|
};
|
|
|
|
static int
|
|
wtap_node_open(struct cdev *dev, int oflags, int devtype, struct thread *p)
|
|
{
|
|
|
|
int err = 0;
|
|
uprintf("Opened device \"echo\" successfully.\n");
|
|
return(err);
|
|
}
|
|
|
|
static int
|
|
wtap_node_close(struct cdev *dev, int fflag, int devtype, struct thread *p)
|
|
{
|
|
|
|
uprintf("Closing device \"echo.\"\n");
|
|
return(0);
|
|
}
|
|
|
|
static int
|
|
wtap_node_write(struct cdev *dev, struct uio *uio, int ioflag)
|
|
{
|
|
int err = 0;
|
|
struct mbuf *m;
|
|
struct wtap_softc *sc;
|
|
uint8_t buf[1024];
|
|
struct epoch_tracker et;
|
|
int buf_len;
|
|
|
|
uprintf("write device %s \"echo.\"\n", devtoname(dev));
|
|
buf_len = MIN(uio->uio_iov->iov_len, 1024);
|
|
err = copyin(uio->uio_iov->iov_base, buf, buf_len);
|
|
|
|
if (err != 0) {
|
|
uprintf("Write failed: bad address!\n");
|
|
return (err);
|
|
}
|
|
|
|
MGETHDR(m, M_NOWAIT, MT_DATA);
|
|
m_copyback(m, 0, buf_len, buf);
|
|
|
|
NET_EPOCH_ENTER(et);
|
|
|
|
sc = (struct wtap_softc *)dev->si_drv1;
|
|
printf("wtap id = %d\n", sc->id);
|
|
wtap_inject(sc, m);
|
|
|
|
NET_EPOCH_EXIT(et);
|
|
|
|
return(err);
|
|
}
|
|
|
|
int
|
|
wtap_node_ioctl(struct cdev *dev, u_long cmd, caddr_t data,
|
|
int fflag, struct thread *td)
|
|
{
|
|
int error = 0;
|
|
|
|
switch(cmd) {
|
|
default:
|
|
DWTAP_PRINTF("Unknown WTAP IOCTL\n");
|
|
error = EINVAL;
|
|
}
|
|
return error;
|
|
}
|
|
|
|
static int wtap_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
|
|
const struct ieee80211_bpf_params *params);
|
|
|
|
static int
|
|
wtap_medium_enqueue(struct wtap_vap *avp, struct mbuf *m)
|
|
{
|
|
|
|
return medium_transmit(avp->av_md, avp->id, m);
|
|
}
|
|
|
|
/*
|
|
* Intercept management frames to collect beacon rssi data
|
|
* and to do ibss merges.
|
|
*/
|
|
static void
|
|
wtap_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m,
|
|
int subtype, const struct ieee80211_rx_stats *stats, int rssi, int nf)
|
|
{
|
|
struct ieee80211vap *vap = ni->ni_vap;
|
|
struct wtap_softc *sc = vap->iv_ic->ic_softc;
|
|
#if 0
|
|
DWTAP_PRINTF("[%d] %s\n", myath_id(ni), __func__);
|
|
#endif
|
|
/*
|
|
* Call up first so subsequent work can use information
|
|
* potentially stored in the node (e.g. for ibss merge).
|
|
*/
|
|
WTAP_VAP(vap)->av_recv_mgmt(ni, m, subtype, stats, rssi, nf);
|
|
|
|
switch (subtype) {
|
|
case IEEE80211_FC0_SUBTYPE_BEACON:
|
|
case IEEE80211_FC0_SUBTYPE_PROBE_RESP:
|
|
if (vap->iv_opmode == IEEE80211_M_IBSS &&
|
|
vap->iv_state == IEEE80211_S_RUN &&
|
|
ieee80211_ibss_merge_check(ni)) {
|
|
uint64_t tsf = wtap_hal_get_tsf(sc->hal);
|
|
|
|
/*
|
|
* Handle ibss merge as needed; check the tsf on the
|
|
* frame before attempting the merge. The 802.11 spec
|
|
* says the station should change it's bssid to match
|
|
* the oldest station with the same ssid, where oldest
|
|
* is determined by the tsf. Note that hardware
|
|
* reconfiguration happens through callback to
|
|
* ath_newstate as the state machine will go from
|
|
* RUN -> RUN when this happens.
|
|
*/
|
|
if (le64toh(ni->ni_tstamp.tsf) >= tsf)
|
|
(void) ieee80211_ibss_merge(ni);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
static int
|
|
wtap_reset_vap(struct ieee80211vap *vap, u_long cmd)
|
|
{
|
|
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
wtap_beacon_update(struct ieee80211vap *vap, int item)
|
|
{
|
|
struct ieee80211_beacon_offsets *bo = &vap->iv_bcn_off;
|
|
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
setbit(bo->bo_flags, item);
|
|
}
|
|
|
|
/*
|
|
* Allocate and setup an initial beacon frame.
|
|
*/
|
|
static int
|
|
wtap_beacon_alloc(struct wtap_softc *sc, struct ieee80211_node *ni)
|
|
{
|
|
struct ieee80211vap *vap = ni->ni_vap;
|
|
struct wtap_vap *avp = WTAP_VAP(vap);
|
|
|
|
DWTAP_PRINTF("[%s] %s\n", ether_sprintf(ni->ni_macaddr), __func__);
|
|
|
|
/*
|
|
* NB: the beacon data buffer must be 32-bit aligned;
|
|
* we assume the mbuf routines will return us something
|
|
* with this alignment (perhaps should assert).
|
|
*/
|
|
avp->beacon = ieee80211_beacon_alloc(ni);
|
|
if (avp->beacon == NULL) {
|
|
printf("%s: cannot get mbuf\n", __func__);
|
|
return ENOMEM;
|
|
}
|
|
avp->bf_node = ieee80211_ref_node(ni);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
wtap_beacon_config(struct wtap_softc *sc, struct ieee80211vap *vap)
|
|
{
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
}
|
|
|
|
static void
|
|
wtap_beacon_intrp(void *arg)
|
|
{
|
|
struct wtap_vap *avp = arg;
|
|
struct ieee80211vap *vap = arg;
|
|
struct wtap_softc *sc = vap->iv_ic->ic_softc;
|
|
struct ieee80211_frame *wh;
|
|
struct mbuf *m;
|
|
uint64_t tsf;
|
|
|
|
if (vap->iv_state < IEEE80211_S_RUN) {
|
|
DWTAP_PRINTF("Skip beacon, not running, state %d", vap->iv_state);
|
|
return ;
|
|
}
|
|
DWTAP_PRINTF("[%d] beacon intrp\n", avp->id); //burst mode
|
|
/*
|
|
* Update dynamic beacon contents. If this returns
|
|
* non-zero then we need to remap the memory because
|
|
* the beacon frame changed size (probably because
|
|
* of the TIM bitmap).
|
|
*/
|
|
m = m_dup(avp->beacon, M_NOWAIT);
|
|
if (ieee80211_beacon_update(avp->bf_node, m, 0)) {
|
|
printf("%s, need to remap the memory because the beacon frame"
|
|
" changed size.\n",__func__);
|
|
}
|
|
|
|
/* Get TSF from HAL, and insert it into beacon frame */
|
|
tsf = wtap_hal_get_tsf(sc->hal);
|
|
wh = mtod(m, struct ieee80211_frame *);
|
|
memcpy(&wh[1], &tsf, sizeof(tsf));
|
|
|
|
if (ieee80211_radiotap_active_vap(vap))
|
|
ieee80211_radiotap_tx(vap, m);
|
|
|
|
#if 0
|
|
medium_transmit(avp->av_md, avp->id, m);
|
|
#endif
|
|
wtap_medium_enqueue(avp, m);
|
|
callout_schedule(&avp->av_swba, avp->av_bcinterval);
|
|
}
|
|
|
|
static int
|
|
wtap_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
|
|
{
|
|
struct ieee80211com *ic = vap->iv_ic;
|
|
struct wtap_softc *sc = ic->ic_softc;
|
|
struct wtap_vap *avp = WTAP_VAP(vap);
|
|
struct ieee80211_node *ni = NULL;
|
|
int error;
|
|
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
|
|
ni = ieee80211_ref_node(vap->iv_bss);
|
|
/*
|
|
* Invoke the parent method to do net80211 work.
|
|
*/
|
|
error = avp->av_newstate(vap, nstate, arg);
|
|
if (error != 0)
|
|
goto bad;
|
|
|
|
if (nstate == IEEE80211_S_RUN) {
|
|
/* NB: collect bss node again, it may have changed */
|
|
ieee80211_free_node(ni);
|
|
ni = ieee80211_ref_node(vap->iv_bss);
|
|
switch (vap->iv_opmode) {
|
|
case IEEE80211_M_IBSS:
|
|
case IEEE80211_M_MBSS:
|
|
/*
|
|
* Stop any previous beacon callout. This may be
|
|
* necessary, for example, when an ibss merge
|
|
* causes reconfiguration; there will be a state
|
|
* transition from RUN->RUN that means we may
|
|
* be called with beacon transmission active.
|
|
*/
|
|
callout_stop(&avp->av_swba);
|
|
|
|
error = wtap_beacon_alloc(sc, ni);
|
|
if (error != 0)
|
|
goto bad;
|
|
|
|
/*
|
|
* If joining an adhoc network defer beacon timer
|
|
* configuration to the next beacon frame so we
|
|
* have a current TSF to use. Otherwise we're
|
|
* starting an ibss/bss so there's no need to delay;
|
|
* if this is the first vap moving to RUN state, then
|
|
* beacon state needs to be [re]configured.
|
|
*/
|
|
if (vap->iv_opmode == IEEE80211_M_IBSS &&
|
|
ni->ni_tstamp.tsf != 0)
|
|
break;
|
|
|
|
wtap_beacon_config(sc, vap);
|
|
|
|
/* Start TSF timer from now, and start s/w beacon alert */
|
|
wtap_hal_reset_tsf(sc->hal);
|
|
callout_reset(&avp->av_swba, avp->av_bcinterval,
|
|
wtap_beacon_intrp, vap);
|
|
break;
|
|
default:
|
|
goto bad;
|
|
}
|
|
} else if (nstate == IEEE80211_S_INIT) {
|
|
callout_stop(&avp->av_swba);
|
|
}
|
|
ieee80211_free_node(ni);
|
|
return 0;
|
|
bad:
|
|
printf("%s: bad\n", __func__);
|
|
ieee80211_free_node(ni);
|
|
return error;
|
|
}
|
|
|
|
static void
|
|
wtap_bmiss(struct ieee80211vap *vap)
|
|
{
|
|
struct wtap_vap *avp = (struct wtap_vap *)vap;
|
|
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
avp->av_bmiss(vap);
|
|
}
|
|
|
|
static struct ieee80211vap *
|
|
wtap_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ],
|
|
int unit, enum ieee80211_opmode opmode, int flags,
|
|
const uint8_t bssid[IEEE80211_ADDR_LEN],
|
|
const uint8_t mac[IEEE80211_ADDR_LEN])
|
|
{
|
|
struct wtap_softc *sc = ic->ic_softc;
|
|
struct ieee80211vap *vap;
|
|
struct wtap_vap *avp;
|
|
int error;
|
|
struct ieee80211_node *ni;
|
|
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
|
|
avp = malloc(sizeof(struct wtap_vap), M_80211_VAP, M_WAITOK | M_ZERO);
|
|
avp->id = sc->id;
|
|
avp->av_md = sc->sc_md;
|
|
avp->av_bcinterval = msecs_to_ticks(BEACON_INTRERVAL + 100*sc->id);
|
|
vap = (struct ieee80211vap *) avp;
|
|
error = ieee80211_vap_setup(ic, vap, name, unit, opmode,
|
|
flags | IEEE80211_CLONE_NOBEACONS, bssid);
|
|
if (error) {
|
|
free(avp, M_80211_VAP);
|
|
return (NULL);
|
|
}
|
|
|
|
/* override various methods */
|
|
avp->av_recv_mgmt = vap->iv_recv_mgmt;
|
|
vap->iv_recv_mgmt = wtap_recv_mgmt;
|
|
vap->iv_reset = wtap_reset_vap;
|
|
vap->iv_update_beacon = wtap_beacon_update;
|
|
avp->av_newstate = vap->iv_newstate;
|
|
vap->iv_newstate = wtap_newstate;
|
|
avp->av_bmiss = vap->iv_bmiss;
|
|
vap->iv_bmiss = wtap_bmiss;
|
|
|
|
/* complete setup */
|
|
ieee80211_vap_attach(vap, ieee80211_media_change,
|
|
ieee80211_media_status, mac);
|
|
avp->av_dev = make_dev(&wtap_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600,
|
|
"%s", (const char *)vap->iv_ifp->if_xname);
|
|
avp->av_dev->si_drv1 = sc;
|
|
callout_init(&avp->av_swba, 0);
|
|
|
|
/* TODO this is a hack to force it to choose the rate we want */
|
|
ni = ieee80211_ref_node(vap->iv_bss);
|
|
ni->ni_txrate = 130;
|
|
ieee80211_free_node(ni);
|
|
return vap;
|
|
}
|
|
|
|
static void
|
|
wtap_vap_delete(struct ieee80211vap *vap)
|
|
{
|
|
struct wtap_vap *avp = WTAP_VAP(vap);
|
|
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
destroy_dev(avp->av_dev);
|
|
callout_stop(&avp->av_swba);
|
|
ieee80211_vap_detach(vap);
|
|
free(avp, M_80211_VAP);
|
|
}
|
|
|
|
static void
|
|
wtap_parent(struct ieee80211com *ic)
|
|
{
|
|
struct wtap_softc *sc = ic->ic_softc;
|
|
|
|
if (ic->ic_nrunning > 0) {
|
|
sc->up = 1;
|
|
ieee80211_start_all(ic);
|
|
} else
|
|
sc->up = 0;
|
|
}
|
|
|
|
static void
|
|
wtap_scan_start(struct ieee80211com *ic)
|
|
{
|
|
|
|
#if 0
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
#endif
|
|
}
|
|
|
|
static void
|
|
wtap_scan_end(struct ieee80211com *ic)
|
|
{
|
|
|
|
#if 0
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
#endif
|
|
}
|
|
|
|
static void
|
|
wtap_set_channel(struct ieee80211com *ic)
|
|
{
|
|
|
|
#if 0
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
#endif
|
|
}
|
|
|
|
static int
|
|
wtap_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
|
|
const struct ieee80211_bpf_params *params)
|
|
{
|
|
#if 0
|
|
DWTAP_PRINTF("%s, %p\n", __func__, m);
|
|
#endif
|
|
struct ieee80211vap *vap = ni->ni_vap;
|
|
struct wtap_vap *avp = WTAP_VAP(vap);
|
|
|
|
if (ieee80211_radiotap_active_vap(vap)) {
|
|
ieee80211_radiotap_tx(vap, m);
|
|
}
|
|
if (m->m_flags & M_TXCB)
|
|
ieee80211_process_callback(ni, m, 0);
|
|
ieee80211_free_node(ni);
|
|
return wtap_medium_enqueue(avp, m);
|
|
}
|
|
|
|
void
|
|
wtap_inject(struct wtap_softc *sc, struct mbuf *m)
|
|
{
|
|
struct wtap_buf *bf = (struct wtap_buf *)malloc(sizeof(struct wtap_buf),
|
|
M_WTAP_RXBUF, M_NOWAIT | M_ZERO);
|
|
KASSERT(bf != NULL, ("could not allocated a new wtap_buf\n"));
|
|
bf->m = m;
|
|
|
|
mtx_lock(&sc->sc_mtx);
|
|
STAILQ_INSERT_TAIL(&sc->sc_rxbuf, bf, bf_list);
|
|
taskqueue_enqueue(sc->sc_tq, &sc->sc_rxtask);
|
|
mtx_unlock(&sc->sc_mtx);
|
|
}
|
|
|
|
static void
|
|
wtap_rx_proc(void *arg, int npending)
|
|
{
|
|
struct epoch_tracker et;
|
|
struct wtap_softc *sc = (struct wtap_softc *)arg;
|
|
struct ieee80211com *ic = &sc->sc_ic;
|
|
struct mbuf *m;
|
|
struct ieee80211_node *ni;
|
|
struct wtap_buf *bf;
|
|
|
|
#if 0
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
#endif
|
|
|
|
for(;;) {
|
|
mtx_lock(&sc->sc_mtx);
|
|
bf = STAILQ_FIRST(&sc->sc_rxbuf);
|
|
if (bf == NULL) {
|
|
mtx_unlock(&sc->sc_mtx);
|
|
return;
|
|
}
|
|
STAILQ_REMOVE_HEAD(&sc->sc_rxbuf, bf_list);
|
|
mtx_unlock(&sc->sc_mtx);
|
|
KASSERT(bf != NULL, ("wtap_buf is NULL\n"));
|
|
m = bf->m;
|
|
DWTAP_PRINTF("[%d] receiving m=%p\n", sc->id, bf->m);
|
|
if (m == NULL) { /* NB: shouldn't happen */
|
|
ic_printf(ic, "%s: no mbuf!\n", __func__);
|
|
free(bf, M_WTAP_RXBUF);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* It's weird to do this, but sometimes wtap will
|
|
* receive AMPDU packets (like ping(8)) even when
|
|
* the ic does not supports 11n HT.
|
|
*/
|
|
m->m_flags &= ~M_AMPDU;
|
|
#if 0
|
|
ieee80211_dump_pkt(ic, mtod(m, caddr_t), 0,0,0);
|
|
#endif
|
|
|
|
/*
|
|
* Locate the node for sender, track state, and then
|
|
* pass the (referenced) node up to the 802.11 layer
|
|
* for its use.
|
|
*/
|
|
ni = ieee80211_find_rxnode_withkey(ic,
|
|
mtod(m, const struct ieee80211_frame_min *),
|
|
IEEE80211_KEYIX_NONE);
|
|
NET_EPOCH_ENTER(et);
|
|
if (ni != NULL) {
|
|
/*
|
|
* Sending station is known, dispatch directly.
|
|
*/
|
|
ieee80211_input(ni, m, 1<<7, 10);
|
|
ieee80211_free_node(ni);
|
|
} else {
|
|
ieee80211_input_all(ic, m, 1<<7, 10);
|
|
}
|
|
NET_EPOCH_EXIT(et);
|
|
|
|
/* The mbufs are freed by the Net80211 stack */
|
|
free(bf, M_WTAP_RXBUF);
|
|
}
|
|
}
|
|
|
|
static void
|
|
wtap_newassoc(struct ieee80211_node *ni, int isnew)
|
|
{
|
|
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
}
|
|
|
|
/*
|
|
* Callback from the 802.11 layer to update WME parameters.
|
|
*/
|
|
static int
|
|
wtap_wme_update(struct ieee80211com *ic)
|
|
{
|
|
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
wtap_update_mcast(struct ieee80211com *ic)
|
|
{
|
|
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
}
|
|
|
|
static void
|
|
wtap_update_promisc(struct ieee80211com *ic)
|
|
{
|
|
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
}
|
|
|
|
static int
|
|
wtap_transmit(struct ieee80211com *ic, struct mbuf *m)
|
|
{
|
|
struct ieee80211_node *ni =
|
|
(struct ieee80211_node *) m->m_pkthdr.rcvif;
|
|
struct ieee80211vap *vap = ni->ni_vap;
|
|
struct wtap_vap *avp = WTAP_VAP(vap);
|
|
|
|
if(ni == NULL){
|
|
printf("m->m_pkthdr.rcvif is NULL we cant radiotap_tx\n");
|
|
}else{
|
|
if (ieee80211_radiotap_active_vap(vap))
|
|
ieee80211_radiotap_tx(vap, m);
|
|
}
|
|
if (m->m_flags & M_TXCB)
|
|
ieee80211_process_callback(ni, m, 0);
|
|
ieee80211_free_node(ni);
|
|
return wtap_medium_enqueue(avp, m);
|
|
}
|
|
|
|
static struct ieee80211_node *
|
|
wtap_node_alloc(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN])
|
|
{
|
|
struct ieee80211_node *ni;
|
|
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
|
|
ni = malloc(sizeof(struct ieee80211_node), M_80211_NODE,
|
|
M_NOWAIT|M_ZERO);
|
|
if (ni == NULL)
|
|
return (NULL);
|
|
|
|
ni->ni_txrate = 130;
|
|
return ni;
|
|
}
|
|
|
|
static void
|
|
wtap_node_free(struct ieee80211_node *ni)
|
|
{
|
|
struct ieee80211com *ic = ni->ni_ic;
|
|
struct wtap_softc *sc = ic->ic_softc;
|
|
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
sc->sc_node_free(ni);
|
|
}
|
|
|
|
int32_t
|
|
wtap_attach(struct wtap_softc *sc, const uint8_t *macaddr)
|
|
{
|
|
struct ieee80211com *ic = &sc->sc_ic;
|
|
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
|
|
sc->up = 0;
|
|
STAILQ_INIT(&sc->sc_rxbuf);
|
|
sc->sc_tq = taskqueue_create("wtap_taskq", M_NOWAIT | M_ZERO,
|
|
taskqueue_thread_enqueue, &sc->sc_tq);
|
|
taskqueue_start_threads(&sc->sc_tq, 1, PI_SOFT, "%s taskQ", sc->name);
|
|
NET_TASK_INIT(&sc->sc_rxtask, 0, wtap_rx_proc, sc);
|
|
|
|
ic->ic_softc = sc;
|
|
ic->ic_name = sc->name;
|
|
ic->ic_phytype = IEEE80211_T_DS;
|
|
ic->ic_opmode = IEEE80211_M_MBSS;
|
|
ic->ic_caps = IEEE80211_C_MBSS | IEEE80211_C_IBSS;
|
|
|
|
ic->ic_max_keyix = 128; /* A value read from Atheros ATH_KEYMAX */
|
|
|
|
ic->ic_regdomain.regdomain = SKU_ETSI;
|
|
ic->ic_regdomain.country = CTRY_SWEDEN;
|
|
ic->ic_regdomain.location = 1; /* Indoors */
|
|
ic->ic_regdomain.isocc[0] = 'S';
|
|
ic->ic_regdomain.isocc[1] = 'E';
|
|
|
|
ic->ic_nchans = 1;
|
|
ic->ic_channels[0].ic_flags = IEEE80211_CHAN_B;
|
|
ic->ic_channels[0].ic_freq = 2412;
|
|
|
|
IEEE80211_ADDR_COPY(ic->ic_macaddr, macaddr);
|
|
ieee80211_ifattach(ic);
|
|
|
|
/* override default methods */
|
|
ic->ic_newassoc = wtap_newassoc;
|
|
ic->ic_wme.wme_update = wtap_wme_update;
|
|
ic->ic_vap_create = wtap_vap_create;
|
|
ic->ic_vap_delete = wtap_vap_delete;
|
|
ic->ic_raw_xmit = wtap_raw_xmit;
|
|
ic->ic_update_mcast = wtap_update_mcast;
|
|
ic->ic_update_promisc = wtap_update_promisc;
|
|
ic->ic_transmit = wtap_transmit;
|
|
ic->ic_parent = wtap_parent;
|
|
|
|
sc->sc_node_alloc = ic->ic_node_alloc;
|
|
ic->ic_node_alloc = wtap_node_alloc;
|
|
sc->sc_node_free = ic->ic_node_free;
|
|
ic->ic_node_free = wtap_node_free;
|
|
|
|
ic->ic_scan_start = wtap_scan_start;
|
|
ic->ic_scan_end = wtap_scan_end;
|
|
ic->ic_set_channel = wtap_set_channel;
|
|
|
|
ieee80211_radiotap_attach(ic,
|
|
&sc->sc_tx_th.wt_ihdr, sizeof(sc->sc_tx_th),
|
|
WTAP_TX_RADIOTAP_PRESENT,
|
|
&sc->sc_rx_th.wr_ihdr, sizeof(sc->sc_rx_th),
|
|
WTAP_RX_RADIOTAP_PRESENT);
|
|
|
|
/* Work here, we must find a way to populate the rate table */
|
|
#if 0
|
|
if(ic->ic_rt == NULL){
|
|
printf("no table for ic_curchan\n");
|
|
ic->ic_rt = ieee80211_get_ratetable(&ic->ic_channels[0]);
|
|
}
|
|
printf("ic->ic_rt =%p\n", ic->ic_rt);
|
|
printf("rate count %d\n", ic->ic_rt->rateCount);
|
|
|
|
uint8_t code = ic->ic_rt->info[0].dot11Rate;
|
|
uint8_t cix = ic->ic_rt->info[0].ctlRateIndex;
|
|
uint8_t ctl_rate = ic->ic_rt->info[cix].dot11Rate;
|
|
printf("code=%d, cix=%d, ctl_rate=%d\n", code, cix, ctl_rate);
|
|
|
|
uint8_t rix0 = ic->ic_rt->rateCodeToIndex[130];
|
|
uint8_t rix1 = ic->ic_rt->rateCodeToIndex[132];
|
|
uint8_t rix2 = ic->ic_rt->rateCodeToIndex[139];
|
|
uint8_t rix3 = ic->ic_rt->rateCodeToIndex[150];
|
|
printf("rix0 %u,rix1 %u,rix2 %u,rix3 %u\n", rix0,rix1,rix2,rix3);
|
|
printf("lpAckDuration=%u\n", ic->ic_rt->info[0].lpAckDuration);
|
|
printf("rate=%d\n", ic->ic_rt->info[0].rateKbps);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
int32_t
|
|
wtap_detach(struct wtap_softc *sc)
|
|
{
|
|
struct ieee80211com *ic = &sc->sc_ic;
|
|
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
ieee80211_ageq_drain(&ic->ic_stageq);
|
|
ieee80211_ifdetach(ic);
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
wtap_resume(struct wtap_softc *sc)
|
|
{
|
|
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
}
|
|
|
|
void
|
|
wtap_suspend(struct wtap_softc *sc)
|
|
{
|
|
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
}
|
|
|
|
void
|
|
wtap_shutdown(struct wtap_softc *sc)
|
|
{
|
|
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
}
|
|
|
|
void
|
|
wtap_intr(struct wtap_softc *sc)
|
|
{
|
|
|
|
DWTAP_PRINTF("%s\n", __func__);
|
|
}
|