Changeset 2389539 in rtems-libbsd


Ignore:
Timestamp:
Nov 16, 2016, 2:02:20 PM (3 years ago)
Author:
Christian Mauderer <Christian.Mauderer@…>
Branches:
fd86c091b97759106da7355ce1dd81ebe030e285, f020f08430150c1656a0ad0a1de13699db9b980b
Children:
5c3223f
Parents:
59338de
git-author:
Christian Mauderer <Christian.Mauderer@…> (11/16/16 14:02:20)
git-committer:
Christian Mauderer <Christian.Mauderer@…> (01/17/17 11:50:57)
Message:

ifconfig/wlan, expat, lib80211: Import from FreeBSD.

Location:
freebsd
Files:
20 added
1 edited
1 moved

Legend:

Unmodified
Added
Removed
  • freebsd/lib/lib80211/lib80211_regdomain.h

    r59338de r2389539  
    2525 * $FreeBSD$
    2626 */
    27 #ifndef _LIB80211_H_
    28 #define _LIB80211_H_
     27#ifndef _LIB80211_REGDOMAIN_H_
     28#define _LIB80211_REGDOMAIN_H_
    2929
    3030#include <sys/cdefs.h>
     
    7676        netband_head     bands_11ng;/* 11ng operation */
    7777        netband_head     bands_11na;/* 11na operation */
     78        netband_head     bands_11ac;/* 11ac 5GHz operation */
     79        netband_head     bands_11acg;/* 11ac 2GHz operation */
    7880
    7981        LIST_ENTRY(regdomain)   next;
     
    119121__END_DECLS
    120122
    121 #endif /* _LIB80211_H_ */
     123#endif /* _LIB80211_REGDOMAIN_H_ */
  • freebsd/sbin/ifconfig/ifieee80211.c

    r59338de r2389539  
    11#include <machine/rtems-bsd-user-space.h>
    2 
    3 #ifdef __rtems__
    4 #include "rtems-bsd-ifconfig-namespace.h"
    5 #endif /* __rtems__ */
    62
    73/*
     
    5046 *    notice, this list of conditions and the following disclaimer in the
    5147 *    documentation and/or other materials provided with the distribution.
    52  * 3. All advertising materials mentioning features or use of this software
    53  *    must display the following acknowledgement:
    54  *      This product includes software developed by the NetBSD
    55  *      Foundation, Inc. and its contributors.
    56  * 4. Neither the name of The NetBSD Foundation nor the names of its
    57  *    contributors may be used to endorse or promote products derived
    58  *    from this software without specific prior written permission.
    5948 *
    6049 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     
    7160 */
    7261
    73 #ifdef __rtems__
    74 #include <machine/rtems-bsd-program.h>
    75 #endif /* __rtems__ */
    7662#include <rtems/bsd/sys/param.h>
    7763#include <sys/ioctl.h>
     
    10793
    10894#include "ifconfig.h"
    109 #include "regdomain.h"
    110 #ifdef __rtems__
    111 #include "rtems-bsd-ifconfig-ifieee80211-data.h"
    112 #endif /* __rtems__ */
     95
     96#include <lib80211/lib80211_regdomain.h>
     97#include <lib80211/lib80211_ioctl.h>
    11398
    11499#ifndef IEEE80211_FIXED_RATE_NONE
     
    137122#define IEEE80211_NODE_AMSDU_RX 0x040000        /* AMSDU rx enabled */
    138123#define IEEE80211_NODE_AMSDU_TX 0x080000        /* AMSDU tx enabled */
     124#define IEEE80211_NODE_VHT      0x100000        /* VHT enabled */
    139125#endif
    140126
     
    161147        [IEEE80211_MODE_11NG]     = "11ng",
    162148        [IEEE80211_MODE_HALF]     = "half",
    163         [IEEE80211_MODE_QUARTER]  = "quarter"
     149        [IEEE80211_MODE_QUARTER]  = "quarter",
     150        [IEEE80211_MODE_VHT_2GHZ] = "11acg",
     151        [IEEE80211_MODE_VHT_5GHZ] = "11ac",
    164152};
    165153
     
    201189}
    202190
     191/* VHT */
     192static int vhtconf = 0;
     193static  int gotvhtconf = 0;
     194
     195static void
     196getvhtconf(int s)
     197{
     198        if (gotvhtconf)
     199                return;
     200        if (get80211val(s, IEEE80211_IOC_VHTCONF, &vhtconf) < 0)
     201                warn("unable to get VHT configuration information");
     202        gotvhtconf = 1;
     203}
     204
    203205/*
    204206 * Collect channel info from the kernel.  We use this (mostly)
     
    218220        ifmr = ifmedia_getstate(s);
    219221        gethtconf(s);
    220 }
    221 
    222 #ifdef __rtems__
    223 static struct regdata *getregdata_rdp = NULL;
    224 #endif /* __rtems__ */
     222        getvhtconf(s);
     223}
     224
    225225static struct regdata *
    226226getregdata(void)
    227227{
    228 #ifndef __rtems__
    229228        static struct regdata *rdp = NULL;
    230 #else /* __rtems__ */
    231         struct regdata *rdp = getregdata_rdp;
    232 #endif /* __rtems__ */
    233229        if (rdp == NULL) {
    234230                rdp = lib80211_alloc_regdata();
    235 #ifdef __rtems__
    236                 getregdata_rdp = rdp;
    237 #endif /* __rtems__ */
    238231                if (rdp == NULL)
    239232                        errx(-1, "missing or corrupted regdomain database");
     
    253246{
    254247        const struct ieee80211_channel *fc = &chaninfo->ic_chans[i];
    255         int j;
     248        u_int j;
    256249
    257250        if ((fc->ic_flags & from) != from)
     
    282275 * channe list (e.g. mode 11a); we want to honor that to avoid
    283276 * confusing behaviour.
     277 */
     278/*
     279 * XXX VHT
    284280 */
    285281static int
     
    332328mapfreq(struct ieee80211_channel *chan, int freq, int flags)
    333329{
    334         int i;
     330        u_int i;
    335331
    336332        for (i = 0; i < chaninfo->ic_nchans; i++) {
     
    352348mapchan(struct ieee80211_channel *chan, int ieee, int flags)
    353349{
    354         int i;
     350        u_int i;
    355351
    356352        for (i = 0; i < chaninfo->ic_nchans; i++) {
     
    389385chan2mode(const struct ieee80211_channel *c)
    390386{
     387        if (IEEE80211_IS_CHAN_VHTA(c))
     388                return IEEE80211_MODE_VHT_5GHZ;
     389        if (IEEE80211_IS_CHAN_VHTG(c))
     390                return IEEE80211_MODE_VHT_2GHZ;
    391391        if (IEEE80211_IS_CHAN_HTA(c))
    392392                return IEEE80211_MODE_11NA;
     
    530530                printf("cryptocaps: 0x%x\n", dc->dc_cryptocaps);
    531531                printf("htcaps    : 0x%x\n", dc->dc_htcaps);
     532                printf("vhtcaps   : 0x%x\n", dc->dc_vhtcaps);
     533#if 0
    532534                memcpy(chaninfo, &dc->dc_chaninfo,
    533535                    IEEE80211_CHANINFO_SPACE(&dc->dc_chaninfo));
    534536                print_channels(s, &dc->dc_chaninfo, 1/*allchans*/, 1/*verbose*/);
     537#endif
    535538        }
    536539#endif
     
    644647        const char *cp;
    645648        int flags;
     649        int is_vht = 0;
    646650
    647651        flags = 0;
     
    664668                                flags |= IEEE80211_CHAN_G;
    665669                                break;
     670                        case 'v':               /* vht: 802.11ac */
     671                                is_vht = 1;
     672                                /* Fallthrough */
    666673                        case 'h':               /* ht = 802.11n */
    667674                        case 'n':               /* 802.11n */
     
    702709                        break;
    703710                case 40:
     711                case 80:
     712                case 160:
     713                        /* Handle the 80/160 VHT flag */
     714                        if (cw == 80)
     715                                flags |= IEEE80211_CHAN_VHT80;
     716                        else if (cw == 160)
     717                                flags |= IEEE80211_CHAN_VHT160;
     718
     719                        /* Fallthrough */
    704720                        if (ep != NULL && *ep == '+')
    705721                                flags |= IEEE80211_CHAN_HT40U;
     
    711727                }
    712728        }
     729
    713730        /*
    714731         * Cleanup specifications.
     
    723740                 */
    724741                flags &= ~IEEE80211_CHAN_HT;
     742                flags &= ~IEEE80211_CHAN_VHT;
    725743        } else {
    726744                /*
     
    742760                        flags |= (chan.ic_flags & IEEE80211_CHAN_HT);
    743761                }
     762
     763                /*
     764                 * If VHT is enabled, then also set the VHT flag and the
     765                 * relevant channel up/down.
     766                 */
     767                if (is_vht && (flags & IEEE80211_CHAN_HT)) {
     768                        /*
     769                         * XXX yes, maybe we should just have VHT, and reuse
     770                         * HT20/HT40U/HT40D
     771                         */
     772                        if (flags & IEEE80211_CHAN_VHT80)
     773                                ;
     774                        else if (flags & IEEE80211_CHAN_HT20)
     775                                flags |= IEEE80211_CHAN_VHT20;
     776                        else if (flags & IEEE80211_CHAN_HT40U)
     777                                flags |= IEEE80211_CHAN_VHT40U;
     778                        else if (flags & IEEE80211_CHAN_HT40D)
     779                                flags |= IEEE80211_CHAN_VHT40D;
     780                }
    744781        }
    745782        return flags;
     
    914951
    915952/*
    916  * This function is purely a NetBSD compatability interface.  The NetBSD
     953 * This function is purely a NetBSD compatibility interface.  The NetBSD
    917954 * interface is too inflexible, but it's there so we'll support it since
    918955 * it's not all that hard.
     
    13671404
    13681405static void
     1406set80211quiet(const char *val, int d, int s, const struct afswtch *rafp)
     1407{
     1408        set80211(s, IEEE80211_IOC_QUIET, d, 0, NULL);
     1409}
     1410
     1411static
     1412DECL_CMD_FUNC(set80211quietperiod, val, d)
     1413{
     1414        set80211(s, IEEE80211_IOC_QUIET_PERIOD, atoi(val), 0, NULL);
     1415}
     1416
     1417static
     1418DECL_CMD_FUNC(set80211quietcount, val, d)
     1419{
     1420        set80211(s, IEEE80211_IOC_QUIET_COUNT, atoi(val), 0, NULL);
     1421}
     1422
     1423static
     1424DECL_CMD_FUNC(set80211quietduration, val, d)
     1425{
     1426        set80211(s, IEEE80211_IOC_QUIET_DUR, atoi(val), 0, NULL);
     1427}
     1428
     1429static
     1430DECL_CMD_FUNC(set80211quietoffset, val, d)
     1431{
     1432        set80211(s, IEEE80211_IOC_QUIET_OFFSET, atoi(val), 0, NULL);
     1433}
     1434
     1435static void
    13691436set80211bgscan(const char *val, int d, int s, const struct afswtch *rafp)
    13701437{
     
    14441511                        case 'q':               /* 1/4-width channels */
    14451512                                flags |= IEEE80211_CHAN_QUARTER;
     1513                                break;
     1514                        case 'v':
     1515                                /* XXX set HT too? */
     1516                                flags |= IEEE80211_CHAN_VHT;
    14461517                                break;
    14471518                        default:
     
    16951766
    16961767        if (get80211val(s, IEEE80211_IOC_AMPDU, &ampdu) < 0)
    1697                 errx(-1, "cannot get AMPDU setting");
     1768                errx(-1, "cannot set AMPDU setting");
    16981769        if (d < 0) {
    16991770                d = -d;
     
    17021773                ampdu |= d;
    17031774        set80211(s, IEEE80211_IOC_AMPDU, ampdu, 0, NULL);
     1775}
     1776
     1777static void
     1778set80211stbc(const char *val, int d, int s, const struct afswtch *rafp)
     1779{
     1780        int stbc;
     1781
     1782        if (get80211val(s, IEEE80211_IOC_STBC, &stbc) < 0)
     1783                errx(-1, "cannot set STBC setting");
     1784        if (d < 0) {
     1785                d = -d;
     1786                stbc &= ~d;
     1787        } else
     1788                stbc |= d;
     1789        set80211(s, IEEE80211_IOC_STBC, stbc, 0, NULL);
    17041790}
    17051791
     
    18461932}
    18471933
     1934static void
     1935set80211vhtconf(const char *val, int d, int s, const struct afswtch *rafp)
     1936{
     1937        if (get80211val(s, IEEE80211_IOC_VHTCONF, &vhtconf) < 0)
     1938                errx(-1, "cannot set VHT setting");
     1939        printf("%s: vhtconf=0x%08x, d=%d\n", __func__, vhtconf, d);
     1940        if (d < 0) {
     1941                d = -d;
     1942                vhtconf &= ~d;
     1943        } else
     1944                vhtconf |= d;
     1945        printf("%s: vhtconf is now 0x%08x\n", __func__, vhtconf);
     1946        set80211(s, IEEE80211_IOC_VHTCONF, vhtconf, 0, NULL);
     1947}
     1948
    18481949static
    18491950DECL_CMD_FUNC(set80211tdmaslot, val, d)
     
    18791980DECL_CMD_FUNC(set80211meshforward, val, d)
    18801981{
    1881         set80211(s, IEEE80211_IOC_MESH_FWRD, atoi(val), 0, NULL);
     1982        set80211(s, IEEE80211_IOC_MESH_FWRD, d, 0, NULL);
     1983}
     1984
     1985static
     1986DECL_CMD_FUNC(set80211meshgate, val, d)
     1987{
     1988        set80211(s, IEEE80211_IOC_MESH_GATE, d, 0, NULL);
    18821989}
    18831990
     
    18851992DECL_CMD_FUNC(set80211meshpeering, val, d)
    18861993{
    1887         set80211(s, IEEE80211_IOC_MESH_AP, atoi(val), 0, NULL);
     1994        set80211(s, IEEE80211_IOC_MESH_AP, d, 0, NULL);
    18881995}
    18891996
     
    19612068         * want to include but that are not explicitly listed.
    19622069         */
    1963         if (flags & IEEE80211_CHAN_HT40) {
    1964                 /* NB: we use an HT40 channel center that matches HT20 */
    1965                 flags = (flags &~ IEEE80211_CHAN_HT40) | IEEE80211_CHAN_HT20;
    1966         }
    19672070        if (chanlookup(avail->ic_chans, avail->ic_nchans, freq, flags) != NULL)
    19682071                return 1;
     
    20162119        lo_adj = (chanFlags & IEEE80211_CHAN_HT40D) ? 20 : 0;
    20172120        channelSep = (chanFlags & IEEE80211_CHAN_2GHZ) ? 0 : 40;
     2121
    20182122        LIST_FOREACH(nb, bands, next) {
    20192123                b = nb->band;
     
    20262130                }
    20272131                prev = NULL;
     2132
    20282133                for (freq = b->freqStart + lo_adj;
    20292134                     freq <= b->freqEnd + hi_adj; freq += b->chanSep) {
     
    20362141                         */
    20372142                        flags = nb->flags | b->flags;
     2143
     2144                        /*
     2145                         * VHT first - HT is a subset.
     2146                         *
     2147                         * XXX TODO: VHT80p80, VHT160 is not yet done.
     2148                         */
     2149                        if (flags & IEEE80211_CHAN_VHT) {
     2150                                if ((chanFlags & IEEE80211_CHAN_VHT20) &&
     2151                                    (flags & IEEE80211_CHAN_VHT20) == 0) {
     2152                                        if (verbose)
     2153                                                printf("%u: skip, not a "
     2154                                                    "VHT20 channel\n", freq);
     2155                                        continue;
     2156                                }
     2157                                if ((chanFlags & IEEE80211_CHAN_VHT40) &&
     2158                                    (flags & IEEE80211_CHAN_VHT40) == 0) {
     2159                                        if (verbose)
     2160                                                printf("%u: skip, not a "
     2161                                                    "VHT40 channel\n", freq);
     2162                                        continue;
     2163                                }
     2164                                if ((chanFlags & IEEE80211_CHAN_VHT80) &&
     2165                                    (flags & IEEE80211_CHAN_VHT80) == 0) {
     2166                                        if (verbose)
     2167                                                printf("%u: skip, not a "
     2168                                                    "VHT80 channel\n", freq);
     2169                                        continue;
     2170                                }
     2171
     2172                                flags &= ~IEEE80211_CHAN_VHT;
     2173                                flags |= chanFlags & IEEE80211_CHAN_VHT;
     2174                        }
     2175
     2176                        /* Now, constrain HT */
    20382177                        if (flags & IEEE80211_CHAN_HT) {
    20392178                                /*
     
    20552194                                                printf("%u: skip, not an "
    20562195                                                    "HT40 channel\n", freq);
    2057                                         continue;
    2058                                 }
    2059                                 /*
    2060                                  * DFS and HT40 don't mix.  This should be
    2061                                  * expressed in the regdomain database but
    2062                                  * just in case enforce it here.
    2063                                  */
    2064                                 if ((chanFlags & IEEE80211_CHAN_HT40) &&
    2065                                     (flags & IEEE80211_CHAN_DFS)) {
    2066                                         if (verbose)
    2067                                                 printf("%u: skip, HT40+DFS "
    2068                                                     "not permitted\n", freq);
    20692196                                        continue;
    20702197                                }
     
    21202247                        c->ic_freq = freq;
    21212248                        c->ic_flags = flags;
    2122                         if (c->ic_flags & IEEE80211_CHAN_DFS)
     2249                if (c->ic_flags & IEEE80211_CHAN_DFS)
    21232250                                c->ic_maxregpower = nb->maxPowerDFS;
    21242251                        else
     
    21972324                        }
    21982325                }
     2326                if (!LIST_EMPTY(&rd->bands_11ac) && dc->dc_vhtcaps != 0) {
     2327                        regdomain_addchans(ci, &rd->bands_11ac, reg,
     2328                            IEEE80211_CHAN_A | IEEE80211_CHAN_HT20 |
     2329                            IEEE80211_CHAN_VHT20,
     2330                            &dc->dc_chaninfo);
     2331
     2332                        /* VHT40 is a function of HT40.. */
     2333                        if (dc->dc_htcaps & IEEE80211_HTCAP_CHWIDTH40) {
     2334                                regdomain_addchans(ci, &rd->bands_11ac, reg,
     2335                                    IEEE80211_CHAN_A | IEEE80211_CHAN_HT40U |
     2336                                    IEEE80211_CHAN_VHT40U,
     2337                                    &dc->dc_chaninfo);
     2338                                regdomain_addchans(ci, &rd->bands_11ac, reg,
     2339                                    IEEE80211_CHAN_A | IEEE80211_CHAN_HT40D |
     2340                                    IEEE80211_CHAN_VHT40D,
     2341                                    &dc->dc_chaninfo);
     2342                        }
     2343
     2344                        /* VHT80 */
     2345                        /* XXX dc_vhtcap? */
     2346                        if (1) {
     2347                                regdomain_addchans(ci, &rd->bands_11ac, reg,
     2348                                    IEEE80211_CHAN_A | IEEE80211_CHAN_HT40U |
     2349                                    IEEE80211_CHAN_VHT80,
     2350                                    &dc->dc_chaninfo);
     2351                                regdomain_addchans(ci, &rd->bands_11ac, reg,
     2352                                    IEEE80211_CHAN_A | IEEE80211_CHAN_HT40D |
     2353                                    IEEE80211_CHAN_VHT80,
     2354                                    &dc->dc_chaninfo);
     2355                        }
     2356
     2357                        /* XXX TODO: VHT80_80, VHT160 */
     2358                }
     2359
    21992360                if (!LIST_EMPTY(&rd->bands_11ng) && dc->dc_htcaps != 0) {
    22002361                        regdomain_addchans(ci, &rd->bands_11ng, reg,
     
    24282589                        *cp++ = '+';
    24292590        }
     2591        if (flags & IEEE80211_NODE_VHT)
     2592                *cp++ = 'V';
    24302593        if (flags & IEEE80211_NODE_WPS)
    24312594                *cp++ = 'W';
     
    24982661{
    24992662#define MS(_v, _f)      (((_v) & _f) >> _f##_S)
    2500         static const char *const acnames[] = { "BE", "BK", "VO", "VI" };
     2663        static const char *acnames[] = { "BE", "BK", "VO", "VI" };
    25012664        const struct ieee80211_wme_param *wme =
    25022665            (const struct ieee80211_wme_param *) ie;
     
    25342697                printf("<version 0x%x info 0x%x>",
    25352698                    wme->wme_version, wme->wme_info);
     2699        }
     2700}
     2701
     2702static void
     2703printvhtcap(const char *tag, const u_int8_t *ie, size_t ielen, int maxlen)
     2704{
     2705        printf("%s", tag);
     2706        if (verbose) {
     2707                const struct ieee80211_ie_vhtcap *vhtcap =
     2708                    (const struct ieee80211_ie_vhtcap *) ie;
     2709                uint32_t vhtcap_info = LE_READ_4(&vhtcap->vht_cap_info);
     2710
     2711                printf("<cap 0x%08x", vhtcap_info);
     2712                printf(" rx_mcs_map 0x%x",
     2713                    LE_READ_2(&vhtcap->supp_mcs.rx_mcs_map));
     2714                printf(" rx_highest %d",
     2715                    LE_READ_2(&vhtcap->supp_mcs.rx_highest) & 0x1fff);
     2716                printf(" tx_mcs_map 0x%x",
     2717                    LE_READ_2(&vhtcap->supp_mcs.tx_mcs_map));
     2718                printf(" tx_highest %d",
     2719                    LE_READ_2(&vhtcap->supp_mcs.tx_highest) & 0x1fff);
     2720
     2721                printf(">");
     2722        }
     2723}
     2724
     2725static void
     2726printvhtinfo(const char *tag, const u_int8_t *ie, size_t ielen, int maxlen)
     2727{
     2728        printf("%s", tag);
     2729        if (verbose) {
     2730                const struct ieee80211_ie_vht_operation *vhtinfo =
     2731                    (const struct ieee80211_ie_vht_operation *) ie;
     2732
     2733                printf("<chw %d freq1_idx %d freq2_idx %d basic_mcs_set 0x%04x>",
     2734                    vhtinfo->chan_width,
     2735                    vhtinfo->center_freq_seg1_idx,
     2736                    vhtinfo->center_freq_seg2_idx,
     2737                    LE_READ_2(&vhtinfo->basic_mcs_set));
     2738        }
     2739}
     2740
     2741static void
     2742printvhtpwrenv(const char *tag, const u_int8_t *ie, size_t ielen, int maxlen)
     2743{
     2744        printf("%s", tag);
     2745        static const char *txpwrmap[] = {
     2746                "20",
     2747                "40",
     2748                "80",
     2749                "160",
     2750        };
     2751        if (verbose) {
     2752                const struct ieee80211_ie_vht_txpwrenv *vhtpwr =
     2753                    (const struct ieee80211_ie_vht_txpwrenv *) ie;
     2754                int i, n;
     2755                const char *sep = "";
     2756
     2757                /* Get count; trim at ielen */
     2758                n = (vhtpwr->tx_info &
     2759                    IEEE80211_VHT_TXPWRENV_INFO_COUNT_MASK) + 1;
     2760                /* Trim at ielen */
     2761                if (n > ielen - 3)
     2762                        n = ielen - 3;
     2763                printf("<tx_info 0x%02x pwr:[", vhtpwr->tx_info);
     2764                for (i = 0; i < n; i++) {
     2765                        printf("%s%s:%.2f", sep, txpwrmap[i],
     2766                            ((float) ((int8_t) ie[i+3])) / 2.0);
     2767                        sep = " ";
     2768                }
     2769
     2770                printf("]>");
    25362771        }
    25372772}
     
    26372872printmeshconf(const char *tag, const uint8_t *ie, size_t ielen, int maxlen)
    26382873{
    2639 #define MATCHOUI(field, oui, string)                                    \
    2640 do {                                                                    \
    2641         if (memcmp(field, oui, 4) == 0)                                 \
    2642                 printf("%s", string);                                   \
    2643 } while (0)
    26442874
    26452875        printf("%s", tag);
     
    26752905                    mconf->conf_cap);
    26762906        }
    2677 #undef MATCHOUI
     2907}
     2908
     2909static void
     2910printbssload(const char *tag, const uint8_t *ie, size_t ielen, int maxlen)
     2911{
     2912        printf("%s", tag);
     2913        if (verbose) {
     2914                const struct ieee80211_bss_load_ie *bssload =
     2915                    (const struct ieee80211_bss_load_ie *) ie;
     2916                printf("<sta count %d, chan load %d, aac %d>",
     2917                    LE_READ_2(&bssload->sta_count),
     2918                    bssload->chan_load,
     2919                    bssload->aac);
     2920        }
     2921}
     2922
     2923static void
     2924printapchanrep(const char *tag, const u_int8_t *ie, size_t ielen, int maxlen)
     2925{
     2926        printf("%s", tag);
     2927        if (verbose) {
     2928                const struct ieee80211_ap_chan_report_ie *ap =
     2929                    (const struct ieee80211_ap_chan_report_ie *) ie;
     2930                const char *sep = "";
     2931                int i;
     2932
     2933                printf("<class %u, chan:[", ap->i_class);
     2934
     2935                for (i = 3; i < ielen; i++) {
     2936                        printf("%s%u", sep, ie[i]);
     2937                        sep = ",";
     2938                }
     2939                printf("]>");
     2940        }
    26782941}
    26792942
     
    28623125printwpsie(const char *tag, const u_int8_t *ie, size_t ielen, int maxlen)
    28633126{
    2864 #define N(a)    (sizeof(a) / sizeof(a[0]))
    28653127        u_int8_t len = ie[1];
    28663128
    28673129        printf("%s", tag);
    28683130        if (verbose) {
    2869                 static const char *const dev_pass_id[] = {
     3131                static const char *dev_pass_id[] = {
    28703132                        "D",    /* Default (PIN) */
    28713133                        "U",    /* User-specified */
     
    29033165                        case IEEE80211_WPS_DEV_PASS_ID:
    29043166                                n = LE_READ_2(ie);
    2905                                 if (n < N(dev_pass_id))
     3167                                if (n < nitems(dev_pass_id))
    29063168                                        printf(" dpi:%s", dev_pass_id[n]);
    29073169                                break;
     
    29173179                printf(">");
    29183180        }
    2919 #undef N
    29203181}
    29213182
     
    29473208        const u_int8_t *p;
    29483209        size_t maxlen;
    2949         int i;
     3210        u_int i;
    29503211
    29513212        if (essid_len > bufsize)
     
    30243285}
    30253286
    3026 /* unaligned little endian access */     
    3027 #define LE_READ_4(p)                                    \
    3028         ((u_int32_t)                                    \
    3029          ((((const u_int8_t *)(p))[0]      ) |          \
    3030           (((const u_int8_t *)(p))[1] <<  8) |          \
    3031           (((const u_int8_t *)(p))[2] << 16) |          \
    3032           (((const u_int8_t *)(p))[3] << 24)))
    3033 
    30343287static __inline int
    30353288iswpaoui(const u_int8_t *frm)
     
    30783331        case IEEE80211_ELEMID_TIM:      return " TIM";
    30793332        case IEEE80211_ELEMID_IBSSPARMS:return " IBSSPARMS";
     3333        case IEEE80211_ELEMID_BSSLOAD:  return " BSSLOAD";
    30803334        case IEEE80211_ELEMID_CHALLENGE:return " CHALLENGE";
    30813335        case IEEE80211_ELEMID_PWRCNSTR: return " PWRCNSTR";
     
    31553409                        printmeshconf(" MESHCONF", vp, 2+vp[1], maxcols);
    31563410                        break;
     3411                case IEEE80211_ELEMID_VHT_CAP:
     3412                        printvhtcap(" VHTCAP", vp, 2+vp[1], maxcols);
     3413                        break;
     3414                case IEEE80211_ELEMID_VHT_OPMODE:
     3415                        printvhtinfo(" VHTOPMODE", vp, 2+vp[1], maxcols);
     3416                        break;
     3417                case IEEE80211_ELEMID_VHT_PWR_ENV:
     3418                        printvhtpwrenv(" VHTPWRENV", vp, 2+vp[1], maxcols);
     3419                        break;
     3420                case IEEE80211_ELEMID_BSSLOAD:
     3421                        printbssload(" BSSLOAD", vp, 2+vp[1], maxcols);
     3422                        break;
     3423                case IEEE80211_ELEMID_APCHANREP:
     3424                        printapchanrep(" APCHANREP", vp, 2+vp[1], maxcols);
     3425                        break;
    31573426                default:
    31583427                        if (verbose)
     
    31713440        if (mi->rssi[0] != 0 || mi->rssi[1] != 0 || mi->rssi[2] != 0) {
    31723441                /* XXX ignore EVM for now */
    3173                 printf(" (rssi %d:%d:%d nf %d:%d:%d)",
    3174                     mi->rssi[0], mi->rssi[1], mi->rssi[2],
     3442                printf(" (rssi %.1f:%.1f:%.1f nf %d:%d:%d)",
     3443                    mi->rssi[0] / 2.0, mi->rssi[1] / 2.0, mi->rssi[2] / 2.0,
    31753444                    mi->noise[0], mi->noise[1], mi->noise[2]);
    31763445        }
     
    31923461        getchaninfo(s);
    31933462
    3194         ssidmax = verbose ? IEEE80211_NWID_LEN - 1 : 14;
    3195         printf("%-*.*s  %-17.17s  %4s %4s  %-7s  %3s %4s\n"
     3463        ssidmax = verbose ? IEEE80211_NWID_LEN : 14;
     3464        printf("%-*.*s  %-17.17s  %4s %4s   %-7s  %3s %4s\n"
    31963465                , ssidmax, ssidmax, "SSID/MESH ID"
    31973466                , "BSSID"
     
    32163485                        idlen = sr->isr_ssid_len;
    32173486                }
    3218                 printf("%-*.*s  %s  %3d  %3dM %3d:%-3d  %3d %-4.4s"
     3487                printf("%-*.*s  %s  %3d  %3dM %4d:%-4d %4d %-4.4s"
    32193488                        , ssidmax
    32203489                          , copy_essid(ssid, ssidmax, idp, idlen)
     
    32473516        }
    32483517        (void) memset(&ireq, 0, sizeof(ireq));
    3249         (void) strncpy(ireq.i_name, name, sizeof(ireq.i_name));
     3518        (void) strlcpy(ireq.i_name, name, sizeof(ireq.i_name));
    32503519        ireq.i_type = IEEE80211_IOC_SCAN_REQ;
    32513520
    32523521        memset(&sr, 0, sizeof(sr));
    32533522        sr.sr_flags = IEEE80211_IOC_SCAN_ACTIVE
     3523                    | IEEE80211_IOC_SCAN_BGSCAN
    32543524                    | IEEE80211_IOC_SCAN_NOPICK
    32553525                    | IEEE80211_IOC_SCAN_ONCE;
     
    32593529        ireq.i_data = &sr;
    32603530        ireq.i_len = sizeof(sr);
    3261         /* NB: only root can trigger a scan so ignore errors */
    3262         if (ioctl(s, SIOCS80211, &ireq) >= 0) {
     3531        /*
     3532         * NB: only root can trigger a scan so ignore errors. Also ignore
     3533         * possible errors from net80211, even if no new scan could be
     3534         * started there might still be a valid scan cache.
     3535         */
     3536        if (ioctl(s, SIOCS80211, &ireq) == 0) {
    32633537                char buf[2048];
    32643538                struct if_announcemsghdr *ifan;
     
    34193693mesh_linkstate_string(uint8_t state)
    34203694{
    3421 #define N(a)    (sizeof(a) / sizeof(a[0]))
    3422         static const char *const state_names[] = {
     3695        static const char *state_names[] = {
    34233696            [0] = "IDLE",
    34243697            [1] = "OPEN-TX",
     
    34293702        };
    34303703
    3431         if (state >= N(state_names)) {
     3704        if (state >= nitems(state_names)) {
    34323705                static char buf[10];
    34333706                snprintf(buf, sizeof(buf), "#%u", state);
     
    34353708        } else
    34363709                return state_names[state];
    3437 #undef N
    34383710}
    34393711
     
    34583730                strlcat(buf, " Turbo", bsize);
    34593731        if (precise) {
    3460                 if (IEEE80211_IS_CHAN_HT20(c))
     3732                /* XXX should make VHT80U, VHT80D */
     3733                if (IEEE80211_IS_CHAN_VHT80(c) &&
     3734                    IEEE80211_IS_CHAN_HT40D(c))
     3735                        strlcat(buf, " vht/80-", bsize);
     3736                else if (IEEE80211_IS_CHAN_VHT80(c) &&
     3737                    IEEE80211_IS_CHAN_HT40U(c))
     3738                        strlcat(buf, " vht/80+", bsize);
     3739                else if (IEEE80211_IS_CHAN_VHT80(c))
     3740                        strlcat(buf, " vht/80", bsize);
     3741                else if (IEEE80211_IS_CHAN_VHT40D(c))
     3742                        strlcat(buf, " vht/40-", bsize);
     3743                else if (IEEE80211_IS_CHAN_VHT40U(c))
     3744                        strlcat(buf, " vht/40+", bsize);
     3745                else if (IEEE80211_IS_CHAN_VHT20(c))
     3746                        strlcat(buf, " vht/20", bsize);
     3747                else if (IEEE80211_IS_CHAN_HT20(c))
    34613748                        strlcat(buf, " ht/20", bsize);
    34623749                else if (IEEE80211_IS_CHAN_HT40D(c))
     
    34653752                        strlcat(buf, " ht/40+", bsize);
    34663753        } else {
    3467                 if (IEEE80211_IS_CHAN_HT(c))
     3754                if (IEEE80211_IS_CHAN_VHT(c))
     3755                        strlcat(buf, " vht", bsize);
     3756                else if (IEEE80211_IS_CHAN_HT(c))
    34683757                        strlcat(buf, " ht", bsize);
    34693758        }
     
    34763765        char buf[14];
    34773766
     3767        if (verb)
     3768                printf("Channel %3u : %u%c%c%c%c%c MHz%-14.14s",
     3769                    ieee80211_mhz2ieee(c->ic_freq, c->ic_flags), c->ic_freq,
     3770                    IEEE80211_IS_CHAN_PASSIVE(c) ? '*' : ' ',
     3771                    IEEE80211_IS_CHAN_DFS(c) ? 'D' : ' ',
     3772                    IEEE80211_IS_CHAN_RADAR(c) ? 'R' : ' ',
     3773                    IEEE80211_IS_CHAN_CWINT(c) ? 'I' : ' ',
     3774                    IEEE80211_IS_CHAN_CACDONE(c) ? 'C' : ' ',
     3775                    get_chaninfo(c, verb, buf, sizeof(buf)));
     3776        else
    34783777        printf("Channel %3u : %u%c MHz%-14.14s",
    3479                 ieee80211_mhz2ieee(c->ic_freq, c->ic_flags), c->ic_freq,
    3480                 IEEE80211_IS_CHAN_PASSIVE(c) ? '*' : ' ',
    3481                 get_chaninfo(c, verb, buf, sizeof(buf)));
     3778            ieee80211_mhz2ieee(c->ic_freq, c->ic_flags), c->ic_freq,
     3779            IEEE80211_IS_CHAN_PASSIVE(c) ? '*' : ' ',
     3780            get_chaninfo(c, verb, buf, sizeof(buf)));
     3781
    34823782}
    34833783
     
    34853785chanpref(const struct ieee80211_channel *c)
    34863786{
     3787        if (IEEE80211_IS_CHAN_VHT160(c))
     3788                return 80;
     3789        if (IEEE80211_IS_CHAN_VHT80_80(c))
     3790                return 75;
     3791        if (IEEE80211_IS_CHAN_VHT80(c))
     3792                return 70;
     3793        if (IEEE80211_IS_CHAN_VHT40(c))
     3794                return 60;
     3795        if (IEEE80211_IS_CHAN_VHT20(c))
     3796                return 50;
    34873797        if (IEEE80211_IS_CHAN_HT40(c))
    34883798                return 40;
     
    36203930                if (isset(reported, c->ic_ieee) && !verbose) {
    36213931                        /* XXX we assume duplicates are adjacent */
     3932                        assert(achans->ic_nchans > 0);
    36223933                        prev = &achans->ic_chans[achans->ic_nchans-1];
    36233934                        /* display highest power on channel */
     
    36563967{
    36573968}
    3658 
    3659 #define IEEE80211_C_BITS \
    3660         "\20\1STA\002803ENCAP\7FF\10TURBOP\11IBSS\12PMGT" \
    3661         "\13HOSTAP\14AHDEMO\15SWRETRY\16TXPMGT\17SHSLOT\20SHPREAMBLE" \
    3662         "\21MONITOR\22DFS\23MBSS\30WPA1\31WPA2\32BURST\33WME\34WDS\36BGSCAN" \
    3663         "\37TXFRAG\40TDMA"
    36643969
    36653970static void
     
    36853990                printb("htcaps", dc->dc_htcaps, IEEE80211_HTCAP_BITS);
    36863991        }
     3992        if (dc->dc_vhtcaps != 0 || verbose) {
     3993                putchar('\n');
     3994                printb("vhtcaps", dc->dc_vhtcaps, IEEE80211_VHTCAP_BITS);
     3995        }
     3996
    36873997        putchar('\n');
    36883998        if (verbose) {
     
    36994009
    37004010        (void) memset(&ireq, 0, sizeof(ireq));
    3701         (void) strncpy(ireq.i_name, name, sizeof(ireq.i_name));
     4011        (void) strlcpy(ireq.i_name, name, sizeof(ireq.i_name));
    37024012        ireq.i_type = param;
    37034013        ireq.i_len = ac;
     
    37494059list_wme(int s)
    37504060{
    3751         static const char *const acnames[] = { "AC_BE", "AC_BK", "AC_VI", "AC_VO" };
     4061        static const char *acnames[] = { "AC_BE", "AC_BK", "AC_VI", "AC_VO" };
    37524062        int ac;
    37534063
     
    38804190
    38814191        (void) memset(&ireq, 0, sizeof(ireq));
    3882         (void) strncpy(ireq.i_name, name, sizeof(ireq.i_name)); /* XXX ?? */
     4192        (void) strlcpy(ireq.i_name, name, sizeof(ireq.i_name)); /* XXX ?? */
    38834193        ireq.i_type = IEEE80211_IOC_MACCMD;
    38844194        ireq.i_val = IEEE80211_MACCMD_POLICY;
     
    39864296
    39874297        (void) memset(&ireq, 0, sizeof(ireq));
    3988         (void) strncpy(ireq.i_name, name, sizeof(ireq.i_name));
     4298        (void) strlcpy(ireq.i_name, name, sizeof(ireq.i_name));
    39894299        ireq.i_type = IEEE80211_IOC_MESH_RTCMD;
    39904300        ireq.i_val = IEEE80211_MESH_RTCMD_LIST;
     
    40104320                        rt->imr_nhops, rt->imr_metric, rt->imr_lifetime,
    40114321                        rt->imr_lastmseq,
     4322                        (rt->imr_flags & IEEE80211_MESHRT_FLAGS_DISCOVER) ?
     4323                            'D' :
    40124324                        (rt->imr_flags & IEEE80211_MESHRT_FLAGS_VALID) ?
    40134325                            'V' : '!',
    40144326                        (rt->imr_flags & IEEE80211_MESHRT_FLAGS_PROXY) ?
    4015                             'P' : ' ');
     4327                            'P' :
     4328                        (rt->imr_flags & IEEE80211_MESHRT_FLAGS_GATE) ?
     4329                            'G' :' ');
    40164330        }
    40174331}
     
    40644378
    40654379        (void) memset(&ifmr, 0, sizeof(ifmr));
    4066         (void) strncpy(ifmr.ifm_name, name, sizeof(ifmr.ifm_name));
     4380        (void) strlcpy(ifmr.ifm_name, name, sizeof(ifmr.ifm_name));
    40674381
    40684382        if (ioctl(s, SIOCGIFMEDIA, (caddr_t)&ifmr) >= 0) {
     
    40754389                if (ifmr.ifm_current & IFM_IEEE80211_HOSTAP)
    40764390                        return IEEE80211_M_HOSTAP;
     4391                if (ifmr.ifm_current & IFM_IEEE80211_IBSS)
     4392                        return IEEE80211_M_IBSS;
    40774393                if (ifmr.ifm_current & IFM_IEEE80211_MONITOR)
    40784394                        return IEEE80211_M_MONITOR;
     
    41234439{
    41244440        static const uint8_t zerodata[IEEE80211_KEYBUF_SIZE];
    4125         int keylen = ik->ik_keylen;
     4441        u_int keylen = ik->ik_keylen;
    41264442        int printcontents;
    41274443
     
    41604476        }
    41614477        if (printcontents) {
    4162                 int i;
     4478                u_int i;
    41634479
    41644480                printf(" <");
     
    42084524
    42094525        (void) memset(&ireq, 0, sizeof(ireq));
    4210         (void) strncpy(ireq.i_name, name, sizeof(ireq.i_name));
     4526        (void) strlcpy(ireq.i_name, name, sizeof(ireq.i_name));
    42114527        ireq.i_type = (!mesh) ? IEEE80211_IOC_SSID : IEEE80211_IOC_MESH_ID;
    42124528        ireq.i_val = ix;
     
    43794695        if (get80211val(s, IEEE80211_IOC_WEP, &wepmode) != -1 &&
    43804696            wepmode != IEEE80211_WEP_NOSUP) {
    4381                 int firstkey;
    43824697
    43834698                switch (wepmode) {
     
    44154730                }
    44164731
    4417                 firstkey = 1;
    44184732                for (i = 0; i < num; i++) {
    44194733                        struct ieee80211req_key ik;
     
    44294743                                        LINE_BREAK();
    44304744                                printkey(&ik);
    4431                                 firstkey = 0;
    44324745                        }
    44334746                }
     
    47035016                                LINE_CHECK("-rifs");
    47045017                }
     5018                if (get80211val(s, IEEE80211_IOC_STBC, &val) != -1) {
     5019                        switch (val) {
     5020                        case 0:
     5021                                LINE_CHECK("-stbc");
     5022                                break;
     5023                        case 1:
     5024                                LINE_CHECK("stbctx -stbcrx");
     5025                                break;
     5026                        case 2:
     5027                                LINE_CHECK("-stbctx stbcrx");
     5028                                break;
     5029                        case 3:
     5030                                if (verbose)
     5031                                        LINE_CHECK("stbc");
     5032                                break;
     5033                        }
     5034                }
     5035        }
     5036
     5037        if (IEEE80211_IS_CHAN_VHT(c) || verbose) {
     5038                getvhtconf(s);
     5039                if (vhtconf & 0x1)
     5040                        LINE_CHECK("vht");
     5041                else
     5042                        LINE_CHECK("-vht");
     5043                if (vhtconf & 0x2)
     5044                        LINE_CHECK("vht40");
     5045                else
     5046                        LINE_CHECK("-vht40");
     5047                if (vhtconf & 0x4)
     5048                        LINE_CHECK("vht80");
     5049                else
     5050                        LINE_CHECK("-vht80");
     5051                if (vhtconf & 0x8)
     5052                        LINE_CHECK("vht80p80");
     5053                else
     5054                        LINE_CHECK("-vht80p80");
     5055                if (vhtconf & 0x10)
     5056                        LINE_CHECK("vht160");
     5057                else
     5058                        LINE_CHECK("-vht160");
    47055059        }
    47065060
     
    48315185                                LINE_CHECK("-meshforward");
    48325186                }
     5187                if (get80211val(s, IEEE80211_IOC_MESH_GATE, &val) != -1) {
     5188                        if (val)
     5189                                LINE_CHECK("meshgate");
     5190                        else
     5191                                LINE_CHECK("-meshgate");
     5192                }
    48335193                if (get80211len(s, IEEE80211_IOC_MESH_PR_METRIC, data, 12,
    48345194                    &len) != -1) {
     
    48715231get80211(int s, int type, void *data, int len)
    48725232{
    4873         struct ieee80211req ireq;
    4874 
    4875         (void) memset(&ireq, 0, sizeof(ireq));
    4876         (void) strncpy(ireq.i_name, name, sizeof(ireq.i_name));
    4877         ireq.i_type = type;
    4878         ireq.i_data = data;
    4879         ireq.i_len = len;
    4880         return ioctl(s, SIOCG80211, &ireq);
     5233
     5234        return (lib80211_get80211(s, name, type, data, len));
    48815235}
    48825236
     
    48845238get80211len(int s, int type, void *data, int len, int *plen)
    48855239{
    4886         struct ieee80211req ireq;
    4887 
    4888         (void) memset(&ireq, 0, sizeof(ireq));
    4889         (void) strncpy(ireq.i_name, name, sizeof(ireq.i_name));
    4890         ireq.i_type = type;
    4891         ireq.i_len = len;
    4892         assert(ireq.i_len == len);      /* NB: check for 16-bit truncation */
    4893         ireq.i_data = data;
    4894         if (ioctl(s, SIOCG80211, &ireq) < 0)
    4895                 return -1;
    4896         *plen = ireq.i_len;
    4897         return 0;
     5240
     5241        return (lib80211_get80211len(s, name, type, data, len, plen));
    48985242}
    48995243
     
    49015245get80211val(int s, int type, int *val)
    49025246{
    4903         struct ieee80211req ireq;
    4904 
    4905         (void) memset(&ireq, 0, sizeof(ireq));
    4906         (void) strncpy(ireq.i_name, name, sizeof(ireq.i_name));
    4907         ireq.i_type = type;
    4908         if (ioctl(s, SIOCG80211, &ireq) < 0)
    4909                 return -1;
    4910         *val = ireq.i_val;
    4911         return 0;
     5247
     5248        return (lib80211_get80211val(s, name, type, val));
    49125249}
    49135250
     
    49155252set80211(int s, int type, int val, int len, void *data)
    49165253{
    4917         struct ieee80211req     ireq;
    4918 
    4919         (void) memset(&ireq, 0, sizeof(ireq));
    4920         (void) strncpy(ireq.i_name, name, sizeof(ireq.i_name));
    4921         ireq.i_type = type;
    4922         ireq.i_val = val;
    4923         ireq.i_len = len;
    4924         assert(ireq.i_len == len);      /* NB: check for 16-bit truncation */
    4925         ireq.i_data = data;
    4926         if (ioctl(s, SIOCS80211, &ireq) < 0)
     5254        int ret;
     5255
     5256        ret = lib80211_set80211(s, name, type, val, len, data);
     5257        if (ret < 0)
    49275258                err(1, "SIOCS80211");
    49285259}
     
    50105341}
    50115342
     5343static void
     5344setdefregdomain(int s)
     5345{
     5346        struct regdata *rdp = getregdata();
     5347        const struct regdomain *rd;
     5348
     5349        /* Check if regdomain/country was already set by a previous call. */
     5350        /* XXX is it possible? */
     5351        if (regdomain.regdomain != 0 ||
     5352            regdomain.country != CTRY_DEFAULT)
     5353                return;
     5354
     5355        getregdomain(s);
     5356
     5357        /* Check if it was already set by the driver. */
     5358        if (regdomain.regdomain != 0 ||
     5359            regdomain.country != CTRY_DEFAULT)
     5360                return;
     5361
     5362        /* Set FCC/US as default. */
     5363        rd = lib80211_regdomain_findbysku(rdp, SKU_FCC);
     5364        if (rd == NULL)
     5365                errx(1, "FCC regdomain was not found");
     5366
     5367        regdomain.regdomain = rd->sku;
     5368        if (rd->cc != NULL)
     5369                defaultcountry(rd);
     5370
     5371        /* Send changes to net80211. */
     5372        setregdomain_cb(s, &regdomain);
     5373
     5374        /* Cleanup (so it can be overriden by subsequent parameters). */
     5375        regdomain.regdomain = 0;
     5376        regdomain.country = CTRY_DEFAULT;
     5377        regdomain.isocc[0] = 0;
     5378        regdomain.isocc[1] = 0;
     5379}
     5380
    50125381/*
    50135382 * Virtual AP cloning support.
     
    50215390{
    50225391        static const uint8_t zerobssid[IEEE80211_ADDR_LEN];
     5392        char orig_name[IFNAMSIZ];
    50235393
    50245394        if (params.icp_parent[0] == '\0')
     
    50315401        if (ioctl(s, SIOCIFCREATE2, ifr) < 0)
    50325402                err(1, "SIOCIFCREATE2");
     5403
     5404        /* XXX preserve original name for ifclonecreate(). */
     5405        strlcpy(orig_name, name, sizeof(orig_name));
     5406        strlcpy(name, ifr->ifr_name, sizeof(name));
     5407
     5408        setdefregdomain(s);
     5409
     5410        strlcpy(name, orig_name, sizeof(name));
    50335411}
    50345412
     
    50575435        ea = ether_aton(arg);
    50585436        if (ea == NULL)
    5059                 errx(1, "%s: cannot parse addres", arg);
     5437                errx(1, "%s: cannot parse address", arg);
    50605438        memcpy(params.icp_macaddr, ea->octet, IEEE80211_ADDR_LEN);
    50615439        params.icp_flags |= IEEE80211_CLONE_MACADDR;
     
    51875565        DEF_CMD_ARG("bgscanintvl",      set80211bgscanintvl),
    51885566        DEF_CMD_ARG("scanvalid",        set80211scanvalid),
     5567        DEF_CMD("quiet",        1,      set80211quiet),
     5568        DEF_CMD("-quiet",       0,      set80211quiet),
     5569        DEF_CMD_ARG("quiet_count",      set80211quietcount),
     5570        DEF_CMD_ARG("quiet_period",     set80211quietperiod),
     5571        DEF_CMD_ARG("quiet_dur",        set80211quietduration),
     5572        DEF_CMD_ARG("quiet_offset",     set80211quietoffset),
    51895573        DEF_CMD_ARG("roam:rssi",        set80211roamrssi),
    51905574        DEF_CMD_ARG("roam:rate",        set80211roamrate),
     
    52165600        DEF_CMD("-amsdu",       -3,     set80211amsdu),
    52175601        DEF_CMD_ARG("amsdulimit",       set80211amsdulimit),
     5602        DEF_CMD("stbcrx",       2,      set80211stbc),
     5603        DEF_CMD("-stbcrx",      -2,     set80211stbc),
     5604        DEF_CMD("stbctx",       1,      set80211stbc),
     5605        DEF_CMD("-stbctx",      -1,     set80211stbc),
     5606        DEF_CMD("stbc",         3,      set80211stbc),          /* NB: tx+rx */
     5607        DEF_CMD("-ampdu",       -3,     set80211stbc),
    52185608        DEF_CMD("puren",        1,      set80211puren),
    52195609        DEF_CMD("-puren",       0,      set80211puren),
     
    52485638        DEF_CMD("ht",           3,      set80211htconf),        /* NB: 20+40 */
    52495639        DEF_CMD("-ht",          0,      set80211htconf),
     5640        DEF_CMD("vht",          1,      set80211vhtconf),
     5641        DEF_CMD("-vht",         0,      set80211vhtconf),
     5642        DEF_CMD("vht40",                2,      set80211vhtconf),
     5643        DEF_CMD("-vht40",               -2,     set80211vhtconf),
     5644        DEF_CMD("vht80",                4,      set80211vhtconf),
     5645        DEF_CMD("-vht80",               -4,     set80211vhtconf),
     5646        DEF_CMD("vht80p80",             8,      set80211vhtconf),
     5647        DEF_CMD("-vht80p80",            -8,     set80211vhtconf),
     5648        DEF_CMD("vht160",               16,     set80211vhtconf),
     5649        DEF_CMD("-vht160",              -16,    set80211vhtconf),
    52505650        DEF_CMD("rifs",         1,      set80211rifs),
    52515651        DEF_CMD("-rifs",        0,      set80211rifs),
     
    52645664        DEF_CMD("meshforward",  1,      set80211meshforward),
    52655665        DEF_CMD("-meshforward", 0,      set80211meshforward),
     5666        DEF_CMD("meshgate",     1,      set80211meshgate),
     5667        DEF_CMD("-meshgate",    0,      set80211meshgate),
    52665668        DEF_CMD("meshpeering",  1,      set80211meshpeering),
    52675669        DEF_CMD("-meshpeering", 0,      set80211meshpeering),
     
    52925694};
    52935695
    5294 #ifndef __rtems__
    52955696static __constructor void
    5296 #else /* __rtems__ */
    5297 void
    5298 #endif /* __rtems__ */
    52995697ieee80211_ctor(void)
    53005698{
    5301 #define N(a)    (sizeof(a) / sizeof(a[0]))
    53025699        int i;
    53035700
    5304         for (i = 0; i < N(ieee80211_cmds);  i++)
     5701        for (i = 0; i < nitems(ieee80211_cmds);  i++)
    53055702                cmd_register(&ieee80211_cmds[i]);
    53065703        af_register(&af_ieee80211);
    53075704        clone_setdefcallback("wlan", wlan_create);
    5308 #undef N
    5309 }
     5705}
Note: See TracChangeset for help on using the changeset viewer.