1153317Ssam/*- 2174244Ssam * Copyright (c) 2002-2007 Sam Leffler, Errno Consulting 3153317Ssam * All rights reserved. 4153317Ssam * 5153317Ssam * Redistribution and use in source and binary forms, with or without 6153317Ssam * modification, are permitted provided that the following conditions 7153317Ssam * are met: 8153317Ssam * 1. Redistributions of source code must retain the above copyright 9153317Ssam * notice, this list of conditions and the following disclaimer, 10153317Ssam * without modification. 11153317Ssam * 2. Redistributions in binary form must reproduce at minimum a disclaimer 12153317Ssam * similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any 13153317Ssam * redistribution must be conditioned upon including a substantially 14153317Ssam * similar Disclaimer requirement for further binary redistribution. 15153317Ssam * 16153317Ssam * NO WARRANTY 17153317Ssam * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18153317Ssam * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19153317Ssam * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY 20153317Ssam * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 21153317Ssam * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, 22153317Ssam * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 23153317Ssam * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24153317Ssam * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 25153317Ssam * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 26153317Ssam * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 27153317Ssam * THE POSSIBILITY OF SUCH DAMAGES. 28153317Ssam * 29153317Ssam * $FreeBSD$ 30153317Ssam */ 31153317Ssam 32153317Ssam/* 33161200Ssam * net80211 statistics class. 34153317Ssam */ 35287297Srodrigc 36287297Srodrigc#include <sys/param.h> 37153317Ssam#include <sys/file.h> 38153317Ssam#include <sys/sockio.h> 39153317Ssam#include <sys/socket.h> 40287297Srodrigc 41153317Ssam#include <net/if.h> 42161200Ssam#include <net/if_dl.h> 43153317Ssam#include <net/if_media.h> 44153317Ssam#include <net/if_var.h> 45153317Ssam#include <net/ethernet.h> 46153317Ssam 47287297Srodrigc#include <err.h> 48287297Srodrigc#include <ifaddrs.h> 49287297Srodrigc#include <signal.h> 50153317Ssam#include <stdio.h> 51170535Ssam#include <stdlib.h> 52161200Ssam#include <string.h> 53153317Ssam#include <unistd.h> 54153317Ssam 55153392Ssam#include "../../../../sys/net80211/ieee80211_ioctl.h" 56153317Ssam 57161200Ssam#include "wlanstats.h" 58153317Ssam 59161200Ssam#ifndef IEEE80211_ADDR_COPY 60161200Ssam#define IEEE80211_ADDR_COPY(dst, src) memcpy(dst, src, IEEE80211_ADDR_LEN) 61161200Ssam#define IEEE80211_ADDR_EQ(a1,a2) (memcmp(a1,a2,IEEE80211_ADDR_LEN) == 0) 62161200Ssam#endif 63161200Ssam 64173306Ssam#define AFTER(prev) ((prev)+1) 65173306Ssam 66161200Ssamstatic const struct fmt wlanstats[] = { 67173306Ssam#define S_RX_BADVERSION 0 68173306Ssam { 5, "rx_badversion", "bvers", "rx frame with bad version" }, 69173306Ssam#define S_RX_TOOSHORT AFTER(S_RX_BADVERSION) 70173306Ssam { 5, "rx_tooshort", "2short", "rx frame too short" }, 71173306Ssam#define S_RX_WRONGBSS AFTER(S_RX_TOOSHORT) 72173306Ssam { 5, "rx_wrongbss", "wrbss", "rx from wrong bssid" }, 73173306Ssam#define S_RX_DUP AFTER(S_RX_WRONGBSS) 74173306Ssam { 5, "rx_dup", "rxdup", "rx discard 'cuz dup" }, 75173306Ssam#define S_RX_WRONGDIR AFTER(S_RX_DUP) 76173306Ssam { 5, "rx_wrongdir", "wrdir", "rx w/ wrong direction" }, 77173306Ssam#define S_RX_MCASTECHO AFTER(S_RX_WRONGDIR) 78173306Ssam { 5, "rx_mcastecho", "mecho", "rx discard 'cuz mcast echo" }, 79173306Ssam#define S_RX_NOTASSOC AFTER(S_RX_MCASTECHO) 80173306Ssam { 6, "rx_notassoc", "!assoc", "rx discard 'cuz sta !assoc" }, 81173306Ssam#define S_RX_NOPRIVACY AFTER(S_RX_NOTASSOC) 82173306Ssam { 6, "rx_noprivacy", "nopriv", "rx w/ wep but privacy off" }, 83173306Ssam#define S_RX_UNENCRYPTED AFTER(S_RX_NOPRIVACY) 84173306Ssam { 6, "rx_unencrypted", "unencr", "rx w/o wep and privacy on" }, 85173306Ssam#define S_RX_WEPFAIL AFTER(S_RX_UNENCRYPTED) 86173306Ssam { 7, "rx_wepfail", "wepfail", "rx wep processing failed" }, 87173306Ssam#define S_RX_DECAP AFTER(S_RX_WEPFAIL) 88161200Ssam { 5, "rx_decap", "decap", "rx decapsulation failed" }, 89173306Ssam#define S_RX_MGTDISCARD AFTER(S_RX_DECAP) 90173306Ssam { 8, "rx_mgtdiscard", "mgtdiscard", "rx discard mgt frames" }, 91173306Ssam#define S_RX_CTL AFTER(S_RX_MGTDISCARD) 92170535Ssam { 5, "rx_ctl", "ctl", "rx ctrl frames" }, 93173306Ssam#define S_RX_BEACON AFTER(S_RX_CTL) 94173306Ssam { 6, "rx_beacon", "beacon", "rx beacon frames" }, 95173306Ssam#define S_RX_RSTOOBIG AFTER(S_RX_BEACON) 96173306Ssam { 6, "rx_rstoobig", "rs2big", "rx rate set truncated" }, 97173306Ssam#define S_RX_ELEM_MISSING AFTER(S_RX_RSTOOBIG) 98173306Ssam { 6, "rx_elem_missing","iemiss", "rx required element missing" }, 99173306Ssam#define S_RX_ELEM_TOOBIG AFTER(S_RX_ELEM_MISSING) 100173306Ssam { 6, "rx_elem_toobig", "ie2big", "rx element too big" }, 101173306Ssam#define S_RX_ELEM_TOOSMALL AFTER(S_RX_ELEM_TOOBIG) 102173306Ssam { 7, "rx_elem_toosmall","ie2small","rx element too small" }, 103173306Ssam#define S_RX_ELEM_UNKNOWN AFTER(S_RX_ELEM_TOOSMALL) 104173306Ssam { 5, "rx_elem_unknown","ieunk", "rx element unknown" }, 105173306Ssam#define S_RX_BADCHAN AFTER(S_RX_ELEM_UNKNOWN) 106173306Ssam { 6, "rx_badchan", "badchan", "rx frame w/ invalid chan" }, 107173306Ssam#define S_RX_CHANMISMATCH AFTER(S_RX_BADCHAN) 108161200Ssam { 5, "rx_chanmismatch","chanmismatch", "rx frame chan mismatch" }, 109173306Ssam#define S_RX_NODEALLOC AFTER(S_RX_CHANMISMATCH) 110161200Ssam { 5, "rx_nodealloc", "nodealloc", "nodes allocated (rx)" }, 111173306Ssam#define S_RX_SSIDMISMATCH AFTER(S_RX_NODEALLOC) 112161200Ssam { 5, "rx_ssidmismatch","ssidmismatch", "rx frame ssid mismatch" }, 113173306Ssam#define S_RX_AUTH_UNSUPPORTED AFTER(S_RX_SSIDMISMATCH) 114161200Ssam { 5, "rx_auth_unsupported","auth_unsupported", 115161200Ssam "rx w/ unsupported auth alg" }, 116173306Ssam#define S_RX_AUTH_FAIL AFTER(S_RX_AUTH_UNSUPPORTED) 117161200Ssam { 5, "rx_auth_fail", "auth_fail", "rx sta auth failure" }, 118178359Ssam#define S_RX_AUTH_FAIL_CODE AFTER(S_RX_AUTH_FAIL) 119178359Ssam { 5, "rx_auth_fail_code","auth_fail_code", 120178359Ssam "last rx auth failure reason" }, 121178359Ssam#define S_RX_AUTH_COUNTERMEASURES AFTER(S_RX_AUTH_FAIL_CODE) 122161200Ssam { 5, "rx_auth_countermeasures", "auth_countermeasures", 123161200Ssam "rx sta auth failure 'cuz of TKIP countermeasures" }, 124173306Ssam#define S_RX_ASSOC_BSS AFTER(S_RX_AUTH_COUNTERMEASURES) 125161200Ssam { 5, "rx_assoc_bss", "assoc_bss", "rx assoc from wrong bssid" }, 126173306Ssam#define S_RX_ASSOC_NOTAUTH AFTER(S_RX_ASSOC_BSS) 127161200Ssam { 5, "rx_assoc_notauth","assoc_notauth", "rx assoc w/o auth" }, 128173306Ssam#define S_RX_ASSOC_CAPMISMATCH AFTER(S_RX_ASSOC_NOTAUTH) 129161200Ssam { 5, "rx_assoc_capmismatch","assoc_capmismatch", 130161200Ssam "rx assoc w/ cap mismatch" }, 131173306Ssam#define S_RX_ASSOC_NORATE AFTER(S_RX_ASSOC_CAPMISMATCH) 132161200Ssam { 5, "rx_assoc_norate","assoc_norate", "rx assoc w/ no rate match" }, 133173306Ssam#define S_RX_ASSOC_BADWPAIE AFTER(S_RX_ASSOC_NORATE) 134161200Ssam { 5, "rx_assoc_badwpaie","assoc_badwpaie", 135161200Ssam "rx assoc w/ bad WPA IE" }, 136173306Ssam#define S_RX_DEAUTH AFTER(S_RX_ASSOC_BADWPAIE) 137161200Ssam { 5, "rx_deauth", "deauth", "rx deauthentication" }, 138178359Ssam#define S_RX_DEAUTH_CODE AFTER(S_RX_DEAUTH) 139178359Ssam { 5, "rx_deauth_code","deauth_code", "last rx deauth reason" }, 140178359Ssam#define S_RX_DISASSOC AFTER(S_RX_DEAUTH_CODE) 141161200Ssam { 5, "rx_disassoc", "disassoc", "rx disassociation" }, 142178359Ssam#define S_RX_DISASSOC_CODE AFTER(S_RX_DISASSOC) 143178359Ssam { 5, "rx_disassoc_code","disassoc_code", 144178359Ssam "last rx disassoc reason" }, 145178359Ssam#define S_BMISS AFTER(S_RX_DISASSOC_CODE) 146178359Ssam { 5, "bmiss", "bmiss", "beacon miss events handled" }, 147178359Ssam#define S_RX_BADSUBTYPE AFTER(S_BMISS) 148161200Ssam { 5, "rx_badsubtype", "badsubtype", "rx frame w/ unknown subtype" }, 149173306Ssam#define S_RX_NOBUF AFTER(S_RX_BADSUBTYPE) 150161200Ssam { 5, "rx_nobuf", "nobuf", "rx failed for lack of mbuf" }, 151173306Ssam#define S_RX_DECRYPTCRC AFTER(S_RX_NOBUF) 152161200Ssam { 5, "rx_decryptcrc", "decryptcrc", "rx decrypt failed on crc" }, 153173306Ssam#define S_RX_AHDEMO_MGT AFTER(S_RX_DECRYPTCRC) 154161200Ssam { 5, "rx_ahdemo_mgt", "ahdemo_mgt", 155161200Ssam "rx discard mgmt frame received in ahdoc demo mode" }, 156173306Ssam#define S_RX_BAD_AUTH AFTER(S_RX_AHDEMO_MGT) 157161200Ssam { 5, "rx_bad_auth", "bad_auth", "rx bad authentication request" }, 158173306Ssam#define S_RX_UNAUTH AFTER(S_RX_BAD_AUTH) 159161200Ssam { 5, "rx_unauth", "unauth", 160161200Ssam "rx discard 'cuz port unauthorized" }, 161173306Ssam#define S_RX_BADKEYID AFTER(S_RX_UNAUTH) 162178699Ssam { 5, "rx_badkeyid", "rxkid", "rx w/ incorrect keyid" }, 163173306Ssam#define S_RX_CCMPREPLAY AFTER(S_RX_BADKEYID) 164161200Ssam { 5, "rx_ccmpreplay", "ccmpreplay", "rx seq# violation (CCMP)" }, 165173306Ssam#define S_RX_CCMPFORMAT AFTER(S_RX_CCMPREPLAY) 166161200Ssam { 5, "rx_ccmpformat", "ccmpformat", "rx format bad (CCMP)" }, 167173306Ssam#define S_RX_CCMPMIC AFTER(S_RX_CCMPFORMAT) 168161200Ssam { 5, "rx_ccmpmic", "ccmpmic", "rx MIC check failed (CCMP)" }, 169173306Ssam#define S_RX_TKIPREPLAY AFTER(S_RX_CCMPMIC) 170161200Ssam { 5, "rx_tkipreplay", "tkipreplay", "rx seq# violation (TKIP)" }, 171173306Ssam#define S_RX_TKIPFORMAT AFTER(S_RX_TKIPREPLAY) 172161200Ssam { 5, "rx_tkipformat", "tkipformat", "rx format bad (TKIP)" }, 173173306Ssam#define S_RX_TKIPMIC AFTER(S_RX_TKIPFORMAT) 174161200Ssam { 5, "rx_tkipmic", "tkipmic", "rx MIC check failed (TKIP)" }, 175173306Ssam#define S_RX_TKIPICV AFTER(S_RX_TKIPMIC) 176161200Ssam { 5, "rx_tkipicv", "tkipicv", "rx ICV check failed (TKIP)" }, 177173306Ssam#define S_RX_BADCIPHER AFTER(S_RX_TKIPICV) 178161200Ssam { 5, "rx_badcipher", "badcipher", "rx failed 'cuz bad cipher/key type" }, 179173306Ssam#define S_RX_NOCIPHERCTX AFTER(S_RX_BADCIPHER) 180161200Ssam { 5, "rx_nocipherctx", "nocipherctx", "rx failed 'cuz key/cipher ctx not setup" }, 181173306Ssam#define S_RX_ACL AFTER(S_RX_NOCIPHERCTX) 182161200Ssam { 5, "rx_acl", "acl", "rx discard 'cuz acl policy" }, 183173306Ssam#define S_TX_NOBUF AFTER(S_RX_ACL) 184161200Ssam { 5, "tx_nobuf", "nobuf", "tx failed for lack of mbuf" }, 185173306Ssam#define S_TX_NONODE AFTER(S_TX_NOBUF) 186161200Ssam { 5, "tx_nonode", "nonode", "tx failed for no node" }, 187173306Ssam#define S_TX_UNKNOWNMGT AFTER(S_TX_NONODE) 188161200Ssam { 5, "tx_unknownmgt", "unknownmgt", "tx of unknown mgt frame" }, 189173306Ssam#define S_TX_BADCIPHER AFTER(S_TX_UNKNOWNMGT) 190161200Ssam { 5, "tx_badcipher", "badcipher", "tx failed 'cuz bad ciper/key type" }, 191173306Ssam#define S_TX_NODEFKEY AFTER(S_TX_BADCIPHER) 192161200Ssam { 5, "tx_nodefkey", "nodefkey", "tx failed 'cuz no defkey" }, 193173306Ssam#define S_TX_NOHEADROOM AFTER(S_TX_NODEFKEY) 194161200Ssam { 5, "tx_noheadroom", "noheadroom", "tx failed 'cuz no space for crypto hdrs" }, 195173306Ssam#define S_TX_FRAGFRAMES AFTER(S_TX_NOHEADROOM) 196161200Ssam { 5, "tx_fragframes", "fragframes", "tx frames fragmented" }, 197173306Ssam#define S_TX_FRAGS AFTER(S_TX_FRAGFRAMES) 198161200Ssam { 5, "tx_frags", "frags", "tx frags generated" }, 199173306Ssam#define S_SCAN_ACTIVE AFTER(S_TX_FRAGS) 200178699Ssam { 5, "scan_active", "ascan", "active scans started" }, 201173306Ssam#define S_SCAN_PASSIVE AFTER(S_SCAN_ACTIVE) 202178699Ssam { 5, "scan_passive", "pscan", "passive scans started" }, 203178359Ssam#define S_SCAN_BG AFTER(S_SCAN_PASSIVE) 204178699Ssam { 5, "scan_bg", "bgscn", "background scans started" }, 205178359Ssam#define S_NODE_TIMEOUT AFTER(S_SCAN_BG) 206173306Ssam { 5, "node_timeout", "node_timeout", "nodes timed out for inactivity" }, 207173306Ssam#define S_CRYPTO_NOMEM AFTER(S_NODE_TIMEOUT) 208161200Ssam { 5, "crypto_nomem", "crypto_nomem", "cipher context malloc failed" }, 209173306Ssam#define S_CRYPTO_TKIP AFTER(S_CRYPTO_NOMEM) 210161200Ssam { 5, "crypto_tkip", "crypto_tkip", "tkip crypto done in s/w" }, 211173306Ssam#define S_CRYPTO_TKIPENMIC AFTER(S_CRYPTO_TKIP) 212161200Ssam { 5, "crypto_tkipenmic","crypto_tkipenmic", "tkip tx MIC done in s/w" }, 213173306Ssam#define S_CRYPTO_TKIPDEMIC AFTER(S_CRYPTO_TKIPENMIC) 214161200Ssam { 5, "crypto_tkipdemic","crypto_tkipdemic", "tkip rx MIC done in s/w" }, 215173306Ssam#define S_CRYPTO_TKIPCM AFTER(S_CRYPTO_TKIPDEMIC) 216161200Ssam { 5, "crypto_tkipcm", "crypto_tkipcm", "tkip dropped frames 'cuz of countermeasures" }, 217173306Ssam#define S_CRYPTO_CCMP AFTER(S_CRYPTO_TKIPCM) 218161200Ssam { 5, "crypto_ccmp", "crypto_ccmp", "ccmp crypto done in s/w" }, 219173306Ssam#define S_CRYPTO_WEP AFTER(S_CRYPTO_CCMP) 220161200Ssam { 5, "crypto_wep", "crypto_wep", "wep crypto done in s/w" }, 221173306Ssam#define S_CRYPTO_SETKEY_CIPHER AFTER(S_CRYPTO_WEP) 222161200Ssam { 5, "crypto_setkey_cipher", "crypto_setkey_cipher","setkey failed 'cuz cipher rejected data" }, 223173306Ssam#define S_CRYPTO_SETKEY_NOKEY AFTER(S_CRYPTO_SETKEY_CIPHER) 224161200Ssam { 5, "crypto_setkey_nokey", "crypto_setkey_nokey","setkey failed 'cuz no key index" }, 225173306Ssam#define S_CRYPTO_DELKEY AFTER(S_CRYPTO_SETKEY_NOKEY) 226161200Ssam { 5, "crypto_delkey", "crypto_delkey", "driver key delete failed" }, 227173306Ssam#define S_CRYPTO_BADCIPHER AFTER(S_CRYPTO_DELKEY) 228161200Ssam { 5, "crypto_badcipher","crypto_badcipher", "setkey failed 'cuz unknown cipher" }, 229173306Ssam#define S_CRYPTO_NOCIPHER AFTER(S_CRYPTO_BADCIPHER) 230161200Ssam { 5, "crypto_nocipher","crypto_nocipher", "setkey failed 'cuz cipher module unavailable" }, 231173306Ssam#define S_CRYPTO_ATTACHFAIL AFTER(S_CRYPTO_NOCIPHER) 232161200Ssam { 5, "crypto_attachfail","crypto_attachfail", "setkey failed 'cuz cipher attach failed" }, 233173306Ssam#define S_CRYPTO_SWFALLBACK AFTER(S_CRYPTO_ATTACHFAIL) 234161200Ssam { 5, "crypto_swfallback","crypto_swfallback", "crypto fell back to s/w implementation" }, 235173306Ssam#define S_CRYPTO_KEYFAIL AFTER(S_CRYPTO_SWFALLBACK) 236161200Ssam { 5, "crypto_keyfail", "crypto_keyfail", "setkey failed 'cuz driver key alloc failed" }, 237173306Ssam#define S_CRYPTO_ENMICFAIL AFTER(S_CRYPTO_KEYFAIL) 238161200Ssam { 5, "crypto_enmicfail","crypto_enmicfail", "enmic failed (may be mbuf exhaustion)" }, 239173306Ssam#define S_IBSS_CAPMISMATCH AFTER(S_CRYPTO_ENMICFAIL) 240161200Ssam { 5, "ibss_capmismatch","ibss_capmismatch", "ibss merge faied 'cuz capabilities mismatch" }, 241173306Ssam#define S_IBSS_NORATE AFTER(S_IBSS_CAPMISMATCH) 242161200Ssam { 5, "ibss_norate", "ibss_norate", "ibss merge faied 'cuz rate set mismatch" }, 243173306Ssam#define S_PS_UNASSOC AFTER(S_IBSS_NORATE) 244161200Ssam { 5, "ps_unassoc", "ps_unassoc", "ps-poll received for unassociated station" }, 245173306Ssam#define S_PS_BADAID AFTER(S_PS_UNASSOC) 246161200Ssam { 5, "ps_badaid", "ps_badaid", "ps-poll received with invalid association id" }, 247173306Ssam#define S_PS_QEMPTY AFTER(S_PS_BADAID) 248161200Ssam { 5, "ps_qempty", "ps_qempty", "ps-poll received with nothing to send" }, 249173306Ssam#define S_FF_BADHDR AFTER(S_PS_QEMPTY) 250161200Ssam { 5, "ff_badhdr", "ff_badhdr", "fast frame rx'd w/ bad hdr" }, 251173306Ssam#define S_FF_TOOSHORT AFTER(S_FF_BADHDR) 252161200Ssam { 5, "ff_tooshort", "ff_tooshort", "fast frame rx decap error" }, 253173306Ssam#define S_FF_SPLIT AFTER(S_FF_TOOSHORT) 254161200Ssam { 5, "ff_split", "ff_split", "fast frame rx split error" }, 255173306Ssam#define S_FF_DECAP AFTER(S_FF_SPLIT) 256161200Ssam { 5, "ff_decap", "ff_decap", "fast frames decap'd" }, 257173306Ssam#define S_FF_ENCAP AFTER(S_FF_DECAP) 258161200Ssam { 5, "ff_encap", "ff_encap", "fast frames encap'd for tx" }, 259173306Ssam#define S_FF_ENCAPFAIL AFTER(S_FF_ENCAP) 260161200Ssam { 5, "ff_encapfail", "ff_encapfail", "fast frames encap failed" }, 261173306Ssam#define S_RX_BADBINTVAL AFTER(S_FF_ENCAPFAIL) 262161200Ssam { 5, "rx_badbintval", "rx_badbintval","rx frame with bogus beacon interval" }, 263173306Ssam#define S_RX_MGMT AFTER(S_RX_BADBINTVAL) 264178699Ssam { 8, "rx_mgmt", "mgmt", "rx management frames" }, 265173306Ssam#define S_RX_DEMICFAIL AFTER(S_RX_MGMT) 266161200Ssam { 5, "rx_demicfail", "rx_demicfail", "rx demic failed" }, 267173306Ssam#define S_RX_DEFRAG AFTER(S_RX_DEMICFAIL) 268161200Ssam { 5, "rx_defrag", "rx_defrag", "rx defragmentation failed" }, 269173306Ssam#define S_RX_ACTION AFTER(S_RX_DEFRAG) 270170535Ssam { 5, "rx_action", "rx_action", "rx action frames" }, 271173306Ssam#define S_AMSDU_TOOSHORT AFTER(S_RX_ACTION) 272173306Ssam { 8, "amsdu_tooshort", "tooshort","A-MSDU rx decap error" }, 273173306Ssam#define S_AMSDU_SPLIT AFTER(S_AMSDU_TOOSHORT) 274173306Ssam { 8, "amsdu_split", "split", "A-MSDU rx failed on frame split" }, 275173306Ssam#define S_AMSDU_DECAP AFTER(S_AMSDU_SPLIT) 276173306Ssam { 8, "amsdu_decap", "decap", "A-MSDU frames received" }, 277173306Ssam#define S_AMSDU_ENCAP AFTER(S_AMSDU_DECAP) 278173306Ssam { 8, "amsdu_encap", "encap", "A-MSDU frames transmitted" }, 279173306Ssam#define S_AMPDU_REORDER AFTER(S_AMSDU_ENCAP) 280173306Ssam { 8, "ampdu_reorder", "reorder","A-MPDU frames held in reorder q" }, 281173306Ssam#define S_AMPDU_FLUSH AFTER(S_AMPDU_REORDER) 282173306Ssam { 8, "ampdu_flush", "flush", "A-MPDU frames sent up from reorder q" }, 283173306Ssam#define S_AMPDU_BARBAD AFTER(S_AMPDU_FLUSH) 284173306Ssam { 6, "ampdu_barbad", "barbad", "A-MPDU BAR rx before ADDBA exchange (or disabled with net.link.ieee80211)" }, 285173306Ssam#define S_AMPDU_BAROOW AFTER(S_AMPDU_BARBAD) 286173306Ssam { 6, "ampdu_baroow", "baroow", "A-MPDU BAR rx out of BA window" }, 287173306Ssam#define S_AMPDU_BARMOVE AFTER(S_AMPDU_BAROOW) 288173306Ssam { 8, "ampdu_barmove", "barmove","A-MPDU BAR rx moved BA window" }, 289173306Ssam#define S_AMPDU_BAR AFTER(S_AMPDU_BARMOVE) 290173306Ssam { 8, "ampdu_bar", "rxbar", "A-MPDU BAR rx successful" }, 291173306Ssam#define S_AMPDU_MOVE AFTER(S_AMPDU_BAR) 292173306Ssam { 5, "ampdu_move", "move", "A-MPDU frame moved BA window" }, 293173306Ssam#define S_AMPDU_OOR AFTER(S_AMPDU_MOVE) 294173306Ssam { 8, "ampdu_oor", "oorx", "A-MPDU frames rx out-of-order" }, 295173306Ssam#define S_AMPDU_COPY AFTER(S_AMPDU_OOR) 296173306Ssam { 8, "ampdu_copy", "copy", "A-MPDU rx window slots copied" }, 297173306Ssam#define S_AMPDU_DROP AFTER(S_AMPDU_COPY) 298173306Ssam { 5, "ampdu_drop", "drop", "A-MPDU frames discarded for out of range seqno" }, 299173306Ssam#define S_AMPDU_AGE AFTER(S_AMPDU_DROP) 300173306Ssam { 5, "ampdu_age", "age", "A-MPDU frames sent up due to old age" }, 301173306Ssam#define S_AMPDU_STOP AFTER(S_AMPDU_AGE) 302173306Ssam { 5, "ampdu_stop", "stop", "A-MPDU streams stopped" }, 303173306Ssam#define S_AMPDU_STOP_FAILED AFTER(S_AMPDU_STOP) 304173306Ssam { 5, "ampdu_stop_failed","!stop", "A-MPDU stop requests failed 'cuz stream not running" }, 305173306Ssam#define S_ADDBA_REJECT AFTER(S_AMPDU_STOP_FAILED) 306173306Ssam { 5, "addba_reject", "reject", "ADDBA requests rejected 'cuz A-MPDU rx is disabled" }, 307173306Ssam#define S_ADDBA_NOREQUEST AFTER(S_ADDBA_REJECT) 308173306Ssam { 5, "addba_norequest","norequest","ADDBA response frames discarded because no ADDBA request was pending" }, 309173306Ssam#define S_ADDBA_BADTOKEN AFTER(S_ADDBA_NOREQUEST) 310173306Ssam { 5, "addba_badtoken", "badtoken","ADDBA response frames discarded 'cuz rx'd dialog token is wrong" }, 311173306Ssam#define S_TX_BADSTATE AFTER(S_ADDBA_BADTOKEN) 312173306Ssam { 4, "tx_badstate", "badstate", "tx failed 'cuz vap not in RUN state" }, 313173306Ssam#define S_TX_NOTASSOC AFTER(S_TX_BADSTATE) 314173306Ssam { 4, "tx_notassoc", "notassoc", "tx failed 'cuz dest sta not associated" }, 315173306Ssam#define S_TX_CLASSIFY AFTER(S_TX_NOTASSOC) 316173306Ssam { 4, "tx_classify", "classify", "tx packet classification failed" }, 317173306Ssam#define S_DWDS_MCAST AFTER(S_TX_CLASSIFY) 318173306Ssam { 8, "dwds_mcast", "dwds_mcast", "mcast frame transmitted on dwds vap discarded" }, 319173306Ssam#define S_DWDS_QDROP AFTER(S_DWDS_MCAST) 320173306Ssam { 8, "dwds_qdrop", "dwds_qdrop", "4-address frame discarded because dwds pending queue is full" }, 321173306Ssam#define S_HT_ASSOC_NOHTCAP AFTER(S_DWDS_QDROP) 322173306Ssam { 4, "ht_nohtcap", "ht_nohtcap", "non-HT station rejected in HT-only BSS" }, 323173306Ssam#define S_HT_ASSOC_DOWNGRADE AFTER(S_HT_ASSOC_NOHTCAP) 324173306Ssam { 4, "ht_downgrade", "ht_downgrade", "HT station downgraded to legacy operation" }, 325173306Ssam#define S_HT_ASSOC_NORATE AFTER(S_HT_ASSOC_DOWNGRADE) 326173306Ssam { 4, "ht_norate", "ht_norate", "HT station rejected because of HT rate set" }, 327195618Srpaulo#define S_MESH_WRONGMESH AFTER(S_HT_ASSOC_NORATE) 328195618Srpaulo { 4, "mesh_wrong", "mesh_wrong", "frame discarded because sender not a mesh sta" }, 329195618Srpaulo#define S_MESH_NOLINK AFTER(S_MESH_WRONGMESH) 330195618Srpaulo { 4, "mesh_nolink", "mesh_nolink", "frame discarded because link not established" }, 331195618Srpaulo#define S_MESH_FWD_TTL AFTER(S_MESH_NOLINK) 332195618Srpaulo { 4, "mesh_fwd_ttl", "mesh_fwd_ttl", "frame not forwarded because TTL zero" }, 333195618Srpaulo#define S_MESH_FWD_NOBUF AFTER(S_MESH_FWD_TTL) 334195618Srpaulo { 4, "mesh_fwd_nobuf", "mesh_fwd_nobuf", "frame not forwarded because mbuf could not be allocated" }, 335195618Srpaulo#define S_MESH_FWD_TOOSHORT AFTER(S_MESH_FWD_NOBUF) 336195618Srpaulo { 4, "mesh_fwd_tooshort", "mesh_fwd_tooshort", "frame not forwarded because too short to have 802.11 header" }, 337195618Srpaulo#define S_MESH_FWD_DISABLED AFTER(S_MESH_FWD_TOOSHORT) 338195618Srpaulo { 4, "mesh_fwd_disabled", "mesh_fwd_disabled", "frame not forwarded because administratively disabled" }, 339195618Srpaulo#define S_MESH_FWD_NOPATH AFTER(S_MESH_FWD_DISABLED) 340195618Srpaulo { 4, "mesh_fwd_nopath", "mesh_fwd_nopath", "frame not forwarded because no path found to destination" }, 341195618Srpaulo#define S_HWMP_WRONGSEQ AFTER(S_MESH_FWD_NOPATH) 342195618Srpaulo { 4, "hwmp_wrongseq", "hwmp_wrongseq", "frame discarded because mesh sequence number is invalid" }, 343195618Srpaulo#define S_HWMP_ROOTREQS AFTER(S_HWMP_WRONGSEQ) 344195618Srpaulo { 4, "hwmp_rootreqs", "hwmp_rootreqs", "root PREQ frames sent" }, 345195618Srpaulo#define S_HWMP_ROOTANN AFTER(S_HWMP_ROOTREQS) 346195618Srpaulo { 4, "hwmp_rootann", "hwmp_rootann", "root RANN frames received" }, 347195811Ssam#define S_MESH_BADAE AFTER(S_HWMP_ROOTANN) 348195811Ssam { 4, "mesh_badae", "mesh_badae", "frame discarded for bad AddressExtension (AE)" }, 349195811Ssam#define S_MESH_RTADDFAILED AFTER(S_MESH_BADAE) 350195811Ssam { 4, "mesh_rtadd", "mesh_rtadd", "mesh route add failed" }, 351195811Ssam#define S_MESH_NOTPROXY AFTER(S_MESH_RTADDFAILED) 352195811Ssam { 8, "mesh_notproxy", "mesh_notproxy","frame discarded because station not acting as a proxy" }, 353195811Ssam#define S_RX_BADALIGN AFTER(S_MESH_NOTPROXY) 354195811Ssam { 4, "rx_badalign", "rx_badalign","frame discarded because payload re-alignment failed" }, 355195811Ssam#define S_INPUT AFTER(S_RX_BADALIGN) 356173306Ssam { 8, "input", "input", "total data frames received" }, 357173306Ssam#define S_RX_UCAST AFTER(S_INPUT) 358161200Ssam { 8, "rx_ucast", "rx_ucast", "unicast data frames received" }, 359173306Ssam#define S_RX_MCAST AFTER(S_RX_UCAST) 360161200Ssam { 8, "rx_mcast", "rx_mcast", "multicast data frames received" }, 361173306Ssam#define S_OUTPUT AFTER(S_RX_MCAST) 362173306Ssam { 8, "output", "output", "total data frames transmit" }, 363173306Ssam#define S_TX_UCAST AFTER(S_OUTPUT) 364161200Ssam { 8, "tx_ucast", "tx_ucast", "unicast data frames sent" }, 365173306Ssam#define S_TX_MCAST AFTER(S_TX_UCAST) 366161200Ssam { 8, "tx_mcast", "tx_mcast", "multicast data frames sent" }, 367173306Ssam#define S_RATE AFTER(S_TX_MCAST) 368297607Sadrian { 7, "rate", "rate", "current transmit rate" }, 369173306Ssam#define S_RSSI AFTER(S_RATE) 370297607Sadrian { 6, "rssi", "rssi", "current rssi" }, 371173306Ssam#define S_NOISE AFTER(S_RSSI) 372178699Ssam { 5, "noise", "noise", "current noise floor (dBm)" }, 373173306Ssam#define S_SIGNAL AFTER(S_NOISE) 374297607Sadrian { 6, "signal", "sig", "current signal (dBm)" }, 375232245Sadrian#define S_BEACON_BAD AFTER(S_SIGNAL) 376232245Sadrian { 9, "beacon_bad", "beaconbad", "bad beacons received" }, 377234019Sadrian#define S_AMPDU_BARTX AFTER(S_BEACON_BAD) 378234019Sadrian { 5, "ampdu_bartx", "bartx", "BAR frames sent" }, 379234019Sadrian#define S_AMPDU_BARTX_FAIL AFTER(S_AMPDU_BARTX) 380234019Sadrian { 9, "ampdu_bartxfail", "bartx_fail", "BAR frames failed to send" }, 381234019Sadrian#define S_AMPDU_BARTX_RETRY AFTER(S_AMPDU_BARTX_FAIL) 382234019Sadrian { 10, "ampdu_bartxretry", "bartx_retry", "BAR frames retried" }, 383161200Ssam}; 384161200Ssam 385161200Ssamstruct wlanstatfoo_p { 386161200Ssam struct wlanstatfoo base; 387161200Ssam int s; 388161200Ssam int opmode; 389161200Ssam uint8_t mac[IEEE80211_ADDR_LEN]; 390161200Ssam struct ifreq ifr; 391161200Ssam struct ieee80211_stats cur; 392161200Ssam struct ieee80211_stats total; 393161200Ssam struct ieee80211req ireq; 394161200Ssam union { 395161200Ssam struct ieee80211req_sta_req info; 396161200Ssam char buf[1024]; 397161200Ssam } u_info; 398161200Ssam struct ieee80211req_sta_stats ncur; 399161200Ssam struct ieee80211req_sta_stats ntotal; 400161200Ssam}; 401161200Ssam 402153317Ssamstatic void 403161200Ssamwlan_setifname(struct wlanstatfoo *wf0, const char *ifname) 404153317Ssam{ 405161200Ssam struct wlanstatfoo_p *wf = (struct wlanstatfoo_p *) wf0; 406161200Ssam 407161200Ssam strncpy(wf->ifr.ifr_name, ifname, sizeof (wf->ifr.ifr_name)); 408161200Ssam strncpy(wf->ireq.i_name, ifname, sizeof (wf->ireq.i_name)); 409153317Ssam} 410153317Ssam 411161200Ssamstatic const char * 412161200Ssamwlan_getifname(struct wlanstatfoo *wf0) 413153317Ssam{ 414161200Ssam struct wlanstatfoo_p *wf = (struct wlanstatfoo_p *) wf0; 415153317Ssam 416161200Ssam return wf->ifr.ifr_name; 417161200Ssam} 418153317Ssam 419161200Ssamstatic int 420161200Ssamwlan_getopmode(struct wlanstatfoo *wf0) 421161200Ssam{ 422161200Ssam struct wlanstatfoo_p *wf = (struct wlanstatfoo_p *) wf0; 423153317Ssam 424161200Ssam if (wf->opmode == -1) { 425161200Ssam struct ifmediareq ifmr; 426153317Ssam 427161200Ssam memset(&ifmr, 0, sizeof(ifmr)); 428161200Ssam strlcpy(ifmr.ifm_name, wf->ifr.ifr_name, sizeof(ifmr.ifm_name)); 429161200Ssam if (ioctl(wf->s, SIOCGIFMEDIA, &ifmr) < 0) 430161200Ssam err(1, "%s (SIOCGIFMEDIA)", wf->ifr.ifr_name); 431188187Ssam if (ifmr.ifm_current & IFM_IEEE80211_ADHOC) { 432188187Ssam if (ifmr.ifm_current & IFM_FLAG0) 433188187Ssam wf->opmode = IEEE80211_M_AHDEMO; 434188187Ssam else 435188187Ssam wf->opmode = IEEE80211_M_IBSS; 436188187Ssam } else if (ifmr.ifm_current & IFM_IEEE80211_HOSTAP) 437161200Ssam wf->opmode = IEEE80211_M_HOSTAP; 438161200Ssam else if (ifmr.ifm_current & IFM_IEEE80211_MONITOR) 439161200Ssam wf->opmode = IEEE80211_M_MONITOR; 440161200Ssam else 441161200Ssam wf->opmode = IEEE80211_M_STA; 442161200Ssam } 443161200Ssam return wf->opmode; 444161200Ssam} 445153317Ssam 446161200Ssamstatic void 447161200Ssamgetlladdr(struct wlanstatfoo_p *wf) 448161200Ssam{ 449161200Ssam const struct sockaddr_dl *sdl; 450161200Ssam struct ifaddrs *ifp, *p; 451153317Ssam 452161200Ssam if (getifaddrs(&ifp) != 0) 453161200Ssam err(1, "getifaddrs"); 454161200Ssam for (p = ifp; p != NULL; p = p->ifa_next) 455161200Ssam if (strcmp(p->ifa_name, wf->ifr.ifr_name) == 0 && 456161200Ssam p->ifa_addr->sa_family == AF_LINK) 457161200Ssam break; 458161200Ssam if (p == NULL) 459161200Ssam errx(1, "did not find link layer address for interface %s", 460161200Ssam wf->ifr.ifr_name); 461161200Ssam sdl = (const struct sockaddr_dl *) p->ifa_addr; 462161200Ssam IEEE80211_ADDR_COPY(wf->mac, LLADDR(sdl)); 463161200Ssam freeifaddrs(ifp); 464153317Ssam} 465153317Ssam 466188187Ssamstatic int 467188187Ssamgetbssid(struct wlanstatfoo_p *wf) 468188187Ssam{ 469188187Ssam wf->ireq.i_type = IEEE80211_IOC_BSSID; 470188187Ssam wf->ireq.i_data = wf->mac; 471188187Ssam wf->ireq.i_len = IEEE80211_ADDR_LEN; 472188187Ssam return ioctl(wf->s, SIOCG80211, &wf->ireq); 473188187Ssam} 474188187Ssam 475161200Ssamstatic void 476161200Ssamwlan_setstamac(struct wlanstatfoo *wf0, const uint8_t *mac) 477153317Ssam{ 478188210Ssam static const uint8_t zeromac[IEEE80211_ADDR_LEN]; 479161200Ssam struct wlanstatfoo_p *wf = (struct wlanstatfoo_p *) wf0; 480153317Ssam 481161200Ssam if (mac == NULL) { 482161200Ssam switch (wlan_getopmode(wf0)) { 483161200Ssam case IEEE80211_M_HOSTAP: 484161200Ssam case IEEE80211_M_MONITOR: 485188210Ssam getlladdr(wf); 486188210Ssam break; 487161200Ssam case IEEE80211_M_IBSS: 488161200Ssam case IEEE80211_M_AHDEMO: 489188210Ssam /* 490188210Ssam * NB: this may not work in which case the 491188210Ssam * mac must be specified on the command line 492188210Ssam */ 493188210Ssam if (getbssid(wf) < 0 || 494188210Ssam IEEE80211_ADDR_EQ(wf->mac, zeromac)) 495188210Ssam getlladdr(wf); 496153317Ssam break; 497161200Ssam case IEEE80211_M_STA: 498188187Ssam if (getbssid(wf) < 0) 499188187Ssam err(1, "%s (IEEE80211_IOC_BSSID)", 500188187Ssam wf->ireq.i_name); 501153317Ssam break; 502153317Ssam } 503161200Ssam } else 504161200Ssam IEEE80211_ADDR_COPY(wf->mac, mac); 505161200Ssam} 506153317Ssam 507161200Ssam/* XXX only fetch what's needed to do reports */ 508161200Ssamstatic void 509161200Ssamwlan_collect(struct wlanstatfoo_p *wf, 510161200Ssam struct ieee80211_stats *stats, struct ieee80211req_sta_stats *nstats) 511161200Ssam{ 512153317Ssam 513161200Ssam IEEE80211_ADDR_COPY(wf->u_info.info.is_u.macaddr, wf->mac); 514161200Ssam wf->ireq.i_type = IEEE80211_IOC_STA_INFO; 515161200Ssam wf->ireq.i_data = (caddr_t) &wf->u_info; 516161200Ssam wf->ireq.i_len = sizeof(wf->u_info); 517188187Ssam if (ioctl(wf->s, SIOCG80211, &wf->ireq) < 0) { 518188187Ssam warn("%s:%s (IEEE80211_IOC_STA_INFO)", wf->ireq.i_name, 519188187Ssam ether_ntoa((const struct ether_addr*) wf->mac)); 520188187Ssam } 521161200Ssam 522161200Ssam IEEE80211_ADDR_COPY(nstats->is_u.macaddr, wf->mac); 523161200Ssam wf->ireq.i_type = IEEE80211_IOC_STA_STATS; 524161200Ssam wf->ireq.i_data = (caddr_t) nstats; 525161200Ssam wf->ireq.i_len = sizeof(*nstats); 526161200Ssam if (ioctl(wf->s, SIOCG80211, &wf->ireq) < 0) 527188187Ssam warn("%s:%s (IEEE80211_IOC_STA_STATS)", wf->ireq.i_name, 528188187Ssam ether_ntoa((const struct ether_addr*) wf->mac)); 529161200Ssam 530161200Ssam wf->ifr.ifr_data = (caddr_t) stats; 531161200Ssam if (ioctl(wf->s, SIOCG80211STATS, &wf->ifr) < 0) 532170535Ssam err(1, "%s (SIOCG80211STATS)", wf->ifr.ifr_name); 533161200Ssam} 534161200Ssam 535161200Ssamstatic void 536262824Sadrianwlan_collect_cur(struct bsdstat *sf) 537161200Ssam{ 538161200Ssam struct wlanstatfoo_p *wf = (struct wlanstatfoo_p *) sf; 539161200Ssam 540161200Ssam wlan_collect(wf, &wf->cur, &wf->ncur); 541161200Ssam} 542161200Ssam 543161200Ssamstatic void 544262824Sadrianwlan_collect_tot(struct bsdstat *sf) 545161200Ssam{ 546161200Ssam struct wlanstatfoo_p *wf = (struct wlanstatfoo_p *) sf; 547161200Ssam 548161200Ssam wlan_collect(wf, &wf->total, &wf->ntotal); 549161200Ssam} 550161200Ssam 551161200Ssamstatic void 552262824Sadrianwlan_update_tot(struct bsdstat *sf) 553161200Ssam{ 554161200Ssam struct wlanstatfoo_p *wf = (struct wlanstatfoo_p *) sf; 555161200Ssam 556161200Ssam wf->total = wf->cur; 557161200Ssam wf->ntotal = wf->ncur; 558161200Ssam} 559161200Ssam 560178359Ssamvoid 561178359Ssamsetreason(char b[], size_t bs, int v) 562178359Ssam{ 563178359Ssam static const char *reasons[] = { 564178359Ssam [IEEE80211_REASON_UNSPECIFIED] = "unspecified", 565178359Ssam [IEEE80211_REASON_AUTH_EXPIRE] = "auth expire", 566178359Ssam [IEEE80211_REASON_AUTH_LEAVE] = "auth leave", 567178359Ssam [IEEE80211_REASON_ASSOC_EXPIRE] = "assoc expire", 568178359Ssam [IEEE80211_REASON_ASSOC_TOOMANY] = "assoc toomany", 569178359Ssam [IEEE80211_REASON_NOT_AUTHED] = "not authed", 570178359Ssam [IEEE80211_REASON_NOT_ASSOCED] = "not assoced", 571178359Ssam [IEEE80211_REASON_ASSOC_LEAVE] = "assoc leave", 572178359Ssam [IEEE80211_REASON_ASSOC_NOT_AUTHED] = "assoc not authed", 573178359Ssam [IEEE80211_REASON_DISASSOC_PWRCAP_BAD] = "disassoc pwrcap bad", 574178359Ssam [IEEE80211_REASON_DISASSOC_SUPCHAN_BAD] = "disassoc supchan bad", 575178359Ssam [IEEE80211_REASON_IE_INVALID] = "ie invalid", 576178359Ssam [IEEE80211_REASON_MIC_FAILURE] = "mic failure", 577178359Ssam [IEEE80211_REASON_4WAY_HANDSHAKE_TIMEOUT]= "4-way handshake timeout", 578178359Ssam [IEEE80211_REASON_GROUP_KEY_UPDATE_TIMEOUT] = "group key update timeout", 579178359Ssam [IEEE80211_REASON_IE_IN_4WAY_DIFFERS] = "ie in 4-way differs", 580178359Ssam [IEEE80211_REASON_GROUP_CIPHER_INVALID] = "group cipher invalid", 581178359Ssam [IEEE80211_REASON_PAIRWISE_CIPHER_INVALID]= "pairwise cipher invalid", 582178359Ssam [IEEE80211_REASON_AKMP_INVALID] = "akmp invalid", 583178359Ssam [IEEE80211_REASON_UNSUPP_RSN_IE_VERSION]= "unsupported rsn ie version", 584178359Ssam [IEEE80211_REASON_INVALID_RSN_IE_CAP] = "invalid rsn ie cap", 585178359Ssam [IEEE80211_REASON_802_1X_AUTH_FAILED] = "802.1x auth failed", 586178359Ssam [IEEE80211_REASON_CIPHER_SUITE_REJECTED]= "cipher suite rejected", 587178359Ssam }; 588287297Srodrigc if (v < nitems(reasons) && reasons[v] != NULL) 589178359Ssam snprintf(b, bs, "%s (%u)", reasons[v], v); 590178359Ssam else 591178359Ssam snprintf(b, bs, "%u", v); 592178359Ssam} 593178359Ssam 594178359Ssamvoid 595178359Ssamsetstatus(char b[], size_t bs, int v) 596178359Ssam{ 597178359Ssam static const char *status[] = { 598178359Ssam [IEEE80211_STATUS_SUCCESS] = "success", 599178359Ssam [IEEE80211_STATUS_UNSPECIFIED] = "unspecified", 600178359Ssam [IEEE80211_STATUS_CAPINFO] = "capinfo", 601178359Ssam [IEEE80211_STATUS_NOT_ASSOCED] = "not assoced", 602178359Ssam [IEEE80211_STATUS_OTHER] = "other", 603178359Ssam [IEEE80211_STATUS_ALG] = "algorithm", 604178359Ssam [IEEE80211_STATUS_SEQUENCE] = "sequence", 605178359Ssam [IEEE80211_STATUS_CHALLENGE] = "challenge", 606178359Ssam [IEEE80211_STATUS_TIMEOUT] = "timeout", 607178359Ssam [IEEE80211_STATUS_TOOMANY] = "toomany", 608178359Ssam [IEEE80211_STATUS_BASIC_RATE] = "basic rate", 609178359Ssam [IEEE80211_STATUS_SP_REQUIRED] = "sp required", 610178359Ssam [IEEE80211_STATUS_PBCC_REQUIRED] = "pbcc required", 611178359Ssam [IEEE80211_STATUS_CA_REQUIRED] = "ca required", 612178359Ssam [IEEE80211_STATUS_SPECMGMT_REQUIRED] = "specmgmt required", 613178359Ssam [IEEE80211_STATUS_PWRCAP_REQUIRED] = "pwrcap required", 614178359Ssam [IEEE80211_STATUS_SUPCHAN_REQUIRED] = "supchan required", 615178359Ssam [IEEE80211_STATUS_SHORTSLOT_REQUIRED] = "shortslot required", 616178359Ssam [IEEE80211_STATUS_DSSSOFDM_REQUIRED] = "dsssofdm required", 617178359Ssam [IEEE80211_STATUS_INVALID_IE] = "invalid ie", 618178359Ssam [IEEE80211_STATUS_GROUP_CIPHER_INVALID] = "group cipher invalid", 619178359Ssam [IEEE80211_STATUS_PAIRWISE_CIPHER_INVALID]= "pairwise cipher invalid", 620178359Ssam [IEEE80211_STATUS_AKMP_INVALID] = "akmp invalid", 621178359Ssam [IEEE80211_STATUS_UNSUPP_RSN_IE_VERSION]= "unsupported rsn ie version", 622178359Ssam [IEEE80211_STATUS_INVALID_RSN_IE_CAP] = "invalid rsn ie cap", 623178359Ssam [IEEE80211_STATUS_CIPHER_SUITE_REJECTED]= "cipher suite rejected", 624178359Ssam }; 625287297Srodrigc if (v < nitems(status) && status[v] != NULL) 626178359Ssam snprintf(b, bs, "%s (%u)", status[v], v); 627178359Ssam else 628178359Ssam snprintf(b, bs, "%u", v); 629178359Ssam} 630178359Ssam 631161200Ssamstatic int 632161200Ssamwlan_getinfo(struct wlanstatfoo_p *wf, int s, char b[], size_t bs) 633161200Ssam{ 634161200Ssam const struct ieee80211req_sta_info *si = &wf->u_info.info.info[0]; 635161200Ssam 636161200Ssam switch (s) { 637161200Ssam case S_RATE: 638297607Sadrian snprintf(b, bs, "%.1fM", (float) si->isi_txmbps/2.0); 639161200Ssam return 1; 640161200Ssam case S_RSSI: 641297607Sadrian snprintf(b, bs, "%.1f", (float) si->isi_rssi/2.0); 642161200Ssam return 1; 643161200Ssam case S_NOISE: 644161200Ssam snprintf(b, bs, "%d", si->isi_noise); 645161200Ssam return 1; 646161200Ssam case S_SIGNAL: 647297607Sadrian snprintf(b, bs, "%.1f", (float) si->isi_rssi/2.0 648297607Sadrian + (float) si->isi_noise); 649161200Ssam return 1; 650178359Ssam case S_RX_AUTH_FAIL_CODE: 651178359Ssam if (wf->cur.is_rx_authfail_code == 0) 652178359Ssam break; 653178359Ssam setstatus(b, bs, wf->cur.is_rx_authfail_code); 654178359Ssam return 1; 655178359Ssam case S_RX_DEAUTH_CODE: 656178359Ssam if (wf->cur.is_rx_deauth_code == 0) 657178359Ssam break; 658178359Ssam setreason(b, bs, wf->cur.is_rx_deauth_code); 659178359Ssam return 1; 660178359Ssam case S_RX_DISASSOC_CODE: 661178359Ssam if (wf->cur.is_rx_disassoc_code == 0) 662178359Ssam break; 663178359Ssam setreason(b, bs, wf->cur.is_rx_disassoc_code); 664178359Ssam return 1; 665153317Ssam } 666161200Ssam b[0] = '\0'; 667161200Ssam return 0; 668161200Ssam} 669161200Ssam 670161200Ssamstatic int 671262824Sadrianwlan_get_curstat(struct bsdstat *sf, int s, char b[], size_t bs) 672161200Ssam{ 673161200Ssam struct wlanstatfoo_p *wf = (struct wlanstatfoo_p *) sf; 674161200Ssam#define STAT(x) \ 675161200Ssam snprintf(b, bs, "%u", wf->cur.is_##x - wf->total.is_##x); return 1 676161200Ssam#define NSTAT(x) \ 677161200Ssam snprintf(b, bs, "%u", \ 678161200Ssam wf->ncur.is_stats.ns_##x - wf->ntotal.is_stats.ns_##x); \ 679161200Ssam return 1 680161200Ssam 681161200Ssam switch (s) { 682161200Ssam case S_RX_BADVERSION: STAT(rx_badversion); 683161200Ssam case S_RX_TOOSHORT: STAT(rx_tooshort); 684161200Ssam case S_RX_WRONGBSS: STAT(rx_wrongbss); 685161200Ssam case S_RX_DUP: STAT(rx_dup); 686161200Ssam case S_RX_WRONGDIR: STAT(rx_wrongdir); 687161200Ssam case S_RX_MCASTECHO: STAT(rx_mcastecho); 688161200Ssam case S_RX_NOTASSOC: STAT(rx_notassoc); 689161200Ssam case S_RX_NOPRIVACY: STAT(rx_noprivacy); 690161200Ssam case S_RX_UNENCRYPTED: STAT(rx_unencrypted); 691161200Ssam case S_RX_WEPFAIL: STAT(rx_wepfail); 692161200Ssam case S_RX_DECAP: STAT(rx_decap); 693161200Ssam case S_RX_MGTDISCARD: STAT(rx_mgtdiscard); 694161200Ssam case S_RX_CTL: STAT(rx_ctl); 695161200Ssam case S_RX_BEACON: STAT(rx_beacon); 696161200Ssam case S_RX_RSTOOBIG: STAT(rx_rstoobig); 697161200Ssam case S_RX_ELEM_MISSING: STAT(rx_elem_missing); 698161200Ssam case S_RX_ELEM_TOOBIG: STAT(rx_elem_toobig); 699161200Ssam case S_RX_ELEM_TOOSMALL: STAT(rx_elem_toosmall); 700161200Ssam case S_RX_ELEM_UNKNOWN: STAT(rx_elem_unknown); 701161200Ssam case S_RX_BADCHAN: STAT(rx_badchan); 702161200Ssam case S_RX_CHANMISMATCH: STAT(rx_chanmismatch); 703161200Ssam case S_RX_NODEALLOC: STAT(rx_nodealloc); 704161200Ssam case S_RX_SSIDMISMATCH: STAT(rx_ssidmismatch); 705161200Ssam case S_RX_AUTH_UNSUPPORTED: STAT(rx_auth_unsupported); 706161200Ssam case S_RX_AUTH_FAIL: STAT(rx_auth_fail); 707161200Ssam case S_RX_AUTH_COUNTERMEASURES: STAT(rx_auth_countermeasures); 708161200Ssam case S_RX_ASSOC_BSS: STAT(rx_assoc_bss); 709161200Ssam case S_RX_ASSOC_NOTAUTH: STAT(rx_assoc_notauth); 710161200Ssam case S_RX_ASSOC_CAPMISMATCH: STAT(rx_assoc_capmismatch); 711161200Ssam case S_RX_ASSOC_NORATE: STAT(rx_assoc_norate); 712161200Ssam case S_RX_ASSOC_BADWPAIE: STAT(rx_assoc_badwpaie); 713161200Ssam case S_RX_DEAUTH: STAT(rx_deauth); 714161200Ssam case S_RX_DISASSOC: STAT(rx_disassoc); 715178359Ssam case S_BMISS: STAT(beacon_miss); 716161200Ssam case S_RX_BADSUBTYPE: STAT(rx_badsubtype); 717161200Ssam case S_RX_NOBUF: STAT(rx_nobuf); 718161200Ssam case S_RX_DECRYPTCRC: STAT(rx_decryptcrc); 719161200Ssam case S_RX_AHDEMO_MGT: STAT(rx_ahdemo_mgt); 720161200Ssam case S_RX_BAD_AUTH: STAT(rx_bad_auth); 721161200Ssam case S_RX_UNAUTH: STAT(rx_unauth); 722161200Ssam case S_RX_BADKEYID: STAT(rx_badkeyid); 723161200Ssam case S_RX_CCMPREPLAY: STAT(rx_ccmpreplay); 724161200Ssam case S_RX_CCMPFORMAT: STAT(rx_ccmpformat); 725161200Ssam case S_RX_CCMPMIC: STAT(rx_ccmpmic); 726161200Ssam case S_RX_TKIPREPLAY: STAT(rx_tkipreplay); 727161200Ssam case S_RX_TKIPFORMAT: STAT(rx_tkipformat); 728161200Ssam case S_RX_TKIPMIC: STAT(rx_tkipmic); 729161200Ssam case S_RX_TKIPICV: STAT(rx_tkipicv); 730161200Ssam case S_RX_BADCIPHER: STAT(rx_badcipher); 731161200Ssam case S_RX_NOCIPHERCTX: STAT(rx_nocipherctx); 732161200Ssam case S_RX_ACL: STAT(rx_acl); 733161200Ssam case S_TX_NOBUF: STAT(tx_nobuf); 734161200Ssam case S_TX_NONODE: STAT(tx_nonode); 735161200Ssam case S_TX_UNKNOWNMGT: STAT(tx_unknownmgt); 736161200Ssam case S_TX_BADCIPHER: STAT(tx_badcipher); 737161200Ssam case S_TX_NODEFKEY: STAT(tx_nodefkey); 738161200Ssam case S_TX_NOHEADROOM: STAT(tx_noheadroom); 739161200Ssam case S_TX_FRAGFRAMES: STAT(tx_fragframes); 740161200Ssam case S_TX_FRAGS: STAT(tx_frags); 741161200Ssam case S_SCAN_ACTIVE: STAT(scan_active); 742161200Ssam case S_SCAN_PASSIVE: STAT(scan_passive); 743178359Ssam case S_SCAN_BG: STAT(scan_bg); 744161200Ssam case S_NODE_TIMEOUT: STAT(node_timeout); 745161200Ssam case S_CRYPTO_NOMEM: STAT(crypto_nomem); 746161200Ssam case S_CRYPTO_TKIP: STAT(crypto_tkip); 747161200Ssam case S_CRYPTO_TKIPENMIC: STAT(crypto_tkipenmic); 748161200Ssam case S_CRYPTO_TKIPDEMIC: STAT(crypto_tkipdemic); 749161200Ssam case S_CRYPTO_TKIPCM: STAT(crypto_tkipcm); 750161200Ssam case S_CRYPTO_CCMP: STAT(crypto_ccmp); 751161200Ssam case S_CRYPTO_WEP: STAT(crypto_wep); 752161200Ssam case S_CRYPTO_SETKEY_CIPHER: STAT(crypto_setkey_cipher); 753161200Ssam case S_CRYPTO_SETKEY_NOKEY: STAT(crypto_setkey_nokey); 754161200Ssam case S_CRYPTO_DELKEY: STAT(crypto_delkey); 755161200Ssam case S_CRYPTO_BADCIPHER: STAT(crypto_badcipher); 756161200Ssam case S_CRYPTO_NOCIPHER: STAT(crypto_nocipher); 757161200Ssam case S_CRYPTO_ATTACHFAIL: STAT(crypto_attachfail); 758161200Ssam case S_CRYPTO_SWFALLBACK: STAT(crypto_swfallback); 759161200Ssam case S_CRYPTO_KEYFAIL: STAT(crypto_keyfail); 760161200Ssam case S_CRYPTO_ENMICFAIL: STAT(crypto_enmicfail); 761161200Ssam case S_IBSS_CAPMISMATCH: STAT(ibss_capmismatch); 762161200Ssam case S_IBSS_NORATE: STAT(ibss_norate); 763161200Ssam case S_PS_UNASSOC: STAT(ps_unassoc); 764161200Ssam case S_PS_BADAID: STAT(ps_badaid); 765161200Ssam case S_PS_QEMPTY: STAT(ps_qempty); 766161200Ssam case S_FF_BADHDR: STAT(ff_badhdr); 767161200Ssam case S_FF_TOOSHORT: STAT(ff_tooshort); 768161200Ssam case S_FF_SPLIT: STAT(ff_split); 769161200Ssam case S_FF_DECAP: STAT(ff_decap); 770161200Ssam case S_FF_ENCAP: STAT(ff_encap); 771297563Sadrian case S_FF_ENCAPFAIL: STAT(ff_encapfail); 772161200Ssam case S_RX_BADBINTVAL: STAT(rx_badbintval); 773161200Ssam case S_RX_MGMT: STAT(rx_mgmt); 774161200Ssam case S_RX_DEMICFAIL: STAT(rx_demicfail); 775161200Ssam case S_RX_DEFRAG: STAT(rx_defrag); 776170535Ssam case S_RX_ACTION: STAT(rx_action); 777170535Ssam case S_AMSDU_TOOSHORT: STAT(amsdu_tooshort); 778170535Ssam case S_AMSDU_SPLIT: STAT(amsdu_split); 779170535Ssam case S_AMSDU_DECAP: STAT(amsdu_decap); 780170535Ssam case S_AMSDU_ENCAP: STAT(amsdu_encap); 781173306Ssam case S_AMPDU_REORDER: STAT(ampdu_rx_reorder); 782170535Ssam case S_AMPDU_FLUSH: STAT(ampdu_rx_flush); 783170535Ssam case S_AMPDU_BARBAD: STAT(ampdu_bar_bad); 784170535Ssam case S_AMPDU_BAROOW: STAT(ampdu_bar_oow); 785173306Ssam case S_AMPDU_BARMOVE: STAT(ampdu_bar_move); 786170535Ssam case S_AMPDU_BAR: STAT(ampdu_bar_rx); 787173306Ssam case S_AMPDU_MOVE: STAT(ampdu_rx_move); 788170535Ssam case S_AMPDU_OOR: STAT(ampdu_rx_oor); 789170535Ssam case S_AMPDU_COPY: STAT(ampdu_rx_copy); 790173306Ssam case S_AMPDU_DROP: STAT(ampdu_rx_drop); 791173306Ssam case S_AMPDU_AGE: STAT(ampdu_rx_age); 792173306Ssam case S_AMPDU_STOP: STAT(ampdu_stop); 793173306Ssam case S_AMPDU_STOP_FAILED:STAT(ampdu_stop_failed); 794173306Ssam case S_ADDBA_REJECT: STAT(addba_reject); 795173306Ssam case S_ADDBA_NOREQUEST: STAT(addba_norequest); 796173306Ssam case S_ADDBA_BADTOKEN: STAT(addba_badtoken); 797173306Ssam case S_TX_BADSTATE: STAT(tx_badstate); 798173306Ssam case S_TX_NOTASSOC: STAT(tx_notassoc); 799173306Ssam case S_TX_CLASSIFY: STAT(tx_classify); 800178359Ssam case S_DWDS_MCAST: STAT(dwds_mcast); 801178359Ssam case S_DWDS_QDROP: STAT(dwds_qdrop); 802173306Ssam case S_HT_ASSOC_NOHTCAP:STAT(ht_assoc_nohtcap); 803173306Ssam case S_HT_ASSOC_DOWNGRADE:STAT(ht_assoc_downgrade); 804173306Ssam case S_HT_ASSOC_NORATE: STAT(ht_assoc_norate); 805195618Srpaulo case S_MESH_WRONGMESH: STAT(mesh_wrongmesh); 806195618Srpaulo case S_MESH_NOLINK: STAT(mesh_nolink); 807195618Srpaulo case S_MESH_FWD_TTL: STAT(mesh_fwd_ttl); 808195618Srpaulo case S_MESH_FWD_NOBUF: STAT(mesh_fwd_nobuf); 809195618Srpaulo case S_MESH_FWD_TOOSHORT: STAT(mesh_fwd_tooshort); 810195618Srpaulo case S_MESH_FWD_DISABLED: STAT(mesh_fwd_disabled); 811195618Srpaulo case S_MESH_FWD_NOPATH: STAT(mesh_fwd_nopath); 812195618Srpaulo case S_HWMP_WRONGSEQ: STAT(hwmp_wrongseq); 813195618Srpaulo case S_HWMP_ROOTREQS: STAT(hwmp_rootreqs); 814195618Srpaulo case S_HWMP_ROOTANN: STAT(hwmp_rootrann); 815195811Ssam case S_MESH_BADAE: STAT(mesh_badae); 816195811Ssam case S_MESH_RTADDFAILED:STAT(mesh_rtaddfailed); 817195811Ssam case S_MESH_NOTPROXY: STAT(mesh_notproxy); 818195811Ssam case S_RX_BADALIGN: STAT(rx_badalign); 819161200Ssam case S_INPUT: NSTAT(rx_data); 820161200Ssam case S_OUTPUT: NSTAT(tx_data); 821161200Ssam case S_RX_UCAST: NSTAT(rx_ucast); 822161200Ssam case S_RX_MCAST: NSTAT(rx_mcast); 823161200Ssam case S_TX_UCAST: NSTAT(tx_ucast); 824161200Ssam case S_TX_MCAST: NSTAT(tx_mcast); 825232245Sadrian case S_BEACON_BAD: STAT(beacon_bad); 826234019Sadrian case S_AMPDU_BARTX: STAT(ampdu_bar_tx); 827234019Sadrian case S_AMPDU_BARTX_RETRY: STAT(ampdu_bar_tx_retry); 828234019Sadrian case S_AMPDU_BARTX_FAIL: STAT(ampdu_bar_tx_fail); 829153317Ssam } 830161200Ssam return wlan_getinfo(wf, s, b, bs); 831161200Ssam#undef NSTAT 832161200Ssam#undef STAT 833153317Ssam} 834161200Ssam 835161200Ssamstatic int 836262824Sadrianwlan_get_totstat(struct bsdstat *sf, int s, char b[], size_t bs) 837161200Ssam{ 838161200Ssam struct wlanstatfoo_p *wf = (struct wlanstatfoo_p *) sf; 839161200Ssam#define STAT(x) \ 840161200Ssam snprintf(b, bs, "%u", wf->total.is_##x); return 1 841161200Ssam#define NSTAT(x) \ 842161200Ssam snprintf(b, bs, "%u", wf->ntotal.is_stats.ns_##x); return 1 843161200Ssam 844161200Ssam switch (s) { 845161200Ssam case S_RX_BADVERSION: STAT(rx_badversion); 846161200Ssam case S_RX_TOOSHORT: STAT(rx_tooshort); 847161200Ssam case S_RX_WRONGBSS: STAT(rx_wrongbss); 848161200Ssam case S_RX_DUP: STAT(rx_dup); 849161200Ssam case S_RX_WRONGDIR: STAT(rx_wrongdir); 850161200Ssam case S_RX_MCASTECHO: STAT(rx_mcastecho); 851161200Ssam case S_RX_NOTASSOC: STAT(rx_notassoc); 852161200Ssam case S_RX_NOPRIVACY: STAT(rx_noprivacy); 853161200Ssam case S_RX_UNENCRYPTED: STAT(rx_unencrypted); 854161200Ssam case S_RX_WEPFAIL: STAT(rx_wepfail); 855161200Ssam case S_RX_DECAP: STAT(rx_decap); 856161200Ssam case S_RX_MGTDISCARD: STAT(rx_mgtdiscard); 857161200Ssam case S_RX_CTL: STAT(rx_ctl); 858161200Ssam case S_RX_BEACON: STAT(rx_beacon); 859161200Ssam case S_RX_RSTOOBIG: STAT(rx_rstoobig); 860161200Ssam case S_RX_ELEM_MISSING: STAT(rx_elem_missing); 861161200Ssam case S_RX_ELEM_TOOBIG: STAT(rx_elem_toobig); 862161200Ssam case S_RX_ELEM_TOOSMALL: STAT(rx_elem_toosmall); 863161200Ssam case S_RX_ELEM_UNKNOWN: STAT(rx_elem_unknown); 864161200Ssam case S_RX_BADCHAN: STAT(rx_badchan); 865161200Ssam case S_RX_CHANMISMATCH: STAT(rx_chanmismatch); 866161200Ssam case S_RX_NODEALLOC: STAT(rx_nodealloc); 867161200Ssam case S_RX_SSIDMISMATCH: STAT(rx_ssidmismatch); 868161200Ssam case S_RX_AUTH_UNSUPPORTED: STAT(rx_auth_unsupported); 869161200Ssam case S_RX_AUTH_FAIL: STAT(rx_auth_fail); 870161200Ssam case S_RX_AUTH_COUNTERMEASURES: STAT(rx_auth_countermeasures); 871161200Ssam case S_RX_ASSOC_BSS: STAT(rx_assoc_bss); 872161200Ssam case S_RX_ASSOC_NOTAUTH: STAT(rx_assoc_notauth); 873161200Ssam case S_RX_ASSOC_CAPMISMATCH: STAT(rx_assoc_capmismatch); 874161200Ssam case S_RX_ASSOC_NORATE: STAT(rx_assoc_norate); 875161200Ssam case S_RX_ASSOC_BADWPAIE: STAT(rx_assoc_badwpaie); 876161200Ssam case S_RX_DEAUTH: STAT(rx_deauth); 877161200Ssam case S_RX_DISASSOC: STAT(rx_disassoc); 878178359Ssam case S_BMISS: STAT(beacon_miss); 879161200Ssam case S_RX_BADSUBTYPE: STAT(rx_badsubtype); 880161200Ssam case S_RX_NOBUF: STAT(rx_nobuf); 881161200Ssam case S_RX_DECRYPTCRC: STAT(rx_decryptcrc); 882161200Ssam case S_RX_AHDEMO_MGT: STAT(rx_ahdemo_mgt); 883161200Ssam case S_RX_BAD_AUTH: STAT(rx_bad_auth); 884161200Ssam case S_RX_UNAUTH: STAT(rx_unauth); 885161200Ssam case S_RX_BADKEYID: STAT(rx_badkeyid); 886161200Ssam case S_RX_CCMPREPLAY: STAT(rx_ccmpreplay); 887161200Ssam case S_RX_CCMPFORMAT: STAT(rx_ccmpformat); 888161200Ssam case S_RX_CCMPMIC: STAT(rx_ccmpmic); 889161200Ssam case S_RX_TKIPREPLAY: STAT(rx_tkipreplay); 890161200Ssam case S_RX_TKIPFORMAT: STAT(rx_tkipformat); 891161200Ssam case S_RX_TKIPMIC: STAT(rx_tkipmic); 892161200Ssam case S_RX_TKIPICV: STAT(rx_tkipicv); 893161200Ssam case S_RX_BADCIPHER: STAT(rx_badcipher); 894161200Ssam case S_RX_NOCIPHERCTX: STAT(rx_nocipherctx); 895161200Ssam case S_RX_ACL: STAT(rx_acl); 896161200Ssam case S_TX_NOBUF: STAT(tx_nobuf); 897161200Ssam case S_TX_NONODE: STAT(tx_nonode); 898161200Ssam case S_TX_UNKNOWNMGT: STAT(tx_unknownmgt); 899161200Ssam case S_TX_BADCIPHER: STAT(tx_badcipher); 900161200Ssam case S_TX_NODEFKEY: STAT(tx_nodefkey); 901161200Ssam case S_TX_NOHEADROOM: STAT(tx_noheadroom); 902161200Ssam case S_TX_FRAGFRAMES: STAT(tx_fragframes); 903161200Ssam case S_TX_FRAGS: STAT(tx_frags); 904161200Ssam case S_SCAN_ACTIVE: STAT(scan_active); 905161200Ssam case S_SCAN_PASSIVE: STAT(scan_passive); 906178359Ssam case S_SCAN_BG: STAT(scan_bg); 907161200Ssam case S_NODE_TIMEOUT: STAT(node_timeout); 908161200Ssam case S_CRYPTO_NOMEM: STAT(crypto_nomem); 909161200Ssam case S_CRYPTO_TKIP: STAT(crypto_tkip); 910161200Ssam case S_CRYPTO_TKIPENMIC: STAT(crypto_tkipenmic); 911161200Ssam case S_CRYPTO_TKIPDEMIC: STAT(crypto_tkipdemic); 912161200Ssam case S_CRYPTO_TKIPCM: STAT(crypto_tkipcm); 913161200Ssam case S_CRYPTO_CCMP: STAT(crypto_ccmp); 914161200Ssam case S_CRYPTO_WEP: STAT(crypto_wep); 915161200Ssam case S_CRYPTO_SETKEY_CIPHER: STAT(crypto_setkey_cipher); 916161200Ssam case S_CRYPTO_SETKEY_NOKEY: STAT(crypto_setkey_nokey); 917161200Ssam case S_CRYPTO_DELKEY: STAT(crypto_delkey); 918161200Ssam case S_CRYPTO_BADCIPHER: STAT(crypto_badcipher); 919161200Ssam case S_CRYPTO_NOCIPHER: STAT(crypto_nocipher); 920161200Ssam case S_CRYPTO_ATTACHFAIL: STAT(crypto_attachfail); 921161200Ssam case S_CRYPTO_SWFALLBACK: STAT(crypto_swfallback); 922161200Ssam case S_CRYPTO_KEYFAIL: STAT(crypto_keyfail); 923161200Ssam case S_CRYPTO_ENMICFAIL: STAT(crypto_enmicfail); 924161200Ssam case S_IBSS_CAPMISMATCH: STAT(ibss_capmismatch); 925161200Ssam case S_IBSS_NORATE: STAT(ibss_norate); 926161200Ssam case S_PS_UNASSOC: STAT(ps_unassoc); 927161200Ssam case S_PS_BADAID: STAT(ps_badaid); 928161200Ssam case S_PS_QEMPTY: STAT(ps_qempty); 929161200Ssam case S_FF_BADHDR: STAT(ff_badhdr); 930161200Ssam case S_FF_TOOSHORT: STAT(ff_tooshort); 931161200Ssam case S_FF_SPLIT: STAT(ff_split); 932161200Ssam case S_FF_DECAP: STAT(ff_decap); 933161200Ssam case S_FF_ENCAP: STAT(ff_encap); 934297563Sadrian case S_FF_ENCAPFAIL: STAT(ff_encapfail); 935161200Ssam case S_RX_BADBINTVAL: STAT(rx_badbintval); 936161200Ssam case S_RX_MGMT: STAT(rx_mgmt); 937161200Ssam case S_RX_DEMICFAIL: STAT(rx_demicfail); 938161200Ssam case S_RX_DEFRAG: STAT(rx_defrag); 939170535Ssam case S_RX_ACTION: STAT(rx_action); 940170535Ssam case S_AMSDU_TOOSHORT: STAT(amsdu_tooshort); 941170535Ssam case S_AMSDU_SPLIT: STAT(amsdu_split); 942170535Ssam case S_AMSDU_DECAP: STAT(amsdu_decap); 943170535Ssam case S_AMSDU_ENCAP: STAT(amsdu_encap); 944173306Ssam case S_AMPDU_REORDER: STAT(ampdu_rx_reorder); 945170535Ssam case S_AMPDU_FLUSH: STAT(ampdu_rx_flush); 946170535Ssam case S_AMPDU_BARBAD: STAT(ampdu_bar_bad); 947170535Ssam case S_AMPDU_BAROOW: STAT(ampdu_bar_oow); 948173306Ssam case S_AMPDU_BARMOVE: STAT(ampdu_bar_move); 949170535Ssam case S_AMPDU_BAR: STAT(ampdu_bar_rx); 950173306Ssam case S_AMPDU_MOVE: STAT(ampdu_rx_move); 951170535Ssam case S_AMPDU_OOR: STAT(ampdu_rx_oor); 952170535Ssam case S_AMPDU_COPY: STAT(ampdu_rx_copy); 953173306Ssam case S_AMPDU_DROP: STAT(ampdu_rx_drop); 954173306Ssam case S_AMPDU_AGE: STAT(ampdu_rx_age); 955173306Ssam case S_AMPDU_STOP: STAT(ampdu_stop); 956173306Ssam case S_AMPDU_STOP_FAILED:STAT(ampdu_stop_failed); 957173306Ssam case S_ADDBA_REJECT: STAT(addba_reject); 958173306Ssam case S_ADDBA_NOREQUEST: STAT(addba_norequest); 959173306Ssam case S_ADDBA_BADTOKEN: STAT(addba_badtoken); 960173306Ssam case S_TX_BADSTATE: STAT(tx_badstate); 961173306Ssam case S_TX_NOTASSOC: STAT(tx_notassoc); 962173306Ssam case S_TX_CLASSIFY: STAT(tx_classify); 963178359Ssam case S_DWDS_MCAST: STAT(dwds_mcast); 964178359Ssam case S_DWDS_QDROP: STAT(dwds_qdrop); 965173306Ssam case S_HT_ASSOC_NOHTCAP:STAT(ht_assoc_nohtcap); 966173306Ssam case S_HT_ASSOC_DOWNGRADE:STAT(ht_assoc_downgrade); 967173306Ssam case S_HT_ASSOC_NORATE: STAT(ht_assoc_norate); 968195618Srpaulo case S_MESH_WRONGMESH: STAT(mesh_wrongmesh); 969195618Srpaulo case S_MESH_NOLINK: STAT(mesh_nolink); 970195618Srpaulo case S_MESH_FWD_TTL: STAT(mesh_fwd_ttl); 971195618Srpaulo case S_MESH_FWD_NOBUF: STAT(mesh_fwd_nobuf); 972195618Srpaulo case S_MESH_FWD_TOOSHORT: STAT(mesh_fwd_tooshort); 973195618Srpaulo case S_MESH_FWD_DISABLED: STAT(mesh_fwd_disabled); 974195618Srpaulo case S_MESH_FWD_NOPATH: STAT(mesh_fwd_nopath); 975195618Srpaulo case S_HWMP_WRONGSEQ: STAT(hwmp_wrongseq); 976195618Srpaulo case S_HWMP_ROOTREQS: STAT(hwmp_rootreqs); 977195618Srpaulo case S_HWMP_ROOTANN: STAT(hwmp_rootrann); 978195811Ssam case S_MESH_BADAE: STAT(mesh_badae); 979195811Ssam case S_MESH_RTADDFAILED:STAT(mesh_rtaddfailed); 980195811Ssam case S_MESH_NOTPROXY: STAT(mesh_notproxy); 981195811Ssam case S_RX_BADALIGN: STAT(rx_badalign); 982161200Ssam case S_INPUT: NSTAT(rx_data); 983161200Ssam case S_OUTPUT: NSTAT(tx_data); 984161200Ssam case S_RX_UCAST: NSTAT(rx_ucast); 985161200Ssam case S_RX_MCAST: NSTAT(rx_mcast); 986161200Ssam case S_TX_UCAST: NSTAT(tx_ucast); 987161200Ssam case S_TX_MCAST: NSTAT(tx_mcast); 988232245Sadrian case S_BEACON_BAD: STAT(beacon_bad); 989234019Sadrian case S_AMPDU_BARTX: STAT(ampdu_bar_tx); 990234019Sadrian case S_AMPDU_BARTX_RETRY: STAT(ampdu_bar_tx_retry); 991234019Sadrian case S_AMPDU_BARTX_FAIL: STAT(ampdu_bar_tx_fail); 992161200Ssam } 993161200Ssam return wlan_getinfo(wf, s, b, bs); 994161200Ssam#undef NSTAT 995161200Ssam#undef STAT 996161200Ssam} 997161200Ssam 998262824SadrianBSDSTAT_DEFINE_BOUNCE(wlanstatfoo) 999161200Ssam 1000161200Ssamstruct wlanstatfoo * 1001161200Ssamwlanstats_new(const char *ifname, const char *fmtstring) 1002161200Ssam{ 1003161200Ssam struct wlanstatfoo_p *wf; 1004161200Ssam 1005161200Ssam wf = calloc(1, sizeof(struct wlanstatfoo_p)); 1006161200Ssam if (wf != NULL) { 1007287297Srodrigc bsdstat_init(&wf->base.base, "wlanstats", wlanstats, 1008287297Srodrigc nitems(wlanstats)); 1009161200Ssam /* override base methods */ 1010161200Ssam wf->base.base.collect_cur = wlan_collect_cur; 1011161200Ssam wf->base.base.collect_tot = wlan_collect_tot; 1012161200Ssam wf->base.base.get_curstat = wlan_get_curstat; 1013161200Ssam wf->base.base.get_totstat = wlan_get_totstat; 1014161200Ssam wf->base.base.update_tot = wlan_update_tot; 1015161200Ssam 1016161200Ssam /* setup bounce functions for public methods */ 1017262824Sadrian BSDSTAT_BOUNCE(wf, wlanstatfoo); 1018161200Ssam 1019161200Ssam /* setup our public methods */ 1020161200Ssam wf->base.setifname = wlan_setifname; 1021161200Ssam wf->base.getifname = wlan_getifname; 1022161200Ssam wf->base.getopmode = wlan_getopmode; 1023161200Ssam wf->base.setstamac = wlan_setstamac; 1024161200Ssam wf->opmode = -1; 1025161200Ssam 1026161200Ssam wf->s = socket(AF_INET, SOCK_DGRAM, 0); 1027161200Ssam if (wf->s < 0) 1028161200Ssam err(1, "socket"); 1029161200Ssam 1030161200Ssam wlan_setifname(&wf->base, ifname); 1031161200Ssam wf->base.setfmt(&wf->base, fmtstring); 1032161200Ssam } 1033161200Ssam return &wf->base; 1034161200Ssam} 1035