wpa_supplicant/wpa_cli.c

   1 /*
   2  * WPA Supplicant - command line interface for wpa_supplicant daemon
   3  * Copyright (c) 2004-2015, 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 "includes.h"
  10
  11 #ifdef CONFIG_CTRL_IFACE
  12
  13 #ifdef CONFIG_CTRL_IFACE_UNIX
  14 #include <dirent.h>
  15 #endif /* CONFIG_CTRL_IFACE_UNIX */
  16
  17 #include "common/wpa_ctrl.h"
  18 #include "utils/common.h"
  19 #include "utils/eloop.h"
  20 #include "utils/edit.h"
  21 #include "utils/list.h"
  22 #include "common/version.h"
  23 #include "common/ieee802_11_defs.h"
  24 #ifdef ANDROID
  25 #include <cutils/properties.h>
  26 #endif /* ANDROID */
  27
  28
  29 static const char *wpa_cli_version =
  30 "wpa_cli v" VERSION_STR "\n"
  31 "Copyright (c) 2004-2015, Jouni Malinen <j@w1.fi> and contributors";
  32
  33
  34 static const char *wpa_cli_license =
  35 "This software may be distributed under the terms of the BSD license.\n"
  36 "See README for more details.\n";
  37
  38 static const char *wpa_cli_full_license =
  39 "This software may be distributed under the terms of the BSD license.\n"
  40 "\n"
  41 "Redistribution and use in source and binary forms, with or without\n"
  42 "modification, are permitted provided that the following conditions are\n"
  43 "met:\n"
  44 "\n"
  45 "1. Redistributions of source code must retain the above copyright\n"
  46 "   notice, this list of conditions and the following disclaimer.\n"
  47 "\n"
  48 "2. Redistributions in binary form must reproduce the above copyright\n"
  49 "   notice, this list of conditions and the following disclaimer in the\n"
  50 "   documentation and/or other materials provided with the distribution.\n"
  51 "\n"
  52 "3. Neither the name(s) of the above-listed copyright holder(s) nor the\n"
  53 "   names of its contributors may be used to endorse or promote products\n"
  54 "   derived from this software without specific prior written permission.\n"
  55 "\n"
  56 "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
  57 "\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
  58 "LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
  59 "A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n"
  60 "OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n"
  61 "SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n"
  62 "LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
  63 "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
  64 "THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
  65 "(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
  66 "OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
  67 "\n";
  68
  69 static struct wpa_ctrl *ctrl_conn;
  70 static struct wpa_ctrl *mon_conn;
  71 static int wpa_cli_quit = 0;
  72 static int wpa_cli_attached = 0;
  73 static int wpa_cli_connected = -1;
  74 static int wpa_cli_last_id = 0;
  75 #ifndef CONFIG_CTRL_IFACE_DIR
  76 #define CONFIG_CTRL_IFACE_DIR "/var/run/wpa_supplicant"
  77 #endif /* CONFIG_CTRL_IFACE_DIR */
  78 static const char *ctrl_iface_dir = CONFIG_CTRL_IFACE_DIR;
  79 static char *ctrl_ifname = NULL;
  80 static const char *pid_file = NULL;
  81 static const char *action_file = NULL;
  82 static int ping_interval = 5;
  83 static int interactive = 0;
  84 static char *ifname_prefix = NULL;
  85
  86 struct cli_txt_entry {
  87         struct dl_list list;
  88         char *txt;
  89 };
  90
  91 static DEFINE_DL_LIST(bsses); /* struct cli_txt_entry */
  92 static DEFINE_DL_LIST(p2p_peers); /* struct cli_txt_entry */
  93 static DEFINE_DL_LIST(p2p_groups); /* struct cli_txt_entry */
  94 static DEFINE_DL_LIST(ifnames); /* struct cli_txt_entry */
  95
  96
  97 static void print_help(const char *cmd);
  98 static void wpa_cli_mon_receive(int sock, void *eloop_ctx, void *sock_ctx);
  99 static void wpa_cli_close_connection(void);
 100 static char * wpa_cli_get_default_ifname(void);
 101 static char ** wpa_list_cmd_list(void);
 102
 103
 104 static void usage(void)
 105 {
 106         printf("wpa_cli [-p<path to ctrl sockets>] [-i<ifname>] [-hvB] "
 107                "[-a<action file>] \\\n"
 108                "        [-P<pid file>] [-g<global ctrl>] [-G<ping interval>]  "
 109                "[command..]\n"
 110                "  -h = help (show this usage text)\n"
 111                "  -v = shown version information\n"
 112                "  -a = run in daemon mode executing the action file based on "
 113                "events from\n"
 114                "       wpa_supplicant\n"
 115                "  -B = run a daemon in the background\n"
 116                "  default path: " CONFIG_CTRL_IFACE_DIR "\n"
 117                "  default interface: first interface found in socket path\n");
 118         print_help(NULL);
 119 }
 120
 121
 122 static void cli_txt_list_free(struct cli_txt_entry *e)
 123 {
 124         dl_list_del(&e->list);
 125         os_free(e->txt);
 126         os_free(e);
 127 }
 128
 129
 130 static void cli_txt_list_flush(struct dl_list *list)
 131 {
 132         struct cli_txt_entry *e;
 133         while ((e = dl_list_first(list, struct cli_txt_entry, list)))
 134                 cli_txt_list_free(e);
 135 }
 136
 137
 138 static struct cli_txt_entry * cli_txt_list_get(struct dl_list *txt_list,
 139                                                const char *txt)
 140 {
 141         struct cli_txt_entry *e;
 142         dl_list_for_each(e, txt_list, struct cli_txt_entry, list) {
 143                 if (os_strcmp(e->txt, txt) == 0)
 144                         return e;
 145         }
 146         return NULL;
 147 }
 148
 149
 150 static void cli_txt_list_del(struct dl_list *txt_list, const char *txt)
 151 {
 152         struct cli_txt_entry *e;
 153         e = cli_txt_list_get(txt_list, txt);
 154         if (e)
 155                 cli_txt_list_free(e);
 156 }
 157
 158
 159 static void cli_txt_list_del_addr(struct dl_list *txt_list, const char *txt)
 160 {
 161         u8 addr[ETH_ALEN];
 162         char buf[18];
 163         if (hwaddr_aton(txt, addr) < 0)
 164                 return;
 165         os_snprintf(buf, sizeof(buf), MACSTR, MAC2STR(addr));
 166         cli_txt_list_del(txt_list, buf);
 167 }
 168
 169
 170 #ifdef CONFIG_P2P
 171 static void cli_txt_list_del_word(struct dl_list *txt_list, const char *txt)
 172 {
 173         const char *end;
 174         char *buf;
 175         end = os_strchr(txt, ' ');
 176         if (end == NULL)
 177                 end = txt + os_strlen(txt);
 178         buf = dup_binstr(txt, end - txt);
 179         if (buf == NULL)
 180                 return;
 181         cli_txt_list_del(txt_list, buf);
 182         os_free(buf);
 183 }
 184 #endif /* CONFIG_P2P */
 185
 186
 187 static int cli_txt_list_add(struct dl_list *txt_list, const char *txt)
 188 {
 189         struct cli_txt_entry *e;
 190         e = cli_txt_list_get(txt_list, txt);
 191         if (e)
 192                 return 0;
 193         e = os_zalloc(sizeof(*e));
 194         if (e == NULL)
 195                 return -1;
 196         e->txt = os_strdup(txt);
 197         if (e->txt == NULL) {
 198                 os_free(e);
 199                 return -1;
 200         }
 201         dl_list_add(txt_list, &e->list);
 202         return 0;
 203 }
 204
 205
 206 #ifdef CONFIG_P2P
 207 static int cli_txt_list_add_addr(struct dl_list *txt_list, const char *txt)
 208 {
 209         u8 addr[ETH_ALEN];
 210         char buf[18];
 211         if (hwaddr_aton(txt, addr) < 0)
 212                 return -1;
 213         os_snprintf(buf, sizeof(buf), MACSTR, MAC2STR(addr));
 214         return cli_txt_list_add(txt_list, buf);
 215 }
 216
 217
 218 static int cli_txt_list_add_word(struct dl_list *txt_list, const char *txt)
 219 {
 220         const char *end;
 221         char *buf;
 222         int ret;
 223         end = os_strchr(txt, ' ');
 224         if (end == NULL)
 225                 end = txt + os_strlen(txt);
 226         buf = dup_binstr(txt, end - txt);
 227         if (buf == NULL)
 228                 return -1;
 229         ret = cli_txt_list_add(txt_list, buf);
 230         os_free(buf);
 231         return ret;
 232 }
 233 #endif /* CONFIG_P2P */
 234
 235
 236 static char ** cli_txt_list_array(struct dl_list *txt_list)
 237 {
 238         unsigned int i, count = dl_list_len(txt_list);
 239         char **res;
 240         struct cli_txt_entry *e;
 241
 242         res = os_calloc(count + 1, sizeof(char *));
 243         if (res == NULL)
 244                 return NULL;
 245
 246         i = 0;
 247         dl_list_for_each(e, txt_list, struct cli_txt_entry, list) {
 248                 res[i] = os_strdup(e->txt);
 249                 if (res[i] == NULL)
 250                         break;
 251                 i++;
 252         }
 253
 254         return res;
 255 }
 256
 257
 258 static int get_cmd_arg_num(const char *str, int pos)
 259 {
 260         int arg = 0, i;
 261
 262         for (i = 0; i <= pos; i++) {
 263                 if (str[i] != ' ') {
 264                         arg++;
 265                         while (i <= pos && str[i] != ' ')
 266                                 i++;
 267                 }
 268         }
 269
 270         if (arg > 0)
 271                 arg--;
 272         return arg;
 273 }
 274
 275
 276 static int str_starts(const char *src, const char *match)
 277 {
 278         return os_strncmp(src, match, os_strlen(match)) == 0;
 279 }
 280
 281
 282 static int wpa_cli_show_event(const char *event)
 283 {
 284         const char *start;
 285
 286         start = os_strchr(event, '>');
 287         if (start == NULL)
 288                 return 1;
 289
 290         start++;
 291         /*
 292          * Skip BSS added/removed events since they can be relatively frequent
 293          * and are likely of not much use for an interactive user.
 294          */
 295         if (str_starts(start, WPA_EVENT_BSS_ADDED) ||
 296             str_starts(start, WPA_EVENT_BSS_REMOVED))
 297                 return 0;
 298
 299         return 1;
 300 }
 301
 302
 303 static int wpa_cli_open_connection(const char *ifname, int attach)
 304 {
 305 #if defined(CONFIG_CTRL_IFACE_UDP) || defined(CONFIG_CTRL_IFACE_NAMED_PIPE)
 306         ctrl_conn = wpa_ctrl_open(ifname);
 307         if (ctrl_conn == NULL)
 308                 return -1;
 309
 310         if (attach && interactive)
 311                 mon_conn = wpa_ctrl_open(ifname);
 312         else
 313                 mon_conn = NULL;
 314 #else /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
 315         char *cfile = NULL;
 316         int flen, res;
 317
 318         if (ifname == NULL)
 319                 return -1;
 320
 321 #ifdef ANDROID
 322         if (access(ctrl_iface_dir, F_OK) < 0) {
 323                 cfile = os_strdup(ifname);
 324                 if (cfile == NULL)
 325                         return -1;
 326         }
 327 #endif /* ANDROID */
 328
 329         if (cfile == NULL) {
 330                 flen = os_strlen(ctrl_iface_dir) + os_strlen(ifname) + 2;
 331                 cfile = os_malloc(flen);
 332                 if (cfile == NULL)
 333                         return -1;
 334                 res = os_snprintf(cfile, flen, "%s/%s", ctrl_iface_dir,
 335                                   ifname);
 336                 if (os_snprintf_error(flen, res)) {
 337                         os_free(cfile);
 338                         return -1;
 339                 }
 340         }
 341
 342         ctrl_conn = wpa_ctrl_open(cfile);
 343         if (ctrl_conn == NULL) {
 344                 os_free(cfile);
 345                 return -1;
 346         }
 347
 348         if (attach && interactive)
 349                 mon_conn = wpa_ctrl_open(cfile);
 350         else
 351                 mon_conn = NULL;
 352         os_free(cfile);
 353 #endif /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
 354
 355         if (mon_conn) {
 356                 if (wpa_ctrl_attach(mon_conn) == 0) {
 357                         wpa_cli_attached = 1;
 358                         if (interactive)
 359                                 eloop_register_read_sock(
 360                                         wpa_ctrl_get_fd(mon_conn),
 361                                         wpa_cli_mon_receive, NULL, NULL);
 362                 } else {
 363                         printf("Warning: Failed to attach to "
 364                                "wpa_supplicant.\n");
 365                         wpa_cli_close_connection();
 366                         return -1;
 367                 }
 368         }
 369
 370         return 0;
 371 }
 372
 373
 374 static void wpa_cli_close_connection(void)
 375 {
 376         if (ctrl_conn == NULL)
 377                 return;
 378
 379         if (wpa_cli_attached) {
 380                 wpa_ctrl_detach(interactive ? mon_conn : ctrl_conn);
 381                 wpa_cli_attached = 0;
 382         }
 383         wpa_ctrl_close(ctrl_conn);
 384         ctrl_conn = NULL;
 385         if (mon_conn) {
 386                 eloop_unregister_read_sock(wpa_ctrl_get_fd(mon_conn));
 387                 wpa_ctrl_close(mon_conn);
 388                 mon_conn = NULL;
 389         }
 390 }
 391
 392
 393 static void wpa_cli_msg_cb(char *msg, size_t len)
 394 {
 395         printf("%s\n", msg);
 396 }
 397
 398
 399 static int _wpa_ctrl_command(struct wpa_ctrl *ctrl, char *cmd, int print)
 400 {
 401         char buf[4096];
 402         size_t len;
 403         int ret;
 404
 405         if (ctrl_conn == NULL) {
 406                 printf("Not connected to wpa_supplicant - command dropped.\n");
 407                 return -1;
 408         }
 409         if (ifname_prefix) {
 410                 os_snprintf(buf, sizeof(buf), "IFNAME=%s %s",
 411                             ifname_prefix, cmd);
 412                 buf[sizeof(buf) - 1] = '\0';
 413                 cmd = buf;
 414         }
 415         len = sizeof(buf) - 1;
 416         ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
 417                                wpa_cli_msg_cb);
 418         if (ret == -2) {
 419                 printf("'%s' command timed out.\n", cmd);
 420                 return -2;
 421         } else if (ret < 0) {
 422                 printf("'%s' command failed.\n", cmd);
 423                 return -1;
 424         }
 425         if (print) {
 426                 buf[len] = '\0';
 427                 printf("%s", buf);
 428                 if (interactive && len > 0 && buf[len - 1] != '\n')
 429                         printf("\n");
 430         }
 431         return 0;
 432 }
 433
 434
 435 static int wpa_ctrl_command(struct wpa_ctrl *ctrl, char *cmd)
 436 {
 437         return _wpa_ctrl_command(ctrl, cmd, 1);
 438 }
 439
 440
 441 static int write_cmd(char *buf, size_t buflen, const char *cmd, int argc,
 442                      char *argv[])
 443 {
 444         int i, res;
 445         char *pos, *end;
 446
 447         pos = buf;
 448         end = buf + buflen;
 449
 450         res = os_snprintf(pos, end - pos, "%s", cmd);
 451         if (os_snprintf_error(end - pos, res))
 452                 goto fail;
 453         pos += res;
 454
 455         for (i = 0; i < argc; i++) {
 456                 res = os_snprintf(pos, end - pos, " %s", argv[i]);
 457                 if (os_snprintf_error(end - pos, res))
 458                         goto fail;
 459                 pos += res;
 460         }
 461
 462         buf[buflen - 1] = '\0';
 463         return 0;
 464
 465 fail:
 466         printf("Too long command\n");
 467         return -1;
 468 }
 469
 470
 471 static int wpa_cli_cmd(struct wpa_ctrl *ctrl, const char *cmd, int min_args,
 472                        int argc, char *argv[])
 473 {
 474         char buf[4096];
 475         if (argc < min_args) {
 476                 printf("Invalid %s command - at least %d argument%s "
 477                        "required.\n", cmd, min_args,
 478                        min_args > 1 ? "s are" : " is");
 479                 return -1;
 480         }
 481         if (write_cmd(buf, sizeof(buf), cmd, argc, argv) < 0)
 482                 return -1;
 483         return wpa_ctrl_command(ctrl, buf);
 484 }
 485
 486
 487 static int wpa_cli_cmd_ifname(struct wpa_ctrl *ctrl, int argc, char *argv[])
 488 {
 489         return wpa_ctrl_command(ctrl, "IFNAME");
 490 }
 491
 492
 493 static int wpa_cli_cmd_status(struct wpa_ctrl *ctrl, int argc, char *argv[])
 494 {
 495         if (argc > 0 && os_strcmp(argv[0], "verbose") == 0)
 496                 return wpa_ctrl_command(ctrl, "STATUS-VERBOSE");
 497         if (argc > 0 && os_strcmp(argv[0], "wps") == 0)
 498                 return wpa_ctrl_command(ctrl, "STATUS-WPS");
 499         if (argc > 0 && os_strcmp(argv[0], "driver") == 0)
 500                 return wpa_ctrl_command(ctrl, "STATUS-DRIVER");
 501         return wpa_ctrl_command(ctrl, "STATUS");
 502 }
 503
 504
 505 static int wpa_cli_cmd_ping(struct wpa_ctrl *ctrl, int argc, char *argv[])
 506 {
 507         return wpa_ctrl_command(ctrl, "PING");
 508 }
 509
 510
 511 static int wpa_cli_cmd_relog(struct wpa_ctrl *ctrl, int argc, char *argv[])
 512 {
 513         return wpa_ctrl_command(ctrl, "RELOG");
 514 }
 515
 516
 517 static int wpa_cli_cmd_note(struct wpa_ctrl *ctrl, int argc, char *argv[])
 518 {
 519         return wpa_cli_cmd(ctrl, "NOTE", 1, argc, argv);
 520 }
 521
 522
 523 static int wpa_cli_cmd_mib(struct wpa_ctrl *ctrl, int argc, char *argv[])
 524 {
 525         return wpa_ctrl_command(ctrl, "MIB");
 526 }
 527
 528
 529 static int wpa_cli_cmd_pmksa(struct wpa_ctrl *ctrl, int argc, char *argv[])
 530 {
 531         return wpa_ctrl_command(ctrl, "PMKSA");
 532 }
 533
 534
 535 static int wpa_cli_cmd_pmksa_flush(struct wpa_ctrl *ctrl, int argc,
 536                                    char *argv[])
 537 {
 538         return wpa_ctrl_command(ctrl, "PMKSA_FLUSH");
 539 }
 540
 541
 542 static int wpa_cli_cmd_help(struct wpa_ctrl *ctrl, int argc, char *argv[])
 543 {
 544         print_help(argc > 0 ? argv[0] : NULL);
 545         return 0;
 546 }
 547
 548
 549 static char ** wpa_cli_complete_help(const char *str, int pos)
 550 {
 551         int arg = get_cmd_arg_num(str, pos);
 552         char **res = NULL;
 553
 554         switch (arg) {
 555         case 1:
 556                 res = wpa_list_cmd_list();
 557                 break;
 558         }
 559
 560         return res;
 561 }
 562
 563
 564 static int wpa_cli_cmd_license(struct wpa_ctrl *ctrl, int argc, char *argv[])
 565 {
 566         printf("%s\n\n%s\n", wpa_cli_version, wpa_cli_full_license);
 567         return 0;
 568 }
 569
 570
 571 static int wpa_cli_cmd_quit(struct wpa_ctrl *ctrl, int argc, char *argv[])
 572 {
 573         wpa_cli_quit = 1;
 574         if (interactive)
 575                 eloop_terminate();
 576         return 0;
 577 }
 578
 579
 580 static int wpa_cli_cmd_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
 581 {
 582         char cmd[256];
 583         int res;
 584
 585         if (argc == 1) {
 586                 res = os_snprintf(cmd, sizeof(cmd), "SET %s ", argv[0]);
 587                 if (os_snprintf_error(sizeof(cmd), res)) {
 588                         printf("Too long SET command.\n");
 589                         return -1;
 590                 }
 591                 return wpa_ctrl_command(ctrl, cmd);
 592         }
 593
 594         return wpa_cli_cmd(ctrl, "SET", 2, argc, argv);
 595 }
 596
 597
 598 static char ** wpa_cli_complete_set(const char *str, int pos)
 599 {
 600         int arg = get_cmd_arg_num(str, pos);
 601         const char *fields[] = {
 602                 /* runtime values */
 603                 "EAPOL::heldPeriod", "EAPOL::authPeriod", "EAPOL::startPeriod",
 604                 "EAPOL::maxStart", "dot11RSNAConfigPMKLifetime",
 605                 "dot11RSNAConfigPMKReauthThreshold", "dot11RSNAConfigSATimeout",
 606                 "wps_fragment_size", "wps_version_number", "ampdu",
 607                 "tdls_testing", "tdls_disabled", "pno", "radio_disabled",
 608                 "uapsd", "ps", "wifi_display", "bssid_filter", "disallow_aps",
 609                 "no_keep_alive",
 610                 /* global configuration parameters */
 611                 "eapol_version", "ap_scan", "disable_scan_offload",
 612                 "fast_reauth", "opensc_engine_path", "pkcs11_engine_path",
 613                 "pkcs11_module_path", "openssl_ciphers",
 614                 "pcsc_reader", "pcsc_pin",
 615                 "driver_param", "dot11RSNAConfigPMKLifetime",
 616                 "dot11RSNAConfigPMKReauthThreshold",
 617                 "dot11RSNAConfigSATimeout",
 618                 "update_config", "load_dynamic_eap", "uuid", "device_name",
 619                 "manufacturer", "model_name", "model_number", "serial_number",
 620                 "device_type", "os_version", "config_methods",
 621                 "wps_cred_processing", "wps_vendor_ext_m1", "sec_device_type",
 622                 "p2p_listen_reg_class", "p2p_listen_channel",
 623                 "p2p_oper_reg_class", "p2p_oper_channel",
 624                 "p2p_go_intent", "p2p_ssid_postfix", "persistent_reconnect",
 625                 "p2p_intra_bss", "p2p_group_idle", "p2p_pref_chan",
 626                 "p2p_no_go_freq",
 627                 "p2p_go_ht40", "p2p_disabled", "p2p_no_group_iface",
 628                 "p2p_go_vht",
 629                 "p2p_ignore_shared_freq", "country", "bss_max_count",
 630                 "bss_expiration_age", "bss_expiration_scan_count",
 631                 "filter_ssids", "filter_rssi", "max_num_sta",
 632                 "disassoc_low_ack", "hs20", "interworking", "hessid",
 633                 "access_network_type", "pbc_in_m1", "autoscan",
 634                 "wps_nfc_dev_pw_id", "wps_nfc_dh_pubkey", "wps_nfc_dh_privkey",
 635                 "wps_nfc_dev_pw", "ext_password_backend",
 636                 "p2p_go_max_inactivity", "auto_interworking", "okc", "pmf",
 637                 "sae_groups", "dtim_period", "beacon_int", "ap_vendor_elements",
 638                 "ignore_old_scan_res", "freq_list", "external_sim",
 639                 "tdls_external_control", "p2p_search_delay"
 640         };
 641         int i, num_fields = ARRAY_SIZE(fields);
 642
 643         if (arg == 1) {
 644                 char **res = os_calloc(num_fields + 1, sizeof(char *));
 645                 if (res == NULL)
 646                         return NULL;
 647                 for (i = 0; i < num_fields; i++) {
 648                         res[i] = os_strdup(fields[i]);
 649                         if (res[i] == NULL)
 650                                 return res;
 651                 }
 652                 return res;
 653         }
 654
 655         if (arg > 1 && os_strncasecmp(str, "set bssid_filter ", 17) == 0)
 656                 return cli_txt_list_array(&bsses);
 657
 658         return NULL;
 659 }
 660
 661
 662 static int wpa_cli_cmd_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
 663 {
 664         return wpa_cli_cmd(ctrl, "GET", 1, argc, argv);
 665 }
 666
 667
 668 static int wpa_cli_cmd_logoff(struct wpa_ctrl *ctrl, int argc, char *argv[])
 669 {
 670         return wpa_ctrl_command(ctrl, "LOGOFF");
 671 }
 672
 673
 674 static int wpa_cli_cmd_logon(struct wpa_ctrl *ctrl, int argc, char *argv[])
 675 {
 676         return wpa_ctrl_command(ctrl, "LOGON");
 677 }
 678
 679
 680 static int wpa_cli_cmd_reassociate(struct wpa_ctrl *ctrl, int argc,
 681                                    char *argv[])
 682 {
 683         return wpa_ctrl_command(ctrl, "REASSOCIATE");
 684 }
 685
 686
 687 static int wpa_cli_cmd_reattach(struct wpa_ctrl *ctrl, int argc, char *argv[])
 688 {
 689         return wpa_ctrl_command(ctrl, "REATTACH");
 690 }
 691
 692
 693 static int wpa_cli_cmd_preauthenticate(struct wpa_ctrl *ctrl, int argc,
 694                                        char *argv[])
 695 {
 696         return wpa_cli_cmd(ctrl, "PREAUTH", 1, argc, argv);
 697 }
 698
 699
 700 static int wpa_cli_cmd_ap_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
 701 {
 702         return wpa_cli_cmd(ctrl, "AP_SCAN", 1, argc, argv);
 703 }
 704
 705
 706 static int wpa_cli_cmd_scan_interval(struct wpa_ctrl *ctrl, int argc,
 707                                      char *argv[])
 708 {
 709         return wpa_cli_cmd(ctrl, "SCAN_INTERVAL", 1, argc, argv);
 710 }
 711
 712
 713 static int wpa_cli_cmd_bss_expire_age(struct wpa_ctrl *ctrl, int argc,
 714                                       char *argv[])
 715 {
 716         return wpa_cli_cmd(ctrl, "BSS_EXPIRE_AGE", 1, argc, argv);
 717 }
 718
 719
 720 static int wpa_cli_cmd_bss_expire_count(struct wpa_ctrl *ctrl, int argc,
 721                                         char *argv[])
 722 {
 723         return wpa_cli_cmd(ctrl, "BSS_EXPIRE_COUNT", 1, argc, argv);
 724 }
 725
 726
 727 static int wpa_cli_cmd_bss_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
 728 {
 729         char cmd[256];
 730         int res;
 731
 732         if (argc < 1)
 733                 res = os_snprintf(cmd, sizeof(cmd), "BSS_FLUSH 0");
 734         else
 735                 res = os_snprintf(cmd, sizeof(cmd), "BSS_FLUSH %s", argv[0]);
 736         if (os_snprintf_error(sizeof(cmd), res)) {
 737                 printf("Too long BSS_FLUSH command.\n");
 738                 return -1;
 739         }
 740         return wpa_ctrl_command(ctrl, cmd);
 741 }
 742
 743
 744 static int wpa_cli_cmd_stkstart(struct wpa_ctrl *ctrl, int argc,
 745                                 char *argv[])
 746 {
 747         return wpa_cli_cmd(ctrl, "STKSTART", 1, argc, argv);
 748 }
 749
 750
 751 static int wpa_cli_cmd_ft_ds(struct wpa_ctrl *ctrl, int argc, char *argv[])
 752 {
 753         return wpa_cli_cmd(ctrl, "FT_DS", 1, argc, argv);
 754 }
 755
 756
 757 static int wpa_cli_cmd_wps_pbc(struct wpa_ctrl *ctrl, int argc, char *argv[])
 758 {
 759         return wpa_cli_cmd(ctrl, "WPS_PBC", 0, argc, argv);
 760 }
 761
 762
 763 static int wpa_cli_cmd_wps_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
 764 {
 765         if (argc == 0) {
 766                 printf("Invalid WPS_PIN command: need one or two arguments:\n"
 767                        "- BSSID: use 'any' to select any\n"
 768                        "- PIN: optional, used only with devices that have no "
 769                        "display\n");
 770                 return -1;
 771         }
 772
 773         return wpa_cli_cmd(ctrl, "WPS_PIN", 1, argc, argv);
 774 }
 775
 776
 777 static int wpa_cli_cmd_wps_check_pin(struct wpa_ctrl *ctrl, int argc,
 778                                      char *argv[])
 779 {
 780         return wpa_cli_cmd(ctrl, "WPS_CHECK_PIN", 1, argc, argv);
 781 }
 782
 783
 784 static int wpa_cli_cmd_wps_cancel(struct wpa_ctrl *ctrl, int argc,
 785                                   char *argv[])
 786 {
 787         return wpa_ctrl_command(ctrl, "WPS_CANCEL");
 788 }
 789
 790
 791 #ifdef CONFIG_WPS_NFC
 792
 793 static int wpa_cli_cmd_wps_nfc(struct wpa_ctrl *ctrl, int argc, char *argv[])
 794 {
 795         return wpa_cli_cmd(ctrl, "WPS_NFC", 0, argc, argv);
 796 }
 797
 798
 799 static int wpa_cli_cmd_wps_nfc_config_token(struct wpa_ctrl *ctrl, int argc,
 800                                             char *argv[])
 801 {
 802         return wpa_cli_cmd(ctrl, "WPS_NFC_CONFIG_TOKEN", 1, argc, argv);
 803 }
 804
 805
 806 static int wpa_cli_cmd_wps_nfc_token(struct wpa_ctrl *ctrl, int argc,
 807                                      char *argv[])
 808 {
 809         return wpa_cli_cmd(ctrl, "WPS_NFC_TOKEN", 1, argc, argv);
 810 }
 811
 812
 813 static int wpa_cli_cmd_wps_nfc_tag_read(struct wpa_ctrl *ctrl, int argc,
 814                                         char *argv[])
 815 {
 816         int ret;
 817         char *buf;
 818         size_t buflen;
 819
 820         if (argc != 1) {
 821                 printf("Invalid 'wps_nfc_tag_read' command - one argument "
 822                        "is required.\n");
 823                 return -1;
 824         }
 825
 826         buflen = 18 + os_strlen(argv[0]);
 827         buf = os_malloc(buflen);
 828         if (buf == NULL)
 829                 return -1;
 830         os_snprintf(buf, buflen, "WPS_NFC_TAG_READ %s", argv[0]);
 831
 832         ret = wpa_ctrl_command(ctrl, buf);
 833         os_free(buf);
 834
 835         return ret;
 836 }
 837
 838
 839 static int wpa_cli_cmd_nfc_get_handover_req(struct wpa_ctrl *ctrl, int argc,
 840                                             char *argv[])
 841 {
 842         return wpa_cli_cmd(ctrl, "NFC_GET_HANDOVER_REQ", 2, argc, argv);
 843 }
 844
 845
 846 static int wpa_cli_cmd_nfc_get_handover_sel(struct wpa_ctrl *ctrl, int argc,
 847                                             char *argv[])
 848 {
 849         return wpa_cli_cmd(ctrl, "NFC_GET_HANDOVER_SEL", 2, argc, argv);
 850 }
 851
 852
 853 static int wpa_cli_cmd_nfc_report_handover(struct wpa_ctrl *ctrl, int argc,
 854                                            char *argv[])
 855 {
 856         return wpa_cli_cmd(ctrl, "NFC_REPORT_HANDOVER", 4, argc, argv);
 857 }
 858
 859 #endif /* CONFIG_WPS_NFC */
 860
 861
 862 static int wpa_cli_cmd_wps_reg(struct wpa_ctrl *ctrl, int argc, char *argv[])
 863 {
 864         char cmd[256];
 865         int res;
 866
 867         if (argc == 2)
 868                 res = os_snprintf(cmd, sizeof(cmd), "WPS_REG %s %s",
 869                                   argv[0], argv[1]);
 870         else if (argc == 5 || argc == 6) {
 871                 char ssid_hex[2 * 32 + 1];
 872                 char key_hex[2 * 64 + 1];
 873                 int i;
 874
 875                 ssid_hex[0] = '\0';
 876                 for (i = 0; i < 32; i++) {
 877                         if (argv[2][i] == '\0')
 878                                 break;
 879                         os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[2][i]);
 880                 }
 881
 882                 key_hex[0] = '\0';
 883                 if (argc == 6) {
 884                         for (i = 0; i < 64; i++) {
 885                                 if (argv[5][i] == '\0')
 886                                         break;
 887                                 os_snprintf(&key_hex[i * 2], 3, "%02x",
 888                                             argv[5][i]);
 889                         }
 890                 }
 891
 892                 res = os_snprintf(cmd, sizeof(cmd),
 893                                   "WPS_REG %s %s %s %s %s %s",
 894                                   argv[0], argv[1], ssid_hex, argv[3], argv[4],
 895                                   key_hex);
 896         } else {
 897                 printf("Invalid WPS_REG command: need two arguments:\n"
 898                        "- BSSID of the target AP\n"
 899                        "- AP PIN\n");
 900                 printf("Alternatively, six arguments can be used to "
 901                        "reconfigure the AP:\n"
 902                        "- BSSID of the target AP\n"
 903                        "- AP PIN\n"
 904                        "- new SSID\n"
 905                        "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
 906                        "- new encr (NONE, WEP, TKIP, CCMP)\n"
 907                        "- new key\n");
 908                 return -1;
 909         }
 910
 911         if (os_snprintf_error(sizeof(cmd), res)) {
 912                 printf("Too long WPS_REG command.\n");
 913                 return -1;
 914         }
 915         return wpa_ctrl_command(ctrl, cmd);
 916 }
 917
 918
 919 static int wpa_cli_cmd_wps_ap_pin(struct wpa_ctrl *ctrl, int argc,
 920                                   char *argv[])
 921 {
 922         return wpa_cli_cmd(ctrl, "WPS_AP_PIN", 1, argc, argv);
 923 }
 924
 925
 926 static int wpa_cli_cmd_wps_er_start(struct wpa_ctrl *ctrl, int argc,
 927                                     char *argv[])
 928 {
 929         return wpa_cli_cmd(ctrl, "WPS_ER_START", 0, argc, argv);
 930 }
 931
 932
 933 static int wpa_cli_cmd_wps_er_stop(struct wpa_ctrl *ctrl, int argc,
 934                                    char *argv[])
 935 {
 936         return wpa_ctrl_command(ctrl, "WPS_ER_STOP");
 937
 938 }
 939
 940
 941 static int wpa_cli_cmd_wps_er_pin(struct wpa_ctrl *ctrl, int argc,
 942                                   char *argv[])
 943 {
 944         if (argc < 2) {
 945                 printf("Invalid WPS_ER_PIN command: need at least two "
 946                        "arguments:\n"
 947                        "- UUID: use 'any' to select any\n"
 948                        "- PIN: Enrollee PIN\n"
 949                        "optional: - Enrollee MAC address\n");
 950                 return -1;
 951         }
 952
 953         return wpa_cli_cmd(ctrl, "WPS_ER_PIN", 2, argc, argv);
 954 }
 955
 956
 957 static int wpa_cli_cmd_wps_er_pbc(struct wpa_ctrl *ctrl, int argc,
 958                                   char *argv[])
 959 {
 960         return wpa_cli_cmd(ctrl, "WPS_ER_PBC", 1, argc, argv);
 961 }
 962
 963
 964 static int wpa_cli_cmd_wps_er_learn(struct wpa_ctrl *ctrl, int argc,
 965                                     char *argv[])
 966 {
 967         if (argc != 2) {
 968                 printf("Invalid WPS_ER_LEARN command: need two arguments:\n"
 969                        "- UUID: specify which AP to use\n"
 970                        "- PIN: AP PIN\n");
 971                 return -1;
 972         }
 973
 974         return wpa_cli_cmd(ctrl, "WPS_ER_LEARN", 2, argc, argv);
 975 }
 976
 977
 978 static int wpa_cli_cmd_wps_er_set_config(struct wpa_ctrl *ctrl, int argc,
 979                                          char *argv[])
 980 {
 981         if (argc != 2) {
 982                 printf("Invalid WPS_ER_SET_CONFIG command: need two "
 983                        "arguments:\n"
 984                        "- UUID: specify which AP to use\n"
 985                        "- Network configuration id\n");
 986                 return -1;
 987         }
 988
 989         return wpa_cli_cmd(ctrl, "WPS_ER_SET_CONFIG", 2, argc, argv);
 990 }
 991
 992
 993 static int wpa_cli_cmd_wps_er_config(struct wpa_ctrl *ctrl, int argc,
 994                                      char *argv[])
 995 {
 996         char cmd[256];
 997         int res;
 998
 999         if (argc == 5 || argc == 6) {
1000                 char ssid_hex[2 * 32 + 1];
1001                 char key_hex[2 * 64 + 1];
1002                 int i;
1003
1004                 ssid_hex[0] = '\0';
1005                 for (i = 0; i < 32; i++) {
1006                         if (argv[2][i] == '\0')
1007                                 break;
1008                         os_snprintf(&ssid_hex[i * 2], 3, "%02x", argv[2][i]);
1009                 }
1010
1011                 key_hex[0] = '\0';
1012                 if (argc == 6) {
1013                         for (i = 0; i < 64; i++) {
1014                                 if (argv[5][i] == '\0')
1015                                         break;
1016                                 os_snprintf(&key_hex[i * 2], 3, "%02x",
1017                                             argv[5][i]);
1018                         }
1019                 }
1020
1021                 res = os_snprintf(cmd, sizeof(cmd),
1022                                   "WPS_ER_CONFIG %s %s %s %s %s %s",
1023                                   argv[0], argv[1], ssid_hex, argv[3], argv[4],
1024                                   key_hex);
1025         } else {
1026                 printf("Invalid WPS_ER_CONFIG command: need six arguments:\n"
1027                        "- AP UUID\n"
1028                        "- AP PIN\n"
1029                        "- new SSID\n"
1030                        "- new auth (OPEN, WPAPSK, WPA2PSK)\n"
1031                        "- new encr (NONE, WEP, TKIP, CCMP)\n"
1032                        "- new key\n");
1033                 return -1;
1034         }
1035
1036         if (os_snprintf_error(sizeof(cmd), res)) {
1037                 printf("Too long WPS_ER_CONFIG command.\n");
1038                 return -1;
1039         }
1040         return wpa_ctrl_command(ctrl, cmd);
1041 }
1042
1043
1044 #ifdef CONFIG_WPS_NFC
1045 static int wpa_cli_cmd_wps_er_nfc_config_token(struct wpa_ctrl *ctrl, int argc,
1046                                                char *argv[])
1047 {
1048         if (argc != 2) {
1049                 printf("Invalid WPS_ER_NFC_CONFIG_TOKEN command: need two "
1050                        "arguments:\n"
1051                        "- WPS/NDEF: token format\n"
1052                        "- UUID: specify which AP to use\n");
1053                 return -1;
1054         }
1055
1056         return wpa_cli_cmd(ctrl, "WPS_ER_NFC_CONFIG_TOKEN", 2, argc, argv);
1057 }
1058 #endif /* CONFIG_WPS_NFC */
1059
1060
1061 static int wpa_cli_cmd_ibss_rsn(struct wpa_ctrl *ctrl, int argc, char *argv[])
1062 {
1063         return wpa_cli_cmd(ctrl, "IBSS_RSN", 1, argc, argv);
1064 }
1065
1066
1067 static int wpa_cli_cmd_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
1068 {
1069         return wpa_cli_cmd(ctrl, "LEVEL", 1, argc, argv);
1070 }
1071
1072
1073 static int wpa_cli_cmd_identity(struct wpa_ctrl *ctrl, int argc, char *argv[])
1074 {
1075         char cmd[256], *pos, *end;
1076         int i, ret;
1077
1078         if (argc < 2) {
1079                 printf("Invalid IDENTITY command: needs two arguments "
1080                        "(network id and identity)\n");
1081                 return -1;
1082         }
1083
1084         end = cmd + sizeof(cmd);
1085         pos = cmd;
1086         ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "IDENTITY-%s:%s",
1087                           argv[0], argv[1]);
1088         if (os_snprintf_error(end - pos, ret)) {
1089                 printf("Too long IDENTITY command.\n");
1090                 return -1;
1091         }
1092         pos += ret;
1093         for (i = 2; i < argc; i++) {
1094                 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1095                 if (os_snprintf_error(end - pos, ret)) {
1096                         printf("Too long IDENTITY command.\n");
1097                         return -1;
1098                 }
1099                 pos += ret;
1100         }
1101
1102         return wpa_ctrl_command(ctrl, cmd);
1103 }
1104
1105
1106 static int wpa_cli_cmd_password(struct wpa_ctrl *ctrl, int argc, char *argv[])
1107 {
1108         char cmd[256], *pos, *end;
1109         int i, ret;
1110
1111         if (argc < 2) {
1112                 printf("Invalid PASSWORD command: needs two arguments "
1113                        "(network id and password)\n");
1114                 return -1;
1115         }
1116
1117         end = cmd + sizeof(cmd);
1118         pos = cmd;
1119         ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSWORD-%s:%s",
1120                           argv[0], argv[1]);
1121         if (os_snprintf_error(end - pos, ret)) {
1122                 printf("Too long PASSWORD command.\n");
1123                 return -1;
1124         }
1125         pos += ret;
1126         for (i = 2; i < argc; i++) {
1127                 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1128                 if (os_snprintf_error(end - pos, ret)) {
1129                         printf("Too long PASSWORD command.\n");
1130                         return -1;
1131                 }
1132                 pos += ret;
1133         }
1134
1135         return wpa_ctrl_command(ctrl, cmd);
1136 }
1137
1138
1139 static int wpa_cli_cmd_new_password(struct wpa_ctrl *ctrl, int argc,
1140                                     char *argv[])
1141 {
1142         char cmd[256], *pos, *end;
1143         int i, ret;
1144
1145         if (argc < 2) {
1146                 printf("Invalid NEW_PASSWORD command: needs two arguments "
1147                        "(network id and password)\n");
1148                 return -1;
1149         }
1150
1151         end = cmd + sizeof(cmd);
1152         pos = cmd;
1153         ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "NEW_PASSWORD-%s:%s",
1154                           argv[0], argv[1]);
1155         if (os_snprintf_error(end - pos, ret)) {
1156                 printf("Too long NEW_PASSWORD command.\n");
1157                 return -1;
1158         }
1159         pos += ret;
1160         for (i = 2; i < argc; i++) {
1161                 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1162                 if (os_snprintf_error(end - pos, ret)) {
1163                         printf("Too long NEW_PASSWORD command.\n");
1164                         return -1;
1165                 }
1166                 pos += ret;
1167         }
1168
1169         return wpa_ctrl_command(ctrl, cmd);
1170 }
1171
1172
1173 static int wpa_cli_cmd_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
1174 {
1175         char cmd[256], *pos, *end;
1176         int i, ret;
1177
1178         if (argc < 2) {
1179                 printf("Invalid PIN command: needs two arguments "
1180                        "(network id and pin)\n");
1181                 return -1;
1182         }
1183
1184         end = cmd + sizeof(cmd);
1185         pos = cmd;
1186         ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PIN-%s:%s",
1187                           argv[0], argv[1]);
1188         if (os_snprintf_error(end - pos, ret)) {
1189                 printf("Too long PIN command.\n");
1190                 return -1;
1191         }
1192         pos += ret;
1193         for (i = 2; i < argc; i++) {
1194                 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1195                 if (os_snprintf_error(end - pos, ret)) {
1196                         printf("Too long PIN command.\n");
1197                         return -1;
1198                 }
1199                 pos += ret;
1200         }
1201         return wpa_ctrl_command(ctrl, cmd);
1202 }
1203
1204
1205 static int wpa_cli_cmd_otp(struct wpa_ctrl *ctrl, int argc, char *argv[])
1206 {
1207         char cmd[256], *pos, *end;
1208         int i, ret;
1209
1210         if (argc < 2) {
1211                 printf("Invalid OTP command: needs two arguments (network "
1212                        "id and password)\n");
1213                 return -1;
1214         }
1215
1216         end = cmd + sizeof(cmd);
1217         pos = cmd;
1218         ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "OTP-%s:%s",
1219                           argv[0], argv[1]);
1220         if (os_snprintf_error(end - pos, ret)) {
1221                 printf("Too long OTP command.\n");
1222                 return -1;
1223         }
1224         pos += ret;
1225         for (i = 2; i < argc; i++) {
1226                 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1227                 if (os_snprintf_error(end - pos, ret)) {
1228                         printf("Too long OTP command.\n");
1229                         return -1;
1230                 }
1231                 pos += ret;
1232         }
1233
1234         return wpa_ctrl_command(ctrl, cmd);
1235 }
1236
1237
1238 static int wpa_cli_cmd_sim(struct wpa_ctrl *ctrl, int argc, char *argv[])
1239 {
1240         char cmd[256], *pos, *end;
1241         int i, ret;
1242
1243         if (argc < 2) {
1244                 printf("Invalid SIM command: needs two arguments "
1245                        "(network id and SIM operation response)\n");
1246                 return -1;
1247         }
1248
1249         end = cmd + sizeof(cmd);
1250         pos = cmd;
1251         ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "SIM-%s:%s",
1252                           argv[0], argv[1]);
1253         if (os_snprintf_error(end - pos, ret)) {
1254                 printf("Too long SIM command.\n");
1255                 return -1;
1256         }
1257         pos += ret;
1258         for (i = 2; i < argc; i++) {
1259                 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1260                 if (os_snprintf_error(end - pos, ret)) {
1261                         printf("Too long SIM command.\n");
1262                         return -1;
1263                 }
1264                 pos += ret;
1265         }
1266         return wpa_ctrl_command(ctrl, cmd);
1267 }
1268
1269
1270 static int wpa_cli_cmd_passphrase(struct wpa_ctrl *ctrl, int argc,
1271                                   char *argv[])
1272 {
1273         char cmd[256], *pos, *end;
1274         int i, ret;
1275
1276         if (argc < 2) {
1277                 printf("Invalid PASSPHRASE command: needs two arguments "
1278                        "(network id and passphrase)\n");
1279                 return -1;
1280         }
1281
1282         end = cmd + sizeof(cmd);
1283         pos = cmd;
1284         ret = os_snprintf(pos, end - pos, WPA_CTRL_RSP "PASSPHRASE-%s:%s",
1285                           argv[0], argv[1]);
1286         if (os_snprintf_error(end - pos, ret)) {
1287                 printf("Too long PASSPHRASE command.\n");
1288                 return -1;
1289         }
1290         pos += ret;
1291         for (i = 2; i < argc; i++) {
1292                 ret = os_snprintf(pos, end - pos, " %s", argv[i]);
1293                 if (os_snprintf_error(end - pos, ret)) {
1294                         printf("Too long PASSPHRASE command.\n");
1295                         return -1;
1296                 }
1297                 pos += ret;
1298         }
1299
1300         return wpa_ctrl_command(ctrl, cmd);
1301 }
1302
1303
1304 static int wpa_cli_cmd_bssid(struct wpa_ctrl *ctrl, int argc, char *argv[])
1305 {
1306         if (argc < 2) {
1307                 printf("Invalid BSSID command: needs two arguments (network "
1308                        "id and BSSID)\n");
1309                 return -1;
1310         }
1311
1312         return wpa_cli_cmd(ctrl, "BSSID", 2, argc, argv);
1313 }
1314
1315
1316 static int wpa_cli_cmd_blacklist(struct wpa_ctrl *ctrl, int argc, char *argv[])
1317 {
1318         return wpa_cli_cmd(ctrl, "BLACKLIST", 0, argc, argv);
1319 }
1320
1321
1322 static int wpa_cli_cmd_log_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
1323 {
1324         return wpa_cli_cmd(ctrl, "LOG_LEVEL", 0, argc, argv);
1325 }
1326
1327
1328 static int wpa_cli_cmd_list_networks(struct wpa_ctrl *ctrl, int argc,
1329                                      char *argv[])
1330 {
1331         return wpa_ctrl_command(ctrl, "LIST_NETWORKS");
1332 }
1333
1334
1335 static int wpa_cli_cmd_select_network(struct wpa_ctrl *ctrl, int argc,
1336                                       char *argv[])
1337 {
1338         return wpa_cli_cmd(ctrl, "SELECT_NETWORK", 1, argc, argv);
1339 }
1340
1341
1342 static int wpa_cli_cmd_enable_network(struct wpa_ctrl *ctrl, int argc,
1343                                       char *argv[])
1344 {
1345         return wpa_cli_cmd(ctrl, "ENABLE_NETWORK", 1, argc, argv);
1346 }
1347
1348
1349 static int wpa_cli_cmd_disable_network(struct wpa_ctrl *ctrl, int argc,
1350                                        char *argv[])
1351 {
1352         return wpa_cli_cmd(ctrl, "DISABLE_NETWORK", 1, argc, argv);
1353 }
1354
1355
1356 static int wpa_cli_cmd_add_network(struct wpa_ctrl *ctrl, int argc,
1357                                    char *argv[])
1358 {
1359         return wpa_ctrl_command(ctrl, "ADD_NETWORK");
1360 }
1361
1362
1363 static int wpa_cli_cmd_remove_network(struct wpa_ctrl *ctrl, int argc,
1364                                       char *argv[])
1365 {
1366         return wpa_cli_cmd(ctrl, "REMOVE_NETWORK", 1, argc, argv);
1367 }
1368
1369
1370 static void wpa_cli_show_network_variables(void)
1371 {
1372         printf("set_network variables:\n"
1373                "  ssid (network name, SSID)\n"
1374                "  psk (WPA passphrase or pre-shared key)\n"
1375                "  key_mgmt (key management protocol)\n"
1376                "  identity (EAP identity)\n"
1377                "  password (EAP password)\n"
1378                "  ...\n"
1379                "\n"
1380                "Note: Values are entered in the same format as the "
1381                "configuration file is using,\n"
1382                "i.e., strings values need to be inside double quotation "
1383                "marks.\n"
1384                "For example: set_network 1 ssid \"network name\"\n"
1385                "\n"
1386                "Please see wpa_supplicant.conf documentation for full list "
1387                "of\navailable variables.\n");
1388 }
1389
1390
1391 static int wpa_cli_cmd_set_network(struct wpa_ctrl *ctrl, int argc,
1392                                    char *argv[])
1393 {
1394         if (argc == 0) {
1395                 wpa_cli_show_network_variables();
1396                 return 0;
1397         }
1398
1399         if (argc < 3) {
1400                 printf("Invalid SET_NETWORK command: needs three arguments\n"
1401                        "(network id, variable name, and value)\n");
1402                 return -1;
1403         }
1404
1405         return wpa_cli_cmd(ctrl, "SET_NETWORK", 3, argc, argv);
1406 }
1407
1408
1409 static int wpa_cli_cmd_get_network(struct wpa_ctrl *ctrl, int argc,
1410                                    char *argv[])
1411 {
1412         if (argc == 0) {
1413                 wpa_cli_show_network_variables();
1414                 return 0;
1415         }
1416
1417         if (argc != 2) {
1418                 printf("Invalid GET_NETWORK command: needs two arguments\n"
1419                        "(network id and variable name)\n");
1420                 return -1;
1421         }
1422
1423         return wpa_cli_cmd(ctrl, "GET_NETWORK", 2, argc, argv);
1424 }
1425
1426
1427 static int wpa_cli_cmd_dup_network(struct wpa_ctrl *ctrl, int argc,
1428                                    char *argv[])
1429 {
1430         if (argc == 0) {
1431                 wpa_cli_show_network_variables();
1432                 return 0;
1433         }
1434
1435         if (argc < 3) {
1436                 printf("Invalid DUP_NETWORK command: needs three arguments\n"
1437                        "(src netid, dest netid, and variable name)\n");
1438                 return -1;
1439         }
1440
1441         return wpa_cli_cmd(ctrl, "DUP_NETWORK", 3, argc, argv);
1442 }
1443
1444
1445 static int wpa_cli_cmd_list_creds(struct wpa_ctrl *ctrl, int argc,
1446                                   char *argv[])
1447 {
1448         return wpa_ctrl_command(ctrl, "LIST_CREDS");
1449 }
1450
1451
1452 static int wpa_cli_cmd_add_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1453 {
1454         return wpa_ctrl_command(ctrl, "ADD_CRED");
1455 }
1456
1457
1458 static int wpa_cli_cmd_remove_cred(struct wpa_ctrl *ctrl, int argc,
1459                                    char *argv[])
1460 {
1461         return wpa_cli_cmd(ctrl, "REMOVE_CRED", 1, argc, argv);
1462 }
1463
1464
1465 static int wpa_cli_cmd_set_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1466 {
1467         if (argc != 3) {
1468                 printf("Invalid SET_CRED command: needs three arguments\n"
1469                        "(cred id, variable name, and value)\n");
1470                 return -1;
1471         }
1472
1473         return wpa_cli_cmd(ctrl, "SET_CRED", 3, argc, argv);
1474 }
1475
1476
1477 static int wpa_cli_cmd_get_cred(struct wpa_ctrl *ctrl, int argc, char *argv[])
1478 {
1479         if (argc != 2) {
1480                 printf("Invalid GET_CRED command: needs two arguments\n"
1481                        "(cred id, variable name)\n");
1482                 return -1;
1483         }
1484
1485         return wpa_cli_cmd(ctrl, "GET_CRED", 2, argc, argv);
1486 }
1487
1488
1489 static int wpa_cli_cmd_disconnect(struct wpa_ctrl *ctrl, int argc,
1490                                   char *argv[])
1491 {
1492         return wpa_ctrl_command(ctrl, "DISCONNECT");
1493 }
1494
1495
1496 static int wpa_cli_cmd_reconnect(struct wpa_ctrl *ctrl, int argc,
1497                                   char *argv[])
1498 {
1499         return wpa_ctrl_command(ctrl, "RECONNECT");
1500 }
1501
1502
1503 static int wpa_cli_cmd_save_config(struct wpa_ctrl *ctrl, int argc,
1504                                    char *argv[])
1505 {
1506         return wpa_ctrl_command(ctrl, "SAVE_CONFIG");
1507 }
1508
1509
1510 static int wpa_cli_cmd_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
1511 {
1512         return wpa_cli_cmd(ctrl, "SCAN", 0, argc, argv);
1513 }
1514
1515
1516 static int wpa_cli_cmd_scan_results(struct wpa_ctrl *ctrl, int argc,
1517                                     char *argv[])
1518 {
1519         return wpa_ctrl_command(ctrl, "SCAN_RESULTS");
1520 }
1521
1522
1523 static int wpa_cli_cmd_bss(struct wpa_ctrl *ctrl, int argc, char *argv[])
1524 {
1525         return wpa_cli_cmd(ctrl, "BSS", 1, argc, argv);
1526 }
1527
1528
1529 static char ** wpa_cli_complete_bss(const char *str, int pos)
1530 {
1531         int arg = get_cmd_arg_num(str, pos);
1532         char **res = NULL;
1533
1534         switch (arg) {
1535         case 1:
1536                 res = cli_txt_list_array(&bsses);
1537                 break;
1538         }
1539
1540         return res;
1541 }
1542
1543
1544 static int wpa_cli_cmd_get_capability(struct wpa_ctrl *ctrl, int argc,
1545                                       char *argv[])
1546 {
1547         if (argc < 1 || argc > 2) {
1548                 printf("Invalid GET_CAPABILITY command: need either one or "
1549                        "two arguments\n");
1550                 return -1;
1551         }
1552
1553         if ((argc == 2) && os_strcmp(argv[1], "strict") != 0) {
1554                 printf("Invalid GET_CAPABILITY command: second argument, "
1555                        "if any, must be 'strict'\n");
1556                 return -1;
1557         }
1558
1559         return wpa_cli_cmd(ctrl, "GET_CAPABILITY", 1, argc, argv);
1560 }
1561
1562
1563 static int wpa_cli_list_interfaces(struct wpa_ctrl *ctrl)
1564 {
1565         printf("Available interfaces:\n");
1566         return wpa_ctrl_command(ctrl, "INTERFACES");
1567 }
1568
1569
1570 static int wpa_cli_cmd_interface(struct wpa_ctrl *ctrl, int argc, char *argv[])
1571 {
1572         if (argc < 1) {
1573                 wpa_cli_list_interfaces(ctrl);
1574                 return 0;
1575         }
1576
1577         wpa_cli_close_connection();
1578         os_free(ctrl_ifname);
1579         ctrl_ifname = os_strdup(argv[0]);
1580         if (!ctrl_ifname) {
1581                 printf("Failed to allocate memory\n");
1582                 return 0;
1583         }
1584
1585         if (wpa_cli_open_connection(ctrl_ifname, 1) == 0) {
1586                 printf("Connected to interface '%s.\n", ctrl_ifname);
1587         } else {
1588                 printf("Could not connect to interface '%s' - re-trying\n",
1589                        ctrl_ifname);
1590         }
1591         return 0;
1592 }
1593
1594
1595 static int wpa_cli_cmd_reconfigure(struct wpa_ctrl *ctrl, int argc,
1596                                    char *argv[])
1597 {
1598         return wpa_ctrl_command(ctrl, "RECONFIGURE");
1599 }
1600
1601
1602 static int wpa_cli_cmd_terminate(struct wpa_ctrl *ctrl, int argc,
1603                                  char *argv[])
1604 {
1605         return wpa_ctrl_command(ctrl, "TERMINATE");
1606 }
1607
1608
1609 static int wpa_cli_cmd_interface_add(struct wpa_ctrl *ctrl, int argc,
1610                                      char *argv[])
1611 {
1612         char cmd[256];
1613         int res;
1614
1615         if (argc < 1) {
1616                 printf("Invalid INTERFACE_ADD command: needs at least one "
1617                        "argument (interface name)\n"
1618                        "All arguments: ifname confname driver ctrl_interface "
1619                        "driver_param bridge_name\n");
1620                 return -1;
1621         }
1622
1623         /*
1624          * INTERFACE_ADD <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB
1625          * <driver_param>TAB<bridge_name>
1626          */
1627         res = os_snprintf(cmd, sizeof(cmd),
1628                           "INTERFACE_ADD %s\t%s\t%s\t%s\t%s\t%s",
1629                           argv[0],
1630                           argc > 1 ? argv[1] : "", argc > 2 ? argv[2] : "",
1631                           argc > 3 ? argv[3] : "", argc > 4 ? argv[4] : "",
1632                           argc > 5 ? argv[5] : "");
1633         if (os_snprintf_error(sizeof(cmd), res))
1634                 return -1;
1635         cmd[sizeof(cmd) - 1] = '\0';
1636         return wpa_ctrl_command(ctrl, cmd);
1637 }
1638
1639
1640 static int wpa_cli_cmd_interface_remove(struct wpa_ctrl *ctrl, int argc,
1641                                         char *argv[])
1642 {
1643         return wpa_cli_cmd(ctrl, "INTERFACE_REMOVE", 1, argc, argv);
1644 }
1645
1646
1647 static int wpa_cli_cmd_interface_list(struct wpa_ctrl *ctrl, int argc,
1648                                       char *argv[])
1649 {
1650         return wpa_ctrl_command(ctrl, "INTERFACE_LIST");
1651 }
1652
1653
1654 #ifdef CONFIG_AP
1655 static int wpa_cli_cmd_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1656 {
1657         return wpa_cli_cmd(ctrl, "STA", 1, argc, argv);
1658 }
1659
1660
1661 static int wpa_ctrl_command_sta(struct wpa_ctrl *ctrl, char *cmd,
1662                                 char *addr, size_t addr_len)
1663 {
1664         char buf[4096], *pos;
1665         size_t len;
1666         int ret;
1667
1668         if (ctrl_conn == NULL) {
1669                 printf("Not connected to hostapd - command dropped.\n");
1670                 return -1;
1671         }
1672         len = sizeof(buf) - 1;
1673         ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
1674                                wpa_cli_msg_cb);
1675         if (ret == -2) {
1676                 printf("'%s' command timed out.\n", cmd);
1677                 return -2;
1678         } else if (ret < 0) {
1679                 printf("'%s' command failed.\n", cmd);
1680                 return -1;
1681         }
1682
1683         buf[len] = '\0';
1684         if (os_memcmp(buf, "FAIL", 4) == 0)
1685                 return -1;
1686         printf("%s", buf);
1687
1688         pos = buf;
1689         while (*pos != '\0' && *pos != '\n')
1690                 pos++;
1691         *pos = '\0';
1692         os_strlcpy(addr, buf, addr_len);
1693         return 0;
1694 }
1695
1696
1697 static int wpa_cli_cmd_all_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1698 {
1699         char addr[32], cmd[64];
1700
1701         if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr)))
1702                 return 0;
1703         do {
1704                 os_snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr);
1705         } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr)) == 0);
1706
1707         return -1;
1708 }
1709
1710
1711 static int wpa_cli_cmd_deauthenticate(struct wpa_ctrl *ctrl, int argc,
1712                                       char *argv[])
1713 {
1714         return wpa_cli_cmd(ctrl, "DEAUTHENTICATE", 1, argc, argv);
1715 }
1716
1717
1718 static int wpa_cli_cmd_disassociate(struct wpa_ctrl *ctrl, int argc,
1719                                     char *argv[])
1720 {
1721         return wpa_cli_cmd(ctrl, "DISASSOCIATE", 1, argc, argv);
1722 }
1723
1724 static int wpa_cli_cmd_chanswitch(struct wpa_ctrl *ctrl, int argc,
1725                                     char *argv[])
1726 {
1727         return wpa_cli_cmd(ctrl, "CHAN_SWITCH", 2, argc, argv);
1728 }
1729
1730 #endif /* CONFIG_AP */
1731
1732
1733 static int wpa_cli_cmd_suspend(struct wpa_ctrl *ctrl, int argc, char *argv[])
1734 {
1735         return wpa_ctrl_command(ctrl, "SUSPEND");
1736 }
1737
1738
1739 static int wpa_cli_cmd_resume(struct wpa_ctrl *ctrl, int argc, char *argv[])
1740 {
1741         return wpa_ctrl_command(ctrl, "RESUME");
1742 }
1743
1744
1745 #ifdef CONFIG_TESTING_OPTIONS
1746 static int wpa_cli_cmd_drop_sa(struct wpa_ctrl *ctrl, int argc, char *argv[])
1747 {
1748         return wpa_ctrl_command(ctrl, "DROP_SA");
1749 }
1750 #endif /* CONFIG_TESTING_OPTIONS */
1751
1752
1753 static int wpa_cli_cmd_roam(struct wpa_ctrl *ctrl, int argc, char *argv[])
1754 {
1755         return wpa_cli_cmd(ctrl, "ROAM", 1, argc, argv);
1756 }
1757
1758
1759 #ifdef CONFIG_MESH
1760
1761 static int wpa_cli_cmd_mesh_interface_add(struct wpa_ctrl *ctrl, int argc,
1762                                           char *argv[])
1763 {
1764         return wpa_cli_cmd(ctrl, "MESH_INTERFACE_ADD", 0, argc, argv);
1765 }
1766
1767
1768 static int wpa_cli_cmd_mesh_group_add(struct wpa_ctrl *ctrl, int argc,
1769                                       char *argv[])
1770 {
1771         return wpa_cli_cmd(ctrl, "MESH_GROUP_ADD", 1, argc, argv);
1772 }
1773
1774
1775 static int wpa_cli_cmd_mesh_group_remove(struct wpa_ctrl *ctrl, int argc,
1776                                          char *argv[])
1777 {
1778         return wpa_cli_cmd(ctrl, "MESH_GROUP_REMOVE", 1, argc, argv);
1779 }
1780
1781 #endif /* CONFIG_MESH */
1782
1783
1784 #ifdef CONFIG_P2P
1785
1786 static int wpa_cli_cmd_p2p_find(struct wpa_ctrl *ctrl, int argc, char *argv[])
1787 {
1788         return wpa_cli_cmd(ctrl, "P2P_FIND", 0, argc, argv);
1789 }
1790
1791
1792 static char ** wpa_cli_complete_p2p_find(const char *str, int pos)
1793 {
1794         char **res = NULL;
1795         int arg = get_cmd_arg_num(str, pos);
1796
1797         res = os_calloc(6, sizeof(char *));
1798         if (res == NULL)
1799                 return NULL;
1800         res[0] = os_strdup("type=social");
1801         if (res[0] == NULL) {
1802                 os_free(res);
1803                 return NULL;
1804         }
1805         res[1] = os_strdup("type=progressive");
1806         if (res[1] == NULL)
1807                 return res;
1808         res[2] = os_strdup("delay=");
1809         if (res[2] == NULL)
1810                 return res;
1811         res[3] = os_strdup("dev_id=");
1812         if (res[3] == NULL)
1813                 return res;
1814         if (arg == 1)
1815                 res[4] = os_strdup("[timeout]");
1816
1817         return res;
1818 }
1819
1820
1821 static int wpa_cli_cmd_p2p_stop_find(struct wpa_ctrl *ctrl, int argc,
1822                                      char *argv[])
1823 {
1824         return wpa_ctrl_command(ctrl, "P2P_STOP_FIND");
1825 }
1826
1827
1828 static int wpa_cli_cmd_p2p_connect(struct wpa_ctrl *ctrl, int argc,
1829                                    char *argv[])
1830 {
1831         return wpa_cli_cmd(ctrl, "P2P_CONNECT", 2, argc, argv);
1832 }
1833
1834
1835 static char ** wpa_cli_complete_p2p_connect(const char *str, int pos)
1836 {
1837         int arg = get_cmd_arg_num(str, pos);
1838         char **res = NULL;
1839
1840         switch (arg) {
1841         case 1:
1842                 res = cli_txt_list_array(&p2p_peers);
1843                 break;
1844         }
1845
1846         return res;
1847 }
1848
1849
1850 static int wpa_cli_cmd_p2p_listen(struct wpa_ctrl *ctrl, int argc,
1851                                   char *argv[])
1852 {
1853         return wpa_cli_cmd(ctrl, "P2P_LISTEN", 0, argc, argv);
1854 }
1855
1856
1857 static int wpa_cli_cmd_p2p_group_remove(struct wpa_ctrl *ctrl, int argc,
1858                                         char *argv[])
1859 {
1860         return wpa_cli_cmd(ctrl, "P2P_GROUP_REMOVE", 1, argc, argv);
1861 }
1862
1863
1864 static char ** wpa_cli_complete_p2p_group_remove(const char *str, int pos)
1865 {
1866         int arg = get_cmd_arg_num(str, pos);
1867         char **res = NULL;
1868
1869         switch (arg) {
1870         case 1:
1871                 res = cli_txt_list_array(&p2p_groups);
1872                 break;
1873         }
1874
1875         return res;
1876 }
1877
1878
1879 static int wpa_cli_cmd_p2p_group_add(struct wpa_ctrl *ctrl, int argc,
1880                                         char *argv[])
1881 {
1882         return wpa_cli_cmd(ctrl, "P2P_GROUP_ADD", 0, argc, argv);
1883 }
1884
1885
1886 static int wpa_cli_cmd_p2p_prov_disc(struct wpa_ctrl *ctrl, int argc,
1887                                      char *argv[])
1888 {
1889         if (argc != 2 && argc != 3) {
1890                 printf("Invalid P2P_PROV_DISC command: needs at least "
1891                        "two arguments, address and config method\n"
1892                        "(display, keypad, or pbc) and an optional join\n");
1893                 return -1;
1894         }
1895
1896         return wpa_cli_cmd(ctrl, "P2P_PROV_DISC", 2, argc, argv);
1897 }
1898
1899
1900 static int wpa_cli_cmd_p2p_get_passphrase(struct wpa_ctrl *ctrl, int argc,
1901                                           char *argv[])
1902 {
1903         return wpa_ctrl_command(ctrl, "P2P_GET_PASSPHRASE");
1904 }
1905
1906
1907 static int wpa_cli_cmd_p2p_serv_disc_req(struct wpa_ctrl *ctrl, int argc,
1908                                          char *argv[])
1909 {
1910         char cmd[4096];
1911
1912         if (argc != 2 && argc != 4) {
1913                 printf("Invalid P2P_SERV_DISC_REQ command: needs two "
1914                        "arguments (address and TLVs) or four arguments "
1915                        "(address, \"upnp\", version, search target "
1916                        "(SSDP ST:)\n");
1917                 return -1;
1918         }
1919
1920         if (write_cmd(cmd, sizeof(cmd), "P2P_SERV_DISC_REQ", argc, argv) < 0)
1921                 return -1;
1922         return wpa_ctrl_command(ctrl, cmd);
1923 }
1924
1925
1926 static int wpa_cli_cmd_p2p_serv_disc_cancel_req(struct wpa_ctrl *ctrl,
1927                                                 int argc, char *argv[])
1928 {
1929         return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_CANCEL_REQ", 1, argc, argv);
1930 }
1931
1932
1933 static int wpa_cli_cmd_p2p_serv_disc_resp(struct wpa_ctrl *ctrl, int argc,
1934                                           char *argv[])
1935 {
1936         char cmd[4096];
1937         int res;
1938
1939         if (argc != 4) {
1940                 printf("Invalid P2P_SERV_DISC_RESP command: needs four "
1941                        "arguments (freq, address, dialog token, and TLVs)\n");
1942                 return -1;
1943         }
1944
1945         res = os_snprintf(cmd, sizeof(cmd), "P2P_SERV_DISC_RESP %s %s %s %s",
1946                           argv[0], argv[1], argv[2], argv[3]);
1947         if (os_snprintf_error(sizeof(cmd), res))
1948                 return -1;
1949         cmd[sizeof(cmd) - 1] = '\0';
1950         return wpa_ctrl_command(ctrl, cmd);
1951 }
1952
1953
1954 static int wpa_cli_cmd_p2p_service_update(struct wpa_ctrl *ctrl, int argc,
1955                                           char *argv[])
1956 {
1957         return wpa_ctrl_command(ctrl, "P2P_SERVICE_UPDATE");
1958 }
1959
1960
1961 static int wpa_cli_cmd_p2p_serv_disc_external(struct wpa_ctrl *ctrl,
1962                                               int argc, char *argv[])
1963 {
1964         return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_EXTERNAL", 1, argc, argv);
1965 }
1966
1967
1968 static int wpa_cli_cmd_p2p_service_flush(struct wpa_ctrl *ctrl, int argc,
1969                                          char *argv[])
1970 {
1971         return wpa_ctrl_command(ctrl, "P2P_SERVICE_FLUSH");
1972 }
1973
1974
1975 static int wpa_cli_cmd_p2p_service_add(struct wpa_ctrl *ctrl, int argc,
1976                                        char *argv[])
1977 {
1978         if (argc < 3) {
1979                 printf("Invalid P2P_SERVICE_ADD command: needs 3-6 arguments\n");
1980                 return -1;
1981         }
1982
1983         return wpa_cli_cmd(ctrl, "P2P_SERVICE_ADD", 3, argc, argv);
1984 }
1985
1986
1987 static int wpa_cli_cmd_p2p_service_rep(struct wpa_ctrl *ctrl, int argc,
1988                                        char *argv[])
1989 {
1990         if (argc < 5 || argc > 6) {
1991                 printf("Invalid P2P_SERVICE_REP command: needs 5-6 "
1992                        "arguments\n");
1993                 return -1;
1994         }
1995
1996         return wpa_cli_cmd(ctrl, "P2P_SERVICE_REP", 5, argc, argv);
1997 }
1998
1999
2000 static int wpa_cli_cmd_p2p_service_del(struct wpa_ctrl *ctrl, int argc,
2001                                        char *argv[])
2002 {
2003         char cmd[4096];
2004         int res;
2005
2006         if (argc != 2 && argc != 3) {
2007                 printf("Invalid P2P_SERVICE_DEL command: needs two or three "
2008                        "arguments\n");
2009                 return -1;
2010         }
2011
2012         if (argc == 3)
2013                 res = os_snprintf(cmd, sizeof(cmd),
2014                                   "P2P_SERVICE_DEL %s %s %s",
2015                                   argv[0], argv[1], argv[2]);
2016         else
2017                 res = os_snprintf(cmd, sizeof(cmd),
2018                                   "P2P_SERVICE_DEL %s %s",
2019                                   argv[0], argv[1]);
2020         if (os_snprintf_error(sizeof(cmd), res))
2021                 return -1;
2022         cmd[sizeof(cmd) - 1] = '\0';
2023         return wpa_ctrl_command(ctrl, cmd);
2024 }
2025
2026
2027 static int wpa_cli_cmd_p2p_reject(struct wpa_ctrl *ctrl,
2028                                   int argc, char *argv[])
2029 {
2030         return wpa_cli_cmd(ctrl, "P2P_REJECT", 1, argc, argv);
2031 }
2032
2033
2034 static int wpa_cli_cmd_p2p_invite(struct wpa_ctrl *ctrl,
2035                                   int argc, char *argv[])
2036 {
2037         return wpa_cli_cmd(ctrl, "P2P_INVITE", 1, argc, argv);
2038 }
2039
2040
2041 static int wpa_cli_cmd_p2p_peer(struct wpa_ctrl *ctrl, int argc, char *argv[])
2042 {
2043         return wpa_cli_cmd(ctrl, "P2P_PEER", 1, argc, argv);
2044 }
2045
2046
2047 static char ** wpa_cli_complete_p2p_peer(const char *str, int pos)
2048 {
2049         int arg = get_cmd_arg_num(str, pos);
2050         char **res = NULL;
2051
2052         switch (arg) {
2053         case 1:
2054                 res = cli_txt_list_array(&p2p_peers);
2055                 break;
2056         }
2057
2058         return res;
2059 }
2060
2061
2062 static int wpa_ctrl_command_p2p_peer(struct wpa_ctrl *ctrl, char *cmd,
2063                                      char *addr, size_t addr_len,
2064                                      int discovered)
2065 {
2066         char buf[4096], *pos;
2067         size_t len;
2068         int ret;
2069
2070         if (ctrl_conn == NULL)
2071                 return -1;
2072         len = sizeof(buf) - 1;
2073         ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
2074                                wpa_cli_msg_cb);
2075         if (ret == -2) {
2076                 printf("'%s' command timed out.\n", cmd);
2077                 return -2;
2078         } else if (ret < 0) {
2079                 printf("'%s' command failed.\n", cmd);
2080                 return -1;
2081         }
2082
2083         buf[len] = '\0';
2084         if (os_memcmp(buf, "FAIL", 4) == 0)
2085                 return -1;
2086
2087         pos = buf;
2088         while (*pos != '\0' && *pos != '\n')
2089                 pos++;
2090         *pos++ = '\0';
2091         os_strlcpy(addr, buf, addr_len);
2092         if (!discovered || os_strstr(pos, "[PROBE_REQ_ONLY]") == NULL)
2093                 printf("%s\n", addr);
2094         return 0;
2095 }
2096
2097
2098 static int wpa_cli_cmd_p2p_peers(struct wpa_ctrl *ctrl, int argc, char *argv[])
2099 {
2100         char addr[32], cmd[64];
2101         int discovered;
2102
2103         discovered = argc > 0 && os_strcmp(argv[0], "discovered") == 0;
2104
2105         if (wpa_ctrl_command_p2p_peer(ctrl, "P2P_PEER FIRST",
2106                                       addr, sizeof(addr), discovered))
2107                 return -1;
2108         do {
2109                 os_snprintf(cmd, sizeof(cmd), "P2P_PEER NEXT-%s", addr);
2110         } while (wpa_ctrl_command_p2p_peer(ctrl, cmd, addr, sizeof(addr),
2111                          discovered) == 0);
2112
2113         return 0;
2114 }
2115
2116
2117 static int wpa_cli_cmd_p2p_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
2118 {
2119         return wpa_cli_cmd(ctrl, "P2P_SET", 2, argc, argv);
2120 }
2121
2122
2123 static char ** wpa_cli_complete_p2p_set(const char *str, int pos)
2124 {
2125         int arg = get_cmd_arg_num(str, pos);
2126         const char *fields[] = {
2127                 "discoverability",
2128                 "managed",
2129                 "listen_channel",
2130                 "ssid_postfix",
2131                 "noa",
2132                 "ps",
2133                 "oppps",
2134                 "ctwindow",
2135                 "disabled",
2136                 "conc_pref",
2137                 "force_long_sd",
2138                 "peer_filter",
2139                 "cross_connect",
2140                 "go_apsd",
2141                 "client_apsd",
2142                 "disallow_freq",
2143                 "disc_int",
2144                 "per_sta_psk",
2145         };
2146         int i, num_fields = ARRAY_SIZE(fields);
2147
2148         if (arg == 1) {
2149                 char **res = os_calloc(num_fields + 1, sizeof(char *));
2150                 if (res == NULL)
2151                         return NULL;
2152                 for (i = 0; i < num_fields; i++) {
2153                         res[i] = os_strdup(fields[i]);
2154                         if (res[i] == NULL)
2155                                 return res;
2156                 }
2157                 return res;
2158         }
2159
2160         if (arg == 2 && os_strncasecmp(str, "p2p_set peer_filter ", 20) == 0)
2161                 return cli_txt_list_array(&p2p_peers);
2162
2163         return NULL;
2164 }
2165
2166
2167 static int wpa_cli_cmd_p2p_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2168 {
2169         return wpa_ctrl_command(ctrl, "P2P_FLUSH");
2170 }
2171
2172
2173 static int wpa_cli_cmd_p2p_cancel(struct wpa_ctrl *ctrl, int argc,
2174                                   char *argv[])
2175 {
2176         return wpa_ctrl_command(ctrl, "P2P_CANCEL");
2177 }
2178
2179
2180 static int wpa_cli_cmd_p2p_unauthorize(struct wpa_ctrl *ctrl, int argc,
2181                                        char *argv[])
2182 {
2183         return wpa_cli_cmd(ctrl, "P2P_UNAUTHORIZE", 1, argc, argv);
2184 }
2185
2186
2187 static int wpa_cli_cmd_p2p_presence_req(struct wpa_ctrl *ctrl, int argc,
2188                                         char *argv[])
2189 {
2190         if (argc != 0 && argc != 2 && argc != 4) {
2191                 printf("Invalid P2P_PRESENCE_REQ command: needs two arguments "
2192                        "(preferred duration, interval; in microsecods).\n"
2193                        "Optional second pair can be used to provide "
2194                        "acceptable values.\n");
2195                 return -1;
2196         }
2197
2198         return wpa_cli_cmd(ctrl, "P2P_PRESENCE_REQ", 0, argc, argv);
2199 }
2200
2201
2202 static int wpa_cli_cmd_p2p_ext_listen(struct wpa_ctrl *ctrl, int argc,
2203                                       char *argv[])
2204 {
2205         if (argc != 0 && argc != 2) {
2206                 printf("Invalid P2P_EXT_LISTEN command: needs two arguments "
2207                        "(availability period, availability interval; in "
2208                        "millisecods).\n"
2209                        "Extended Listen Timing can be cancelled with this "
2210                        "command when used without parameters.\n");
2211                 return -1;
2212         }
2213
2214         return wpa_cli_cmd(ctrl, "P2P_EXT_LISTEN", 0, argc, argv);
2215 }
2216
2217
2218 static int wpa_cli_cmd_p2p_remove_client(struct wpa_ctrl *ctrl, int argc,
2219                                          char *argv[])
2220 {
2221         return wpa_cli_cmd(ctrl, "P2P_REMOVE_CLIENT", 1, argc, argv);
2222 }
2223
2224 #endif /* CONFIG_P2P */
2225
2226 #ifdef CONFIG_WIFI_DISPLAY
2227
2228 static int wpa_cli_cmd_wfd_subelem_set(struct wpa_ctrl *ctrl, int argc,
2229                                        char *argv[])
2230 {
2231         char cmd[100];
2232         int res;
2233
2234         if (argc != 1 && argc != 2) {
2235                 printf("Invalid WFD_SUBELEM_SET command: needs one or two "
2236                        "arguments (subelem, hexdump)\n");
2237                 return -1;
2238         }
2239
2240         res = os_snprintf(cmd, sizeof(cmd), "WFD_SUBELEM_SET %s %s",
2241                           argv[0], argc > 1 ? argv[1] : "");
2242         if (os_snprintf_error(sizeof(cmd), res))
2243                 return -1;
2244         cmd[sizeof(cmd) - 1] = '\0';
2245         return wpa_ctrl_command(ctrl, cmd);
2246 }
2247
2248
2249 static int wpa_cli_cmd_wfd_subelem_get(struct wpa_ctrl *ctrl, int argc,
2250                                        char *argv[])
2251 {
2252         char cmd[100];
2253         int res;
2254
2255         if (argc != 1) {
2256                 printf("Invalid WFD_SUBELEM_GET command: needs one "
2257                        "argument (subelem)\n");
2258                 return -1;
2259         }
2260
2261         res = os_snprintf(cmd, sizeof(cmd), "WFD_SUBELEM_GET %s",
2262                           argv[0]);
2263         if (os_snprintf_error(sizeof(cmd), res))
2264                 return -1;
2265         cmd[sizeof(cmd) - 1] = '\0';
2266         return wpa_ctrl_command(ctrl, cmd);
2267 }
2268 #endif /* CONFIG_WIFI_DISPLAY */
2269
2270
2271 #ifdef CONFIG_INTERWORKING
2272 static int wpa_cli_cmd_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
2273                                   char *argv[])
2274 {
2275         return wpa_ctrl_command(ctrl, "FETCH_ANQP");
2276 }
2277
2278
2279 static int wpa_cli_cmd_stop_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
2280                                        char *argv[])
2281 {
2282         return wpa_ctrl_command(ctrl, "STOP_FETCH_ANQP");
2283 }
2284
2285
2286 static int wpa_cli_cmd_interworking_select(struct wpa_ctrl *ctrl, int argc,
2287                                            char *argv[])
2288 {
2289         return wpa_cli_cmd(ctrl, "INTERWORKING_SELECT", 0, argc, argv);
2290 }
2291
2292
2293 static int wpa_cli_cmd_interworking_connect(struct wpa_ctrl *ctrl, int argc,
2294                                             char *argv[])
2295 {
2296         return wpa_cli_cmd(ctrl, "INTERWORKING_CONNECT", 1, argc, argv);
2297 }
2298
2299
2300 static int wpa_cli_cmd_anqp_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
2301 {
2302         return wpa_cli_cmd(ctrl, "ANQP_GET", 2, argc, argv);
2303 }
2304
2305
2306 static int wpa_cli_cmd_gas_request(struct wpa_ctrl *ctrl, int argc,
2307                                    char *argv[])
2308 {
2309         return wpa_cli_cmd(ctrl, "GAS_REQUEST", 2, argc, argv);
2310 }
2311
2312
2313 static int wpa_cli_cmd_gas_response_get(struct wpa_ctrl *ctrl, int argc,
2314                                         char *argv[])
2315 {
2316         return wpa_cli_cmd(ctrl, "GAS_RESPONSE_GET", 2, argc, argv);
2317 }
2318 #endif /* CONFIG_INTERWORKING */
2319
2320
2321 #ifdef CONFIG_HS20
2322
2323 static int wpa_cli_cmd_hs20_anqp_get(struct wpa_ctrl *ctrl, int argc,
2324                                      char *argv[])
2325 {
2326         return wpa_cli_cmd(ctrl, "HS20_ANQP_GET", 2, argc, argv);
2327 }
2328
2329
2330 static int wpa_cli_cmd_get_nai_home_realm_list(struct wpa_ctrl *ctrl, int argc,
2331                                                char *argv[])
2332 {
2333         char cmd[512];
2334
2335         if (argc == 0) {
2336                 printf("Command needs one or two arguments (dst mac addr and "
2337                        "optional home realm)\n");
2338                 return -1;
2339         }
2340
2341         if (write_cmd(cmd, sizeof(cmd), "HS20_GET_NAI_HOME_REALM_LIST",
2342                       argc, argv) < 0)
2343                 return -1;
2344
2345         return wpa_ctrl_command(ctrl, cmd);
2346 }
2347
2348
2349 static int wpa_cli_cmd_hs20_icon_request(struct wpa_ctrl *ctrl, int argc,
2350                                          char *argv[])
2351 {
2352         char cmd[512];
2353
2354         if (argc < 2) {
2355                 printf("Command needs two arguments (dst mac addr and "
2356                        "icon name)\n");
2357                 return -1;
2358         }
2359
2360         if (write_cmd(cmd, sizeof(cmd), "HS20_ICON_REQUEST", argc, argv) < 0)
2361                 return -1;
2362
2363         return wpa_ctrl_command(ctrl, cmd);
2364 }
2365
2366
2367 static int wpa_cli_cmd_fetch_osu(struct wpa_ctrl *ctrl, int argc, char *argv[])
2368 {
2369         return wpa_ctrl_command(ctrl, "FETCH_OSU");
2370 }
2371
2372
2373 static int wpa_cli_cmd_cancel_fetch_osu(struct wpa_ctrl *ctrl, int argc,
2374                                         char *argv[])
2375 {
2376         return wpa_ctrl_command(ctrl, "CANCEL_FETCH_OSU");
2377 }
2378
2379 #endif /* CONFIG_HS20 */
2380
2381
2382 static int wpa_cli_cmd_sta_autoconnect(struct wpa_ctrl *ctrl, int argc,
2383                                        char *argv[])
2384 {
2385         return wpa_cli_cmd(ctrl, "STA_AUTOCONNECT", 1, argc, argv);
2386 }
2387
2388
2389 static int wpa_cli_cmd_tdls_discover(struct wpa_ctrl *ctrl, int argc,
2390                                      char *argv[])
2391 {
2392         return wpa_cli_cmd(ctrl, "TDLS_DISCOVER", 1, argc, argv);
2393 }
2394
2395
2396 static int wpa_cli_cmd_tdls_setup(struct wpa_ctrl *ctrl, int argc,
2397                                   char *argv[])
2398 {
2399         return wpa_cli_cmd(ctrl, "TDLS_SETUP", 1, argc, argv);
2400 }
2401
2402
2403 static int wpa_cli_cmd_tdls_teardown(struct wpa_ctrl *ctrl, int argc,
2404                                      char *argv[])
2405 {
2406         return wpa_cli_cmd(ctrl, "TDLS_TEARDOWN", 1, argc, argv);
2407 }
2408
2409
2410 static int wpa_cli_cmd_wmm_ac_addts(struct wpa_ctrl *ctrl, int argc,
2411                                     char *argv[])
2412 {
2413         return wpa_cli_cmd(ctrl, "WMM_AC_ADDTS", 3, argc, argv);
2414 }
2415
2416
2417 static int wpa_cli_cmd_wmm_ac_delts(struct wpa_ctrl *ctrl, int argc,
2418                                     char *argv[])
2419 {
2420         return wpa_cli_cmd(ctrl, "WMM_AC_DELTS", 1, argc, argv);
2421 }
2422
2423
2424 static int wpa_cli_cmd_wmm_ac_status(struct wpa_ctrl *ctrl, int argc,
2425                                     char *argv[])
2426 {
2427         return wpa_ctrl_command(ctrl, "WMM_AC_STATUS");
2428 }
2429
2430
2431 static int wpa_cli_cmd_tdls_chan_switch(struct wpa_ctrl *ctrl, int argc,
2432                                         char *argv[])
2433 {
2434         return wpa_cli_cmd(ctrl, "TDLS_CHAN_SWITCH", 2, argc, argv);
2435 }
2436
2437
2438 static int wpa_cli_cmd_tdls_cancel_chan_switch(struct wpa_ctrl *ctrl, int argc,
2439                                                char *argv[])
2440 {
2441         return wpa_cli_cmd(ctrl, "TDLS_CANCEL_CHAN_SWITCH", 1, argc, argv);
2442 }
2443
2444
2445 static int wpa_cli_cmd_signal_poll(struct wpa_ctrl *ctrl, int argc,
2446                                    char *argv[])
2447 {
2448         return wpa_ctrl_command(ctrl, "SIGNAL_POLL");
2449 }
2450
2451
2452 static int wpa_cli_cmd_pktcnt_poll(struct wpa_ctrl *ctrl, int argc,
2453                                    char *argv[])
2454 {
2455         return wpa_ctrl_command(ctrl, "PKTCNT_POLL");
2456 }
2457
2458
2459 static int wpa_cli_cmd_reauthenticate(struct wpa_ctrl *ctrl, int argc,
2460                                       char *argv[])
2461 {
2462         return wpa_ctrl_command(ctrl, "REAUTHENTICATE");
2463 }
2464
2465
2466 #ifdef CONFIG_AUTOSCAN
2467
2468 static int wpa_cli_cmd_autoscan(struct wpa_ctrl *ctrl, int argc, char *argv[])
2469 {
2470         if (argc == 0)
2471                 return wpa_ctrl_command(ctrl, "AUTOSCAN ");
2472
2473         return wpa_cli_cmd(ctrl, "AUTOSCAN", 0, argc, argv);
2474 }
2475
2476 #endif /* CONFIG_AUTOSCAN */
2477
2478
2479 #ifdef CONFIG_WNM
2480
2481 static int wpa_cli_cmd_wnm_sleep(struct wpa_ctrl *ctrl, int argc, char *argv[])
2482 {
2483         return wpa_cli_cmd(ctrl, "WNM_SLEEP", 0, argc, argv);
2484 }
2485
2486
2487 static int wpa_cli_cmd_wnm_bss_query(struct wpa_ctrl *ctrl, int argc, char *argv[])
2488 {
2489         return wpa_cli_cmd(ctrl, "WNM_BSS_QUERY", 1, argc, argv);
2490 }
2491
2492 #endif /* CONFIG_WNM */
2493
2494
2495 static int wpa_cli_cmd_raw(struct wpa_ctrl *ctrl, int argc, char *argv[])
2496 {
2497         if (argc == 0)
2498                 return -1;
2499         return wpa_cli_cmd(ctrl, argv[0], 0, argc - 1, &argv[1]);
2500 }
2501
2502
2503 #ifdef ANDROID
2504 static int wpa_cli_cmd_driver(struct wpa_ctrl *ctrl, int argc, char *argv[])
2505 {
2506         return wpa_cli_cmd(ctrl, "DRIVER", 1, argc, argv);
2507 }
2508 #endif /* ANDROID */
2509
2510
2511 static int wpa_cli_cmd_vendor(struct wpa_ctrl *ctrl, int argc, char *argv[])
2512 {
2513         return wpa_cli_cmd(ctrl, "VENDOR", 1, argc, argv);
2514 }
2515
2516
2517 static int wpa_cli_cmd_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2518 {
2519         return wpa_ctrl_command(ctrl, "FLUSH");
2520 }
2521
2522
2523 static int wpa_cli_cmd_radio_work(struct wpa_ctrl *ctrl, int argc, char *argv[])
2524 {
2525         return wpa_cli_cmd(ctrl, "RADIO_WORK", 1, argc, argv);
2526 }
2527
2528
2529 static int wpa_cli_cmd_neighbor_rep_request(struct wpa_ctrl *ctrl, int argc,
2530                                             char *argv[])
2531 {
2532         return wpa_cli_cmd(ctrl, "NEIGHBOR_REP_REQUEST", 0, argc, argv);
2533 }
2534
2535
2536 static int wpa_cli_cmd_erp_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2537 {
2538         return wpa_ctrl_command(ctrl, "ERP_FLUSH");
2539 }
2540
2541
2542 static int wpa_cli_cmd_mac_rand_scan(struct wpa_ctrl *ctrl, int argc,
2543                                      char *argv[])
2544 {
2545         return wpa_cli_cmd(ctrl, "MAC_RAND_SCAN", 1, argc, argv);
2546 }
2547
2548
2549 enum wpa_cli_cmd_flags {
2550         cli_cmd_flag_none               = 0x00,
2551         cli_cmd_flag_sensitive          = 0x01
2552 };
2553
2554 struct wpa_cli_cmd {
2555         const char *cmd;
2556         int (*handler)(struct wpa_ctrl *ctrl, int argc, char *argv[]);
2557         char ** (*completion)(const char *str, int pos);
2558         enum wpa_cli_cmd_flags flags;
2559         const char *usage;
2560 };
2561
2562 static struct wpa_cli_cmd wpa_cli_commands[] = {
2563         { "status", wpa_cli_cmd_status, NULL,
2564           cli_cmd_flag_none,
2565           "[verbose] = get current WPA/EAPOL/EAP status" },
2566         { "ifname", wpa_cli_cmd_ifname, NULL,
2567           cli_cmd_flag_none,
2568           "= get current interface name" },
2569         { "ping", wpa_cli_cmd_ping, NULL,
2570           cli_cmd_flag_none,
2571           "= pings wpa_supplicant" },
2572         { "relog", wpa_cli_cmd_relog, NULL,
2573           cli_cmd_flag_none,
2574           "= re-open log-file (allow rolling logs)" },
2575         { "note", wpa_cli_cmd_note, NULL,
2576           cli_cmd_flag_none,
2577           "<text> = add a note to wpa_supplicant debug log" },
2578         { "mib", wpa_cli_cmd_mib, NULL,
2579           cli_cmd_flag_none,
2580           "= get MIB variables (dot1x, dot11)" },
2581         { "help", wpa_cli_cmd_help, wpa_cli_complete_help,
2582           cli_cmd_flag_none,
2583           "[command] = show usage help" },
2584         { "interface", wpa_cli_cmd_interface, NULL,
2585           cli_cmd_flag_none,
2586           "[ifname] = show interfaces/select interface" },
2587         { "level", wpa_cli_cmd_level, NULL,
2588           cli_cmd_flag_none,
2589           "<debug level> = change debug level" },
2590         { "license", wpa_cli_cmd_license, NULL,
2591           cli_cmd_flag_none,
2592           "= show full wpa_cli license" },
2593         { "quit", wpa_cli_cmd_quit, NULL,
2594           cli_cmd_flag_none,
2595           "= exit wpa_cli" },
2596         { "set", wpa_cli_cmd_set, wpa_cli_complete_set,
2597           cli_cmd_flag_none,
2598           "= set variables (shows list of variables when run without "
2599           "arguments)" },
2600         { "get", wpa_cli_cmd_get, NULL,
2601           cli_cmd_flag_none,
2602           "<name> = get information" },
2603         { "logon", wpa_cli_cmd_logon, NULL,
2604           cli_cmd_flag_none,
2605           "= IEEE 802.1X EAPOL state machine logon" },
2606         { "logoff", wpa_cli_cmd_logoff, NULL,
2607           cli_cmd_flag_none,
2608           "= IEEE 802.1X EAPOL state machine logoff" },
2609         { "pmksa", wpa_cli_cmd_pmksa, NULL,
2610           cli_cmd_flag_none,
2611           "= show PMKSA cache" },
2612         { "pmksa_flush", wpa_cli_cmd_pmksa_flush, NULL,
2613           cli_cmd_flag_none,
2614           "= flush PMKSA cache entries" },
2615         { "reassociate", wpa_cli_cmd_reassociate, NULL,
2616           cli_cmd_flag_none,
2617           "= force reassociation" },
2618         { "reattach", wpa_cli_cmd_reattach, NULL,
2619           cli_cmd_flag_none,
2620           "= force reassociation back to the same BSS" },
2621         { "preauthenticate", wpa_cli_cmd_preauthenticate, wpa_cli_complete_bss,
2622           cli_cmd_flag_none,
2623           "<BSSID> = force preauthentication" },
2624         { "identity", wpa_cli_cmd_identity, NULL,
2625           cli_cmd_flag_none,
2626           "<network id> <identity> = configure identity for an SSID" },
2627         { "password", wpa_cli_cmd_password, NULL,
2628           cli_cmd_flag_sensitive,
2629           "<network id> <password> = configure password for an SSID" },
2630         { "new_password", wpa_cli_cmd_new_password, NULL,
2631           cli_cmd_flag_sensitive,
2632           "<network id> <password> = change password for an SSID" },
2633         { "pin", wpa_cli_cmd_pin, NULL,
2634           cli_cmd_flag_sensitive,
2635           "<network id> <pin> = configure pin for an SSID" },
2636         { "otp", wpa_cli_cmd_otp, NULL,
2637           cli_cmd_flag_sensitive,
2638           "<network id> <password> = configure one-time-password for an SSID"
2639         },
2640         { "passphrase", wpa_cli_cmd_passphrase, NULL,
2641           cli_cmd_flag_sensitive,
2642           "<network id> <passphrase> = configure private key passphrase\n"
2643           "  for an SSID" },
2644         { "sim", wpa_cli_cmd_sim, NULL,
2645           cli_cmd_flag_sensitive,
2646           "<network id> <pin> = report SIM operation result" },
2647         { "bssid", wpa_cli_cmd_bssid, NULL,
2648           cli_cmd_flag_none,
2649           "<network id> <BSSID> = set preferred BSSID for an SSID" },
2650         { "blacklist", wpa_cli_cmd_blacklist, wpa_cli_complete_bss,
2651           cli_cmd_flag_none,
2652           "<BSSID> = add a BSSID to the blacklist\n"
2653           "blacklist clear = clear the blacklist\n"
2654           "blacklist = display the blacklist" },
2655         { "log_level", wpa_cli_cmd_log_level, NULL,
2656           cli_cmd_flag_none,
2657           "<level> [<timestamp>] = update the log level/timestamp\n"
2658           "log_level = display the current log level and log options" },
2659         { "list_networks", wpa_cli_cmd_list_networks, NULL,
2660           cli_cmd_flag_none,
2661           "= list configured networks" },
2662         { "select_network", wpa_cli_cmd_select_network, NULL,
2663           cli_cmd_flag_none,
2664           "<network id> = select a network (disable others)" },
2665         { "enable_network", wpa_cli_cmd_enable_network, NULL,
2666           cli_cmd_flag_none,
2667           "<network id> = enable a network" },
2668         { "disable_network", wpa_cli_cmd_disable_network, NULL,
2669           cli_cmd_flag_none,
2670           "<network id> = disable a network" },
2671         { "add_network", wpa_cli_cmd_add_network, NULL,
2672           cli_cmd_flag_none,
2673           "= add a network" },
2674         { "remove_network", wpa_cli_cmd_remove_network, NULL,
2675           cli_cmd_flag_none,
2676           "<network id> = remove a network" },
2677         { "set_network", wpa_cli_cmd_set_network, NULL,
2678           cli_cmd_flag_sensitive,
2679           "<network id> <variable> <value> = set network variables (shows\n"
2680           "  list of variables when run without arguments)" },
2681         { "get_network", wpa_cli_cmd_get_network, NULL,
2682           cli_cmd_flag_none,
2683           "<network id> <variable> = get network variables" },
2684         { "dup_network", wpa_cli_cmd_dup_network, NULL,
2685           cli_cmd_flag_none,
2686           "<src network id> <dst network id> <variable> = duplicate network variables"
2687         },
2688         { "list_creds", wpa_cli_cmd_list_creds, NULL,
2689           cli_cmd_flag_none,
2690           "= list configured credentials" },
2691         { "add_cred", wpa_cli_cmd_add_cred, NULL,
2692           cli_cmd_flag_none,
2693           "= add a credential" },
2694         { "remove_cred", wpa_cli_cmd_remove_cred, NULL,
2695           cli_cmd_flag_none,
2696           "<cred id> = remove a credential" },
2697         { "set_cred", wpa_cli_cmd_set_cred, NULL,
2698           cli_cmd_flag_sensitive,
2699           "<cred id> <variable> <value> = set credential variables" },
2700         { "get_cred", wpa_cli_cmd_get_cred, NULL,
2701           cli_cmd_flag_none,
2702           "<cred id> <variable> = get credential variables" },
2703         { "save_config", wpa_cli_cmd_save_config, NULL,
2704           cli_cmd_flag_none,
2705           "= save the current configuration" },
2706         { "disconnect", wpa_cli_cmd_disconnect, NULL,
2707           cli_cmd_flag_none,
2708           "= disconnect and wait for reassociate/reconnect command before\n"
2709           "  connecting" },
2710         { "reconnect", wpa_cli_cmd_reconnect, NULL,
2711           cli_cmd_flag_none,
2712           "= like reassociate, but only takes effect if already disconnected"
2713         },
2714         { "scan", wpa_cli_cmd_scan, NULL,
2715           cli_cmd_flag_none,
2716           "= request new BSS scan" },
2717         { "scan_results", wpa_cli_cmd_scan_results, NULL,
2718           cli_cmd_flag_none,
2719           "= get latest scan results" },
2720         { "bss", wpa_cli_cmd_bss, wpa_cli_complete_bss,
2721           cli_cmd_flag_none,
2722           "<<idx> | <bssid>> = get detailed scan result info" },
2723         { "get_capability", wpa_cli_cmd_get_capability, NULL,
2724           cli_cmd_flag_none,
2725           "<eap/pairwise/group/key_mgmt/proto/auth_alg/channels/freq/modes> "
2726           "= get capabilies" },
2727         { "reconfigure", wpa_cli_cmd_reconfigure, NULL,
2728           cli_cmd_flag_none,
2729           "= force wpa_supplicant to re-read its configuration file" },
2730         { "terminate", wpa_cli_cmd_terminate, NULL,
2731           cli_cmd_flag_none,
2732           "= terminate wpa_supplicant" },
2733         { "interface_add", wpa_cli_cmd_interface_add, NULL,
2734           cli_cmd_flag_none,
2735           "<ifname> <confname> <driver> <ctrl_interface> <driver_param>\n"
2736           "  <bridge_name> = adds new interface, all parameters but <ifname>\n"
2737           "  are optional" },
2738         { "interface_remove", wpa_cli_cmd_interface_remove, NULL,
2739           cli_cmd_flag_none,
2740           "<ifname> = removes the interface" },
2741         { "interface_list", wpa_cli_cmd_interface_list, NULL,
2742           cli_cmd_flag_none,
2743           "= list available interfaces" },
2744         { "ap_scan", wpa_cli_cmd_ap_scan, NULL,
2745           cli_cmd_flag_none,
2746           "<value> = set ap_scan parameter" },
2747         { "scan_interval", wpa_cli_cmd_scan_interval, NULL,
2748           cli_cmd_flag_none,
2749           "<value> = set scan_interval parameter (in seconds)" },
2750         { "bss_expire_age", wpa_cli_cmd_bss_expire_age, NULL,
2751           cli_cmd_flag_none,
2752           "<value> = set BSS expiration age parameter" },
2753         { "bss_expire_count", wpa_cli_cmd_bss_expire_count, NULL,
2754           cli_cmd_flag_none,
2755           "<value> = set BSS expiration scan count parameter" },
2756         { "bss_flush", wpa_cli_cmd_bss_flush, NULL,
2757           cli_cmd_flag_none,
2758           "<value> = set BSS flush age (0 by default)" },
2759         { "stkstart", wpa_cli_cmd_stkstart, NULL,
2760           cli_cmd_flag_none,
2761           "<addr> = request STK negotiation with <addr>" },
2762         { "ft_ds", wpa_cli_cmd_ft_ds, wpa_cli_complete_bss,
2763           cli_cmd_flag_none,
2764           "<addr> = request over-the-DS FT with <addr>" },
2765         { "wps_pbc", wpa_cli_cmd_wps_pbc, wpa_cli_complete_bss,
2766           cli_cmd_flag_none,
2767           "[BSSID] = start Wi-Fi Protected Setup: Push Button Configuration" },
2768         { "wps_pin", wpa_cli_cmd_wps_pin, wpa_cli_complete_bss,
2769           cli_cmd_flag_sensitive,
2770           "<BSSID> [PIN] = start WPS PIN method (returns PIN, if not "
2771           "hardcoded)" },
2772         { "wps_check_pin", wpa_cli_cmd_wps_check_pin, NULL,
2773           cli_cmd_flag_sensitive,
2774           "<PIN> = verify PIN checksum" },
2775         { "wps_cancel", wpa_cli_cmd_wps_cancel, NULL, cli_cmd_flag_none,
2776           "Cancels the pending WPS operation" },
2777 #ifdef CONFIG_WPS_NFC
2778         { "wps_nfc", wpa_cli_cmd_wps_nfc, wpa_cli_complete_bss,
2779           cli_cmd_flag_none,
2780           "[BSSID] = start Wi-Fi Protected Setup: NFC" },
2781         { "wps_nfc_config_token", wpa_cli_cmd_wps_nfc_config_token, NULL,
2782           cli_cmd_flag_none,
2783           "<WPS|NDEF> = build configuration token" },
2784         { "wps_nfc_token", wpa_cli_cmd_wps_nfc_token, NULL,
2785           cli_cmd_flag_none,
2786           "<WPS|NDEF> = create password token" },
2787         { "wps_nfc_tag_read", wpa_cli_cmd_wps_nfc_tag_read, NULL,
2788           cli_cmd_flag_sensitive,
2789           "<hexdump of payload> = report read NFC tag with WPS data" },
2790         { "nfc_get_handover_req", wpa_cli_cmd_nfc_get_handover_req, NULL,
2791           cli_cmd_flag_none,
2792           "<NDEF> <WPS> = create NFC handover request" },
2793         { "nfc_get_handover_sel", wpa_cli_cmd_nfc_get_handover_sel, NULL,
2794           cli_cmd_flag_none,
2795           "<NDEF> <WPS> = create NFC handover select" },
2796         { "nfc_report_handover", wpa_cli_cmd_nfc_report_handover, NULL,
2797           cli_cmd_flag_none,
2798           "<role> <type> <hexdump of req> <hexdump of sel> = report completed "
2799           "NFC handover" },
2800 #endif /* CONFIG_WPS_NFC */
2801         { "wps_reg", wpa_cli_cmd_wps_reg, wpa_cli_complete_bss,
2802           cli_cmd_flag_sensitive,
2803           "<BSSID> <AP PIN> = start WPS Registrar to configure an AP" },
2804         { "wps_ap_pin", wpa_cli_cmd_wps_ap_pin, NULL,
2805           cli_cmd_flag_sensitive,
2806           "[params..] = enable/disable AP PIN" },
2807         { "wps_er_start", wpa_cli_cmd_wps_er_start, NULL,
2808           cli_cmd_flag_none,
2809           "[IP address] = start Wi-Fi Protected Setup External Registrar" },
2810         { "wps_er_stop", wpa_cli_cmd_wps_er_stop, NULL,
2811           cli_cmd_flag_none,
2812           "= stop Wi-Fi Protected Setup External Registrar" },
2813         { "wps_er_pin", wpa_cli_cmd_wps_er_pin, NULL,
2814           cli_cmd_flag_sensitive,
2815           "<UUID> <PIN> = add an Enrollee PIN to External Registrar" },
2816         { "wps_er_pbc", wpa_cli_cmd_wps_er_pbc, NULL,
2817           cli_cmd_flag_none,
2818           "<UUID> = accept an Enrollee PBC using External Registrar" },
2819         { "wps_er_learn", wpa_cli_cmd_wps_er_learn, NULL,
2820           cli_cmd_flag_sensitive,
2821           "<UUID> <PIN> = learn AP configuration" },
2822         { "wps_er_set_config", wpa_cli_cmd_wps_er_set_config, NULL,
2823           cli_cmd_flag_none,
2824           "<UUID> <network id> = set AP configuration for enrolling" },
2825         { "wps_er_config", wpa_cli_cmd_wps_er_config, NULL,
2826           cli_cmd_flag_sensitive,
2827           "<UUID> <PIN> <SSID> <auth> <encr> <key> = configure AP" },
2828 #ifdef CONFIG_WPS_NFC
2829         { "wps_er_nfc_config_token", wpa_cli_cmd_wps_er_nfc_config_token, NULL,
2830           cli_cmd_flag_none,
2831           "<WPS/NDEF> <UUID> = build NFC configuration token" },
2832 #endif /* CONFIG_WPS_NFC */
2833         { "ibss_rsn", wpa_cli_cmd_ibss_rsn, NULL,
2834           cli_cmd_flag_none,
2835           "<addr> = request RSN authentication with <addr> in IBSS" },
2836 #ifdef CONFIG_AP
2837         { "sta", wpa_cli_cmd_sta, NULL,
2838           cli_cmd_flag_none,
2839           "<addr> = get information about an associated station (AP)" },
2840         { "all_sta", wpa_cli_cmd_all_sta, NULL,
2841           cli_cmd_flag_none,
2842           "= get information about all associated stations (AP)" },
2843         { "deauthenticate", wpa_cli_cmd_deauthenticate, NULL,
2844           cli_cmd_flag_none,
2845           "<addr> = deauthenticate a station" },
2846         { "disassociate", wpa_cli_cmd_disassociate, NULL,
2847           cli_cmd_flag_none,
2848           "<addr> = disassociate a station" },
2849         { "chan_switch", wpa_cli_cmd_chanswitch, NULL,
2850           cli_cmd_flag_none,
2851           "<cs_count> <freq> [sec_channel_offset=] [center_freq1=]"
2852           " [center_freq2=] [bandwidth=] [blocktx] [ht|vht]"
2853           " = CSA parameters" },
2854 #endif /* CONFIG_AP */
2855         { "suspend", wpa_cli_cmd_suspend, NULL, cli_cmd_flag_none,
2856           "= notification of suspend/hibernate" },
2857         { "resume", wpa_cli_cmd_resume, NULL, cli_cmd_flag_none,
2858           "= notification of resume/thaw" },
2859 #ifdef CONFIG_TESTING_OPTIONS
2860         { "drop_sa", wpa_cli_cmd_drop_sa, NULL, cli_cmd_flag_none,
2861           "= drop SA without deauth/disassoc (test command)" },
2862 #endif /* CONFIG_TESTING_OPTIONS */
2863         { "roam", wpa_cli_cmd_roam, wpa_cli_complete_bss,
2864           cli_cmd_flag_none,
2865           "<addr> = roam to the specified BSS" },
2866 #ifdef CONFIG_MESH
2867         { "mesh_interface_add", wpa_cli_cmd_mesh_interface_add, NULL,
2868           cli_cmd_flag_none,
2869           "[ifname] = Create a new mesh interface" },
2870         { "mesh_group_add", wpa_cli_cmd_mesh_group_add, NULL,
2871           cli_cmd_flag_none,
2872           "<network id> = join a mesh network (disable others)" },
2873         { "mesh_group_remove", wpa_cli_cmd_mesh_group_remove, NULL,
2874           cli_cmd_flag_none,
2875           "<ifname> = Remove mesh group interface" },
2876 #endif /* CONFIG_MESH */
2877 #ifdef CONFIG_P2P
2878         { "p2p_find", wpa_cli_cmd_p2p_find, wpa_cli_complete_p2p_find,
2879           cli_cmd_flag_none,
2880           "[timeout] [type=*] = find P2P Devices for up-to timeout seconds" },
2881         { "p2p_stop_find", wpa_cli_cmd_p2p_stop_find, NULL, cli_cmd_flag_none,
2882           "= stop P2P Devices search" },
2883         { "p2p_connect", wpa_cli_cmd_p2p_connect, wpa_cli_complete_p2p_connect,
2884           cli_cmd_flag_none,
2885           "<addr> <\"pbc\"|PIN> [ht40] = connect to a P2P Device" },
2886         { "p2p_listen", wpa_cli_cmd_p2p_listen, NULL, cli_cmd_flag_none,
2887           "[timeout] = listen for P2P Devices for up-to timeout seconds" },
2888         { "p2p_group_remove", wpa_cli_cmd_p2p_group_remove,
2889           wpa_cli_complete_p2p_group_remove, cli_cmd_flag_none,
2890           "<ifname> = remove P2P group interface (terminate group if GO)" },
2891         { "p2p_group_add", wpa_cli_cmd_p2p_group_add, NULL, cli_cmd_flag_none,
2892           "[ht40] = add a new P2P group (local end as GO)" },
2893         { "p2p_prov_disc", wpa_cli_cmd_p2p_prov_disc,
2894           wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
2895           "<addr> <method> = request provisioning discovery" },
2896         { "p2p_get_passphrase", wpa_cli_cmd_p2p_get_passphrase, NULL,
2897           cli_cmd_flag_none,
2898           "= get the passphrase for a group (GO only)" },
2899         { "p2p_serv_disc_req", wpa_cli_cmd_p2p_serv_disc_req,
2900           wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
2901           "<addr> <TLVs> = schedule service discovery request" },
2902         { "p2p_serv_disc_cancel_req", wpa_cli_cmd_p2p_serv_disc_cancel_req,
2903           NULL, cli_cmd_flag_none,
2904           "<id> = cancel pending service discovery request" },
2905         { "p2p_serv_disc_resp", wpa_cli_cmd_p2p_serv_disc_resp, NULL,
2906           cli_cmd_flag_none,
2907           "<freq> <addr> <dialog token> <TLVs> = service discovery response" },
2908         { "p2p_service_update", wpa_cli_cmd_p2p_service_update, NULL,
2909           cli_cmd_flag_none,
2910           "= indicate change in local services" },
2911         { "p2p_serv_disc_external", wpa_cli_cmd_p2p_serv_disc_external, NULL,
2912           cli_cmd_flag_none,
2913           "<external> = set external processing of service discovery" },
2914         { "p2p_service_flush", wpa_cli_cmd_p2p_service_flush, NULL,
2915           cli_cmd_flag_none,
2916           "= remove all stored service entries" },
2917         { "p2p_service_add", wpa_cli_cmd_p2p_service_add, NULL,
2918           cli_cmd_flag_none,
2919           "<bonjour|upnp|asp> <query|version> <response|service> = add a local "
2920           "service" },
2921         { "p2p_service_rep", wpa_cli_cmd_p2p_service_rep, NULL,
2922           cli_cmd_flag_none,
2923           "asp <auto> <adv_id> <svc_state> <svc_string> [<svc_info>] = replace "
2924           "local ASP service" },
2925         { "p2p_service_del", wpa_cli_cmd_p2p_service_del, NULL,
2926           cli_cmd_flag_none,
2927           "<bonjour|upnp> <query|version> [|service] = remove a local "
2928           "service" },
2929         { "p2p_reject", wpa_cli_cmd_p2p_reject, wpa_cli_complete_p2p_peer,
2930           cli_cmd_flag_none,
2931           "<addr> = reject connection attempts from a specific peer" },
2932         { "p2p_invite", wpa_cli_cmd_p2p_invite, NULL,
2933           cli_cmd_flag_none,
2934           "<cmd> [peer=addr] = invite peer" },
2935         { "p2p_peers", wpa_cli_cmd_p2p_peers, NULL, cli_cmd_flag_none,
2936           "[discovered] = list known (optionally, only fully discovered) P2P "
2937           "peers" },
2938         { "p2p_peer", wpa_cli_cmd_p2p_peer, wpa_cli_complete_p2p_peer,
2939           cli_cmd_flag_none,
2940           "<address> = show information about known P2P peer" },
2941         { "p2p_set", wpa_cli_cmd_p2p_set, wpa_cli_complete_p2p_set,
2942           cli_cmd_flag_none,
2943           "<field> <value> = set a P2P parameter" },
2944         { "p2p_flush", wpa_cli_cmd_p2p_flush, NULL, cli_cmd_flag_none,
2945           "= flush P2P state" },
2946         { "p2p_cancel", wpa_cli_cmd_p2p_cancel, NULL, cli_cmd_flag_none,
2947           "= cancel P2P group formation" },
2948         { "p2p_unauthorize", wpa_cli_cmd_p2p_unauthorize,
2949           wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
2950           "<address> = unauthorize a peer" },
2951         { "p2p_presence_req", wpa_cli_cmd_p2p_presence_req, NULL,
2952           cli_cmd_flag_none,
2953           "[<duration> <interval>] [<duration> <interval>] = request GO "
2954           "presence" },
2955         { "p2p_ext_listen", wpa_cli_cmd_p2p_ext_listen, NULL,
2956           cli_cmd_flag_none,
2957           "[<period> <interval>] = set extended listen timing" },
2958         { "p2p_remove_client", wpa_cli_cmd_p2p_remove_client,
2959           wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
2960           "<address|iface=address> = remove a peer from all groups" },
2961 #endif /* CONFIG_P2P */
2962 #ifdef CONFIG_WIFI_DISPLAY
2963         { "wfd_subelem_set", wpa_cli_cmd_wfd_subelem_set, NULL,
2964           cli_cmd_flag_none,
2965           "<subelem> [contents] = set Wi-Fi Display subelement" },
2966         { "wfd_subelem_get", wpa_cli_cmd_wfd_subelem_get, NULL,
2967           cli_cmd_flag_none,
2968           "<subelem> = get Wi-Fi Display subelement" },
2969 #endif /* CONFIG_WIFI_DISPLAY */
2970 #ifdef CONFIG_INTERWORKING
2971         { "fetch_anqp", wpa_cli_cmd_fetch_anqp, NULL, cli_cmd_flag_none,
2972           "= fetch ANQP information for all APs" },
2973         { "stop_fetch_anqp", wpa_cli_cmd_stop_fetch_anqp, NULL,
2974           cli_cmd_flag_none,
2975           "= stop fetch_anqp operation" },
2976         { "interworking_select", wpa_cli_cmd_interworking_select, NULL,
2977           cli_cmd_flag_none,
2978           "[auto] = perform Interworking network selection" },
2979         { "interworking_connect", wpa_cli_cmd_interworking_connect,
2980           wpa_cli_complete_bss, cli_cmd_flag_none,
2981           "<BSSID> = connect using Interworking credentials" },
2982         { "anqp_get", wpa_cli_cmd_anqp_get, wpa_cli_complete_bss,
2983           cli_cmd_flag_none,
2984           "<addr> <info id>[,<info id>]... = request ANQP information" },
2985         { "gas_request", wpa_cli_cmd_gas_request, wpa_cli_complete_bss,
2986           cli_cmd_flag_none,
2987           "<addr> <AdvProtoID> [QueryReq] = GAS request" },
2988         { "gas_response_get", wpa_cli_cmd_gas_response_get,
2989           wpa_cli_complete_bss, cli_cmd_flag_none,
2990           "<addr> <dialog token> [start,len] = Fetch last GAS response" },
2991 #endif /* CONFIG_INTERWORKING */
2992 #ifdef CONFIG_HS20
2993         { "hs20_anqp_get", wpa_cli_cmd_hs20_anqp_get, wpa_cli_complete_bss,
2994           cli_cmd_flag_none,
2995           "<addr> <subtype>[,<subtype>]... = request HS 2.0 ANQP information"
2996         },
2997         { "nai_home_realm_list", wpa_cli_cmd_get_nai_home_realm_list,
2998           wpa_cli_complete_bss, cli_cmd_flag_none,
2999           "<addr> <home realm> = get HS20 nai home realm list" },
3000         { "hs20_icon_request", wpa_cli_cmd_hs20_icon_request,
3001           wpa_cli_complete_bss, cli_cmd_flag_none,
3002           "<addr> <icon name> = get Hotspot 2.0 OSU icon" },
3003         { "fetch_osu", wpa_cli_cmd_fetch_osu, NULL, cli_cmd_flag_none,
3004           "= fetch OSU provider information from all APs" },
3005         { "cancel_fetch_osu", wpa_cli_cmd_cancel_fetch_osu, NULL,
3006           cli_cmd_flag_none,
3007           "= cancel fetch_osu command" },
3008 #endif /* CONFIG_HS20 */
3009         { "sta_autoconnect", wpa_cli_cmd_sta_autoconnect, NULL,
3010           cli_cmd_flag_none,
3011           "<0/1> = disable/enable automatic reconnection" },
3012         { "tdls_discover", wpa_cli_cmd_tdls_discover, NULL,
3013           cli_cmd_flag_none,
3014           "<addr> = request TDLS discovery with <addr>" },
3015         { "tdls_setup", wpa_cli_cmd_tdls_setup, NULL,
3016           cli_cmd_flag_none,
3017           "<addr> = request TDLS setup with <addr>" },
3018         { "tdls_teardown", wpa_cli_cmd_tdls_teardown, NULL,
3019           cli_cmd_flag_none,
3020           "<addr> = tear down TDLS with <addr>" },
3021         { "wmm_ac_addts", wpa_cli_cmd_wmm_ac_addts, NULL,
3022           cli_cmd_flag_none,
3023           "<uplink/downlink/bidi> <tsid=0..7> <up=0..7> [nominal_msdu_size=#] "
3024           "[mean_data_rate=#] [min_phy_rate=#] [sba=#] [fixed_nominal_msdu] "
3025           "= add WMM-AC traffic stream" },
3026         { "wmm_ac_delts", wpa_cli_cmd_wmm_ac_delts, NULL,
3027           cli_cmd_flag_none,
3028           "<tsid> = delete WMM-AC traffic stream" },
3029         { "wmm_ac_status", wpa_cli_cmd_wmm_ac_status, NULL,
3030           cli_cmd_flag_none,
3031           "= show status for Wireless Multi-Media Admission-Control" },
3032         { "tdls_chan_switch", wpa_cli_cmd_tdls_chan_switch, NULL,
3033           cli_cmd_flag_none,
3034           "<addr> <oper class> <freq> [sec_channel_offset=] [center_freq1=] "
3035           "[center_freq2=] [bandwidth=] [ht|vht] = enable channel switching "
3036           "with TDLS peer" },
3037         { "tdls_cancel_chan_switch", wpa_cli_cmd_tdls_cancel_chan_switch, NULL,
3038           cli_cmd_flag_none,
3039           "<addr> = disable channel switching with TDLS peer <addr>" },
3040         { "signal_poll", wpa_cli_cmd_signal_poll, NULL,
3041           cli_cmd_flag_none,
3042           "= get signal parameters" },
3043         { "pktcnt_poll", wpa_cli_cmd_pktcnt_poll, NULL,
3044           cli_cmd_flag_none,
3045           "= get TX/RX packet counters" },
3046         { "reauthenticate", wpa_cli_cmd_reauthenticate, NULL,
3047           cli_cmd_flag_none,
3048           "= trigger IEEE 802.1X/EAPOL reauthentication" },
3049 #ifdef CONFIG_AUTOSCAN
3050         { "autoscan", wpa_cli_cmd_autoscan, NULL, cli_cmd_flag_none,
3051           "[params] = Set or unset (if none) autoscan parameters" },
3052 #endif /* CONFIG_AUTOSCAN */
3053 #ifdef CONFIG_WNM
3054         { "wnm_sleep", wpa_cli_cmd_wnm_sleep, NULL, cli_cmd_flag_none,
3055           "<enter/exit> [interval=#] = enter/exit WNM-Sleep mode" },
3056         { "wnm_bss_query", wpa_cli_cmd_wnm_bss_query, NULL, cli_cmd_flag_none,
3057           "<query reason> = Send BSS Transition Management Query" },
3058 #endif /* CONFIG_WNM */
3059         { "raw", wpa_cli_cmd_raw, NULL, cli_cmd_flag_sensitive,
3060           "<params..> = Sent unprocessed command" },
3061         { "flush", wpa_cli_cmd_flush, NULL, cli_cmd_flag_none,
3062           "= flush wpa_supplicant state" },
3063 #ifdef ANDROID
3064         { "driver", wpa_cli_cmd_driver, NULL, cli_cmd_flag_none,
3065           "<command> = driver private commands" },
3066 #endif /* ANDROID */
3067         { "radio_work", wpa_cli_cmd_radio_work, NULL, cli_cmd_flag_none,
3068           "= radio_work <show/add/done>" },
3069         { "vendor", wpa_cli_cmd_vendor, NULL, cli_cmd_flag_none,
3070           "<vendor id> <command id> [<hex formatted command argument>] = Send vendor command"
3071         },
3072         { "neighbor_rep_request",
3073           wpa_cli_cmd_neighbor_rep_request, NULL, cli_cmd_flag_none,
3074           "[ssid=<SSID>] = Trigger request to AP for neighboring AP report "
3075           "(with optional given SSID, default: current SSID)"
3076         },
3077         { "erp_flush", wpa_cli_cmd_erp_flush, NULL, cli_cmd_flag_none,
3078           "= flush ERP keys" },
3079         { "mac_rand_scan",
3080           wpa_cli_cmd_mac_rand_scan, NULL, cli_cmd_flag_none,
3081           "<scan|sched|pno|all> enable=<0/1> [addr=mac-address "
3082           "mask=mac-address-mask] = scan MAC randomization"
3083         },
3084         { NULL, NULL, NULL, cli_cmd_flag_none, NULL }
3085 };
3086
3087
3088 /*
3089  * Prints command usage, lines are padded with the specified string.
3090  */
3091 static void print_cmd_help(struct wpa_cli_cmd *cmd, const char *pad)
3092 {
3093         char c;
3094         size_t n;
3095
3096         printf("%s%s ", pad, cmd->cmd);
3097         for (n = 0; (c = cmd->usage[n]); n++) {
3098                 printf("%c", c);
3099                 if (c == '\n')
3100                         printf("%s", pad);
3101         }
3102         printf("\n");
3103 }
3104
3105
3106 static void print_help(const char *cmd)
3107 {
3108         int n;
3109         printf("commands:\n");
3110         for (n = 0; wpa_cli_commands[n].cmd; n++) {
3111                 if (cmd == NULL || str_starts(wpa_cli_commands[n].cmd, cmd))
3112                         print_cmd_help(&wpa_cli_commands[n], "  ");
3113         }
3114 }
3115
3116
3117 static int wpa_cli_edit_filter_history_cb(void *ctx, const char *cmd)
3118 {
3119         const char *c, *delim;
3120         int n;
3121         size_t len;
3122
3123         delim = os_strchr(cmd, ' ');
3124         if (delim)
3125                 len = delim - cmd;
3126         else
3127                 len = os_strlen(cmd);
3128
3129         for (n = 0; (c = wpa_cli_commands[n].cmd); n++) {
3130                 if (os_strncasecmp(cmd, c, len) == 0 && len == os_strlen(c))
3131                         return (wpa_cli_commands[n].flags &
3132                                 cli_cmd_flag_sensitive);
3133         }
3134         return 0;
3135 }
3136
3137
3138 static char ** wpa_list_cmd_list(void)
3139 {
3140         char **res;
3141         int i, count;
3142         struct cli_txt_entry *e;
3143
3144         count = ARRAY_SIZE(wpa_cli_commands);
3145         count += dl_list_len(&p2p_groups);
3146         count += dl_list_len(&ifnames);
3147         res = os_calloc(count + 1, sizeof(char *));
3148         if (res == NULL)
3149                 return NULL;
3150
3151         for (i = 0; wpa_cli_commands[i].cmd; i++) {
3152                 res[i] = os_strdup(wpa_cli_commands[i].cmd);
3153                 if (res[i] == NULL)
3154                         break;
3155         }
3156
3157         dl_list_for_each(e, &p2p_groups, struct cli_txt_entry, list) {
3158                 size_t len = 8 + os_strlen(e->txt);
3159                 res[i] = os_malloc(len);
3160                 if (res[i] == NULL)
3161                         break;
3162                 os_snprintf(res[i], len, "ifname=%s", e->txt);
3163                 i++;
3164         }
3165
3166         dl_list_for_each(e, &ifnames, struct cli_txt_entry, list) {
3167                 res[i] = os_strdup(e->txt);
3168                 if (res[i] == NULL)
3169                         break;
3170                 i++;
3171         }
3172
3173         return res;
3174 }
3175
3176
3177 static char ** wpa_cli_cmd_completion(const char *cmd, const char *str,
3178                                       int pos)
3179 {
3180         int i;
3181
3182         for (i = 0; wpa_cli_commands[i].cmd; i++) {
3183                 if (os_strcasecmp(wpa_cli_commands[i].cmd, cmd) == 0) {
3184                         if (wpa_cli_commands[i].completion)
3185                                 return wpa_cli_commands[i].completion(str,
3186                                                                       pos);
3187                         edit_clear_line();
3188                         printf("\r%s\n", wpa_cli_commands[i].usage);
3189                         edit_redraw();
3190                         break;
3191                 }
3192         }
3193
3194         return NULL;
3195 }
3196
3197
3198 static char ** wpa_cli_edit_completion_cb(void *ctx, const char *str, int pos)
3199 {
3200         char **res;
3201         const char *end;
3202         char *cmd;
3203
3204         if (pos > 7 && os_strncasecmp(str, "IFNAME=", 7) == 0) {
3205                 end = os_strchr(str, ' ');
3206                 if (end && pos > end - str) {
3207                         pos -= end - str + 1;
3208                         str = end + 1;
3209                 }
3210         }
3211
3212         end = os_strchr(str, ' ');
3213         if (end == NULL || str + pos < end)
3214                 return wpa_list_cmd_list();
3215
3216         cmd = os_malloc(pos + 1);
3217         if (cmd == NULL)
3218                 return NULL;
3219         os_memcpy(cmd, str, pos);
3220         cmd[end - str] = '\0';
3221         res = wpa_cli_cmd_completion(cmd, str, pos);
3222         os_free(cmd);
3223         return res;
3224 }
3225
3226
3227 static int wpa_request(struct wpa_ctrl *ctrl, int argc, char *argv[])
3228 {
3229         struct wpa_cli_cmd *cmd, *match = NULL;
3230         int count;
3231         int ret = 0;
3232
3233         if (argc > 1 && os_strncasecmp(argv[0], "IFNAME=", 7) == 0) {
3234                 ifname_prefix = argv[0] + 7;
3235                 argv = &argv[1];
3236                 argc--;
3237         } else
3238                 ifname_prefix = NULL;
3239
3240         if (argc == 0)
3241                 return -1;
3242
3243         count = 0;
3244         cmd = wpa_cli_commands;
3245         while (cmd->cmd) {
3246                 if (os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0)
3247                 {
3248                         match = cmd;
3249                         if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
3250                                 /* we have an exact match */
3251                                 count = 1;
3252                                 break;
3253                         }
3254                         count++;
3255                 }
3256                 cmd++;
3257         }
3258
3259         if (count > 1) {
3260                 printf("Ambiguous command '%s'; possible commands:", argv[0]);
3261                 cmd = wpa_cli_commands;
3262                 while (cmd->cmd) {
3263                         if (os_strncasecmp(cmd->cmd, argv[0],
3264                                            os_strlen(argv[0])) == 0) {
3265                                 printf(" %s", cmd->cmd);
3266                         }
3267                         cmd++;
3268                 }
3269                 printf("\n");
3270                 ret = 1;
3271         } else if (count == 0) {
3272                 printf("Unknown command '%s'\n", argv[0]);
3273                 ret = 1;
3274         } else {
3275                 ret = match->handler(ctrl, argc - 1, &argv[1]);
3276         }
3277
3278         return ret;
3279 }
3280
3281
3282 static int str_match(const char *a, const char *b)
3283 {
3284         return os_strncmp(a, b, os_strlen(b)) == 0;
3285 }
3286
3287
3288 static int wpa_cli_exec(const char *program, const char *arg1,
3289                         const char *arg2)
3290 {
3291         char *arg;
3292         size_t len;
3293         int res;
3294
3295         len = os_strlen(arg1) + os_strlen(arg2) + 2;
3296         arg = os_malloc(len);
3297         if (arg == NULL)
3298                 return -1;
3299         os_snprintf(arg, len, "%s %s", arg1, arg2);
3300         res = os_exec(program, arg, 1);
3301         os_free(arg);
3302
3303         return res;
3304 }
3305
3306
3307 static void wpa_cli_action_process(const char *msg)
3308 {
3309         const char *pos;
3310         char *copy = NULL, *id, *pos2;
3311         const char *ifname = ctrl_ifname;
3312         char ifname_buf[100];
3313
3314         pos = msg;
3315         if (os_strncmp(pos, "IFNAME=", 7) == 0) {
3316                 const char *end;
3317                 end = os_strchr(pos + 7, ' ');
3318                 if (end && (unsigned int) (end - pos) < sizeof(ifname_buf)) {
3319                         pos += 7;
3320                         os_memcpy(ifname_buf, pos, end - pos);
3321                         ifname_buf[end - pos] = '\0';
3322                         ifname = ifname_buf;
3323                         pos = end + 1;
3324                 }
3325         }
3326         if (*pos == '<') {
3327                 const char *prev = pos;
3328                 /* skip priority */
3329                 pos = os_strchr(pos, '>');
3330                 if (pos)
3331                         pos++;
3332                 else
3333                         pos = prev;
3334         }
3335
3336         if (str_match(pos, WPA_EVENT_CONNECTED)) {
3337                 int new_id = -1;
3338                 os_unsetenv("WPA_ID");
3339                 os_unsetenv("WPA_ID_STR");
3340                 os_unsetenv("WPA_CTRL_DIR");
3341
3342                 pos = os_strstr(pos, "[id=");
3343                 if (pos)
3344                         copy = os_strdup(pos + 4);
3345
3346                 if (copy) {
3347                         pos2 = id = copy;
3348                         while (*pos2 && *pos2 != ' ')
3349                                 pos2++;
3350                         *pos2++ = '\0';
3351                         new_id = atoi(id);
3352                         os_setenv("WPA_ID", id, 1);
3353                         while (*pos2 && *pos2 != '=')
3354                                 pos2++;
3355                         if (*pos2 == '=')
3356                                 pos2++;
3357                         id = pos2;
3358                         while (*pos2 && *pos2 != ']')
3359                                 pos2++;
3360                         *pos2 = '\0';
3361                         os_setenv("WPA_ID_STR", id, 1);
3362                         os_free(copy);
3363                 }
3364
3365                 os_setenv("WPA_CTRL_DIR", ctrl_iface_dir, 1);
3366
3367                 if (wpa_cli_connected <= 0 || new_id != wpa_cli_last_id) {
3368                         wpa_cli_connected = 1;
3369                         wpa_cli_last_id = new_id;
3370                         wpa_cli_exec(action_file, ifname, "CONNECTED");
3371                 }
3372         } else if (str_match(pos, WPA_EVENT_DISCONNECTED)) {
3373                 if (wpa_cli_connected) {
3374                         wpa_cli_connected = 0;
3375                         wpa_cli_exec(action_file, ifname, "DISCONNECTED");
3376                 }
3377         } else if (str_match(pos, MESH_GROUP_STARTED)) {
3378                 wpa_cli_exec(action_file, ctrl_ifname, pos);
3379         } else if (str_match(pos, MESH_GROUP_REMOVED)) {
3380                 wpa_cli_exec(action_file, ctrl_ifname, pos);
3381         } else if (str_match(pos, MESH_PEER_CONNECTED)) {
3382                 wpa_cli_exec(action_file, ctrl_ifname, pos);
3383         } else if (str_match(pos, MESH_PEER_DISCONNECTED)) {
3384                 wpa_cli_exec(action_file, ctrl_ifname, pos);
3385         } else if (str_match(pos, P2P_EVENT_GROUP_STARTED)) {
3386                 wpa_cli_exec(action_file, ifname, pos);
3387         } else if (str_match(pos, P2P_EVENT_GROUP_REMOVED)) {
3388                 wpa_cli_exec(action_file, ifname, pos);
3389         } else if (str_match(pos, P2P_EVENT_CROSS_CONNECT_ENABLE)) {
3390                 wpa_cli_exec(action_file, ifname, pos);
3391         } else if (str_match(pos, P2P_EVENT_CROSS_CONNECT_DISABLE)) {
3392                 wpa_cli_exec(action_file, ifname, pos);
3393         } else if (str_match(pos, P2P_EVENT_GO_NEG_FAILURE)) {
3394                 wpa_cli_exec(action_file, ifname, pos);
3395         } else if (str_match(pos, WPS_EVENT_SUCCESS)) {
3396                 wpa_cli_exec(action_file, ifname, pos);
3397         } else if (str_match(pos, WPS_EVENT_FAIL)) {
3398                 wpa_cli_exec(action_file, ifname, pos);
3399         } else if (str_match(pos, AP_STA_CONNECTED)) {
3400                 wpa_cli_exec(action_file, ifname, pos);
3401         } else if (str_match(pos, AP_STA_DISCONNECTED)) {
3402                 wpa_cli_exec(action_file, ifname, pos);
3403         } else if (str_match(pos, ESS_DISASSOC_IMMINENT)) {
3404                 wpa_cli_exec(action_file, ifname, pos);
3405         } else if (str_match(pos, HS20_SUBSCRIPTION_REMEDIATION)) {
3406                 wpa_cli_exec(action_file, ifname, pos);
3407         } else if (str_match(pos, HS20_DEAUTH_IMMINENT_NOTICE)) {
3408                 wpa_cli_exec(action_file, ifname, pos);
3409         } else if (str_match(pos, WPA_EVENT_TERMINATING)) {
3410                 printf("wpa_supplicant is terminating - stop monitoring\n");
3411                 wpa_cli_quit = 1;
3412         }
3413 }
3414
3415
3416 #ifndef CONFIG_ANSI_C_EXTRA
3417 static void wpa_cli_action_cb(char *msg, size_t len)
3418 {
3419         wpa_cli_action_process(msg);
3420 }
3421 #endif /* CONFIG_ANSI_C_EXTRA */
3422
3423
3424 static void wpa_cli_reconnect(void)
3425 {
3426         wpa_cli_close_connection();
3427         if (wpa_cli_open_connection(ctrl_ifname, 1) < 0)
3428                 return;
3429
3430         if (interactive) {
3431                 edit_clear_line();
3432                 printf("\rConnection to wpa_supplicant re-established\n");
3433                 edit_redraw();
3434         }
3435 }
3436
3437
3438 static void cli_event(const char *str)
3439 {
3440         const char *start, *s;
3441
3442         start = os_strchr(str, '>');
3443         if (start == NULL)
3444                 return;
3445
3446         start++;
3447
3448         if (str_starts(start, WPA_EVENT_BSS_ADDED)) {
3449                 s = os_strchr(start, ' ');
3450                 if (s == NULL)
3451                         return;
3452                 s = os_strchr(s + 1, ' ');
3453                 if (s == NULL)
3454                         return;
3455                 cli_txt_list_add(&bsses, s + 1);
3456                 return;
3457         }
3458
3459         if (str_starts(start, WPA_EVENT_BSS_REMOVED)) {
3460                 s = os_strchr(start, ' ');
3461                 if (s == NULL)
3462                         return;
3463                 s = os_strchr(s + 1, ' ');
3464                 if (s == NULL)
3465                         return;
3466                 cli_txt_list_del_addr(&bsses, s + 1);
3467                 return;
3468         }
3469
3470 #ifdef CONFIG_P2P
3471         if (str_starts(start, P2P_EVENT_DEVICE_FOUND)) {
3472                 s = os_strstr(start, " p2p_dev_addr=");
3473                 if (s == NULL)
3474                         return;
3475                 cli_txt_list_add_addr(&p2p_peers, s + 14);
3476                 return;
3477         }
3478
3479         if (str_starts(start, P2P_EVENT_DEVICE_LOST)) {
3480                 s = os_strstr(start, " p2p_dev_addr=");
3481                 if (s == NULL)
3482                         return;
3483                 cli_txt_list_del_addr(&p2p_peers, s + 14);
3484                 return;
3485         }
3486
3487         if (str_starts(start, P2P_EVENT_GROUP_STARTED)) {
3488                 s = os_strchr(start, ' ');
3489                 if (s == NULL)
3490                         return;
3491                 cli_txt_list_add_word(&p2p_groups, s + 1);
3492                 return;
3493         }
3494
3495         if (str_starts(start, P2P_EVENT_GROUP_REMOVED)) {
3496                 s = os_strchr(start, ' ');
3497                 if (s == NULL)
3498                         return;
3499                 cli_txt_list_del_word(&p2p_groups, s + 1);
3500                 return;
3501         }
3502 #endif /* CONFIG_P2P */
3503 }
3504
3505
3506 static int check_terminating(const char *msg)
3507 {
3508         const char *pos = msg;
3509
3510         if (*pos == '<') {
3511                 /* skip priority */
3512                 pos = os_strchr(pos, '>');
3513                 if (pos)
3514                         pos++;
3515                 else
3516                         pos = msg;
3517         }
3518
3519         if (str_match(pos, WPA_EVENT_TERMINATING) && ctrl_conn) {
3520                 edit_clear_line();
3521                 printf("\rConnection to wpa_supplicant lost - trying to "
3522                        "reconnect\n");
3523                 edit_redraw();
3524                 wpa_cli_attached = 0;
3525                 wpa_cli_close_connection();
3526                 return 1;
3527         }
3528
3529         return 0;
3530 }
3531
3532
3533 static void wpa_cli_recv_pending(struct wpa_ctrl *ctrl, int action_monitor)
3534 {
3535         if (ctrl_conn == NULL) {
3536                 wpa_cli_reconnect();
3537                 return;
3538         }
3539         while (wpa_ctrl_pending(ctrl) > 0) {
3540                 char buf[4096];
3541                 size_t len = sizeof(buf) - 1;
3542                 if (wpa_ctrl_recv(ctrl, buf, &len) == 0) {
3543                         buf[len] = '\0';
3544                         if (action_monitor)
3545                                 wpa_cli_action_process(buf);
3546                         else {
3547                                 cli_event(buf);
3548                                 if (wpa_cli_show_event(buf)) {
3549                                         edit_clear_line();
3550                                         printf("\r%s\n", buf);
3551                                         edit_redraw();
3552                                 }
3553
3554                                 if (interactive && check_terminating(buf) > 0)
3555                                         return;
3556                         }
3557                 } else {
3558                         printf("Could not read pending message.\n");
3559                         break;
3560                 }
3561         }
3562
3563         if (wpa_ctrl_pending(ctrl) < 0) {
3564                 printf("Connection to wpa_supplicant lost - trying to "
3565                        "reconnect\n");
3566                 wpa_cli_reconnect();
3567         }
3568 }
3569
3570 #define max_args 10
3571
3572 static int tokenize_cmd(char *cmd, char *argv[])
3573 {
3574         char *pos;
3575         int argc = 0;
3576
3577         pos = cmd;
3578         for (;;) {
3579                 while (*pos == ' ')
3580                         pos++;
3581                 if (*pos == '\0')
3582                         break;
3583                 argv[argc] = pos;
3584                 argc++;
3585                 if (argc == max_args)
3586                         break;
3587                 if (*pos == '"') {
3588                         char *pos2 = os_strrchr(pos, '"');
3589                         if (pos2)
3590                                 pos = pos2 + 1;
3591                 }
3592                 while (*pos != '\0' && *pos != ' ')
3593                         pos++;
3594                 if (*pos == ' ')
3595                         *pos++ = '\0';
3596         }
3597
3598         return argc;
3599 }
3600
3601
3602 static void wpa_cli_ping(void *eloop_ctx, void *timeout_ctx)
3603 {
3604         if (ctrl_conn) {
3605                 int res;
3606                 char *prefix = ifname_prefix;
3607
3608                 ifname_prefix = NULL;
3609                 res = _wpa_ctrl_command(ctrl_conn, "PING", 0);
3610                 ifname_prefix = prefix;
3611                 if (res) {
3612                         printf("Connection to wpa_supplicant lost - trying to "
3613                                "reconnect\n");
3614                         wpa_cli_close_connection();
3615                 }
3616         }
3617         if (!ctrl_conn)
3618                 wpa_cli_reconnect();
3619         eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
3620 }
3621
3622
3623 static void wpa_cli_mon_receive(int sock, void *eloop_ctx, void *sock_ctx)
3624 {
3625         wpa_cli_recv_pending(mon_conn, 0);
3626 }
3627
3628
3629 static void wpa_cli_edit_cmd_cb(void *ctx, char *cmd)
3630 {
3631         char *argv[max_args];
3632         int argc;
3633         argc = tokenize_cmd(cmd, argv);
3634         if (argc)
3635                 wpa_request(ctrl_conn, argc, argv);
3636 }
3637
3638
3639 static void wpa_cli_edit_eof_cb(void *ctx)
3640 {
3641         eloop_terminate();
3642 }
3643
3644
3645 static int warning_displayed = 0;
3646 static char *hfile = NULL;
3647 static int edit_started = 0;
3648
3649 static void start_edit(void)
3650 {
3651         char *home;
3652         char *ps = NULL;
3653
3654 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
3655         ps = wpa_ctrl_get_remote_ifname(ctrl_conn);
3656 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
3657
3658         home = getenv("HOME");
3659         if (home) {
3660                 const char *fname = ".wpa_cli_history";
3661                 int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
3662                 hfile = os_malloc(hfile_len);
3663                 if (hfile)
3664                         os_snprintf(hfile, hfile_len, "%s/%s", home, fname);
3665         }
3666
3667         if (edit_init(wpa_cli_edit_cmd_cb, wpa_cli_edit_eof_cb,
3668                       wpa_cli_edit_completion_cb, NULL, hfile, ps) < 0) {
3669                 eloop_terminate();
3670                 return;
3671         }
3672
3673         edit_started = 1;
3674         eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
3675 }
3676
3677
3678 static void update_bssid_list(struct wpa_ctrl *ctrl)
3679 {
3680         char buf[4096];
3681         size_t len = sizeof(buf);
3682         int ret;
3683         char *cmd = "BSS RANGE=ALL MASK=0x2";
3684         char *pos, *end;
3685
3686         if (ctrl == NULL)
3687                 return;
3688         ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
3689         if (ret < 0)
3690                 return;
3691         buf[len] = '\0';
3692
3693         pos = buf;
3694         while (pos) {
3695                 pos = os_strstr(pos, "bssid=");
3696                 if (pos == NULL)
3697                         break;
3698                 pos += 6;
3699                 end = os_strchr(pos, '\n');
3700                 if (end == NULL)
3701                         break;
3702                 *end = '\0';
3703                 cli_txt_list_add(&bsses, pos);
3704                 pos = end + 1;
3705         }
3706 }
3707
3708
3709 static void update_ifnames(struct wpa_ctrl *ctrl)
3710 {
3711         char buf[4096];
3712         size_t len = sizeof(buf);
3713         int ret;
3714         char *cmd = "INTERFACES";
3715         char *pos, *end;
3716         char txt[200];
3717
3718         cli_txt_list_flush(&ifnames);
3719
3720         if (ctrl == NULL)
3721                 return;
3722         ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
3723         if (ret < 0)
3724                 return;
3725         buf[len] = '\0';
3726
3727         pos = buf;
3728         while (pos) {
3729                 end = os_strchr(pos, '\n');
3730                 if (end == NULL)
3731                         break;
3732                 *end = '\0';
3733                 ret = os_snprintf(txt, sizeof(txt), "ifname=%s", pos);
3734                 if (!os_snprintf_error(sizeof(txt), ret))
3735                         cli_txt_list_add(&ifnames, txt);
3736                 pos = end + 1;
3737         }
3738 }
3739
3740
3741 static void try_connection(void *eloop_ctx, void *timeout_ctx)
3742 {
3743         if (ctrl_conn)
3744                 goto done;
3745
3746         if (ctrl_ifname == NULL)
3747                 ctrl_ifname = wpa_cli_get_default_ifname();
3748
3749         if (!wpa_cli_open_connection(ctrl_ifname, 1) == 0) {
3750                 if (!warning_displayed) {
3751                         printf("Could not connect to wpa_supplicant: "
3752                                "%s - re-trying\n",
3753                                ctrl_ifname ? ctrl_ifname : "(nil)");
3754                         warning_displayed = 1;
3755                 }
3756                 eloop_register_timeout(1, 0, try_connection, NULL, NULL);
3757                 return;
3758         }
3759
3760         update_bssid_list(ctrl_conn);
3761
3762         if (warning_displayed)
3763                 printf("Connection established.\n");
3764
3765 done:
3766         start_edit();
3767 }
3768
3769
3770 static void wpa_cli_interactive(void)
3771 {
3772         printf("\nInteractive mode\n\n");
3773
3774         eloop_register_timeout(0, 0, try_connection, NULL, NULL);
3775         eloop_run();
3776         eloop_cancel_timeout(try_connection, NULL, NULL);
3777
3778         cli_txt_list_flush(&p2p_peers);
3779         cli_txt_list_flush(&p2p_groups);
3780         cli_txt_list_flush(&bsses);
3781         cli_txt_list_flush(&ifnames);
3782         if (edit_started)
3783                 edit_deinit(hfile, wpa_cli_edit_filter_history_cb);
3784         os_free(hfile);
3785         eloop_cancel_timeout(wpa_cli_ping, NULL, NULL);
3786         wpa_cli_close_connection();
3787 }
3788
3789
3790 static void wpa_cli_action(struct wpa_ctrl *ctrl)
3791 {
3792 #ifdef CONFIG_ANSI_C_EXTRA
3793         /* TODO: ANSI C version(?) */
3794         printf("Action processing not supported in ANSI C build.\n");
3795 #else /* CONFIG_ANSI_C_EXTRA */
3796         fd_set rfds;
3797         int fd, res;
3798         struct timeval tv;
3799         char buf[256]; /* note: large enough to fit in unsolicited messages */
3800         size_t len;
3801
3802         fd = wpa_ctrl_get_fd(ctrl);
3803
3804         while (!wpa_cli_quit) {
3805                 FD_ZERO(&rfds);
3806                 FD_SET(fd, &rfds);
3807                 tv.tv_sec = ping_interval;
3808                 tv.tv_usec = 0;
3809                 res = select(fd + 1, &rfds, NULL, NULL, &tv);
3810                 if (res < 0 && errno != EINTR) {
3811                         perror("select");
3812                         break;
3813                 }
3814
3815                 if (FD_ISSET(fd, &rfds))
3816                         wpa_cli_recv_pending(ctrl, 1);
3817                 else {
3818                         /* verify that connection is still working */
3819                         len = sizeof(buf) - 1;
3820                         if (wpa_ctrl_request(ctrl, "PING", 4, buf, &len,
3821                                              wpa_cli_action_cb) < 0 ||
3822                             len < 4 || os_memcmp(buf, "PONG", 4) != 0) {
3823                                 printf("wpa_supplicant did not reply to PING "
3824                                        "command - exiting\n");
3825                                 break;
3826                         }
3827                 }
3828         }
3829 #endif /* CONFIG_ANSI_C_EXTRA */
3830 }
3831
3832
3833 static void wpa_cli_cleanup(void)
3834 {
3835         wpa_cli_close_connection();
3836         if (pid_file)
3837                 os_daemonize_terminate(pid_file);
3838
3839         os_program_deinit();
3840 }
3841
3842
3843 static void wpa_cli_terminate(int sig, void *ctx)
3844 {
3845         eloop_terminate();
3846 }
3847
3848
3849 static char * wpa_cli_get_default_ifname(void)
3850 {
3851         char *ifname = NULL;
3852
3853 #ifdef CONFIG_CTRL_IFACE_UNIX
3854         struct dirent *dent;
3855         DIR *dir = opendir(ctrl_iface_dir);
3856         if (!dir) {
3857 #ifdef ANDROID
3858                 char ifprop[PROPERTY_VALUE_MAX];
3859                 if (property_get("wifi.interface", ifprop, NULL) != 0) {
3860                         ifname = os_strdup(ifprop);
3861                         printf("Using interface '%s'\n", ifname);
3862                         return ifname;
3863                 }
3864 #endif /* ANDROID */
3865                 return NULL;
3866         }
3867         while ((dent = readdir(dir))) {
3868 #ifdef _DIRENT_HAVE_D_TYPE
3869                 /*
3870                  * Skip the file if it is not a socket. Also accept
3871                  * DT_UNKNOWN (0) in case the C library or underlying
3872                  * file system does not support d_type.
3873                  */
3874                 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN)
3875                         continue;
3876 #endif /* _DIRENT_HAVE_D_TYPE */
3877                 if (os_strcmp(dent->d_name, ".") == 0 ||
3878                     os_strcmp(dent->d_name, "..") == 0)
3879                         continue;
3880                 printf("Selected interface '%s'\n", dent->d_name);
3881                 ifname = os_strdup(dent->d_name);
3882                 break;
3883         }
3884         closedir(dir);
3885 #endif /* CONFIG_CTRL_IFACE_UNIX */
3886
3887 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
3888         char buf[4096], *pos;
3889         size_t len;
3890         struct wpa_ctrl *ctrl;
3891         int ret;
3892
3893         ctrl = wpa_ctrl_open(NULL);
3894         if (ctrl == NULL)
3895                 return NULL;
3896
3897         len = sizeof(buf) - 1;
3898         ret = wpa_ctrl_request(ctrl, "INTERFACES", 10, buf, &len, NULL);
3899         if (ret >= 0) {
3900                 buf[len] = '\0';
3901                 pos = os_strchr(buf, '\n');
3902                 if (pos)
3903                         *pos = '\0';
3904                 ifname = os_strdup(buf);
3905         }
3906         wpa_ctrl_close(ctrl);
3907 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3908
3909         return ifname;
3910 }
3911
3912
3913 int main(int argc, char *argv[])
3914 {
3915         int c;
3916         int daemonize = 0;
3917         int ret = 0;
3918         const char *global = NULL;
3919
3920         if (os_program_init())
3921                 return -1;
3922
3923         for (;;) {
3924                 c = getopt(argc, argv, "a:Bg:G:hi:p:P:v");
3925                 if (c < 0)
3926                         break;
3927                 switch (c) {
3928                 case 'a':
3929                         action_file = optarg;
3930                         break;
3931                 case 'B':
3932                         daemonize = 1;
3933                         break;
3934                 case 'g':
3935                         global = optarg;
3936                         break;
3937                 case 'G':
3938                         ping_interval = atoi(optarg);
3939                         break;
3940                 case 'h':
3941                         usage();
3942                         return 0;
3943                 case 'v':
3944                         printf("%s\n", wpa_cli_version);
3945                         return 0;
3946                 case 'i':
3947                         os_free(ctrl_ifname);
3948                         ctrl_ifname = os_strdup(optarg);
3949                         break;
3950                 case 'p':
3951                         ctrl_iface_dir = optarg;
3952                         break;
3953                 case 'P':
3954                         pid_file = optarg;
3955                         break;
3956                 default:
3957                         usage();
3958                         return -1;
3959                 }
3960         }
3961
3962         interactive = (argc == optind) && (action_file == NULL);
3963
3964         if (interactive)
3965                 printf("%s\n\n%s\n\n", wpa_cli_version, wpa_cli_license);
3966
3967         if (eloop_init())
3968                 return -1;
3969
3970         if (global) {
3971 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
3972                 ctrl_conn = wpa_ctrl_open(NULL);
3973 #else /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3974                 ctrl_conn = wpa_ctrl_open(global);
3975 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3976                 if (ctrl_conn == NULL) {
3977                         fprintf(stderr, "Failed to connect to wpa_supplicant "
3978                                 "global interface: %s  error: %s\n",
3979                                 global, strerror(errno));
3980                         return -1;
3981                 }
3982
3983                 if (interactive) {
3984                         update_ifnames(ctrl_conn);
3985                         mon_conn = wpa_ctrl_open(global);
3986                         if (mon_conn) {
3987                                 if (wpa_ctrl_attach(mon_conn) == 0) {
3988                                         wpa_cli_attached = 1;
3989                                         eloop_register_read_sock(
3990                                                 wpa_ctrl_get_fd(mon_conn),
3991                                                 wpa_cli_mon_receive,
3992                                                 NULL, NULL);
3993                                 } else {
3994                                         printf("Failed to open monitor "
3995                                                "connection through global "
3996                                                "control interface\n");
3997                                 }
3998                         }
3999                 }
4000         }
4001
4002         eloop_register_signal_terminate(wpa_cli_terminate, NULL);
4003
4004         if (ctrl_ifname == NULL)
4005                 ctrl_ifname = wpa_cli_get_default_ifname();
4006
4007         if (interactive) {
4008                 wpa_cli_interactive();
4009         } else {
4010                 if (!global &&
4011                     wpa_cli_open_connection(ctrl_ifname, 0) < 0) {
4012                         fprintf(stderr, "Failed to connect to non-global "
4013                                 "ctrl_ifname: %s  error: %s\n",
4014                                 ctrl_ifname ? ctrl_ifname : "(nil)",
4015                                 strerror(errno));
4016                         return -1;
4017                 }
4018
4019                 if (action_file) {
4020                         if (wpa_ctrl_attach(ctrl_conn) == 0) {
4021                                 wpa_cli_attached = 1;
4022                         } else {
4023                                 printf("Warning: Failed to attach to "
4024                                        "wpa_supplicant.\n");
4025                                 return -1;
4026                         }
4027                 }
4028
4029                 if (daemonize && os_daemonize(pid_file))
4030                         return -1;
4031
4032                 if (action_file)
4033                         wpa_cli_action(ctrl_conn);
4034                 else
4035                         ret = wpa_request(ctrl_conn, argc - optind,
4036                                           &argv[optind]);
4037         }
4038
4039         os_free(ctrl_ifname);
4040         eloop_destroy();
4041         wpa_cli_cleanup();
4042
4043         return ret;
4044 }
4045
4046 #else /* CONFIG_CTRL_IFACE */
4047 int main(int argc, char *argv[])
4048 {
4049         printf("CONFIG_CTRL_IFACE not defined - wpa_cli disabled\n");
4050         return -1;
4051 }
4052 #endif /* CONFIG_CTRL_IFACE */