wlantest/wlantest_cli.c

   1 /*
   2  * wlantest controller
   3  * Copyright (c) 2010-2013, Jouni Malinen <j@w1.fi>
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "utils/includes.h"
  10 #include <sys/un.h>
  11
  12 #include "utils/common.h"
  13 #include "utils/eloop.h"
  14 #include "utils/edit.h"
  15 #include "wlantest_ctrl.h"
  16
  17
  18 static int get_cmd_arg_num(const char *str, int pos)
  19 {
  20         int arg = 0, i;
  21
  22         for (i = 0; i <= pos; i++) {
  23                 if (str[i] != ' ') {
  24                         arg++;
  25                         while (i <= pos && str[i] != ' ')
  26                                 i++;
  27                 }
  28         }
  29
  30         if (arg > 0)
  31                 arg--;
  32         return arg;
  33 }
  34
  35
  36 static int get_prev_arg_pos(const char *str, int pos)
  37 {
  38         while (pos > 0 && str[pos - 1] != ' ')
  39                 pos--;
  40         while (pos > 0 && str[pos - 1] == ' ')
  41                 pos--;
  42         while (pos > 0 && str[pos - 1] != ' ')
  43                 pos--;
  44         return pos;
  45 }
  46
  47
  48 static u8 * attr_get(u8 *buf, size_t buflen, enum wlantest_ctrl_attr attr,
  49                      size_t *len)
  50 {
  51         u8 *pos = buf;
  52
  53         while (pos + 8 <= buf + buflen) {
  54                 enum wlantest_ctrl_attr a;
  55                 size_t alen;
  56                 a = WPA_GET_BE32(pos);
  57                 pos += 4;
  58                 alen = WPA_GET_BE32(pos);
  59                 pos += 4;
  60                 if (pos + alen > buf + buflen) {
  61                         printf("Invalid control message attribute\n");
  62                         return NULL;
  63                 }
  64                 if (a == attr) {
  65                         *len = alen;
  66                         return pos;
  67                 }
  68                 pos += alen;
  69         }
  70
  71         return NULL;
  72 }
  73
  74
  75 static u8 * attr_hdr_add(u8 *pos, u8 *end, enum wlantest_ctrl_attr attr,
  76                          size_t len)
  77 {
  78         if (pos == NULL || end - pos < 8 + len)
  79                 return NULL;
  80         WPA_PUT_BE32(pos, attr);
  81         pos += 4;
  82         WPA_PUT_BE32(pos, len);
  83         pos += 4;
  84         return pos;
  85 }
  86
  87
  88 static u8 * attr_add_str(u8 *pos, u8 *end, enum wlantest_ctrl_attr attr,
  89                          const char *str)
  90 {
  91         size_t len = os_strlen(str);
  92
  93         if (pos == NULL || end - pos < 8 + len)
  94                 return NULL;
  95         WPA_PUT_BE32(pos, attr);
  96         pos += 4;
  97         WPA_PUT_BE32(pos, len);
  98         pos += 4;
  99         os_memcpy(pos, str, len);
 100         pos += len;
 101         return pos;
 102 }
 103
 104
 105 static u8 * attr_add_be32(u8 *pos, u8 *end, enum wlantest_ctrl_attr attr,
 106                           u32 val)
 107 {
 108         if (pos == NULL || end - pos < 12)
 109                 return NULL;
 110         WPA_PUT_BE32(pos, attr);
 111         pos += 4;
 112         WPA_PUT_BE32(pos, 4);
 113         pos += 4;
 114         WPA_PUT_BE32(pos, val);
 115         pos += 4;
 116         return pos;
 117 }
 118
 119
 120 static int cmd_send_and_recv(int s, const u8 *cmd, size_t cmd_len,
 121                              u8 *resp, size_t max_resp_len)
 122 {
 123         int res;
 124         enum wlantest_ctrl_cmd cmd_resp;
 125
 126         if (send(s, cmd, cmd_len, 0) < 0)
 127                 return -1;
 128         res = recv(s, resp, max_resp_len, 0);
 129         if (res < 4)
 130                 return -1;
 131
 132         cmd_resp = WPA_GET_BE32(resp);
 133         if (cmd_resp == WLANTEST_CTRL_SUCCESS)
 134                 return res;
 135
 136         if (cmd_resp == WLANTEST_CTRL_UNKNOWN_CMD)
 137                 printf("Unknown command\n");
 138         else if (cmd_resp == WLANTEST_CTRL_INVALID_CMD)
 139                 printf("Invalid command\n");
 140
 141         return -1;
 142 }
 143
 144
 145 static int cmd_simple(int s, enum wlantest_ctrl_cmd cmd)
 146 {
 147         u8 buf[4];
 148         int res;
 149         WPA_PUT_BE32(buf, cmd);
 150         res = cmd_send_and_recv(s, buf, sizeof(buf), buf, sizeof(buf));
 151         return res < 0 ? -1 : 0;
 152 }
 153
 154
 155 static char ** get_bssid_list(int s)
 156 {
 157         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
 158         u8 buf[4];
 159         u8 *bssid;
 160         size_t len;
 161         int rlen, i;
 162         char **res;
 163
 164         WPA_PUT_BE32(buf, WLANTEST_CTRL_LIST_BSS);
 165         rlen = cmd_send_and_recv(s, buf, sizeof(buf), resp, sizeof(resp));
 166         if (rlen < 0)
 167                 return NULL;
 168
 169         bssid = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_BSSID, &len);
 170         if (bssid == NULL)
 171                 return NULL;
 172
 173         res = os_calloc(len / ETH_ALEN + 1, sizeof(char *));
 174         if (res == NULL)
 175                 return NULL;
 176         for (i = 0; i < len / ETH_ALEN; i++) {
 177                 res[i] = os_zalloc(18);
 178                 if (res[i] == NULL)
 179                         break;
 180                 os_snprintf(res[i], 18, MACSTR, MAC2STR(bssid + ETH_ALEN * i));
 181         }
 182
 183         return res;
 184 }
 185
 186
 187 static char ** get_sta_list(int s, const u8 *bssid, int add_bcast)
 188 {
 189         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
 190         u8 buf[100], *pos, *end;
 191         u8 *addr;
 192         size_t len;
 193         int rlen, i;
 194         char **res;
 195
 196         pos = buf;
 197         end = buf + sizeof(buf);
 198         WPA_PUT_BE32(pos, WLANTEST_CTRL_LIST_STA);
 199         pos += 4;
 200         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
 201         os_memcpy(pos, bssid, ETH_ALEN);
 202         pos += ETH_ALEN;
 203         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
 204         if (rlen < 0)
 205                 return NULL;
 206
 207         addr = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_STA_ADDR, &len);
 208         if (addr == NULL)
 209                 return NULL;
 210
 211         res = os_calloc(len / ETH_ALEN + 1 + add_bcast, sizeof(char *));
 212         if (res == NULL)
 213                 return NULL;
 214         for (i = 0; i < len / ETH_ALEN; i++) {
 215                 res[i] = os_zalloc(18);
 216                 if (res[i] == NULL)
 217                         break;
 218                 os_snprintf(res[i], 18, MACSTR, MAC2STR(addr + ETH_ALEN * i));
 219         }
 220         if (add_bcast)
 221                 res[i] = os_strdup("ff:ff:ff:ff:ff:ff");
 222
 223         return res;
 224 }
 225
 226
 227 static int cmd_ping(int s, int argc, char *argv[])
 228 {
 229         int res = cmd_simple(s, WLANTEST_CTRL_PING);
 230         if (res == 0)
 231                 printf("PONG\n");
 232         return res == 0;
 233 }
 234
 235
 236 static int cmd_terminate(int s, int argc, char *argv[])
 237 {
 238         return cmd_simple(s, WLANTEST_CTRL_TERMINATE);
 239 }
 240
 241
 242 static int cmd_list_bss(int s, int argc, char *argv[])
 243 {
 244         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
 245         u8 buf[4];
 246         u8 *bssid;
 247         size_t len;
 248         int rlen, i;
 249
 250         WPA_PUT_BE32(buf, WLANTEST_CTRL_LIST_BSS);
 251         rlen = cmd_send_and_recv(s, buf, sizeof(buf), resp, sizeof(resp));
 252         if (rlen < 0)
 253                 return -1;
 254
 255         bssid = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_BSSID, &len);
 256         if (bssid == NULL)
 257                 return -1;
 258
 259         for (i = 0; i < len / ETH_ALEN; i++)
 260                 printf(MACSTR " ", MAC2STR(bssid + ETH_ALEN * i));
 261         printf("\n");
 262
 263         return 0;
 264 }
 265
 266
 267 static int cmd_list_sta(int s, int argc, char *argv[])
 268 {
 269         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
 270         u8 buf[100], *pos;
 271         u8 *addr;
 272         size_t len;
 273         int rlen, i;
 274
 275         if (argc < 1) {
 276                 printf("list_sta needs one argument: BSSID\n");
 277                 return -1;
 278         }
 279
 280         pos = buf;
 281         WPA_PUT_BE32(pos, WLANTEST_CTRL_LIST_STA);
 282         pos += 4;
 283         WPA_PUT_BE32(pos, WLANTEST_ATTR_BSSID);
 284         pos += 4;
 285         WPA_PUT_BE32(pos, ETH_ALEN);
 286         pos += 4;
 287         if (hwaddr_aton(argv[0], pos) < 0) {
 288                 printf("Invalid BSSID '%s'\n", argv[0]);
 289                 return -1;
 290         }
 291         pos += ETH_ALEN;
 292
 293         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
 294         if (rlen < 0)
 295                 return -1;
 296
 297         addr = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_STA_ADDR, &len);
 298         if (addr == NULL)
 299                 return -1;
 300
 301         for (i = 0; i < len / ETH_ALEN; i++)
 302                 printf(MACSTR " ", MAC2STR(addr + ETH_ALEN * i));
 303         printf("\n");
 304
 305         return 0;
 306 }
 307
 308
 309 static char ** complete_list_sta(int s, const char *str, int pos)
 310 {
 311         if (get_cmd_arg_num(str, pos) == 1)
 312                 return get_bssid_list(s);
 313         return NULL;
 314 }
 315
 316
 317 static int cmd_flush(int s, int argc, char *argv[])
 318 {
 319         return cmd_simple(s, WLANTEST_CTRL_FLUSH);
 320 }
 321
 322
 323 static int cmd_clear_sta_counters(int s, int argc, char *argv[])
 324 {
 325         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
 326         u8 buf[100], *pos;
 327         int rlen;
 328
 329         if (argc < 2) {
 330                 printf("clear_sta_counters needs two arguments: BSSID and "
 331                        "STA address\n");
 332                 return -1;
 333         }
 334
 335         pos = buf;
 336         WPA_PUT_BE32(pos, WLANTEST_CTRL_CLEAR_STA_COUNTERS);
 337         pos += 4;
 338         WPA_PUT_BE32(pos, WLANTEST_ATTR_BSSID);
 339         pos += 4;
 340         WPA_PUT_BE32(pos, ETH_ALEN);
 341         pos += 4;
 342         if (hwaddr_aton(argv[0], pos) < 0) {
 343                 printf("Invalid BSSID '%s'\n", argv[0]);
 344                 return -1;
 345         }
 346         pos += ETH_ALEN;
 347
 348         WPA_PUT_BE32(pos, WLANTEST_ATTR_STA_ADDR);
 349         pos += 4;
 350         WPA_PUT_BE32(pos, ETH_ALEN);
 351         pos += 4;
 352         if (hwaddr_aton(argv[1], pos) < 0) {
 353                 printf("Invalid STA address '%s'\n", argv[1]);
 354                 return -1;
 355         }
 356         pos += ETH_ALEN;
 357
 358         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
 359         if (rlen < 0)
 360                 return -1;
 361         printf("OK\n");
 362         return 0;
 363 }
 364
 365
 366 static char ** complete_clear_sta_counters(int s, const char *str, int pos)
 367 {
 368         int arg = get_cmd_arg_num(str, pos);
 369         char **res = NULL;
 370         u8 addr[ETH_ALEN];
 371
 372         switch (arg) {
 373         case 1:
 374                 res = get_bssid_list(s);
 375                 break;
 376         case 2:
 377                 if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
 378                         break;
 379                 res = get_sta_list(s, addr, 0);
 380                 break;
 381         }
 382
 383         return res;
 384 }
 385
 386
 387 static int cmd_clear_bss_counters(int s, int argc, char *argv[])
 388 {
 389         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
 390         u8 buf[100], *pos;
 391         int rlen;
 392
 393         if (argc < 1) {
 394                 printf("clear_bss_counters needs one argument: BSSID\n");
 395                 return -1;
 396         }
 397
 398         pos = buf;
 399         WPA_PUT_BE32(pos, WLANTEST_CTRL_CLEAR_BSS_COUNTERS);
 400         pos += 4;
 401         WPA_PUT_BE32(pos, WLANTEST_ATTR_BSSID);
 402         pos += 4;
 403         WPA_PUT_BE32(pos, ETH_ALEN);
 404         pos += 4;
 405         if (hwaddr_aton(argv[0], pos) < 0) {
 406                 printf("Invalid BSSID '%s'\n", argv[0]);
 407                 return -1;
 408         }
 409         pos += ETH_ALEN;
 410
 411         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
 412         if (rlen < 0)
 413                 return -1;
 414         printf("OK\n");
 415         return 0;
 416 }
 417
 418
 419 static char ** complete_clear_bss_counters(int s, const char *str, int pos)
 420 {
 421         if (get_cmd_arg_num(str, pos) == 1)
 422                 return get_bssid_list(s);
 423         return NULL;
 424 }
 425
 426
 427 static int cmd_clear_tdls_counters(int s, int argc, char *argv[])
 428 {
 429         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
 430         u8 buf[100], *pos;
 431         int rlen;
 432
 433         if (argc < 3) {
 434                 printf("clear_tdls_counters needs three arguments: BSSID, "
 435                        "STA1 address, STA2 address\n");
 436                 return -1;
 437         }
 438
 439         pos = buf;
 440         WPA_PUT_BE32(pos, WLANTEST_CTRL_CLEAR_TDLS_COUNTERS);
 441         pos += 4;
 442         WPA_PUT_BE32(pos, WLANTEST_ATTR_BSSID);
 443         pos += 4;
 444         WPA_PUT_BE32(pos, ETH_ALEN);
 445         pos += 4;
 446         if (hwaddr_aton(argv[0], pos) < 0) {
 447                 printf("Invalid BSSID '%s'\n", argv[0]);
 448                 return -1;
 449         }
 450         pos += ETH_ALEN;
 451
 452         WPA_PUT_BE32(pos, WLANTEST_ATTR_STA_ADDR);
 453         pos += 4;
 454         WPA_PUT_BE32(pos, ETH_ALEN);
 455         pos += 4;
 456         if (hwaddr_aton(argv[1], pos) < 0) {
 457                 printf("Invalid STA1 address '%s'\n", argv[1]);
 458                 return -1;
 459         }
 460         pos += ETH_ALEN;
 461
 462         WPA_PUT_BE32(pos, WLANTEST_ATTR_STA2_ADDR);
 463         pos += 4;
 464         WPA_PUT_BE32(pos, ETH_ALEN);
 465         pos += 4;
 466         if (hwaddr_aton(argv[2], pos) < 0) {
 467                 printf("Invalid STA2 address '%s'\n", argv[2]);
 468                 return -1;
 469         }
 470         pos += ETH_ALEN;
 471
 472         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
 473         if (rlen < 0)
 474                 return -1;
 475         printf("OK\n");
 476         return 0;
 477 }
 478
 479
 480 static char ** complete_clear_tdls_counters(int s, const char *str, int pos)
 481 {
 482         int arg = get_cmd_arg_num(str, pos);
 483         char **res = NULL;
 484         u8 addr[ETH_ALEN];
 485
 486         switch (arg) {
 487         case 1:
 488                 res = get_bssid_list(s);
 489                 break;
 490         case 2:
 491         case 3:
 492                 if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
 493                         break;
 494                 res = get_sta_list(s, addr, 0);
 495                 break;
 496         }
 497
 498         return res;
 499 }
 500
 501
 502 struct sta_counters {
 503         const char *name;
 504         enum wlantest_sta_counter num;
 505 };
 506
 507 static const struct sta_counters sta_counters[] = {
 508         { "auth_tx", WLANTEST_STA_COUNTER_AUTH_TX },
 509         { "auth_rx", WLANTEST_STA_COUNTER_AUTH_RX },
 510         { "assocreq_tx", WLANTEST_STA_COUNTER_ASSOCREQ_TX },
 511         { "reassocreq_tx", WLANTEST_STA_COUNTER_REASSOCREQ_TX },
 512         { "ptk_learned", WLANTEST_STA_COUNTER_PTK_LEARNED },
 513         { "valid_deauth_tx", WLANTEST_STA_COUNTER_VALID_DEAUTH_TX },
 514         { "valid_deauth_rx", WLANTEST_STA_COUNTER_VALID_DEAUTH_RX },
 515         { "invalid_deauth_tx", WLANTEST_STA_COUNTER_INVALID_DEAUTH_TX },
 516         { "invalid_deauth_rx", WLANTEST_STA_COUNTER_INVALID_DEAUTH_RX },
 517         { "valid_disassoc_tx", WLANTEST_STA_COUNTER_VALID_DISASSOC_TX },
 518         { "valid_disassoc_rx", WLANTEST_STA_COUNTER_VALID_DISASSOC_RX },
 519         { "invalid_disassoc_tx", WLANTEST_STA_COUNTER_INVALID_DISASSOC_TX },
 520         { "invalid_disassoc_rx", WLANTEST_STA_COUNTER_INVALID_DISASSOC_RX },
 521         { "valid_saqueryreq_tx", WLANTEST_STA_COUNTER_VALID_SAQUERYREQ_TX },
 522         { "valid_saqueryreq_rx", WLANTEST_STA_COUNTER_VALID_SAQUERYREQ_RX },
 523         { "invalid_saqueryreq_tx",
 524           WLANTEST_STA_COUNTER_INVALID_SAQUERYREQ_TX },
 525         { "invalid_saqueryreq_rx",
 526           WLANTEST_STA_COUNTER_INVALID_SAQUERYREQ_RX },
 527         { "valid_saqueryresp_tx", WLANTEST_STA_COUNTER_VALID_SAQUERYRESP_TX },
 528         { "valid_saqueryresp_rx", WLANTEST_STA_COUNTER_VALID_SAQUERYRESP_RX },
 529         { "invalid_saqueryresp_tx",
 530           WLANTEST_STA_COUNTER_INVALID_SAQUERYRESP_TX },
 531         { "invalid_saqueryresp_rx",
 532           WLANTEST_STA_COUNTER_INVALID_SAQUERYRESP_RX },
 533         { "ping_ok", WLANTEST_STA_COUNTER_PING_OK },
 534         { "assocresp_comeback", WLANTEST_STA_COUNTER_ASSOCRESP_COMEBACK },
 535         { "reassocresp_comeback", WLANTEST_STA_COUNTER_REASSOCRESP_COMEBACK },
 536         { "ping_ok_first_assoc", WLANTEST_STA_COUNTER_PING_OK_FIRST_ASSOC },
 537         { "valid_deauth_rx_ack", WLANTEST_STA_COUNTER_VALID_DEAUTH_RX_ACK },
 538         { "valid_disassoc_rx_ack",
 539           WLANTEST_STA_COUNTER_VALID_DISASSOC_RX_ACK },
 540         { "invalid_deauth_rx_ack",
 541           WLANTEST_STA_COUNTER_INVALID_DEAUTH_RX_ACK },
 542         { "invalid_disassoc_rx_ack",
 543           WLANTEST_STA_COUNTER_INVALID_DISASSOC_RX_ACK },
 544         { "deauth_rx_asleep", WLANTEST_STA_COUNTER_DEAUTH_RX_ASLEEP },
 545         { "deauth_rx_awake", WLANTEST_STA_COUNTER_DEAUTH_RX_AWAKE },
 546         { "disassoc_rx_asleep", WLANTEST_STA_COUNTER_DISASSOC_RX_ASLEEP },
 547         { "disassoc_rx_awake", WLANTEST_STA_COUNTER_DISASSOC_RX_AWAKE },
 548         { "prot_data_tx", WLANTEST_STA_COUNTER_PROT_DATA_TX },
 549         { "deauth_rx_rc6", WLANTEST_STA_COUNTER_DEAUTH_RX_RC6 },
 550         { "deauth_rx_rc7", WLANTEST_STA_COUNTER_DEAUTH_RX_RC7 },
 551         { "disassoc_rx_rc6", WLANTEST_STA_COUNTER_DISASSOC_RX_RC6 },
 552         { "disassoc_rx_rc7", WLANTEST_STA_COUNTER_DISASSOC_RX_RC7 },
 553         { NULL, 0 }
 554 };
 555
 556 static int cmd_get_sta_counter(int s, int argc, char *argv[])
 557 {
 558         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
 559         u8 buf[100], *end, *pos;
 560         int rlen, i;
 561         size_t len;
 562
 563         if (argc != 3) {
 564                 printf("get_sta_counter needs at three arguments: "
 565                        "counter name, BSSID, and STA address\n");
 566                 return -1;
 567         }
 568
 569         pos = buf;
 570         end = buf + sizeof(buf);
 571         WPA_PUT_BE32(pos, WLANTEST_CTRL_GET_STA_COUNTER);
 572         pos += 4;
 573
 574         for (i = 0; sta_counters[i].name; i++) {
 575                 if (os_strcasecmp(sta_counters[i].name, argv[0]) == 0)
 576                         break;
 577         }
 578         if (sta_counters[i].name == NULL) {
 579                 printf("Unknown STA counter '%s'\n", argv[0]);
 580                 printf("Counters:");
 581                 for (i = 0; sta_counters[i].name; i++)
 582                         printf(" %s", sta_counters[i].name);
 583                 printf("\n");
 584                 return -1;
 585         }
 586
 587         pos = attr_add_be32(pos, end, WLANTEST_ATTR_STA_COUNTER,
 588                             sta_counters[i].num);
 589         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
 590         if (hwaddr_aton(argv[1], pos) < 0) {
 591                 printf("Invalid BSSID '%s'\n", argv[1]);
 592                 return -1;
 593         }
 594         pos += ETH_ALEN;
 595
 596         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
 597         if (hwaddr_aton(argv[2], pos) < 0) {
 598                 printf("Invalid STA address '%s'\n", argv[2]);
 599                 return -1;
 600         }
 601         pos += ETH_ALEN;
 602
 603         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
 604         if (rlen < 0)
 605                 return -1;
 606
 607         pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_COUNTER, &len);
 608         if (pos == NULL || len != 4)
 609                 return -1;
 610         printf("%u\n", WPA_GET_BE32(pos));
 611         return 0;
 612 }
 613
 614
 615 static char ** complete_get_sta_counter(int s, const char *str, int pos)
 616 {
 617         int arg = get_cmd_arg_num(str, pos);
 618         char **res = NULL;
 619         int i, count;
 620         u8 addr[ETH_ALEN];
 621
 622         switch (arg) {
 623         case 1:
 624                 /* counter list */
 625                 count = sizeof(sta_counters) / sizeof(sta_counters[0]);
 626                 res = os_calloc(count, sizeof(char *));
 627                 if (res == NULL)
 628                         return NULL;
 629                 for (i = 0; sta_counters[i].name; i++) {
 630                         res[i] = os_strdup(sta_counters[i].name);
 631                         if (res[i] == NULL)
 632                                 break;
 633                 }
 634                 break;
 635         case 2:
 636                 res = get_bssid_list(s);
 637                 break;
 638         case 3:
 639                 if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
 640                         break;
 641                 res = get_sta_list(s, addr, 0);
 642                 break;
 643         }
 644
 645         return res;
 646 }
 647
 648
 649 struct bss_counters {
 650         const char *name;
 651         enum wlantest_bss_counter num;
 652 };
 653
 654 static const struct bss_counters bss_counters[] = {
 655         { "valid_bip_mmie", WLANTEST_BSS_COUNTER_VALID_BIP_MMIE },
 656         { "invalid_bip_mmie", WLANTEST_BSS_COUNTER_INVALID_BIP_MMIE },
 657         { "missing_bip_mmie", WLANTEST_BSS_COUNTER_MISSING_BIP_MMIE },
 658         { "bip_deauth", WLANTEST_BSS_COUNTER_BIP_DEAUTH },
 659         { "bip_disassoc", WLANTEST_BSS_COUNTER_BIP_DISASSOC },
 660         { NULL, 0 }
 661 };
 662
 663 static int cmd_get_bss_counter(int s, int argc, char *argv[])
 664 {
 665         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
 666         u8 buf[100], *end, *pos;
 667         int rlen, i;
 668         size_t len;
 669
 670         if (argc != 2) {
 671                 printf("get_bss_counter needs at two arguments: "
 672                        "counter name and BSSID\n");
 673                 return -1;
 674         }
 675
 676         pos = buf;
 677         end = buf + sizeof(buf);
 678         WPA_PUT_BE32(pos, WLANTEST_CTRL_GET_BSS_COUNTER);
 679         pos += 4;
 680
 681         for (i = 0; bss_counters[i].name; i++) {
 682                 if (os_strcasecmp(bss_counters[i].name, argv[0]) == 0)
 683                         break;
 684         }
 685         if (bss_counters[i].name == NULL) {
 686                 printf("Unknown BSS counter '%s'\n", argv[0]);
 687                 printf("Counters:");
 688                 for (i = 0; bss_counters[i].name; i++)
 689                         printf(" %s", bss_counters[i].name);
 690                 printf("\n");
 691                 return -1;
 692         }
 693
 694         pos = attr_add_be32(pos, end, WLANTEST_ATTR_BSS_COUNTER,
 695                             bss_counters[i].num);
 696         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
 697         if (hwaddr_aton(argv[1], pos) < 0) {
 698                 printf("Invalid BSSID '%s'\n", argv[1]);
 699                 return -1;
 700         }
 701         pos += ETH_ALEN;
 702
 703         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
 704         if (rlen < 0)
 705                 return -1;
 706
 707         pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_COUNTER, &len);
 708         if (pos == NULL || len != 4)
 709                 return -1;
 710         printf("%u\n", WPA_GET_BE32(pos));
 711         return 0;
 712 }
 713
 714
 715 static char ** complete_get_bss_counter(int s, const char *str, int pos)
 716 {
 717         int arg = get_cmd_arg_num(str, pos);
 718         char **res = NULL;
 719         int i, count;
 720
 721         switch (arg) {
 722         case 1:
 723                 /* counter list */
 724                 count = sizeof(bss_counters) / sizeof(bss_counters[0]);
 725                 res = os_calloc(count, sizeof(char *));
 726                 if (res == NULL)
 727                         return NULL;
 728                 for (i = 0; bss_counters[i].name; i++) {
 729                         res[i] = os_strdup(bss_counters[i].name);
 730                         if (res[i] == NULL)
 731                                 break;
 732                 }
 733                 break;
 734         case 2:
 735                 res = get_bssid_list(s);
 736                 break;
 737         }
 738
 739         return res;
 740 }
 741
 742
 743 struct tdls_counters {
 744         const char *name;
 745         enum wlantest_tdls_counter num;
 746 };
 747
 748 static const struct tdls_counters tdls_counters[] = {
 749         { "valid_direct_link", WLANTEST_TDLS_COUNTER_VALID_DIRECT_LINK },
 750         { "invalid_direct_link", WLANTEST_TDLS_COUNTER_INVALID_DIRECT_LINK },
 751         { "valid_ap_path", WLANTEST_TDLS_COUNTER_VALID_AP_PATH },
 752         { "invalid_ap_path", WLANTEST_TDLS_COUNTER_INVALID_AP_PATH },
 753         { "setup_req", WLANTEST_TDLS_COUNTER_SETUP_REQ },
 754         { "setup_resp_ok", WLANTEST_TDLS_COUNTER_SETUP_RESP_OK },
 755         { "setup_resp_fail", WLANTEST_TDLS_COUNTER_SETUP_RESP_FAIL },
 756         { "setup_conf_ok", WLANTEST_TDLS_COUNTER_SETUP_CONF_OK },
 757         { "setup_conf_fail", WLANTEST_TDLS_COUNTER_SETUP_CONF_FAIL },
 758         { "teardown", WLANTEST_TDLS_COUNTER_TEARDOWN },
 759         { NULL, 0 }
 760 };
 761
 762 static int cmd_get_tdls_counter(int s, int argc, char *argv[])
 763 {
 764         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
 765         u8 buf[100], *end, *pos;
 766         int rlen, i;
 767         size_t len;
 768
 769         if (argc != 4) {
 770                 printf("get_tdls_counter needs four arguments: "
 771                        "counter name, BSSID, STA1 address, STA2 address\n");
 772                 return -1;
 773         }
 774
 775         pos = buf;
 776         end = buf + sizeof(buf);
 777         WPA_PUT_BE32(pos, WLANTEST_CTRL_GET_TDLS_COUNTER);
 778         pos += 4;
 779
 780         for (i = 0; tdls_counters[i].name; i++) {
 781                 if (os_strcasecmp(tdls_counters[i].name, argv[0]) == 0)
 782                         break;
 783         }
 784         if (tdls_counters[i].name == NULL) {
 785                 printf("Unknown TDLS counter '%s'\n", argv[0]);
 786                 printf("Counters:");
 787                 for (i = 0; tdls_counters[i].name; i++)
 788                         printf(" %s", tdls_counters[i].name);
 789                 printf("\n");
 790                 return -1;
 791         }
 792
 793         pos = attr_add_be32(pos, end, WLANTEST_ATTR_TDLS_COUNTER,
 794                             tdls_counters[i].num);
 795         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
 796         if (hwaddr_aton(argv[1], pos) < 0) {
 797                 printf("Invalid BSSID '%s'\n", argv[1]);
 798                 return -1;
 799         }
 800         pos += ETH_ALEN;
 801
 802         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
 803         if (hwaddr_aton(argv[2], pos) < 0) {
 804                 printf("Invalid STA1 address '%s'\n", argv[2]);
 805                 return -1;
 806         }
 807         pos += ETH_ALEN;
 808
 809         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA2_ADDR, ETH_ALEN);
 810         if (hwaddr_aton(argv[3], pos) < 0) {
 811                 printf("Invalid STA2 address '%s'\n", argv[3]);
 812                 return -1;
 813         }
 814         pos += ETH_ALEN;
 815
 816         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
 817         if (rlen < 0)
 818                 return -1;
 819
 820         pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_COUNTER, &len);
 821         if (pos == NULL || len != 4)
 822                 return -1;
 823         printf("%u\n", WPA_GET_BE32(pos));
 824         return 0;
 825 }
 826
 827
 828 static char ** complete_get_tdls_counter(int s, const char *str, int pos)
 829 {
 830         int arg = get_cmd_arg_num(str, pos);
 831         char **res = NULL;
 832         int i, count;
 833         u8 addr[ETH_ALEN];
 834
 835         switch (arg) {
 836         case 1:
 837                 /* counter list */
 838                 count = sizeof(tdls_counters) / sizeof(tdls_counters[0]);
 839                 res = os_calloc(count, sizeof(char *));
 840                 if (res == NULL)
 841                         return NULL;
 842                 for (i = 0; tdls_counters[i].name; i++) {
 843                         res[i] = os_strdup(tdls_counters[i].name);
 844                         if (res[i] == NULL)
 845                                 break;
 846                 }
 847                 break;
 848         case 2:
 849                 res = get_bssid_list(s);
 850                 break;
 851         case 3:
 852         case 4:
 853                 if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
 854                         break;
 855                 res = get_sta_list(s, addr, 0);
 856                 break;
 857         }
 858
 859         return res;
 860 }
 861
 862
 863 struct inject_frames {
 864         const char *name;
 865         enum wlantest_inject_frame frame;
 866 };
 867
 868 static const struct inject_frames inject_frames[] = {
 869         { "auth", WLANTEST_FRAME_AUTH },
 870         { "assocreq", WLANTEST_FRAME_ASSOCREQ },
 871         { "reassocreq", WLANTEST_FRAME_REASSOCREQ },
 872         { "deauth", WLANTEST_FRAME_DEAUTH },
 873         { "disassoc", WLANTEST_FRAME_DISASSOC },
 874         { "saqueryreq", WLANTEST_FRAME_SAQUERYREQ },
 875         { NULL, 0 }
 876 };
 877
 878 static int cmd_inject(int s, int argc, char *argv[])
 879 {
 880         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
 881         u8 buf[100], *end, *pos;
 882         int rlen, i;
 883         enum wlantest_inject_protection prot;
 884
 885         /* <frame> <prot> <sender> <BSSID> <STA/ff:ff:ff:ff:ff:ff> */
 886
 887         if (argc < 5) {
 888                 printf("inject needs five arguments: frame, protection, "
 889                        "sender, BSSID, STA/ff:ff:ff:ff:ff:ff\n");
 890                 return -1;
 891         }
 892
 893         pos = buf;
 894         end = buf + sizeof(buf);
 895         WPA_PUT_BE32(pos, WLANTEST_CTRL_INJECT);
 896         pos += 4;
 897
 898         for (i = 0; inject_frames[i].name; i++) {
 899                 if (os_strcasecmp(inject_frames[i].name, argv[0]) == 0)
 900                         break;
 901         }
 902         if (inject_frames[i].name == NULL) {
 903                 printf("Unknown inject frame '%s'\n", argv[0]);
 904                 printf("Frames:");
 905                 for (i = 0; inject_frames[i].name; i++)
 906                         printf(" %s", inject_frames[i].name);
 907                 printf("\n");
 908                 return -1;
 909         }
 910
 911         pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_FRAME,
 912                             inject_frames[i].frame);
 913
 914         if (os_strcasecmp(argv[1], "normal") == 0)
 915                 prot = WLANTEST_INJECT_NORMAL;
 916         else if (os_strcasecmp(argv[1], "protected") == 0)
 917                 prot = WLANTEST_INJECT_PROTECTED;
 918         else if (os_strcasecmp(argv[1], "unprotected") == 0)
 919                 prot = WLANTEST_INJECT_UNPROTECTED;
 920         else if (os_strcasecmp(argv[1], "incorrect") == 0)
 921                 prot = WLANTEST_INJECT_INCORRECT_KEY;
 922         else {
 923                 printf("Unknown protection type '%s'\n", argv[1]);
 924                 printf("Protection types: normal protected unprotected "
 925                        "incorrect\n");
 926                 return -1;
 927         }
 928         pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_PROTECTION, prot);
 929
 930         if (os_strcasecmp(argv[2], "ap") == 0) {
 931                 pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_SENDER_AP,
 932                                     1);
 933         } else if (os_strcasecmp(argv[2], "sta") == 0) {
 934                 pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_SENDER_AP,
 935                                     0);
 936         } else {
 937                 printf("Unknown sender '%s'\n", argv[2]);
 938                 printf("Sender types: ap sta\n");
 939                 return -1;
 940         }
 941
 942         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
 943         if (hwaddr_aton(argv[3], pos) < 0) {
 944                 printf("Invalid BSSID '%s'\n", argv[3]);
 945                 return -1;
 946         }
 947         pos += ETH_ALEN;
 948
 949         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
 950         if (hwaddr_aton(argv[4], pos) < 0) {
 951                 printf("Invalid STA '%s'\n", argv[4]);
 952                 return -1;
 953         }
 954         pos += ETH_ALEN;
 955
 956         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
 957         if (rlen < 0)
 958                 return -1;
 959         printf("OK\n");
 960         return 0;
 961 }
 962
 963
 964 static char ** complete_inject(int s, const char *str, int pos)
 965 {
 966         int arg = get_cmd_arg_num(str, pos);
 967         char **res = NULL;
 968         int i, count;
 969         u8 addr[ETH_ALEN];
 970
 971         switch (arg) {
 972         case 1:
 973                 /* frame list */
 974                 count = sizeof(inject_frames) / sizeof(inject_frames[0]);
 975                 res = os_calloc(count, sizeof(char *));
 976                 if (res == NULL)
 977                         break;
 978                 for (i = 0; inject_frames[i].name; i++) {
 979                         res[i] = os_strdup(inject_frames[i].name);
 980                         if (res[i] == NULL)
 981                                 break;
 982                 }
 983                 break;
 984         case 2:
 985                 res = os_calloc(5, sizeof(char *));
 986                 if (res == NULL)
 987                         break;
 988                 res[0] = os_strdup("normal");
 989                 if (res[0] == NULL)
 990                         break;
 991                 res[1] = os_strdup("protected");
 992                 if (res[1] == NULL)
 993                         break;
 994                 res[2] = os_strdup("unprotected");
 995                 if (res[2] == NULL)
 996                         break;
 997                 res[3] = os_strdup("incorrect");
 998                 if (res[3] == NULL)
 999                         break;
1000                 break;
1001         case 3:
1002                 res = os_calloc(3, sizeof(char *));
1003                 if (res == NULL)
1004                         break;
1005                 res[0] = os_strdup("ap");
1006                 if (res[0] == NULL)
1007                         break;
1008                 res[1] = os_strdup("sta");
1009                 if (res[1] == NULL)
1010                         break;
1011                 break;
1012         case 4:
1013                 res = get_bssid_list(s);
1014                 break;
1015         case 5:
1016                 if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
1017                         break;
1018                 res = get_sta_list(s, addr, 1);
1019                 break;
1020         }
1021
1022         return res;
1023 }
1024
1025
1026 static u8 * add_hex(u8 *pos, u8 *end, const char *str)
1027 {
1028         const char *s;
1029         int val;
1030
1031         s = str;
1032         while (*s) {
1033                 while (*s == ' ' || *s == '\t' || *s == '\r' || *s == '\n' ||
1034                        *s == ':')
1035                         s++;
1036                 if (*s == '\0')
1037                         break;
1038                 if (*s == '#') {
1039                         while (*s != '\0' && *s != '\r' && *s != '\n')
1040                                 s++;
1041                         continue;
1042                 }
1043
1044                 val = hex2byte(s);
1045                 if (val < 0) {
1046                         printf("Invalid hex encoding '%s'\n", s);
1047                         return NULL;
1048                 }
1049                 if (pos == end) {
1050                         printf("Too long frame\n");
1051                         return NULL;
1052                 }
1053                 *pos++ = val;
1054                 s += 2;
1055         }
1056
1057         return pos;
1058 }
1059
1060
1061 static int cmd_send(int s, int argc, char *argv[])
1062 {
1063         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1064         u8 buf[WLANTEST_CTRL_MAX_CMD_LEN], *end, *pos, *len_pos;
1065         int rlen;
1066         enum wlantest_inject_protection prot;
1067         int arg;
1068
1069         /* <prot> <raw frame as hex dump> */
1070
1071         if (argc < 2) {
1072                 printf("send needs two arguments: protected/unprotected, "
1073                        "raw frame as hex dump\n");
1074                 return -1;
1075         }
1076
1077         pos = buf;
1078         end = buf + sizeof(buf);
1079         WPA_PUT_BE32(pos, WLANTEST_CTRL_SEND);
1080         pos += 4;
1081
1082         if (os_strcasecmp(argv[0], "normal") == 0)
1083                 prot = WLANTEST_INJECT_NORMAL;
1084         else if (os_strcasecmp(argv[0], "protected") == 0)
1085                 prot = WLANTEST_INJECT_PROTECTED;
1086         else if (os_strcasecmp(argv[0], "unprotected") == 0)
1087                 prot = WLANTEST_INJECT_UNPROTECTED;
1088         else if (os_strcasecmp(argv[0], "incorrect") == 0)
1089                 prot = WLANTEST_INJECT_INCORRECT_KEY;
1090         else {
1091                 printf("Unknown protection type '%s'\n", argv[1]);
1092                 printf("Protection types: normal protected unprotected "
1093                        "incorrect\n");
1094                 return -1;
1095         }
1096         pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_PROTECTION, prot);
1097
1098         WPA_PUT_BE32(pos, WLANTEST_ATTR_FRAME);
1099         pos += 4;
1100         len_pos = pos;
1101         pos += 4;
1102
1103         for (arg = 1; pos && arg < argc; arg++)
1104                 pos = add_hex(pos, end, argv[arg]);
1105         if (pos == NULL)
1106                 return -1;
1107
1108         WPA_PUT_BE32(len_pos, pos - len_pos - 4);
1109
1110         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
1111         if (rlen < 0)
1112                 return -1;
1113         printf("OK\n");
1114         return 0;
1115 }
1116
1117
1118 static char ** complete_send(int s, const char *str, int pos)
1119 {
1120         int arg = get_cmd_arg_num(str, pos);
1121         char **res = NULL;
1122
1123         switch (arg) {
1124         case 1:
1125                 res = os_calloc(5, sizeof(char *));
1126                 if (res == NULL)
1127                         break;
1128                 res[0] = os_strdup("normal");
1129                 if (res[0] == NULL)
1130                         break;
1131                 res[1] = os_strdup("protected");
1132                 if (res[1] == NULL)
1133                         break;
1134                 res[2] = os_strdup("unprotected");
1135                 if (res[2] == NULL)
1136                         break;
1137                 res[3] = os_strdup("incorrect");
1138                 if (res[3] == NULL)
1139                         break;
1140                 break;
1141         }
1142
1143         return res;
1144 }
1145
1146
1147 static int cmd_version(int s, int argc, char *argv[])
1148 {
1149         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1150         u8 buf[4];
1151         char *version;
1152         size_t len;
1153         int rlen, i;
1154
1155         WPA_PUT_BE32(buf, WLANTEST_CTRL_VERSION);
1156         rlen = cmd_send_and_recv(s, buf, sizeof(buf), resp, sizeof(resp));
1157         if (rlen < 0)
1158                 return -1;
1159
1160         version = (char *) attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_VERSION,
1161                                     &len);
1162         if (version == NULL)
1163                 return -1;
1164
1165         for (i = 0; i < len; i++)
1166                 putchar(version[i]);
1167         printf("\n");
1168
1169         return 0;
1170 }
1171
1172
1173 static int cmd_add_passphrase(int s, int argc, char *argv[])
1174 {
1175         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1176         u8 buf[100], *pos, *end;
1177         size_t len;
1178         int rlen;
1179
1180         if (argc < 1) {
1181                 printf("add_passphrase needs one argument: passphrase\n");
1182                 return -1;
1183         }
1184
1185         len = os_strlen(argv[0]);
1186         if (len < 8 || len > 63) {
1187                 printf("Invalid passphrase '%s'\n", argv[0]);
1188                 return -1;
1189         }
1190         pos = buf;
1191         end = buf + sizeof(buf);
1192         WPA_PUT_BE32(pos, WLANTEST_CTRL_ADD_PASSPHRASE);
1193         pos += 4;
1194         pos = attr_add_str(pos, end, WLANTEST_ATTR_PASSPHRASE,
1195                            argv[0]);
1196         if (argc > 1) {
1197                 pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
1198                 if (hwaddr_aton(argv[1], pos) < 0) {
1199                         printf("Invalid BSSID '%s'\n", argv[3]);
1200                         return -1;
1201                 }
1202                 pos += ETH_ALEN;
1203         }
1204
1205         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
1206         if (rlen < 0)
1207                 return -1;
1208         return 0;
1209 }
1210
1211
1212 static int cmd_add_wepkey(int s, int argc, char *argv[])
1213 {
1214         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1215         u8 buf[100], *pos, *end;
1216         int rlen;
1217
1218         if (argc < 1) {
1219                 printf("add_wepkey needs one argument: WEP key\n");
1220                 return -1;
1221         }
1222
1223         pos = buf;
1224         end = buf + sizeof(buf);
1225         WPA_PUT_BE32(pos, WLANTEST_CTRL_ADD_PASSPHRASE);
1226         pos += 4;
1227         pos = attr_add_str(pos, end, WLANTEST_ATTR_WEPKEY, argv[0]);
1228
1229         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
1230         if (rlen < 0)
1231                 return -1;
1232         return 0;
1233 }
1234
1235
1236 struct sta_infos {
1237         const char *name;
1238         enum wlantest_sta_info num;
1239 };
1240
1241 static const struct sta_infos sta_infos[] = {
1242         { "proto", WLANTEST_STA_INFO_PROTO },
1243         { "pairwise", WLANTEST_STA_INFO_PAIRWISE },
1244         { "key_mgmt", WLANTEST_STA_INFO_KEY_MGMT },
1245         { "rsn_capab", WLANTEST_STA_INFO_RSN_CAPAB },
1246         { "state", WLANTEST_STA_INFO_STATE },
1247         { "gtk", WLANTEST_STA_INFO_GTK },
1248         { NULL, 0 }
1249 };
1250
1251 static int cmd_info_sta(int s, int argc, char *argv[])
1252 {
1253         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1254         u8 buf[100], *end, *pos;
1255         int rlen, i;
1256         size_t len;
1257         char info[100];
1258
1259         if (argc != 3) {
1260                 printf("sta_info needs at three arguments: "
1261                        "counter name, BSSID, and STA address\n");
1262                 return -1;
1263         }
1264
1265         pos = buf;
1266         end = buf + sizeof(buf);
1267         WPA_PUT_BE32(pos, WLANTEST_CTRL_INFO_STA);
1268         pos += 4;
1269
1270         for (i = 0; sta_infos[i].name; i++) {
1271                 if (os_strcasecmp(sta_infos[i].name, argv[0]) == 0)
1272                         break;
1273         }
1274         if (sta_infos[i].name == NULL) {
1275                 printf("Unknown STA info '%s'\n", argv[0]);
1276                 printf("Info fields:");
1277                 for (i = 0; sta_infos[i].name; i++)
1278                         printf(" %s", sta_infos[i].name);
1279                 printf("\n");
1280                 return -1;
1281         }
1282
1283         pos = attr_add_be32(pos, end, WLANTEST_ATTR_STA_INFO,
1284                             sta_infos[i].num);
1285         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
1286         if (hwaddr_aton(argv[1], pos) < 0) {
1287                 printf("Invalid BSSID '%s'\n", argv[1]);
1288                 return -1;
1289         }
1290         pos += ETH_ALEN;
1291
1292         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
1293         if (hwaddr_aton(argv[2], pos) < 0) {
1294                 printf("Invalid STA address '%s'\n", argv[2]);
1295                 return -1;
1296         }
1297         pos += ETH_ALEN;
1298
1299         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
1300         if (rlen < 0)
1301                 return -1;
1302
1303         pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_INFO, &len);
1304         if (pos == NULL)
1305                 return -1;
1306         if (len >= sizeof(info))
1307                 len = sizeof(info) - 1;
1308         os_memcpy(info, pos, len);
1309         info[len] = '\0';
1310         printf("%s\n", info);
1311         return 0;
1312 }
1313
1314
1315 static char ** complete_info_sta(int s, const char *str, int pos)
1316 {
1317         int arg = get_cmd_arg_num(str, pos);
1318         char **res = NULL;
1319         int i, count;
1320         u8 addr[ETH_ALEN];
1321
1322         switch (arg) {
1323         case 1:
1324                 /* counter list */
1325                 count = sizeof(sta_infos) / sizeof(sta_infos[0]);
1326                 res = os_calloc(count, sizeof(char *));
1327                 if (res == NULL)
1328                         return NULL;
1329                 for (i = 0; sta_infos[i].name; i++) {
1330                         res[i] = os_strdup(sta_infos[i].name);
1331                         if (res[i] == NULL)
1332                                 break;
1333                 }
1334                 break;
1335         case 2:
1336                 res = get_bssid_list(s);
1337                 break;
1338         case 3:
1339                 if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
1340                         break;
1341                 res = get_sta_list(s, addr, 0);
1342                 break;
1343         }
1344
1345         return res;
1346 }
1347
1348
1349 struct bss_infos {
1350         const char *name;
1351         enum wlantest_bss_info num;
1352 };
1353
1354 static const struct bss_infos bss_infos[] = {
1355         { "proto", WLANTEST_BSS_INFO_PROTO },
1356         { "pairwise", WLANTEST_BSS_INFO_PAIRWISE },
1357         { "group", WLANTEST_BSS_INFO_GROUP },
1358         { "group_mgmt", WLANTEST_BSS_INFO_GROUP_MGMT },
1359         { "key_mgmt", WLANTEST_BSS_INFO_KEY_MGMT },
1360         { "rsn_capab", WLANTEST_BSS_INFO_RSN_CAPAB },
1361         { NULL, 0 }
1362 };
1363
1364 static int cmd_info_bss(int s, int argc, char *argv[])
1365 {
1366         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1367         u8 buf[100], *end, *pos;
1368         int rlen, i;
1369         size_t len;
1370         char info[100];
1371
1372         if (argc != 2) {
1373                 printf("bss_info needs at two arguments: "
1374                        "field name and BSSID\n");
1375                 return -1;
1376         }
1377
1378         pos = buf;
1379         end = buf + sizeof(buf);
1380         WPA_PUT_BE32(pos, WLANTEST_CTRL_INFO_BSS);
1381         pos += 4;
1382
1383         for (i = 0; bss_infos[i].name; i++) {
1384                 if (os_strcasecmp(bss_infos[i].name, argv[0]) == 0)
1385                         break;
1386         }
1387         if (bss_infos[i].name == NULL) {
1388                 printf("Unknown BSS info '%s'\n", argv[0]);
1389                 printf("Info fields:");
1390                 for (i = 0; bss_infos[i].name; i++)
1391                         printf(" %s", bss_infos[i].name);
1392                 printf("\n");
1393                 return -1;
1394         }
1395
1396         pos = attr_add_be32(pos, end, WLANTEST_ATTR_BSS_INFO,
1397                             bss_infos[i].num);
1398         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
1399         if (hwaddr_aton(argv[1], pos) < 0) {
1400                 printf("Invalid BSSID '%s'\n", argv[1]);
1401                 return -1;
1402         }
1403         pos += ETH_ALEN;
1404
1405         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
1406         if (rlen < 0)
1407                 return -1;
1408
1409         pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_INFO, &len);
1410         if (pos == NULL)
1411                 return -1;
1412         if (len >= sizeof(info))
1413                 len = sizeof(info) - 1;
1414         os_memcpy(info, pos, len);
1415         info[len] = '\0';
1416         printf("%s\n", info);
1417         return 0;
1418 }
1419
1420
1421 static char ** complete_info_bss(int s, const char *str, int pos)
1422 {
1423         int arg = get_cmd_arg_num(str, pos);
1424         char **res = NULL;
1425         int i, count;
1426
1427         switch (arg) {
1428         case 1:
1429                 /* counter list */
1430                 count = sizeof(bss_infos) / sizeof(bss_infos[0]);
1431                 res = os_calloc(count, sizeof(char *));
1432                 if (res == NULL)
1433                         return NULL;
1434                 for (i = 0; bss_infos[i].name; i++) {
1435                         res[i] = os_strdup(bss_infos[i].name);
1436                         if (res[i] == NULL)
1437                                 break;
1438                 }
1439                 break;
1440         case 2:
1441                 res = get_bssid_list(s);
1442                 break;
1443         }
1444
1445         return res;
1446 }
1447
1448
1449 struct wlantest_cli_cmd {
1450         const char *cmd;
1451         int (*handler)(int s, int argc, char *argv[]);
1452         const char *usage;
1453         char ** (*complete)(int s, const char *str, int pos);
1454 };
1455
1456 static const struct wlantest_cli_cmd wlantest_cli_commands[] = {
1457         { "ping", cmd_ping, "= test connection to wlantest", NULL },
1458         { "terminate", cmd_terminate, "= terminate wlantest", NULL },
1459         { "list_bss", cmd_list_bss, "= get BSS list", NULL },
1460         { "list_sta", cmd_list_sta, "<BSSID> = get STA list",
1461           complete_list_sta },
1462         { "flush", cmd_flush, "= drop all collected BSS data", NULL },
1463         { "clear_sta_counters", cmd_clear_sta_counters,
1464           "<BSSID> <STA> = clear STA counters", complete_clear_sta_counters },
1465         { "clear_bss_counters", cmd_clear_bss_counters,
1466           "<BSSID> = clear BSS counters", complete_clear_bss_counters },
1467         { "get_sta_counter", cmd_get_sta_counter,
1468           "<counter> <BSSID> <STA> = get STA counter value",
1469           complete_get_sta_counter },
1470         { "get_bss_counter", cmd_get_bss_counter,
1471           "<counter> <BSSID> = get BSS counter value",
1472           complete_get_bss_counter },
1473         { "inject", cmd_inject,
1474           "<frame> <prot> <sender> <BSSID> <STA/ff:ff:ff:ff:ff:ff>",
1475           complete_inject },
1476         { "send", cmd_send,
1477           "<prot> <raw frame as hex dump>",
1478           complete_send },
1479         { "version", cmd_version, "= get wlantest version", NULL },
1480         { "add_passphrase", cmd_add_passphrase,
1481           "<passphrase> = add a known passphrase", NULL },
1482         { "add_wepkey", cmd_add_wepkey,
1483           "<WEP key> = add a known WEP key", NULL },
1484         { "info_sta", cmd_info_sta,
1485           "<field> <BSSID> <STA> = get STA information",
1486           complete_info_sta },
1487         { "info_bss", cmd_info_bss,
1488           "<field> <BSSID> = get BSS information",
1489           complete_info_bss },
1490         { "clear_tdls_counters", cmd_clear_tdls_counters,
1491           "<BSSID> <STA1> <STA2> = clear TDLS counters",
1492           complete_clear_tdls_counters },
1493         { "get_tdls_counter", cmd_get_tdls_counter,
1494           "<counter> <BSSID> <STA1> <STA2> = get TDLS counter value",
1495           complete_get_tdls_counter },
1496         { "get_bss_counter", cmd_get_bss_counter,
1497           "<counter> <BSSID> = get BSS counter value",
1498           complete_get_bss_counter },
1499         { NULL, NULL, NULL, NULL }
1500 };
1501
1502
1503 static int ctrl_command(int s, int argc, char *argv[])
1504 {
1505         const struct wlantest_cli_cmd *cmd, *match = NULL;
1506         int count = 0;
1507         int ret = 0;
1508
1509         for (cmd = wlantest_cli_commands; cmd->cmd; cmd++) {
1510                 if (os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0)
1511                 {
1512                         match = cmd;
1513                         if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
1514                                 /* exact match */
1515                                 count = 1;
1516                                 break;
1517                         }
1518                         count++;
1519                 }
1520         }
1521
1522         if (count > 1) {
1523                 printf("Ambiguous command '%s'; possible commands:", argv[0]);
1524                 for (cmd = wlantest_cli_commands; cmd->cmd; cmd++) {
1525                         if (os_strncasecmp(cmd->cmd, argv[0],
1526                                            os_strlen(argv[0])) == 0) {
1527                                 printf(" %s", cmd->cmd);
1528                         }
1529                 }
1530                 printf("\n");
1531                 ret = 1;
1532         } else if (count == 0) {
1533                 printf("Unknown command '%s'\n", argv[0]);
1534                 ret = 1;
1535         } else {
1536                 ret = match->handler(s, argc - 1, &argv[1]);
1537         }
1538
1539         return ret;
1540 }
1541
1542
1543 struct wlantest_cli {
1544         int s;
1545 };
1546
1547
1548 #define max_args 10
1549
1550 static int tokenize_cmd(char *cmd, char *argv[])
1551 {
1552         char *pos;
1553         int argc = 0;
1554
1555         pos = cmd;
1556         for (;;) {
1557                 while (*pos == ' ')
1558                         pos++;
1559                 if (*pos == '\0')
1560                         break;
1561                 argv[argc] = pos;
1562                 argc++;
1563                 if (argc == max_args)
1564                         break;
1565                 if (*pos == '"') {
1566                         char *pos2 = os_strrchr(pos, '"');
1567                         if (pos2)
1568                                 pos = pos2 + 1;
1569                 }
1570                 while (*pos != '\0' && *pos != ' ')
1571                         pos++;
1572                 if (*pos == ' ')
1573                         *pos++ = '\0';
1574         }
1575
1576         return argc;
1577 }
1578
1579
1580 static void wlantest_cli_edit_cmd_cb(void *ctx, char *cmd)
1581 {
1582         struct wlantest_cli *cli = ctx;
1583         char *argv[max_args];
1584         int argc;
1585         argc = tokenize_cmd(cmd, argv);
1586         if (argc) {
1587                 int ret = ctrl_command(cli->s, argc, argv);
1588                 if (ret < 0)
1589                         printf("FAIL\n");
1590         }
1591 }
1592
1593
1594 static void wlantest_cli_eloop_terminate(int sig, void *signal_ctx)
1595 {
1596         eloop_terminate();
1597 }
1598
1599
1600 static void wlantest_cli_edit_eof_cb(void *ctx)
1601 {
1602         eloop_terminate();
1603 }
1604
1605
1606 static char ** wlantest_cli_cmd_list(void)
1607 {
1608         char **res;
1609         int i, count;
1610
1611         count = sizeof(wlantest_cli_commands) /
1612                 sizeof(wlantest_cli_commands[0]);
1613         res = os_calloc(count, sizeof(char *));
1614         if (res == NULL)
1615                 return NULL;
1616
1617         for (i = 0; wlantest_cli_commands[i].cmd; i++) {
1618                 res[i] = os_strdup(wlantest_cli_commands[i].cmd);
1619                 if (res[i] == NULL)
1620                         break;
1621         }
1622
1623         return res;
1624 }
1625
1626
1627 static char ** wlantest_cli_cmd_completion(struct wlantest_cli *cli,
1628                                            const char *cmd, const char *str,
1629                                            int pos)
1630 {
1631         int i;
1632
1633         for (i = 0; wlantest_cli_commands[i].cmd; i++) {
1634                 const struct wlantest_cli_cmd *c = &wlantest_cli_commands[i];
1635                 if (os_strcasecmp(c->cmd, cmd) == 0) {
1636                         edit_clear_line();
1637                         printf("\r%s\n", c->usage);
1638                         edit_redraw();
1639                         if (c->complete)
1640                                 return c->complete(cli->s, str, pos);
1641                         break;
1642                 }
1643         }
1644
1645         return NULL;
1646 }
1647
1648
1649 static char ** wlantest_cli_edit_completion_cb(void *ctx, const char *str,
1650                                                int pos)
1651 {
1652         struct wlantest_cli *cli = ctx;
1653         char **res;
1654         const char *end;
1655         char *cmd;
1656
1657         end = os_strchr(str, ' ');
1658         if (end == NULL || str + pos < end)
1659                 return wlantest_cli_cmd_list();
1660
1661         cmd = os_malloc(pos + 1);
1662         if (cmd == NULL)
1663                 return NULL;
1664         os_memcpy(cmd, str, pos);
1665         cmd[end - str] = '\0';
1666         res = wlantest_cli_cmd_completion(cli, cmd, str, pos);
1667         os_free(cmd);
1668         return res;
1669 }
1670
1671
1672 static void wlantest_cli_interactive(int s)
1673 {
1674         struct wlantest_cli cli;
1675         char *home, *hfile = NULL;
1676
1677         if (eloop_init())
1678                 return;
1679
1680         home = getenv("HOME");
1681         if (home) {
1682                 const char *fname = ".wlantest_cli_history";
1683                 int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
1684                 hfile = os_malloc(hfile_len);
1685                 if (hfile)
1686                         os_snprintf(hfile, hfile_len, "%s/%s", home, fname);
1687         }
1688
1689         cli.s = s;
1690         eloop_register_signal_terminate(wlantest_cli_eloop_terminate, &cli);
1691         edit_init(wlantest_cli_edit_cmd_cb, wlantest_cli_edit_eof_cb,
1692                   wlantest_cli_edit_completion_cb, &cli, hfile, NULL);
1693
1694         eloop_run();
1695
1696         edit_deinit(hfile, NULL);
1697         os_free(hfile);
1698         eloop_destroy();
1699 }
1700
1701
1702 int main(int argc, char *argv[])
1703 {
1704         int s;
1705         struct sockaddr_un addr;
1706         int ret = 0;
1707
1708         if (os_program_init())
1709                 return -1;
1710
1711         s = socket(AF_UNIX, SOCK_SEQPACKET, 0);
1712         if (s < 0) {
1713                 perror("socket");
1714                 return -1;
1715         }
1716
1717         os_memset(&addr, 0, sizeof(addr));
1718         addr.sun_family = AF_UNIX;
1719         os_strlcpy(addr.sun_path + 1, WLANTEST_SOCK_NAME,
1720                    sizeof(addr.sun_path) - 1);
1721         if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
1722                 perror("connect");
1723                 close(s);
1724                 return -1;
1725         }
1726
1727         if (argc > 1) {
1728                 ret = ctrl_command(s, argc - 1, &argv[1]);
1729                 if (ret < 0)
1730                         printf("FAIL\n");
1731         } else {
1732                 wlantest_cli_interactive(s);
1733         }
1734
1735         close(s);
1736
1737         os_program_deinit();
1738
1739         return ret;
1740 }