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 = ARRAY_SIZE(sta_counters);
 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 = ARRAY_SIZE(bss_counters);
 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 static int cmd_relog(int s, int argc, char *argv[])
 744 {
 745         return cmd_simple(s, WLANTEST_CTRL_RELOG);
 746 }
 747
 748
 749 struct tdls_counters {
 750         const char *name;
 751         enum wlantest_tdls_counter num;
 752 };
 753
 754 static const struct tdls_counters tdls_counters[] = {
 755         { "valid_direct_link", WLANTEST_TDLS_COUNTER_VALID_DIRECT_LINK },
 756         { "invalid_direct_link", WLANTEST_TDLS_COUNTER_INVALID_DIRECT_LINK },
 757         { "valid_ap_path", WLANTEST_TDLS_COUNTER_VALID_AP_PATH },
 758         { "invalid_ap_path", WLANTEST_TDLS_COUNTER_INVALID_AP_PATH },
 759         { "setup_req", WLANTEST_TDLS_COUNTER_SETUP_REQ },
 760         { "setup_resp_ok", WLANTEST_TDLS_COUNTER_SETUP_RESP_OK },
 761         { "setup_resp_fail", WLANTEST_TDLS_COUNTER_SETUP_RESP_FAIL },
 762         { "setup_conf_ok", WLANTEST_TDLS_COUNTER_SETUP_CONF_OK },
 763         { "setup_conf_fail", WLANTEST_TDLS_COUNTER_SETUP_CONF_FAIL },
 764         { "teardown", WLANTEST_TDLS_COUNTER_TEARDOWN },
 765         { NULL, 0 }
 766 };
 767
 768 static int cmd_get_tdls_counter(int s, int argc, char *argv[])
 769 {
 770         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
 771         u8 buf[100], *end, *pos;
 772         int rlen, i;
 773         size_t len;
 774
 775         if (argc != 4) {
 776                 printf("get_tdls_counter needs four arguments: "
 777                        "counter name, BSSID, STA1 address, STA2 address\n");
 778                 return -1;
 779         }
 780
 781         pos = buf;
 782         end = buf + sizeof(buf);
 783         WPA_PUT_BE32(pos, WLANTEST_CTRL_GET_TDLS_COUNTER);
 784         pos += 4;
 785
 786         for (i = 0; tdls_counters[i].name; i++) {
 787                 if (os_strcasecmp(tdls_counters[i].name, argv[0]) == 0)
 788                         break;
 789         }
 790         if (tdls_counters[i].name == NULL) {
 791                 printf("Unknown TDLS counter '%s'\n", argv[0]);
 792                 printf("Counters:");
 793                 for (i = 0; tdls_counters[i].name; i++)
 794                         printf(" %s", tdls_counters[i].name);
 795                 printf("\n");
 796                 return -1;
 797         }
 798
 799         pos = attr_add_be32(pos, end, WLANTEST_ATTR_TDLS_COUNTER,
 800                             tdls_counters[i].num);
 801         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
 802         if (hwaddr_aton(argv[1], pos) < 0) {
 803                 printf("Invalid BSSID '%s'\n", argv[1]);
 804                 return -1;
 805         }
 806         pos += ETH_ALEN;
 807
 808         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
 809         if (hwaddr_aton(argv[2], pos) < 0) {
 810                 printf("Invalid STA1 address '%s'\n", argv[2]);
 811                 return -1;
 812         }
 813         pos += ETH_ALEN;
 814
 815         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA2_ADDR, ETH_ALEN);
 816         if (hwaddr_aton(argv[3], pos) < 0) {
 817                 printf("Invalid STA2 address '%s'\n", argv[3]);
 818                 return -1;
 819         }
 820         pos += ETH_ALEN;
 821
 822         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
 823         if (rlen < 0)
 824                 return -1;
 825
 826         pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_COUNTER, &len);
 827         if (pos == NULL || len != 4)
 828                 return -1;
 829         printf("%u\n", WPA_GET_BE32(pos));
 830         return 0;
 831 }
 832
 833
 834 static char ** complete_get_tdls_counter(int s, const char *str, int pos)
 835 {
 836         int arg = get_cmd_arg_num(str, pos);
 837         char **res = NULL;
 838         int i, count;
 839         u8 addr[ETH_ALEN];
 840
 841         switch (arg) {
 842         case 1:
 843                 /* counter list */
 844                 count = ARRAY_SIZE(tdls_counters);
 845                 res = os_calloc(count, sizeof(char *));
 846                 if (res == NULL)
 847                         return NULL;
 848                 for (i = 0; tdls_counters[i].name; i++) {
 849                         res[i] = os_strdup(tdls_counters[i].name);
 850                         if (res[i] == NULL)
 851                                 break;
 852                 }
 853                 break;
 854         case 2:
 855                 res = get_bssid_list(s);
 856                 break;
 857         case 3:
 858         case 4:
 859                 if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
 860                         break;
 861                 res = get_sta_list(s, addr, 0);
 862                 break;
 863         }
 864
 865         return res;
 866 }
 867
 868
 869 struct inject_frames {
 870         const char *name;
 871         enum wlantest_inject_frame frame;
 872 };
 873
 874 static const struct inject_frames inject_frames[] = {
 875         { "auth", WLANTEST_FRAME_AUTH },
 876         { "assocreq", WLANTEST_FRAME_ASSOCREQ },
 877         { "reassocreq", WLANTEST_FRAME_REASSOCREQ },
 878         { "deauth", WLANTEST_FRAME_DEAUTH },
 879         { "disassoc", WLANTEST_FRAME_DISASSOC },
 880         { "saqueryreq", WLANTEST_FRAME_SAQUERYREQ },
 881         { NULL, 0 }
 882 };
 883
 884 static int cmd_inject(int s, int argc, char *argv[])
 885 {
 886         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
 887         u8 buf[100], *end, *pos;
 888         int rlen, i;
 889         enum wlantest_inject_protection prot;
 890
 891         /* <frame> <prot> <sender> <BSSID> <STA/ff:ff:ff:ff:ff:ff> */
 892
 893         if (argc < 5) {
 894                 printf("inject needs five arguments: frame, protection, "
 895                        "sender, BSSID, STA/ff:ff:ff:ff:ff:ff\n");
 896                 return -1;
 897         }
 898
 899         pos = buf;
 900         end = buf + sizeof(buf);
 901         WPA_PUT_BE32(pos, WLANTEST_CTRL_INJECT);
 902         pos += 4;
 903
 904         for (i = 0; inject_frames[i].name; i++) {
 905                 if (os_strcasecmp(inject_frames[i].name, argv[0]) == 0)
 906                         break;
 907         }
 908         if (inject_frames[i].name == NULL) {
 909                 printf("Unknown inject frame '%s'\n", argv[0]);
 910                 printf("Frames:");
 911                 for (i = 0; inject_frames[i].name; i++)
 912                         printf(" %s", inject_frames[i].name);
 913                 printf("\n");
 914                 return -1;
 915         }
 916
 917         pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_FRAME,
 918                             inject_frames[i].frame);
 919
 920         if (os_strcasecmp(argv[1], "normal") == 0)
 921                 prot = WLANTEST_INJECT_NORMAL;
 922         else if (os_strcasecmp(argv[1], "protected") == 0)
 923                 prot = WLANTEST_INJECT_PROTECTED;
 924         else if (os_strcasecmp(argv[1], "unprotected") == 0)
 925                 prot = WLANTEST_INJECT_UNPROTECTED;
 926         else if (os_strcasecmp(argv[1], "incorrect") == 0)
 927                 prot = WLANTEST_INJECT_INCORRECT_KEY;
 928         else {
 929                 printf("Unknown protection type '%s'\n", argv[1]);
 930                 printf("Protection types: normal protected unprotected "
 931                        "incorrect\n");
 932                 return -1;
 933         }
 934         pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_PROTECTION, prot);
 935
 936         if (os_strcasecmp(argv[2], "ap") == 0) {
 937                 pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_SENDER_AP,
 938                                     1);
 939         } else if (os_strcasecmp(argv[2], "sta") == 0) {
 940                 pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_SENDER_AP,
 941                                     0);
 942         } else {
 943                 printf("Unknown sender '%s'\n", argv[2]);
 944                 printf("Sender types: ap sta\n");
 945                 return -1;
 946         }
 947
 948         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
 949         if (hwaddr_aton(argv[3], pos) < 0) {
 950                 printf("Invalid BSSID '%s'\n", argv[3]);
 951                 return -1;
 952         }
 953         pos += ETH_ALEN;
 954
 955         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
 956         if (hwaddr_aton(argv[4], pos) < 0) {
 957                 printf("Invalid STA '%s'\n", argv[4]);
 958                 return -1;
 959         }
 960         pos += ETH_ALEN;
 961
 962         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
 963         if (rlen < 0)
 964                 return -1;
 965         printf("OK\n");
 966         return 0;
 967 }
 968
 969
 970 static char ** complete_inject(int s, const char *str, int pos)
 971 {
 972         int arg = get_cmd_arg_num(str, pos);
 973         char **res = NULL;
 974         int i, count;
 975         u8 addr[ETH_ALEN];
 976
 977         switch (arg) {
 978         case 1:
 979                 /* frame list */
 980                 count = ARRAY_SIZE(inject_frames);
 981                 res = os_calloc(count, sizeof(char *));
 982                 if (res == NULL)
 983                         break;
 984                 for (i = 0; inject_frames[i].name; i++) {
 985                         res[i] = os_strdup(inject_frames[i].name);
 986                         if (res[i] == NULL)
 987                                 break;
 988                 }
 989                 break;
 990         case 2:
 991                 res = os_calloc(5, sizeof(char *));
 992                 if (res == NULL)
 993                         break;
 994                 res[0] = os_strdup("normal");
 995                 if (res[0] == NULL)
 996                         break;
 997                 res[1] = os_strdup("protected");
 998                 if (res[1] == NULL)
 999                         break;
1000                 res[2] = os_strdup("unprotected");
1001                 if (res[2] == NULL)
1002                         break;
1003                 res[3] = os_strdup("incorrect");
1004                 if (res[3] == NULL)
1005                         break;
1006                 break;
1007         case 3:
1008                 res = os_calloc(3, sizeof(char *));
1009                 if (res == NULL)
1010                         break;
1011                 res[0] = os_strdup("ap");
1012                 if (res[0] == NULL)
1013                         break;
1014                 res[1] = os_strdup("sta");
1015                 if (res[1] == NULL)
1016                         break;
1017                 break;
1018         case 4:
1019                 res = get_bssid_list(s);
1020                 break;
1021         case 5:
1022                 if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
1023                         break;
1024                 res = get_sta_list(s, addr, 1);
1025                 break;
1026         }
1027
1028         return res;
1029 }
1030
1031
1032 static u8 * add_hex(u8 *pos, u8 *end, const char *str)
1033 {
1034         const char *s;
1035         int val;
1036
1037         s = str;
1038         while (*s) {
1039                 while (*s == ' ' || *s == '\t' || *s == '\r' || *s == '\n' ||
1040                        *s == ':')
1041                         s++;
1042                 if (*s == '\0')
1043                         break;
1044                 if (*s == '#') {
1045                         while (*s != '\0' && *s != '\r' && *s != '\n')
1046                                 s++;
1047                         continue;
1048                 }
1049
1050                 val = hex2byte(s);
1051                 if (val < 0) {
1052                         printf("Invalid hex encoding '%s'\n", s);
1053                         return NULL;
1054                 }
1055                 if (pos == end) {
1056                         printf("Too long frame\n");
1057                         return NULL;
1058                 }
1059                 *pos++ = val;
1060                 s += 2;
1061         }
1062
1063         return pos;
1064 }
1065
1066
1067 static int cmd_send(int s, int argc, char *argv[])
1068 {
1069         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1070         u8 buf[WLANTEST_CTRL_MAX_CMD_LEN], *end, *pos, *len_pos;
1071         int rlen;
1072         enum wlantest_inject_protection prot;
1073         int arg;
1074
1075         /* <prot> <raw frame as hex dump> */
1076
1077         if (argc < 2) {
1078                 printf("send needs two arguments: protected/unprotected, "
1079                        "raw frame as hex dump\n");
1080                 return -1;
1081         }
1082
1083         pos = buf;
1084         end = buf + sizeof(buf);
1085         WPA_PUT_BE32(pos, WLANTEST_CTRL_SEND);
1086         pos += 4;
1087
1088         if (os_strcasecmp(argv[0], "normal") == 0)
1089                 prot = WLANTEST_INJECT_NORMAL;
1090         else if (os_strcasecmp(argv[0], "protected") == 0)
1091                 prot = WLANTEST_INJECT_PROTECTED;
1092         else if (os_strcasecmp(argv[0], "unprotected") == 0)
1093                 prot = WLANTEST_INJECT_UNPROTECTED;
1094         else if (os_strcasecmp(argv[0], "incorrect") == 0)
1095                 prot = WLANTEST_INJECT_INCORRECT_KEY;
1096         else {
1097                 printf("Unknown protection type '%s'\n", argv[1]);
1098                 printf("Protection types: normal protected unprotected "
1099                        "incorrect\n");
1100                 return -1;
1101         }
1102         pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_PROTECTION, prot);
1103
1104         WPA_PUT_BE32(pos, WLANTEST_ATTR_FRAME);
1105         pos += 4;
1106         len_pos = pos;
1107         pos += 4;
1108
1109         for (arg = 1; pos && arg < argc; arg++)
1110                 pos = add_hex(pos, end, argv[arg]);
1111         if (pos == NULL)
1112                 return -1;
1113
1114         WPA_PUT_BE32(len_pos, pos - len_pos - 4);
1115
1116         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
1117         if (rlen < 0)
1118                 return -1;
1119         printf("OK\n");
1120         return 0;
1121 }
1122
1123
1124 static char ** complete_send(int s, const char *str, int pos)
1125 {
1126         int arg = get_cmd_arg_num(str, pos);
1127         char **res = NULL;
1128
1129         switch (arg) {
1130         case 1:
1131                 res = os_calloc(5, sizeof(char *));
1132                 if (res == NULL)
1133                         break;
1134                 res[0] = os_strdup("normal");
1135                 if (res[0] == NULL)
1136                         break;
1137                 res[1] = os_strdup("protected");
1138                 if (res[1] == NULL)
1139                         break;
1140                 res[2] = os_strdup("unprotected");
1141                 if (res[2] == NULL)
1142                         break;
1143                 res[3] = os_strdup("incorrect");
1144                 if (res[3] == NULL)
1145                         break;
1146                 break;
1147         }
1148
1149         return res;
1150 }
1151
1152
1153 static int cmd_version(int s, int argc, char *argv[])
1154 {
1155         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1156         u8 buf[4];
1157         char *version;
1158         size_t len;
1159         int rlen, i;
1160
1161         WPA_PUT_BE32(buf, WLANTEST_CTRL_VERSION);
1162         rlen = cmd_send_and_recv(s, buf, sizeof(buf), resp, sizeof(resp));
1163         if (rlen < 0)
1164                 return -1;
1165
1166         version = (char *) attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_VERSION,
1167                                     &len);
1168         if (version == NULL)
1169                 return -1;
1170
1171         for (i = 0; i < len; i++)
1172                 putchar(version[i]);
1173         printf("\n");
1174
1175         return 0;
1176 }
1177
1178
1179 static int cmd_add_passphrase(int s, int argc, char *argv[])
1180 {
1181         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1182         u8 buf[100], *pos, *end;
1183         size_t len;
1184         int rlen;
1185
1186         if (argc < 1) {
1187                 printf("add_passphrase needs one argument: passphrase\n");
1188                 return -1;
1189         }
1190
1191         len = os_strlen(argv[0]);
1192         if (len < 8 || len > 63) {
1193                 printf("Invalid passphrase '%s'\n", argv[0]);
1194                 return -1;
1195         }
1196         pos = buf;
1197         end = buf + sizeof(buf);
1198         WPA_PUT_BE32(pos, WLANTEST_CTRL_ADD_PASSPHRASE);
1199         pos += 4;
1200         pos = attr_add_str(pos, end, WLANTEST_ATTR_PASSPHRASE,
1201                            argv[0]);
1202         if (argc > 1) {
1203                 pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
1204                 if (hwaddr_aton(argv[1], pos) < 0) {
1205                         printf("Invalid BSSID '%s'\n", argv[3]);
1206                         return -1;
1207                 }
1208                 pos += ETH_ALEN;
1209         }
1210
1211         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
1212         if (rlen < 0)
1213                 return -1;
1214         return 0;
1215 }
1216
1217
1218 static int cmd_add_wepkey(int s, int argc, char *argv[])
1219 {
1220         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1221         u8 buf[100], *pos, *end;
1222         int rlen;
1223
1224         if (argc < 1) {
1225                 printf("add_wepkey needs one argument: WEP key\n");
1226                 return -1;
1227         }
1228
1229         pos = buf;
1230         end = buf + sizeof(buf);
1231         WPA_PUT_BE32(pos, WLANTEST_CTRL_ADD_PASSPHRASE);
1232         pos += 4;
1233         pos = attr_add_str(pos, end, WLANTEST_ATTR_WEPKEY, argv[0]);
1234
1235         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
1236         if (rlen < 0)
1237                 return -1;
1238         return 0;
1239 }
1240
1241
1242 struct sta_infos {
1243         const char *name;
1244         enum wlantest_sta_info num;
1245 };
1246
1247 static const struct sta_infos sta_infos[] = {
1248         { "proto", WLANTEST_STA_INFO_PROTO },
1249         { "pairwise", WLANTEST_STA_INFO_PAIRWISE },
1250         { "key_mgmt", WLANTEST_STA_INFO_KEY_MGMT },
1251         { "rsn_capab", WLANTEST_STA_INFO_RSN_CAPAB },
1252         { "state", WLANTEST_STA_INFO_STATE },
1253         { "gtk", WLANTEST_STA_INFO_GTK },
1254         { NULL, 0 }
1255 };
1256
1257 static int cmd_info_sta(int s, int argc, char *argv[])
1258 {
1259         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1260         u8 buf[100], *end, *pos;
1261         int rlen, i;
1262         size_t len;
1263         char info[100];
1264
1265         if (argc != 3) {
1266                 printf("sta_info needs at three arguments: "
1267                        "counter name, BSSID, and STA address\n");
1268                 return -1;
1269         }
1270
1271         pos = buf;
1272         end = buf + sizeof(buf);
1273         WPA_PUT_BE32(pos, WLANTEST_CTRL_INFO_STA);
1274         pos += 4;
1275
1276         for (i = 0; sta_infos[i].name; i++) {
1277                 if (os_strcasecmp(sta_infos[i].name, argv[0]) == 0)
1278                         break;
1279         }
1280         if (sta_infos[i].name == NULL) {
1281                 printf("Unknown STA info '%s'\n", argv[0]);
1282                 printf("Info fields:");
1283                 for (i = 0; sta_infos[i].name; i++)
1284                         printf(" %s", sta_infos[i].name);
1285                 printf("\n");
1286                 return -1;
1287         }
1288
1289         pos = attr_add_be32(pos, end, WLANTEST_ATTR_STA_INFO,
1290                             sta_infos[i].num);
1291         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
1292         if (hwaddr_aton(argv[1], pos) < 0) {
1293                 printf("Invalid BSSID '%s'\n", argv[1]);
1294                 return -1;
1295         }
1296         pos += ETH_ALEN;
1297
1298         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
1299         if (hwaddr_aton(argv[2], pos) < 0) {
1300                 printf("Invalid STA address '%s'\n", argv[2]);
1301                 return -1;
1302         }
1303         pos += ETH_ALEN;
1304
1305         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
1306         if (rlen < 0)
1307                 return -1;
1308
1309         pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_INFO, &len);
1310         if (pos == NULL)
1311                 return -1;
1312         if (len >= sizeof(info))
1313                 len = sizeof(info) - 1;
1314         os_memcpy(info, pos, len);
1315         info[len] = '\0';
1316         printf("%s\n", info);
1317         return 0;
1318 }
1319
1320
1321 static char ** complete_info_sta(int s, const char *str, int pos)
1322 {
1323         int arg = get_cmd_arg_num(str, pos);
1324         char **res = NULL;
1325         int i, count;
1326         u8 addr[ETH_ALEN];
1327
1328         switch (arg) {
1329         case 1:
1330                 /* counter list */
1331                 count = ARRAY_SIZE(sta_infos);
1332                 res = os_calloc(count, sizeof(char *));
1333                 if (res == NULL)
1334                         return NULL;
1335                 for (i = 0; sta_infos[i].name; i++) {
1336                         res[i] = os_strdup(sta_infos[i].name);
1337                         if (res[i] == NULL)
1338                                 break;
1339                 }
1340                 break;
1341         case 2:
1342                 res = get_bssid_list(s);
1343                 break;
1344         case 3:
1345                 if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
1346                         break;
1347                 res = get_sta_list(s, addr, 0);
1348                 break;
1349         }
1350
1351         return res;
1352 }
1353
1354
1355 struct bss_infos {
1356         const char *name;
1357         enum wlantest_bss_info num;
1358 };
1359
1360 static const struct bss_infos bss_infos[] = {
1361         { "proto", WLANTEST_BSS_INFO_PROTO },
1362         { "pairwise", WLANTEST_BSS_INFO_PAIRWISE },
1363         { "group", WLANTEST_BSS_INFO_GROUP },
1364         { "group_mgmt", WLANTEST_BSS_INFO_GROUP_MGMT },
1365         { "key_mgmt", WLANTEST_BSS_INFO_KEY_MGMT },
1366         { "rsn_capab", WLANTEST_BSS_INFO_RSN_CAPAB },
1367         { NULL, 0 }
1368 };
1369
1370 static int cmd_info_bss(int s, int argc, char *argv[])
1371 {
1372         u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
1373         u8 buf[100], *end, *pos;
1374         int rlen, i;
1375         size_t len;
1376         char info[100];
1377
1378         if (argc != 2) {
1379                 printf("bss_info needs at two arguments: "
1380                        "field name and BSSID\n");
1381                 return -1;
1382         }
1383
1384         pos = buf;
1385         end = buf + sizeof(buf);
1386         WPA_PUT_BE32(pos, WLANTEST_CTRL_INFO_BSS);
1387         pos += 4;
1388
1389         for (i = 0; bss_infos[i].name; i++) {
1390                 if (os_strcasecmp(bss_infos[i].name, argv[0]) == 0)
1391                         break;
1392         }
1393         if (bss_infos[i].name == NULL) {
1394                 printf("Unknown BSS info '%s'\n", argv[0]);
1395                 printf("Info fields:");
1396                 for (i = 0; bss_infos[i].name; i++)
1397                         printf(" %s", bss_infos[i].name);
1398                 printf("\n");
1399                 return -1;
1400         }
1401
1402         pos = attr_add_be32(pos, end, WLANTEST_ATTR_BSS_INFO,
1403                             bss_infos[i].num);
1404         pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
1405         if (hwaddr_aton(argv[1], pos) < 0) {
1406                 printf("Invalid BSSID '%s'\n", argv[1]);
1407                 return -1;
1408         }
1409         pos += ETH_ALEN;
1410
1411         rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
1412         if (rlen < 0)
1413                 return -1;
1414
1415         pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_INFO, &len);
1416         if (pos == NULL)
1417                 return -1;
1418         if (len >= sizeof(info))
1419                 len = sizeof(info) - 1;
1420         os_memcpy(info, pos, len);
1421         info[len] = '\0';
1422         printf("%s\n", info);
1423         return 0;
1424 }
1425
1426
1427 static char ** complete_info_bss(int s, const char *str, int pos)
1428 {
1429         int arg = get_cmd_arg_num(str, pos);
1430         char **res = NULL;
1431         int i, count;
1432
1433         switch (arg) {
1434         case 1:
1435                 /* counter list */
1436                 count = ARRAY_SIZE(bss_infos);
1437                 res = os_calloc(count, sizeof(char *));
1438                 if (res == NULL)
1439                         return NULL;
1440                 for (i = 0; bss_infos[i].name; i++) {
1441                         res[i] = os_strdup(bss_infos[i].name);
1442                         if (res[i] == NULL)
1443                                 break;
1444                 }
1445                 break;
1446         case 2:
1447                 res = get_bssid_list(s);
1448                 break;
1449         }
1450
1451         return res;
1452 }
1453
1454
1455 struct wlantest_cli_cmd {
1456         const char *cmd;
1457         int (*handler)(int s, int argc, char *argv[]);
1458         const char *usage;
1459         char ** (*complete)(int s, const char *str, int pos);
1460 };
1461
1462 static const struct wlantest_cli_cmd wlantest_cli_commands[] = {
1463         { "ping", cmd_ping, "= test connection to wlantest", NULL },
1464         { "terminate", cmd_terminate, "= terminate wlantest", NULL },
1465         { "list_bss", cmd_list_bss, "= get BSS list", NULL },
1466         { "list_sta", cmd_list_sta, "<BSSID> = get STA list",
1467           complete_list_sta },
1468         { "flush", cmd_flush, "= drop all collected BSS data", NULL },
1469         { "clear_sta_counters", cmd_clear_sta_counters,
1470           "<BSSID> <STA> = clear STA counters", complete_clear_sta_counters },
1471         { "clear_bss_counters", cmd_clear_bss_counters,
1472           "<BSSID> = clear BSS counters", complete_clear_bss_counters },
1473         { "get_sta_counter", cmd_get_sta_counter,
1474           "<counter> <BSSID> <STA> = get STA counter value",
1475           complete_get_sta_counter },
1476         { "get_bss_counter", cmd_get_bss_counter,
1477           "<counter> <BSSID> = get BSS counter value",
1478           complete_get_bss_counter },
1479         { "inject", cmd_inject,
1480           "<frame> <prot> <sender> <BSSID> <STA/ff:ff:ff:ff:ff:ff>",
1481           complete_inject },
1482         { "send", cmd_send,
1483           "<prot> <raw frame as hex dump>",
1484           complete_send },
1485         { "version", cmd_version, "= get wlantest version", NULL },
1486         { "add_passphrase", cmd_add_passphrase,
1487           "<passphrase> = add a known passphrase", NULL },
1488         { "add_wepkey", cmd_add_wepkey,
1489           "<WEP key> = add a known WEP key", NULL },
1490         { "info_sta", cmd_info_sta,
1491           "<field> <BSSID> <STA> = get STA information",
1492           complete_info_sta },
1493         { "info_bss", cmd_info_bss,
1494           "<field> <BSSID> = get BSS information",
1495           complete_info_bss },
1496         { "clear_tdls_counters", cmd_clear_tdls_counters,
1497           "<BSSID> <STA1> <STA2> = clear TDLS counters",
1498           complete_clear_tdls_counters },
1499         { "get_tdls_counter", cmd_get_tdls_counter,
1500           "<counter> <BSSID> <STA1> <STA2> = get TDLS counter value",
1501           complete_get_tdls_counter },
1502         { "get_bss_counter", cmd_get_bss_counter,
1503           "<counter> <BSSID> = get BSS counter value",
1504           complete_get_bss_counter },
1505         { "relog", cmd_relog, "= re-open log-file (allow rolling logs)", NULL },
1506         { NULL, NULL, NULL, NULL }
1507 };
1508
1509
1510 static int ctrl_command(int s, int argc, char *argv[])
1511 {
1512         const struct wlantest_cli_cmd *cmd, *match = NULL;
1513         int count = 0;
1514         int ret = 0;
1515
1516         for (cmd = wlantest_cli_commands; cmd->cmd; cmd++) {
1517                 if (os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0)
1518                 {
1519                         match = cmd;
1520                         if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
1521                                 /* exact match */
1522                                 count = 1;
1523                                 break;
1524                         }
1525                         count++;
1526                 }
1527         }
1528
1529         if (count > 1) {
1530                 printf("Ambiguous command '%s'; possible commands:", argv[0]);
1531                 for (cmd = wlantest_cli_commands; cmd->cmd; cmd++) {
1532                         if (os_strncasecmp(cmd->cmd, argv[0],
1533                                            os_strlen(argv[0])) == 0) {
1534                                 printf(" %s", cmd->cmd);
1535                         }
1536                 }
1537                 printf("\n");
1538                 ret = 1;
1539         } else if (count == 0) {
1540                 printf("Unknown command '%s'\n", argv[0]);
1541                 ret = 1;
1542         } else {
1543                 ret = match->handler(s, argc - 1, &argv[1]);
1544         }
1545
1546         return ret;
1547 }
1548
1549
1550 struct wlantest_cli {
1551         int s;
1552 };
1553
1554
1555 #define max_args 10
1556
1557 static int tokenize_cmd(char *cmd, char *argv[])
1558 {
1559         char *pos;
1560         int argc = 0;
1561
1562         pos = cmd;
1563         for (;;) {
1564                 while (*pos == ' ')
1565                         pos++;
1566                 if (*pos == '\0')
1567                         break;
1568                 argv[argc] = pos;
1569                 argc++;
1570                 if (argc == max_args)
1571                         break;
1572                 if (*pos == '"') {
1573                         char *pos2 = os_strrchr(pos, '"');
1574                         if (pos2)
1575                                 pos = pos2 + 1;
1576                 }
1577                 while (*pos != '\0' && *pos != ' ')
1578                         pos++;
1579                 if (*pos == ' ')
1580                         *pos++ = '\0';
1581         }
1582
1583         return argc;
1584 }
1585
1586
1587 static void wlantest_cli_edit_cmd_cb(void *ctx, char *cmd)
1588 {
1589         struct wlantest_cli *cli = ctx;
1590         char *argv[max_args];
1591         int argc;
1592         argc = tokenize_cmd(cmd, argv);
1593         if (argc) {
1594                 int ret = ctrl_command(cli->s, argc, argv);
1595                 if (ret < 0)
1596                         printf("FAIL\n");
1597         }
1598 }
1599
1600
1601 static void wlantest_cli_eloop_terminate(int sig, void *signal_ctx)
1602 {
1603         eloop_terminate();
1604 }
1605
1606
1607 static void wlantest_cli_edit_eof_cb(void *ctx)
1608 {
1609         eloop_terminate();
1610 }
1611
1612
1613 static char ** wlantest_cli_cmd_list(void)
1614 {
1615         char **res;
1616         int i;
1617
1618         res = os_calloc(ARRAY_SIZE(wlantest_cli_commands), sizeof(char *));
1619         if (res == NULL)
1620                 return NULL;
1621
1622         for (i = 0; wlantest_cli_commands[i].cmd; i++) {
1623                 res[i] = os_strdup(wlantest_cli_commands[i].cmd);
1624                 if (res[i] == NULL)
1625                         break;
1626         }
1627
1628         return res;
1629 }
1630
1631
1632 static char ** wlantest_cli_cmd_completion(struct wlantest_cli *cli,
1633                                            const char *cmd, const char *str,
1634                                            int pos)
1635 {
1636         int i;
1637
1638         for (i = 0; wlantest_cli_commands[i].cmd; i++) {
1639                 const struct wlantest_cli_cmd *c = &wlantest_cli_commands[i];
1640                 if (os_strcasecmp(c->cmd, cmd) == 0) {
1641                         edit_clear_line();
1642                         printf("\r%s\n", c->usage);
1643                         edit_redraw();
1644                         if (c->complete)
1645                                 return c->complete(cli->s, str, pos);
1646                         break;
1647                 }
1648         }
1649
1650         return NULL;
1651 }
1652
1653
1654 static char ** wlantest_cli_edit_completion_cb(void *ctx, const char *str,
1655                                                int pos)
1656 {
1657         struct wlantest_cli *cli = ctx;
1658         char **res;
1659         const char *end;
1660         char *cmd;
1661
1662         end = os_strchr(str, ' ');
1663         if (end == NULL || str + pos < end)
1664                 return wlantest_cli_cmd_list();
1665
1666         cmd = os_malloc(pos + 1);
1667         if (cmd == NULL)
1668                 return NULL;
1669         os_memcpy(cmd, str, pos);
1670         cmd[end - str] = '\0';
1671         res = wlantest_cli_cmd_completion(cli, cmd, str, pos);
1672         os_free(cmd);
1673         return res;
1674 }
1675
1676
1677 static void wlantest_cli_interactive(int s)
1678 {
1679         struct wlantest_cli cli;
1680         char *home, *hfile = NULL;
1681
1682         if (eloop_init())
1683                 return;
1684
1685         home = getenv("HOME");
1686         if (home) {
1687                 const char *fname = ".wlantest_cli_history";
1688                 int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
1689                 hfile = os_malloc(hfile_len);
1690                 if (hfile)
1691                         os_snprintf(hfile, hfile_len, "%s/%s", home, fname);
1692         }
1693
1694         cli.s = s;
1695         eloop_register_signal_terminate(wlantest_cli_eloop_terminate, &cli);
1696         edit_init(wlantest_cli_edit_cmd_cb, wlantest_cli_edit_eof_cb,
1697                   wlantest_cli_edit_completion_cb, &cli, hfile, NULL);
1698
1699         eloop_run();
1700
1701         edit_deinit(hfile, NULL);
1702         os_free(hfile);
1703         eloop_destroy();
1704 }
1705
1706
1707 int main(int argc, char *argv[])
1708 {
1709         int s;
1710         struct sockaddr_un addr;
1711         int ret = 0;
1712
1713         if (os_program_init())
1714                 return -1;
1715
1716         s = socket(AF_UNIX, SOCK_SEQPACKET, 0);
1717         if (s < 0) {
1718                 perror("socket");
1719                 return -1;
1720         }
1721
1722         os_memset(&addr, 0, sizeof(addr));
1723         addr.sun_family = AF_UNIX;
1724         os_strlcpy(addr.sun_path + 1, WLANTEST_SOCK_NAME,
1725                    sizeof(addr.sun_path) - 1);
1726         if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
1727                 perror("connect");
1728                 close(s);
1729                 return -1;
1730         }
1731
1732         if (argc > 1) {
1733                 ret = ctrl_command(s, argc - 1, &argv[1]);
1734                 if (ret < 0)
1735                         printf("FAIL\n");
1736         } else {
1737                 wlantest_cli_interactive(s);
1738         }
1739
1740         close(s);
1741
1742         os_program_deinit();
1743
1744         return ret;
1745 }