usr.sbin/wlanctl/wlanctl.c

   1 /* $NetBSD: wlanctl.c,v 1.10 2007/12/22 00:58:15 dyoung Exp $ */
   2 /*-
   3  * Copyright (c) 2005 David Young.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or
   6  * without modification, are permitted provided that the following
   7  * conditions are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above
  11  *    copyright notice, this list of conditions and the following
  12  *    disclaimer in the documentation and/or other materials provided
  13  *    with the distribution.
  14  * 3. The name of David Young may not be used to endorse or promote
  15  *    products derived from this software without specific prior
  16  *    written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY David Young ``AS IS'' AND ANY
  19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  20  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  21  * PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL David
  22  * Young BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  23  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  24  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  26  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  27  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  29  * OF SUCH DAMAGE.
  30  */
  31 #include <err.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <unistd.h>
  36 #include <assert.h>
  37
  38 #include <sys/param.h>
  39 #include <sys/sysctl.h>
  40 #include <sys/inttypes.h>
  41 #include <sys/ioctl.h>
  42 #include <sys/types.h>
  43 #include <sys/socket.h>
  44
  45 #include <net/if.h>
  46 #include <net/if_media.h>
  47 #include <netinet/in.h>
  48 #include <netinet/if_ether.h>
  49
  50 #include <net80211/ieee80211.h>
  51 #include <net80211/ieee80211_sysctl.h>
  52
  53 struct flagname {
  54         u_int32_t fn_flag;
  55         const char *fn_name;
  56 };
  57
  58 struct cmdflags {
  59         int     cf_v;   /* verbose */
  60         int     cf_a;   /* all 802.11 interfaces */
  61         int     cf_p;   /* public (i.e. non-private) dests */
  62 };
  63
  64 static void             print_flags(u_int32_t, const struct flagname *, u_int);
  65 static int              dump_nodes(const char *, int, struct cmdflags *);
  66 static const char       *ether_string(u_int8_t *);
  67 static void             parse_args(int *, char ***, struct cmdflags *);
  68 static void             print_capinfo(u_int16_t);
  69 static void             print_channel(u_int16_t, u_int16_t, u_int16_t);
  70 static void             print_node_flags(u_int32_t);
  71 static void             print_rateset(struct ieee80211_rateset *, int);
  72 static void             usage(void);
  73
  74 static void
  75 print_rateset(struct ieee80211_rateset *rs, int txrate)
  76 {
  77         int i, rate;
  78         const char *fmt, *basic;
  79
  80         printf("\trates");
  81
  82         for (i = 0; i < rs->rs_nrates; i++) {
  83
  84                 if ((rs->rs_rates[i] & IEEE80211_RATE_BASIC) != 0)
  85                         basic = "*";
  86                 else
  87                         basic = "";
  88                 if (i == txrate)
  89                         fmt = " [%s%d.%d]";
  90                 else
  91                         fmt = " %s%d.%d";
  92                 rate = 5 * (rs->rs_rates[i] & IEEE80211_RATE_VAL);
  93                 printf(fmt, basic, rate / 10, rate % 10);
  94         }
  95         printf("\n");
  96 }
  97
  98 static void
  99 print_flags(u_int32_t flags, const struct flagname *flagnames, u_int nname)
 100 {
 101         u_int i;
 102         const char *delim;
 103         delim = "<";
 104
 105         for (i = 0; i < nname; i++) {
 106                 if ((flags & flagnames[i].fn_flag) != 0) {
 107                         printf("%s%s", delim, flagnames[i].fn_name);
 108                         delim = ",";
 109                 }
 110         }
 111
 112         printf("%s\n", (delim[0] == '<') ? "" : ">");
 113 }
 114
 115 static void
 116 print_node_flags(u_int32_t flags)
 117 {
 118         static const struct flagname nodeflags[] = {
 119                   {IEEE80211_NODE_SYSCTL_F_BSS, "bss"}
 120                 , {IEEE80211_NODE_SYSCTL_F_STA, "sta"}
 121                 , {IEEE80211_NODE_SYSCTL_F_SCAN, "scan"}
 122         };
 123         printf("\tnode flags %04x", flags);
 124
 125         print_flags(flags, nodeflags, __arraycount(nodeflags));
 126 }
 127
 128 static void
 129 print_capinfo(u_int16_t capinfo)
 130 {
 131         static const struct flagname capflags[] = {
 132                 {IEEE80211_CAPINFO_ESS, "ess"},
 133                 {IEEE80211_CAPINFO_IBSS, "ibss"},
 134                 {IEEE80211_CAPINFO_CF_POLLABLE, "cf pollable"},
 135                 {IEEE80211_CAPINFO_CF_POLLREQ, "request cf poll"},
 136                 {IEEE80211_CAPINFO_PRIVACY, "privacy"},
 137                 {IEEE80211_CAPINFO_SHORT_PREAMBLE, "short preamble"},
 138                 {IEEE80211_CAPINFO_PBCC, "pbcc"},
 139                 {IEEE80211_CAPINFO_CHNL_AGILITY, "channel agility"},
 140                 {IEEE80211_CAPINFO_SHORT_SLOTTIME, "short slot-time"},
 141                 {IEEE80211_CAPINFO_RSN, "rsn"},
 142                 {IEEE80211_CAPINFO_DSSSOFDM, "dsss-ofdm"}
 143         };
 144
 145         printf("\tcapabilities %04x", capinfo);
 146
 147         print_flags(capinfo, capflags, __arraycount(capflags));
 148 }
 149
 150 static const char *
 151 ether_string(u_int8_t *addr)
 152 {
 153         struct ether_addr ea;
 154         (void)memcpy(ea.ether_addr_octet, addr, sizeof(ea.ether_addr_octet));
 155         return ether_ntoa(&ea);
 156 }
 157
 158 static void
 159 print_channel(u_int16_t chanidx, u_int16_t freq, u_int16_t flags)
 160 {
 161         static const struct flagname chanflags[] = {
 162                 {IEEE80211_CHAN_TURBO, "turbo"},
 163                 {IEEE80211_CHAN_CCK, "cck"},
 164                 {IEEE80211_CHAN_OFDM, "ofdm"},
 165                 {IEEE80211_CHAN_2GHZ, "2.4GHz"},
 166                 {IEEE80211_CHAN_5GHZ, "5GHz"},
 167                 {IEEE80211_CHAN_PASSIVE, "passive scan"},
 168                 {IEEE80211_CHAN_DYN, "dynamic cck-ofdm"},
 169                 {IEEE80211_CHAN_GFSK, "gfsk"}
 170         };
 171         printf("\tchan %d freq %dMHz flags %04x", chanidx, freq, flags);
 172
 173         print_flags(flags, chanflags, __arraycount(chanflags));
 174 }
 175
 176 /*
 177  *
 178  * ifname:   dump nodes belonging to the given interface, or belonging
 179  *           to all interfaces if NULL
 180  * hdr_type: header type: IEEE80211_SYSCTL_T_NODE -> generic node,
 181  *                        IEEE80211_SYSCTL_T_RSSADAPT -> rssadapt(9) info,
 182  *                        IEEE80211_SYSCTL_T_DRVSPEC -> driver specific.
 183  * cf:       command flags, cf_v != 0 -> verbose
 184  */
 185 static int
 186 dump_nodes(const char *ifname_arg, int hdr_type, struct cmdflags *cf)
 187 {
 188 #if 0
 189 /*39*/  u_int8_t        ns_erp;         /* 11g only */
 190 /*40*/  u_int32_t       ns_rstamp;      /* recv timestamp */
 191 /*64*/  u_int16_t       ns_fhdwell;     /* FH only */
 192 /*66*/  u_int8_t        ns_fhindex;     /* FH only */
 193 /*68*/
 194 #endif
 195         u_int i, ifindex;
 196         size_t namelen, nodes_len, totallen;
 197         int name[12];
 198         int *vname;
 199         char ifname[IFNAMSIZ];
 200         struct ieee80211_node_sysctl *pns, *ns;
 201         u_int64_t ts;
 202
 203         namelen = __arraycount(name);
 204
 205         if (sysctlnametomib("net.link.ieee80211.nodes", &name[0],
 206             &namelen) != 0) {
 207                 warn("sysctlnametomib");
 208                 return -1;
 209         }
 210
 211         if (ifname_arg == NULL)
 212                 ifindex = 0;
 213         else if ((ifindex = if_nametoindex(ifname_arg)) == 0) {
 214                 warn("if_nametoindex");
 215                 return -1;
 216         }
 217
 218         totallen = namelen + IEEE80211_SYSCTL_NODENAMELEN;
 219         if (totallen >= __arraycount(name)) {
 220                 warnx("Internal error finding sysctl mib");
 221                 return -1;
 222         }
 223         vname = &name[namelen];
 224
 225         vname[IEEE80211_SYSCTL_NODENAME_IF] = ifindex;
 226         vname[IEEE80211_SYSCTL_NODENAME_OP] = IEEE80211_SYSCTL_OP_ALL;
 227         vname[IEEE80211_SYSCTL_NODENAME_ARG] = 0;
 228         vname[IEEE80211_SYSCTL_NODENAME_TYPE] = hdr_type;
 229         vname[IEEE80211_SYSCTL_NODENAME_ELTSIZE] = sizeof(*ns);
 230         vname[IEEE80211_SYSCTL_NODENAME_ELTCOUNT] = INT_MAX;
 231
 232         /* how many? */
 233         if (sysctl(name, totallen, NULL, &nodes_len, NULL, 0) != 0) {
 234                 warn("sysctl(count)");
 235                 return -1;
 236         }
 237
 238         ns = malloc(nodes_len);
 239
 240         if (ns == NULL) {
 241                 warn("malloc");
 242                 return -1;
 243         }
 244
 245         vname[IEEE80211_SYSCTL_NODENAME_ELTCOUNT] = nodes_len / sizeof(ns[0]);
 246
 247         /* Get them. */
 248         if (sysctl(name, totallen, ns, &nodes_len, NULL, 0) != 0) {
 249                 warn("sysctl(get)");
 250                 return -1;
 251         }
 252
 253         for (i = 0; i < nodes_len / sizeof(ns[0]); i++) {
 254                 pns = &ns[i];
 255                 if (if_indextoname(pns->ns_ifindex, ifname) == NULL) {
 256                         warn("if_indextoname");
 257                         return -1;
 258                 }
 259                 if (cf->cf_p && (pns->ns_capinfo & IEEE80211_CAPINFO_PRIVACY))
 260                         continue;
 261                 printf("%s: mac %s ", ifname, ether_string(pns->ns_macaddr));
 262                 printf("bss %s\n", ether_string(pns->ns_bssid));
 263                 print_node_flags(pns->ns_flags);
 264
 265                 /* TBD deal with binary ESSID */
 266                 printf("\tess <%.*s>\n", pns->ns_esslen, pns->ns_essid);
 267
 268                 print_channel(pns->ns_chanidx, pns->ns_freq, pns->ns_chanflags);
 269
 270                 print_capinfo(pns->ns_capinfo);
 271
 272                 assert(sizeof(ts) == sizeof(pns->ns_tstamp));
 273                 memcpy(&ts, &pns->ns_tstamp[0], sizeof(ts));
 274                 printf("\tbeacon-interval %d TU tsft %" PRIu64 " us\n",
 275                     pns->ns_intval, (u_int64_t)le64toh(ts));
 276
 277                 print_rateset(&pns->ns_rates, pns->ns_txrate);
 278
 279                 printf("\tassoc-id %d assoc-failed %d inactivity %ds\n",
 280                     pns->ns_associd, pns->ns_fails, pns->ns_inact);
 281
 282                 printf("\trssi %d txseq %d rxseq %d\n",
 283                     pns->ns_rssi, pns->ns_txseq, pns->ns_rxseq);
 284         }
 285         return 0;
 286 }
 287
 288 static void
 289 usage(void)
 290 {
 291         fprintf(stderr, "usage: %s [ -p ] [ -v ] -a\n"
 292             "\t[ -v ] interface [ interface ... ]\n", getprogname());
 293         exit(EXIT_FAILURE);
 294 }
 295
 296 static void
 297 parse_args(int *argcp, char ***argvp, struct cmdflags *cf)
 298 {
 299         int ch;
 300
 301         (void)memset(cf, 0, sizeof(*cf));
 302
 303         while ((ch = getopt(*argcp, *argvp, "apv")) != -1) {
 304                 switch (ch) {
 305                 case 'a':
 306                         cf->cf_a = 1;
 307                         break;
 308                 case 'p':
 309                         cf->cf_p = 1;
 310                         break;
 311                 case 'v':
 312                         cf->cf_v = 1;
 313                         break;
 314                 default:
 315                         warnx("unknown option -%c", ch);
 316                         usage();
 317                 }
 318         }
 319
 320         *argcp -= optind;
 321         *argvp += optind;
 322 }
 323
 324 #define LOGICAL_XOR(x, y) (!(x) != !(y))
 325
 326 int
 327 main(int argc, char **argv)
 328 {
 329         int i;
 330         struct cmdflags cf;
 331
 332         parse_args(&argc, &argv, &cf);
 333
 334         if (!LOGICAL_XOR(argc > 0, cf.cf_a))
 335                 usage();
 336
 337         if (cf.cf_a) {
 338                 if (dump_nodes(NULL, IEEE80211_SYSCTL_T_NODE, &cf) != 0)
 339                         return EXIT_FAILURE;
 340                 return EXIT_SUCCESS;
 341         }
 342         for (i = 0; i < argc; i++) {
 343                 if (dump_nodes(argv[i], IEEE80211_SYSCTL_T_NODE, &cf) != 0)
 344                         return EXIT_FAILURE;
 345         }
 346
 347         return EXIT_SUCCESS;
 348 }