wpa_supplicant/wpa_cli.c

   1 /*
   2  * WPA Supplicant - command line interface for wpa_supplicant daemon
   3  * Copyright (c) 2004-2013, Jouni Malinen <j@w1.fi>
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "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-2014, 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
1581         if (wpa_cli_open_connection(ctrl_ifname, 1) == 0) {
1582                 printf("Connected to interface '%s.\n", ctrl_ifname);
1583         } else {
1584                 printf("Could not connect to interface '%s' - re-trying\n",
1585                        ctrl_ifname);
1586         }
1587         return 0;
1588 }
1589
1590
1591 static int wpa_cli_cmd_reconfigure(struct wpa_ctrl *ctrl, int argc,
1592                                    char *argv[])
1593 {
1594         return wpa_ctrl_command(ctrl, "RECONFIGURE");
1595 }
1596
1597
1598 static int wpa_cli_cmd_terminate(struct wpa_ctrl *ctrl, int argc,
1599                                  char *argv[])
1600 {
1601         return wpa_ctrl_command(ctrl, "TERMINATE");
1602 }
1603
1604
1605 static int wpa_cli_cmd_interface_add(struct wpa_ctrl *ctrl, int argc,
1606                                      char *argv[])
1607 {
1608         char cmd[256];
1609         int res;
1610
1611         if (argc < 1) {
1612                 printf("Invalid INTERFACE_ADD command: needs at least one "
1613                        "argument (interface name)\n"
1614                        "All arguments: ifname confname driver ctrl_interface "
1615                        "driver_param bridge_name\n");
1616                 return -1;
1617         }
1618
1619         /*
1620          * INTERFACE_ADD <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB
1621          * <driver_param>TAB<bridge_name>
1622          */
1623         res = os_snprintf(cmd, sizeof(cmd),
1624                           "INTERFACE_ADD %s\t%s\t%s\t%s\t%s\t%s",
1625                           argv[0],
1626                           argc > 1 ? argv[1] : "", argc > 2 ? argv[2] : "",
1627                           argc > 3 ? argv[3] : "", argc > 4 ? argv[4] : "",
1628                           argc > 5 ? argv[5] : "");
1629         if (os_snprintf_error(sizeof(cmd), res))
1630                 return -1;
1631         cmd[sizeof(cmd) - 1] = '\0';
1632         return wpa_ctrl_command(ctrl, cmd);
1633 }
1634
1635
1636 static int wpa_cli_cmd_interface_remove(struct wpa_ctrl *ctrl, int argc,
1637                                         char *argv[])
1638 {
1639         return wpa_cli_cmd(ctrl, "INTERFACE_REMOVE", 1, argc, argv);
1640 }
1641
1642
1643 static int wpa_cli_cmd_interface_list(struct wpa_ctrl *ctrl, int argc,
1644                                       char *argv[])
1645 {
1646         return wpa_ctrl_command(ctrl, "INTERFACE_LIST");
1647 }
1648
1649
1650 #ifdef CONFIG_AP
1651 static int wpa_cli_cmd_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1652 {
1653         return wpa_cli_cmd(ctrl, "STA", 1, argc, argv);
1654 }
1655
1656
1657 static int wpa_ctrl_command_sta(struct wpa_ctrl *ctrl, char *cmd,
1658                                 char *addr, size_t addr_len)
1659 {
1660         char buf[4096], *pos;
1661         size_t len;
1662         int ret;
1663
1664         if (ctrl_conn == NULL) {
1665                 printf("Not connected to hostapd - command dropped.\n");
1666                 return -1;
1667         }
1668         len = sizeof(buf) - 1;
1669         ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
1670                                wpa_cli_msg_cb);
1671         if (ret == -2) {
1672                 printf("'%s' command timed out.\n", cmd);
1673                 return -2;
1674         } else if (ret < 0) {
1675                 printf("'%s' command failed.\n", cmd);
1676                 return -1;
1677         }
1678
1679         buf[len] = '\0';
1680         if (os_memcmp(buf, "FAIL", 4) == 0)
1681                 return -1;
1682         printf("%s", buf);
1683
1684         pos = buf;
1685         while (*pos != '\0' && *pos != '\n')
1686                 pos++;
1687         *pos = '\0';
1688         os_strlcpy(addr, buf, addr_len);
1689         return 0;
1690 }
1691
1692
1693 static int wpa_cli_cmd_all_sta(struct wpa_ctrl *ctrl, int argc, char *argv[])
1694 {
1695         char addr[32], cmd[64];
1696
1697         if (wpa_ctrl_command_sta(ctrl, "STA-FIRST", addr, sizeof(addr)))
1698                 return 0;
1699         do {
1700                 os_snprintf(cmd, sizeof(cmd), "STA-NEXT %s", addr);
1701         } while (wpa_ctrl_command_sta(ctrl, cmd, addr, sizeof(addr)) == 0);
1702
1703         return -1;
1704 }
1705
1706
1707 static int wpa_cli_cmd_deauthenticate(struct wpa_ctrl *ctrl, int argc,
1708                                       char *argv[])
1709 {
1710         return wpa_cli_cmd(ctrl, "DEAUTHENTICATE", 1, argc, argv);
1711 }
1712
1713
1714 static int wpa_cli_cmd_disassociate(struct wpa_ctrl *ctrl, int argc,
1715                                     char *argv[])
1716 {
1717         return wpa_cli_cmd(ctrl, "DISASSOCIATE", 1, argc, argv);
1718 }
1719
1720 static int wpa_cli_cmd_chanswitch(struct wpa_ctrl *ctrl, int argc,
1721                                     char *argv[])
1722 {
1723         return wpa_cli_cmd(ctrl, "CHAN_SWITCH", 2, argc, argv);
1724 }
1725
1726 #endif /* CONFIG_AP */
1727
1728
1729 static int wpa_cli_cmd_suspend(struct wpa_ctrl *ctrl, int argc, char *argv[])
1730 {
1731         return wpa_ctrl_command(ctrl, "SUSPEND");
1732 }
1733
1734
1735 static int wpa_cli_cmd_resume(struct wpa_ctrl *ctrl, int argc, char *argv[])
1736 {
1737         return wpa_ctrl_command(ctrl, "RESUME");
1738 }
1739
1740
1741 #ifdef CONFIG_TESTING_OPTIONS
1742 static int wpa_cli_cmd_drop_sa(struct wpa_ctrl *ctrl, int argc, char *argv[])
1743 {
1744         return wpa_ctrl_command(ctrl, "DROP_SA");
1745 }
1746 #endif /* CONFIG_TESTING_OPTIONS */
1747
1748
1749 static int wpa_cli_cmd_roam(struct wpa_ctrl *ctrl, int argc, char *argv[])
1750 {
1751         return wpa_cli_cmd(ctrl, "ROAM", 1, argc, argv);
1752 }
1753
1754
1755 #ifdef CONFIG_MESH
1756
1757 static int wpa_cli_cmd_mesh_interface_add(struct wpa_ctrl *ctrl, int argc,
1758                                           char *argv[])
1759 {
1760         return wpa_cli_cmd(ctrl, "MESH_INTERFACE_ADD", 0, argc, argv);
1761 }
1762
1763
1764 static int wpa_cli_cmd_mesh_group_add(struct wpa_ctrl *ctrl, int argc,
1765                                       char *argv[])
1766 {
1767         return wpa_cli_cmd(ctrl, "MESH_GROUP_ADD", 1, argc, argv);
1768 }
1769
1770
1771 static int wpa_cli_cmd_mesh_group_remove(struct wpa_ctrl *ctrl, int argc,
1772                                          char *argv[])
1773 {
1774         return wpa_cli_cmd(ctrl, "MESH_GROUP_REMOVE", 1, argc, argv);
1775 }
1776
1777 #endif /* CONFIG_MESH */
1778
1779
1780 #ifdef CONFIG_P2P
1781
1782 static int wpa_cli_cmd_p2p_find(struct wpa_ctrl *ctrl, int argc, char *argv[])
1783 {
1784         return wpa_cli_cmd(ctrl, "P2P_FIND", 0, argc, argv);
1785 }
1786
1787
1788 static char ** wpa_cli_complete_p2p_find(const char *str, int pos)
1789 {
1790         char **res = NULL;
1791         int arg = get_cmd_arg_num(str, pos);
1792
1793         res = os_calloc(6, sizeof(char *));
1794         if (res == NULL)
1795                 return NULL;
1796         res[0] = os_strdup("type=social");
1797         if (res[0] == NULL) {
1798                 os_free(res);
1799                 return NULL;
1800         }
1801         res[1] = os_strdup("type=progressive");
1802         if (res[1] == NULL)
1803                 return res;
1804         res[2] = os_strdup("delay=");
1805         if (res[2] == NULL)
1806                 return res;
1807         res[3] = os_strdup("dev_id=");
1808         if (res[3] == NULL)
1809                 return res;
1810         if (arg == 1)
1811                 res[4] = os_strdup("[timeout]");
1812
1813         return res;
1814 }
1815
1816
1817 static int wpa_cli_cmd_p2p_stop_find(struct wpa_ctrl *ctrl, int argc,
1818                                      char *argv[])
1819 {
1820         return wpa_ctrl_command(ctrl, "P2P_STOP_FIND");
1821 }
1822
1823
1824 static int wpa_cli_cmd_p2p_connect(struct wpa_ctrl *ctrl, int argc,
1825                                    char *argv[])
1826 {
1827         return wpa_cli_cmd(ctrl, "P2P_CONNECT", 2, argc, argv);
1828 }
1829
1830
1831 static char ** wpa_cli_complete_p2p_connect(const char *str, int pos)
1832 {
1833         int arg = get_cmd_arg_num(str, pos);
1834         char **res = NULL;
1835
1836         switch (arg) {
1837         case 1:
1838                 res = cli_txt_list_array(&p2p_peers);
1839                 break;
1840         }
1841
1842         return res;
1843 }
1844
1845
1846 static int wpa_cli_cmd_p2p_listen(struct wpa_ctrl *ctrl, int argc,
1847                                   char *argv[])
1848 {
1849         return wpa_cli_cmd(ctrl, "P2P_LISTEN", 0, argc, argv);
1850 }
1851
1852
1853 static int wpa_cli_cmd_p2p_group_remove(struct wpa_ctrl *ctrl, int argc,
1854                                         char *argv[])
1855 {
1856         return wpa_cli_cmd(ctrl, "P2P_GROUP_REMOVE", 1, argc, argv);
1857 }
1858
1859
1860 static char ** wpa_cli_complete_p2p_group_remove(const char *str, int pos)
1861 {
1862         int arg = get_cmd_arg_num(str, pos);
1863         char **res = NULL;
1864
1865         switch (arg) {
1866         case 1:
1867                 res = cli_txt_list_array(&p2p_groups);
1868                 break;
1869         }
1870
1871         return res;
1872 }
1873
1874
1875 static int wpa_cli_cmd_p2p_group_add(struct wpa_ctrl *ctrl, int argc,
1876                                         char *argv[])
1877 {
1878         return wpa_cli_cmd(ctrl, "P2P_GROUP_ADD", 0, argc, argv);
1879 }
1880
1881
1882 static int wpa_cli_cmd_p2p_prov_disc(struct wpa_ctrl *ctrl, int argc,
1883                                      char *argv[])
1884 {
1885         if (argc != 2 && argc != 3) {
1886                 printf("Invalid P2P_PROV_DISC command: needs at least "
1887                        "two arguments, address and config method\n"
1888                        "(display, keypad, or pbc) and an optional join\n");
1889                 return -1;
1890         }
1891
1892         return wpa_cli_cmd(ctrl, "P2P_PROV_DISC", 2, argc, argv);
1893 }
1894
1895
1896 static int wpa_cli_cmd_p2p_get_passphrase(struct wpa_ctrl *ctrl, int argc,
1897                                           char *argv[])
1898 {
1899         return wpa_ctrl_command(ctrl, "P2P_GET_PASSPHRASE");
1900 }
1901
1902
1903 static int wpa_cli_cmd_p2p_serv_disc_req(struct wpa_ctrl *ctrl, int argc,
1904                                          char *argv[])
1905 {
1906         char cmd[4096];
1907
1908         if (argc != 2 && argc != 4) {
1909                 printf("Invalid P2P_SERV_DISC_REQ command: needs two "
1910                        "arguments (address and TLVs) or four arguments "
1911                        "(address, \"upnp\", version, search target "
1912                        "(SSDP ST:)\n");
1913                 return -1;
1914         }
1915
1916         if (write_cmd(cmd, sizeof(cmd), "P2P_SERV_DISC_REQ", argc, argv) < 0)
1917                 return -1;
1918         return wpa_ctrl_command(ctrl, cmd);
1919 }
1920
1921
1922 static int wpa_cli_cmd_p2p_serv_disc_cancel_req(struct wpa_ctrl *ctrl,
1923                                                 int argc, char *argv[])
1924 {
1925         return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_CANCEL_REQ", 1, argc, argv);
1926 }
1927
1928
1929 static int wpa_cli_cmd_p2p_serv_disc_resp(struct wpa_ctrl *ctrl, int argc,
1930                                           char *argv[])
1931 {
1932         char cmd[4096];
1933         int res;
1934
1935         if (argc != 4) {
1936                 printf("Invalid P2P_SERV_DISC_RESP command: needs four "
1937                        "arguments (freq, address, dialog token, and TLVs)\n");
1938                 return -1;
1939         }
1940
1941         res = os_snprintf(cmd, sizeof(cmd), "P2P_SERV_DISC_RESP %s %s %s %s",
1942                           argv[0], argv[1], argv[2], argv[3]);
1943         if (os_snprintf_error(sizeof(cmd), res))
1944                 return -1;
1945         cmd[sizeof(cmd) - 1] = '\0';
1946         return wpa_ctrl_command(ctrl, cmd);
1947 }
1948
1949
1950 static int wpa_cli_cmd_p2p_service_update(struct wpa_ctrl *ctrl, int argc,
1951                                           char *argv[])
1952 {
1953         return wpa_ctrl_command(ctrl, "P2P_SERVICE_UPDATE");
1954 }
1955
1956
1957 static int wpa_cli_cmd_p2p_serv_disc_external(struct wpa_ctrl *ctrl,
1958                                               int argc, char *argv[])
1959 {
1960         return wpa_cli_cmd(ctrl, "P2P_SERV_DISC_EXTERNAL", 1, argc, argv);
1961 }
1962
1963
1964 static int wpa_cli_cmd_p2p_service_flush(struct wpa_ctrl *ctrl, int argc,
1965                                          char *argv[])
1966 {
1967         return wpa_ctrl_command(ctrl, "P2P_SERVICE_FLUSH");
1968 }
1969
1970
1971 static int wpa_cli_cmd_p2p_service_add(struct wpa_ctrl *ctrl, int argc,
1972                                        char *argv[])
1973 {
1974         char cmd[4096];
1975         int res;
1976
1977         if (argc != 3 && argc != 4) {
1978                 printf("Invalid P2P_SERVICE_ADD command: needs three or four "
1979                        "arguments\n");
1980                 return -1;
1981         }
1982
1983         if (argc == 4)
1984                 res = os_snprintf(cmd, sizeof(cmd),
1985                                   "P2P_SERVICE_ADD %s %s %s %s",
1986                                   argv[0], argv[1], argv[2], argv[3]);
1987         else
1988                 res = os_snprintf(cmd, sizeof(cmd),
1989                                   "P2P_SERVICE_ADD %s %s %s",
1990                                   argv[0], argv[1], argv[2]);
1991         if (os_snprintf_error(sizeof(cmd), res))
1992                 return -1;
1993         cmd[sizeof(cmd) - 1] = '\0';
1994         return wpa_ctrl_command(ctrl, cmd);
1995 }
1996
1997
1998 static int wpa_cli_cmd_p2p_service_del(struct wpa_ctrl *ctrl, int argc,
1999                                        char *argv[])
2000 {
2001         char cmd[4096];
2002         int res;
2003
2004         if (argc != 2 && argc != 3) {
2005                 printf("Invalid P2P_SERVICE_DEL command: needs two or three "
2006                        "arguments\n");
2007                 return -1;
2008         }
2009
2010         if (argc == 3)
2011                 res = os_snprintf(cmd, sizeof(cmd),
2012                                   "P2P_SERVICE_DEL %s %s %s",
2013                                   argv[0], argv[1], argv[2]);
2014         else
2015                 res = os_snprintf(cmd, sizeof(cmd),
2016                                   "P2P_SERVICE_DEL %s %s",
2017                                   argv[0], argv[1]);
2018         if (os_snprintf_error(sizeof(cmd), res))
2019                 return -1;
2020         cmd[sizeof(cmd) - 1] = '\0';
2021         return wpa_ctrl_command(ctrl, cmd);
2022 }
2023
2024
2025 static int wpa_cli_cmd_p2p_reject(struct wpa_ctrl *ctrl,
2026                                   int argc, char *argv[])
2027 {
2028         return wpa_cli_cmd(ctrl, "P2P_REJECT", 1, argc, argv);
2029 }
2030
2031
2032 static int wpa_cli_cmd_p2p_invite(struct wpa_ctrl *ctrl,
2033                                   int argc, char *argv[])
2034 {
2035         return wpa_cli_cmd(ctrl, "P2P_INVITE", 1, argc, argv);
2036 }
2037
2038
2039 static int wpa_cli_cmd_p2p_peer(struct wpa_ctrl *ctrl, int argc, char *argv[])
2040 {
2041         return wpa_cli_cmd(ctrl, "P2P_PEER", 1, argc, argv);
2042 }
2043
2044
2045 static char ** wpa_cli_complete_p2p_peer(const char *str, int pos)
2046 {
2047         int arg = get_cmd_arg_num(str, pos);
2048         char **res = NULL;
2049
2050         switch (arg) {
2051         case 1:
2052                 res = cli_txt_list_array(&p2p_peers);
2053                 break;
2054         }
2055
2056         return res;
2057 }
2058
2059
2060 static int wpa_ctrl_command_p2p_peer(struct wpa_ctrl *ctrl, char *cmd,
2061                                      char *addr, size_t addr_len,
2062                                      int discovered)
2063 {
2064         char buf[4096], *pos;
2065         size_t len;
2066         int ret;
2067
2068         if (ctrl_conn == NULL)
2069                 return -1;
2070         len = sizeof(buf) - 1;
2071         ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,
2072                                wpa_cli_msg_cb);
2073         if (ret == -2) {
2074                 printf("'%s' command timed out.\n", cmd);
2075                 return -2;
2076         } else if (ret < 0) {
2077                 printf("'%s' command failed.\n", cmd);
2078                 return -1;
2079         }
2080
2081         buf[len] = '\0';
2082         if (os_memcmp(buf, "FAIL", 4) == 0)
2083                 return -1;
2084
2085         pos = buf;
2086         while (*pos != '\0' && *pos != '\n')
2087                 pos++;
2088         *pos++ = '\0';
2089         os_strlcpy(addr, buf, addr_len);
2090         if (!discovered || os_strstr(pos, "[PROBE_REQ_ONLY]") == NULL)
2091                 printf("%s\n", addr);
2092         return 0;
2093 }
2094
2095
2096 static int wpa_cli_cmd_p2p_peers(struct wpa_ctrl *ctrl, int argc, char *argv[])
2097 {
2098         char addr[32], cmd[64];
2099         int discovered;
2100
2101         discovered = argc > 0 && os_strcmp(argv[0], "discovered") == 0;
2102
2103         if (wpa_ctrl_command_p2p_peer(ctrl, "P2P_PEER FIRST",
2104                                       addr, sizeof(addr), discovered))
2105                 return -1;
2106         do {
2107                 os_snprintf(cmd, sizeof(cmd), "P2P_PEER NEXT-%s", addr);
2108         } while (wpa_ctrl_command_p2p_peer(ctrl, cmd, addr, sizeof(addr),
2109                          discovered) == 0);
2110
2111         return 0;
2112 }
2113
2114
2115 static int wpa_cli_cmd_p2p_set(struct wpa_ctrl *ctrl, int argc, char *argv[])
2116 {
2117         return wpa_cli_cmd(ctrl, "P2P_SET", 2, argc, argv);
2118 }
2119
2120
2121 static char ** wpa_cli_complete_p2p_set(const char *str, int pos)
2122 {
2123         int arg = get_cmd_arg_num(str, pos);
2124         const char *fields[] = {
2125                 "discoverability",
2126                 "managed",
2127                 "listen_channel",
2128                 "ssid_postfix",
2129                 "noa",
2130                 "ps",
2131                 "oppps",
2132                 "ctwindow",
2133                 "disabled",
2134                 "conc_pref",
2135                 "force_long_sd",
2136                 "peer_filter",
2137                 "cross_connect",
2138                 "go_apsd",
2139                 "client_apsd",
2140                 "disallow_freq",
2141                 "disc_int",
2142                 "per_sta_psk",
2143         };
2144         int i, num_fields = ARRAY_SIZE(fields);
2145
2146         if (arg == 1) {
2147                 char **res = os_calloc(num_fields + 1, sizeof(char *));
2148                 if (res == NULL)
2149                         return NULL;
2150                 for (i = 0; i < num_fields; i++) {
2151                         res[i] = os_strdup(fields[i]);
2152                         if (res[i] == NULL)
2153                                 return res;
2154                 }
2155                 return res;
2156         }
2157
2158         if (arg == 2 && os_strncasecmp(str, "p2p_set peer_filter ", 20) == 0)
2159                 return cli_txt_list_array(&p2p_peers);
2160
2161         return NULL;
2162 }
2163
2164
2165 static int wpa_cli_cmd_p2p_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2166 {
2167         return wpa_ctrl_command(ctrl, "P2P_FLUSH");
2168 }
2169
2170
2171 static int wpa_cli_cmd_p2p_cancel(struct wpa_ctrl *ctrl, int argc,
2172                                   char *argv[])
2173 {
2174         return wpa_ctrl_command(ctrl, "P2P_CANCEL");
2175 }
2176
2177
2178 static int wpa_cli_cmd_p2p_unauthorize(struct wpa_ctrl *ctrl, int argc,
2179                                        char *argv[])
2180 {
2181         return wpa_cli_cmd(ctrl, "P2P_UNAUTHORIZE", 1, argc, argv);
2182 }
2183
2184
2185 static int wpa_cli_cmd_p2p_presence_req(struct wpa_ctrl *ctrl, int argc,
2186                                         char *argv[])
2187 {
2188         if (argc != 0 && argc != 2 && argc != 4) {
2189                 printf("Invalid P2P_PRESENCE_REQ command: needs two arguments "
2190                        "(preferred duration, interval; in microsecods).\n"
2191                        "Optional second pair can be used to provide "
2192                        "acceptable values.\n");
2193                 return -1;
2194         }
2195
2196         return wpa_cli_cmd(ctrl, "P2P_PRESENCE_REQ", 0, argc, argv);
2197 }
2198
2199
2200 static int wpa_cli_cmd_p2p_ext_listen(struct wpa_ctrl *ctrl, int argc,
2201                                       char *argv[])
2202 {
2203         if (argc != 0 && argc != 2) {
2204                 printf("Invalid P2P_EXT_LISTEN command: needs two arguments "
2205                        "(availability period, availability interval; in "
2206                        "millisecods).\n"
2207                        "Extended Listen Timing can be cancelled with this "
2208                        "command when used without parameters.\n");
2209                 return -1;
2210         }
2211
2212         return wpa_cli_cmd(ctrl, "P2P_EXT_LISTEN", 0, argc, argv);
2213 }
2214
2215
2216 static int wpa_cli_cmd_p2p_remove_client(struct wpa_ctrl *ctrl, int argc,
2217                                          char *argv[])
2218 {
2219         return wpa_cli_cmd(ctrl, "P2P_REMOVE_CLIENT", 1, argc, argv);
2220 }
2221
2222 #endif /* CONFIG_P2P */
2223
2224 #ifdef CONFIG_WIFI_DISPLAY
2225
2226 static int wpa_cli_cmd_wfd_subelem_set(struct wpa_ctrl *ctrl, int argc,
2227                                        char *argv[])
2228 {
2229         char cmd[100];
2230         int res;
2231
2232         if (argc != 1 && argc != 2) {
2233                 printf("Invalid WFD_SUBELEM_SET command: needs one or two "
2234                        "arguments (subelem, hexdump)\n");
2235                 return -1;
2236         }
2237
2238         res = os_snprintf(cmd, sizeof(cmd), "WFD_SUBELEM_SET %s %s",
2239                           argv[0], argc > 1 ? argv[1] : "");
2240         if (os_snprintf_error(sizeof(cmd), res))
2241                 return -1;
2242         cmd[sizeof(cmd) - 1] = '\0';
2243         return wpa_ctrl_command(ctrl, cmd);
2244 }
2245
2246
2247 static int wpa_cli_cmd_wfd_subelem_get(struct wpa_ctrl *ctrl, int argc,
2248                                        char *argv[])
2249 {
2250         char cmd[100];
2251         int res;
2252
2253         if (argc != 1) {
2254                 printf("Invalid WFD_SUBELEM_GET command: needs one "
2255                        "argument (subelem)\n");
2256                 return -1;
2257         }
2258
2259         res = os_snprintf(cmd, sizeof(cmd), "WFD_SUBELEM_GET %s",
2260                           argv[0]);
2261         if (os_snprintf_error(sizeof(cmd), res))
2262                 return -1;
2263         cmd[sizeof(cmd) - 1] = '\0';
2264         return wpa_ctrl_command(ctrl, cmd);
2265 }
2266 #endif /* CONFIG_WIFI_DISPLAY */
2267
2268
2269 #ifdef CONFIG_INTERWORKING
2270 static int wpa_cli_cmd_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
2271                                   char *argv[])
2272 {
2273         return wpa_ctrl_command(ctrl, "FETCH_ANQP");
2274 }
2275
2276
2277 static int wpa_cli_cmd_stop_fetch_anqp(struct wpa_ctrl *ctrl, int argc,
2278                                        char *argv[])
2279 {
2280         return wpa_ctrl_command(ctrl, "STOP_FETCH_ANQP");
2281 }
2282
2283
2284 static int wpa_cli_cmd_interworking_select(struct wpa_ctrl *ctrl, int argc,
2285                                            char *argv[])
2286 {
2287         return wpa_cli_cmd(ctrl, "INTERWORKING_SELECT", 0, argc, argv);
2288 }
2289
2290
2291 static int wpa_cli_cmd_interworking_connect(struct wpa_ctrl *ctrl, int argc,
2292                                             char *argv[])
2293 {
2294         return wpa_cli_cmd(ctrl, "INTERWORKING_CONNECT", 1, argc, argv);
2295 }
2296
2297
2298 static int wpa_cli_cmd_anqp_get(struct wpa_ctrl *ctrl, int argc, char *argv[])
2299 {
2300         return wpa_cli_cmd(ctrl, "ANQP_GET", 2, argc, argv);
2301 }
2302
2303
2304 static int wpa_cli_cmd_gas_request(struct wpa_ctrl *ctrl, int argc,
2305                                    char *argv[])
2306 {
2307         return wpa_cli_cmd(ctrl, "GAS_REQUEST", 2, argc, argv);
2308 }
2309
2310
2311 static int wpa_cli_cmd_gas_response_get(struct wpa_ctrl *ctrl, int argc,
2312                                         char *argv[])
2313 {
2314         return wpa_cli_cmd(ctrl, "GAS_RESPONSE_GET", 2, argc, argv);
2315 }
2316 #endif /* CONFIG_INTERWORKING */
2317
2318
2319 #ifdef CONFIG_HS20
2320
2321 static int wpa_cli_cmd_hs20_anqp_get(struct wpa_ctrl *ctrl, int argc,
2322                                      char *argv[])
2323 {
2324         return wpa_cli_cmd(ctrl, "HS20_ANQP_GET", 2, argc, argv);
2325 }
2326
2327
2328 static int wpa_cli_cmd_get_nai_home_realm_list(struct wpa_ctrl *ctrl, int argc,
2329                                                char *argv[])
2330 {
2331         char cmd[512];
2332
2333         if (argc == 0) {
2334                 printf("Command needs one or two arguments (dst mac addr and "
2335                        "optional home realm)\n");
2336                 return -1;
2337         }
2338
2339         if (write_cmd(cmd, sizeof(cmd), "HS20_GET_NAI_HOME_REALM_LIST",
2340                       argc, argv) < 0)
2341                 return -1;
2342
2343         return wpa_ctrl_command(ctrl, cmd);
2344 }
2345
2346
2347 static int wpa_cli_cmd_hs20_icon_request(struct wpa_ctrl *ctrl, int argc,
2348                                          char *argv[])
2349 {
2350         char cmd[512];
2351
2352         if (argc < 2) {
2353                 printf("Command needs two arguments (dst mac addr and "
2354                        "icon name)\n");
2355                 return -1;
2356         }
2357
2358         if (write_cmd(cmd, sizeof(cmd), "HS20_ICON_REQUEST", argc, argv) < 0)
2359                 return -1;
2360
2361         return wpa_ctrl_command(ctrl, cmd);
2362 }
2363
2364
2365 static int wpa_cli_cmd_fetch_osu(struct wpa_ctrl *ctrl, int argc, char *argv[])
2366 {
2367         return wpa_ctrl_command(ctrl, "FETCH_OSU");
2368 }
2369
2370
2371 static int wpa_cli_cmd_cancel_fetch_osu(struct wpa_ctrl *ctrl, int argc,
2372                                         char *argv[])
2373 {
2374         return wpa_ctrl_command(ctrl, "CANCEL_FETCH_OSU");
2375 }
2376
2377 #endif /* CONFIG_HS20 */
2378
2379
2380 static int wpa_cli_cmd_sta_autoconnect(struct wpa_ctrl *ctrl, int argc,
2381                                        char *argv[])
2382 {
2383         return wpa_cli_cmd(ctrl, "STA_AUTOCONNECT", 1, argc, argv);
2384 }
2385
2386
2387 static int wpa_cli_cmd_tdls_discover(struct wpa_ctrl *ctrl, int argc,
2388                                      char *argv[])
2389 {
2390         return wpa_cli_cmd(ctrl, "TDLS_DISCOVER", 1, argc, argv);
2391 }
2392
2393
2394 static int wpa_cli_cmd_tdls_setup(struct wpa_ctrl *ctrl, int argc,
2395                                   char *argv[])
2396 {
2397         return wpa_cli_cmd(ctrl, "TDLS_SETUP", 1, argc, argv);
2398 }
2399
2400
2401 static int wpa_cli_cmd_tdls_teardown(struct wpa_ctrl *ctrl, int argc,
2402                                      char *argv[])
2403 {
2404         return wpa_cli_cmd(ctrl, "TDLS_TEARDOWN", 1, argc, argv);
2405 }
2406
2407
2408 static int wpa_cli_cmd_wmm_ac_addts(struct wpa_ctrl *ctrl, int argc,
2409                                     char *argv[])
2410 {
2411         return wpa_cli_cmd(ctrl, "WMM_AC_ADDTS", 3, argc, argv);
2412 }
2413
2414
2415 static int wpa_cli_cmd_wmm_ac_delts(struct wpa_ctrl *ctrl, int argc,
2416                                     char *argv[])
2417 {
2418         return wpa_cli_cmd(ctrl, "WMM_AC_DELTS", 1, argc, argv);
2419 }
2420
2421
2422 static int wpa_cli_cmd_wmm_ac_status(struct wpa_ctrl *ctrl, int argc,
2423                                     char *argv[])
2424 {
2425         return wpa_ctrl_command(ctrl, "WMM_AC_STATUS");
2426 }
2427
2428
2429 static int wpa_cli_cmd_tdls_chan_switch(struct wpa_ctrl *ctrl, int argc,
2430                                         char *argv[])
2431 {
2432         return wpa_cli_cmd(ctrl, "TDLS_CHAN_SWITCH", 2, argc, argv);
2433 }
2434
2435
2436 static int wpa_cli_cmd_tdls_cancel_chan_switch(struct wpa_ctrl *ctrl, int argc,
2437                                                char *argv[])
2438 {
2439         return wpa_cli_cmd(ctrl, "TDLS_CANCEL_CHAN_SWITCH", 1, argc, argv);
2440 }
2441
2442
2443 static int wpa_cli_cmd_signal_poll(struct wpa_ctrl *ctrl, int argc,
2444                                    char *argv[])
2445 {
2446         return wpa_ctrl_command(ctrl, "SIGNAL_POLL");
2447 }
2448
2449
2450 static int wpa_cli_cmd_pktcnt_poll(struct wpa_ctrl *ctrl, int argc,
2451                                    char *argv[])
2452 {
2453         return wpa_ctrl_command(ctrl, "PKTCNT_POLL");
2454 }
2455
2456
2457 static int wpa_cli_cmd_reauthenticate(struct wpa_ctrl *ctrl, int argc,
2458                                       char *argv[])
2459 {
2460         return wpa_ctrl_command(ctrl, "REAUTHENTICATE");
2461 }
2462
2463
2464 #ifdef CONFIG_AUTOSCAN
2465
2466 static int wpa_cli_cmd_autoscan(struct wpa_ctrl *ctrl, int argc, char *argv[])
2467 {
2468         if (argc == 0)
2469                 return wpa_ctrl_command(ctrl, "AUTOSCAN ");
2470
2471         return wpa_cli_cmd(ctrl, "AUTOSCAN", 0, argc, argv);
2472 }
2473
2474 #endif /* CONFIG_AUTOSCAN */
2475
2476
2477 #ifdef CONFIG_WNM
2478
2479 static int wpa_cli_cmd_wnm_sleep(struct wpa_ctrl *ctrl, int argc, char *argv[])
2480 {
2481         return wpa_cli_cmd(ctrl, "WNM_SLEEP", 0, argc, argv);
2482 }
2483
2484
2485 static int wpa_cli_cmd_wnm_bss_query(struct wpa_ctrl *ctrl, int argc, char *argv[])
2486 {
2487         return wpa_cli_cmd(ctrl, "WNM_BSS_QUERY", 1, argc, argv);
2488 }
2489
2490 #endif /* CONFIG_WNM */
2491
2492
2493 static int wpa_cli_cmd_raw(struct wpa_ctrl *ctrl, int argc, char *argv[])
2494 {
2495         if (argc == 0)
2496                 return -1;
2497         return wpa_cli_cmd(ctrl, argv[0], 0, argc - 1, &argv[1]);
2498 }
2499
2500
2501 #ifdef ANDROID
2502 static int wpa_cli_cmd_driver(struct wpa_ctrl *ctrl, int argc, char *argv[])
2503 {
2504         return wpa_cli_cmd(ctrl, "DRIVER", 1, argc, argv);
2505 }
2506 #endif /* ANDROID */
2507
2508
2509 static int wpa_cli_cmd_vendor(struct wpa_ctrl *ctrl, int argc, char *argv[])
2510 {
2511         return wpa_cli_cmd(ctrl, "VENDOR", 1, argc, argv);
2512 }
2513
2514
2515 static int wpa_cli_cmd_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2516 {
2517         return wpa_ctrl_command(ctrl, "FLUSH");
2518 }
2519
2520
2521 static int wpa_cli_cmd_radio_work(struct wpa_ctrl *ctrl, int argc, char *argv[])
2522 {
2523         return wpa_cli_cmd(ctrl, "RADIO_WORK", 1, argc, argv);
2524 }
2525
2526
2527 static int wpa_cli_cmd_neighbor_rep_request(struct wpa_ctrl *ctrl, int argc,
2528                                             char *argv[])
2529 {
2530         return wpa_cli_cmd(ctrl, "NEIGHBOR_REP_REQUEST", 0, argc, argv);
2531 }
2532
2533
2534 static int wpa_cli_cmd_erp_flush(struct wpa_ctrl *ctrl, int argc, char *argv[])
2535 {
2536         return wpa_ctrl_command(ctrl, "ERP_FLUSH");
2537 }
2538
2539
2540 static int wpa_cli_cmd_mac_rand_scan(struct wpa_ctrl *ctrl, int argc,
2541                                      char *argv[])
2542 {
2543         return wpa_cli_cmd(ctrl, "MAC_RAND_SCAN", 1, argc, argv);
2544 }
2545
2546
2547 enum wpa_cli_cmd_flags {
2548         cli_cmd_flag_none               = 0x00,
2549         cli_cmd_flag_sensitive          = 0x01
2550 };
2551
2552 struct wpa_cli_cmd {
2553         const char *cmd;
2554         int (*handler)(struct wpa_ctrl *ctrl, int argc, char *argv[]);
2555         char ** (*completion)(const char *str, int pos);
2556         enum wpa_cli_cmd_flags flags;
2557         const char *usage;
2558 };
2559
2560 static struct wpa_cli_cmd wpa_cli_commands[] = {
2561         { "status", wpa_cli_cmd_status, NULL,
2562           cli_cmd_flag_none,
2563           "[verbose] = get current WPA/EAPOL/EAP status" },
2564         { "ifname", wpa_cli_cmd_ifname, NULL,
2565           cli_cmd_flag_none,
2566           "= get current interface name" },
2567         { "ping", wpa_cli_cmd_ping, NULL,
2568           cli_cmd_flag_none,
2569           "= pings wpa_supplicant" },
2570         { "relog", wpa_cli_cmd_relog, NULL,
2571           cli_cmd_flag_none,
2572           "= re-open log-file (allow rolling logs)" },
2573         { "note", wpa_cli_cmd_note, NULL,
2574           cli_cmd_flag_none,
2575           "<text> = add a note to wpa_supplicant debug log" },
2576         { "mib", wpa_cli_cmd_mib, NULL,
2577           cli_cmd_flag_none,
2578           "= get MIB variables (dot1x, dot11)" },
2579         { "help", wpa_cli_cmd_help, wpa_cli_complete_help,
2580           cli_cmd_flag_none,
2581           "[command] = show usage help" },
2582         { "interface", wpa_cli_cmd_interface, NULL,
2583           cli_cmd_flag_none,
2584           "[ifname] = show interfaces/select interface" },
2585         { "level", wpa_cli_cmd_level, NULL,
2586           cli_cmd_flag_none,
2587           "<debug level> = change debug level" },
2588         { "license", wpa_cli_cmd_license, NULL,
2589           cli_cmd_flag_none,
2590           "= show full wpa_cli license" },
2591         { "quit", wpa_cli_cmd_quit, NULL,
2592           cli_cmd_flag_none,
2593           "= exit wpa_cli" },
2594         { "set", wpa_cli_cmd_set, wpa_cli_complete_set,
2595           cli_cmd_flag_none,
2596           "= set variables (shows list of variables when run without "
2597           "arguments)" },
2598         { "get", wpa_cli_cmd_get, NULL,
2599           cli_cmd_flag_none,
2600           "<name> = get information" },
2601         { "logon", wpa_cli_cmd_logon, NULL,
2602           cli_cmd_flag_none,
2603           "= IEEE 802.1X EAPOL state machine logon" },
2604         { "logoff", wpa_cli_cmd_logoff, NULL,
2605           cli_cmd_flag_none,
2606           "= IEEE 802.1X EAPOL state machine logoff" },
2607         { "pmksa", wpa_cli_cmd_pmksa, NULL,
2608           cli_cmd_flag_none,
2609           "= show PMKSA cache" },
2610         { "pmksa_flush", wpa_cli_cmd_pmksa_flush, NULL,
2611           cli_cmd_flag_none,
2612           "= flush PMKSA cache entries" },
2613         { "reassociate", wpa_cli_cmd_reassociate, NULL,
2614           cli_cmd_flag_none,
2615           "= force reassociation" },
2616         { "reattach", wpa_cli_cmd_reattach, NULL,
2617           cli_cmd_flag_none,
2618           "= force reassociation back to the same BSS" },
2619         { "preauthenticate", wpa_cli_cmd_preauthenticate, wpa_cli_complete_bss,
2620           cli_cmd_flag_none,
2621           "<BSSID> = force preauthentication" },
2622         { "identity", wpa_cli_cmd_identity, NULL,
2623           cli_cmd_flag_none,
2624           "<network id> <identity> = configure identity for an SSID" },
2625         { "password", wpa_cli_cmd_password, NULL,
2626           cli_cmd_flag_sensitive,
2627           "<network id> <password> = configure password for an SSID" },
2628         { "new_password", wpa_cli_cmd_new_password, NULL,
2629           cli_cmd_flag_sensitive,
2630           "<network id> <password> = change password for an SSID" },
2631         { "pin", wpa_cli_cmd_pin, NULL,
2632           cli_cmd_flag_sensitive,
2633           "<network id> <pin> = configure pin for an SSID" },
2634         { "otp", wpa_cli_cmd_otp, NULL,
2635           cli_cmd_flag_sensitive,
2636           "<network id> <password> = configure one-time-password for an SSID"
2637         },
2638         { "passphrase", wpa_cli_cmd_passphrase, NULL,
2639           cli_cmd_flag_sensitive,
2640           "<network id> <passphrase> = configure private key passphrase\n"
2641           "  for an SSID" },
2642         { "sim", wpa_cli_cmd_sim, NULL,
2643           cli_cmd_flag_sensitive,
2644           "<network id> <pin> = report SIM operation result" },
2645         { "bssid", wpa_cli_cmd_bssid, NULL,
2646           cli_cmd_flag_none,
2647           "<network id> <BSSID> = set preferred BSSID for an SSID" },
2648         { "blacklist", wpa_cli_cmd_blacklist, wpa_cli_complete_bss,
2649           cli_cmd_flag_none,
2650           "<BSSID> = add a BSSID to the blacklist\n"
2651           "blacklist clear = clear the blacklist\n"
2652           "blacklist = display the blacklist" },
2653         { "log_level", wpa_cli_cmd_log_level, NULL,
2654           cli_cmd_flag_none,
2655           "<level> [<timestamp>] = update the log level/timestamp\n"
2656           "log_level = display the current log level and log options" },
2657         { "list_networks", wpa_cli_cmd_list_networks, NULL,
2658           cli_cmd_flag_none,
2659           "= list configured networks" },
2660         { "select_network", wpa_cli_cmd_select_network, NULL,
2661           cli_cmd_flag_none,
2662           "<network id> = select a network (disable others)" },
2663         { "enable_network", wpa_cli_cmd_enable_network, NULL,
2664           cli_cmd_flag_none,
2665           "<network id> = enable a network" },
2666         { "disable_network", wpa_cli_cmd_disable_network, NULL,
2667           cli_cmd_flag_none,
2668           "<network id> = disable a network" },
2669         { "add_network", wpa_cli_cmd_add_network, NULL,
2670           cli_cmd_flag_none,
2671           "= add a network" },
2672         { "remove_network", wpa_cli_cmd_remove_network, NULL,
2673           cli_cmd_flag_none,
2674           "<network id> = remove a network" },
2675         { "set_network", wpa_cli_cmd_set_network, NULL,
2676           cli_cmd_flag_sensitive,
2677           "<network id> <variable> <value> = set network variables (shows\n"
2678           "  list of variables when run without arguments)" },
2679         { "get_network", wpa_cli_cmd_get_network, NULL,
2680           cli_cmd_flag_none,
2681           "<network id> <variable> = get network variables" },
2682         { "dup_network", wpa_cli_cmd_dup_network, NULL,
2683           cli_cmd_flag_none,
2684           "<src network id> <dst network id> <variable> = duplicate network variables"
2685         },
2686         { "list_creds", wpa_cli_cmd_list_creds, NULL,
2687           cli_cmd_flag_none,
2688           "= list configured credentials" },
2689         { "add_cred", wpa_cli_cmd_add_cred, NULL,
2690           cli_cmd_flag_none,
2691           "= add a credential" },
2692         { "remove_cred", wpa_cli_cmd_remove_cred, NULL,
2693           cli_cmd_flag_none,
2694           "<cred id> = remove a credential" },
2695         { "set_cred", wpa_cli_cmd_set_cred, NULL,
2696           cli_cmd_flag_sensitive,
2697           "<cred id> <variable> <value> = set credential variables" },
2698         { "get_cred", wpa_cli_cmd_get_cred, NULL,
2699           cli_cmd_flag_none,
2700           "<cred id> <variable> = get credential variables" },
2701         { "save_config", wpa_cli_cmd_save_config, NULL,
2702           cli_cmd_flag_none,
2703           "= save the current configuration" },
2704         { "disconnect", wpa_cli_cmd_disconnect, NULL,
2705           cli_cmd_flag_none,
2706           "= disconnect and wait for reassociate/reconnect command before\n"
2707           "  connecting" },
2708         { "reconnect", wpa_cli_cmd_reconnect, NULL,
2709           cli_cmd_flag_none,
2710           "= like reassociate, but only takes effect if already disconnected"
2711         },
2712         { "scan", wpa_cli_cmd_scan, NULL,
2713           cli_cmd_flag_none,
2714           "= request new BSS scan" },
2715         { "scan_results", wpa_cli_cmd_scan_results, NULL,
2716           cli_cmd_flag_none,
2717           "= get latest scan results" },
2718         { "bss", wpa_cli_cmd_bss, wpa_cli_complete_bss,
2719           cli_cmd_flag_none,
2720           "<<idx> | <bssid>> = get detailed scan result info" },
2721         { "get_capability", wpa_cli_cmd_get_capability, NULL,
2722           cli_cmd_flag_none,
2723           "<eap/pairwise/group/key_mgmt/proto/auth_alg/channels/freq/modes> "
2724           "= get capabilies" },
2725         { "reconfigure", wpa_cli_cmd_reconfigure, NULL,
2726           cli_cmd_flag_none,
2727           "= force wpa_supplicant to re-read its configuration file" },
2728         { "terminate", wpa_cli_cmd_terminate, NULL,
2729           cli_cmd_flag_none,
2730           "= terminate wpa_supplicant" },
2731         { "interface_add", wpa_cli_cmd_interface_add, NULL,
2732           cli_cmd_flag_none,
2733           "<ifname> <confname> <driver> <ctrl_interface> <driver_param>\n"
2734           "  <bridge_name> = adds new interface, all parameters but <ifname>\n"
2735           "  are optional" },
2736         { "interface_remove", wpa_cli_cmd_interface_remove, NULL,
2737           cli_cmd_flag_none,
2738           "<ifname> = removes the interface" },
2739         { "interface_list", wpa_cli_cmd_interface_list, NULL,
2740           cli_cmd_flag_none,
2741           "= list available interfaces" },
2742         { "ap_scan", wpa_cli_cmd_ap_scan, NULL,
2743           cli_cmd_flag_none,
2744           "<value> = set ap_scan parameter" },
2745         { "scan_interval", wpa_cli_cmd_scan_interval, NULL,
2746           cli_cmd_flag_none,
2747           "<value> = set scan_interval parameter (in seconds)" },
2748         { "bss_expire_age", wpa_cli_cmd_bss_expire_age, NULL,
2749           cli_cmd_flag_none,
2750           "<value> = set BSS expiration age parameter" },
2751         { "bss_expire_count", wpa_cli_cmd_bss_expire_count, NULL,
2752           cli_cmd_flag_none,
2753           "<value> = set BSS expiration scan count parameter" },
2754         { "bss_flush", wpa_cli_cmd_bss_flush, NULL,
2755           cli_cmd_flag_none,
2756           "<value> = set BSS flush age (0 by default)" },
2757         { "stkstart", wpa_cli_cmd_stkstart, NULL,
2758           cli_cmd_flag_none,
2759           "<addr> = request STK negotiation with <addr>" },
2760         { "ft_ds", wpa_cli_cmd_ft_ds, wpa_cli_complete_bss,
2761           cli_cmd_flag_none,
2762           "<addr> = request over-the-DS FT with <addr>" },
2763         { "wps_pbc", wpa_cli_cmd_wps_pbc, wpa_cli_complete_bss,
2764           cli_cmd_flag_none,
2765           "[BSSID] = start Wi-Fi Protected Setup: Push Button Configuration" },
2766         { "wps_pin", wpa_cli_cmd_wps_pin, wpa_cli_complete_bss,
2767           cli_cmd_flag_sensitive,
2768           "<BSSID> [PIN] = start WPS PIN method (returns PIN, if not "
2769           "hardcoded)" },
2770         { "wps_check_pin", wpa_cli_cmd_wps_check_pin, NULL,
2771           cli_cmd_flag_sensitive,
2772           "<PIN> = verify PIN checksum" },
2773         { "wps_cancel", wpa_cli_cmd_wps_cancel, NULL, cli_cmd_flag_none,
2774           "Cancels the pending WPS operation" },
2775 #ifdef CONFIG_WPS_NFC
2776         { "wps_nfc", wpa_cli_cmd_wps_nfc, wpa_cli_complete_bss,
2777           cli_cmd_flag_none,
2778           "[BSSID] = start Wi-Fi Protected Setup: NFC" },
2779         { "wps_nfc_config_token", wpa_cli_cmd_wps_nfc_config_token, NULL,
2780           cli_cmd_flag_none,
2781           "<WPS|NDEF> = build configuration token" },
2782         { "wps_nfc_token", wpa_cli_cmd_wps_nfc_token, NULL,
2783           cli_cmd_flag_none,
2784           "<WPS|NDEF> = create password token" },
2785         { "wps_nfc_tag_read", wpa_cli_cmd_wps_nfc_tag_read, NULL,
2786           cli_cmd_flag_sensitive,
2787           "<hexdump of payload> = report read NFC tag with WPS data" },
2788         { "nfc_get_handover_req", wpa_cli_cmd_nfc_get_handover_req, NULL,
2789           cli_cmd_flag_none,
2790           "<NDEF> <WPS> = create NFC handover request" },
2791         { "nfc_get_handover_sel", wpa_cli_cmd_nfc_get_handover_sel, NULL,
2792           cli_cmd_flag_none,
2793           "<NDEF> <WPS> = create NFC handover select" },
2794         { "nfc_report_handover", wpa_cli_cmd_nfc_report_handover, NULL,
2795           cli_cmd_flag_none,
2796           "<role> <type> <hexdump of req> <hexdump of sel> = report completed "
2797           "NFC handover" },
2798 #endif /* CONFIG_WPS_NFC */
2799         { "wps_reg", wpa_cli_cmd_wps_reg, wpa_cli_complete_bss,
2800           cli_cmd_flag_sensitive,
2801           "<BSSID> <AP PIN> = start WPS Registrar to configure an AP" },
2802         { "wps_ap_pin", wpa_cli_cmd_wps_ap_pin, NULL,
2803           cli_cmd_flag_sensitive,
2804           "[params..] = enable/disable AP PIN" },
2805         { "wps_er_start", wpa_cli_cmd_wps_er_start, NULL,
2806           cli_cmd_flag_none,
2807           "[IP address] = start Wi-Fi Protected Setup External Registrar" },
2808         { "wps_er_stop", wpa_cli_cmd_wps_er_stop, NULL,
2809           cli_cmd_flag_none,
2810           "= stop Wi-Fi Protected Setup External Registrar" },
2811         { "wps_er_pin", wpa_cli_cmd_wps_er_pin, NULL,
2812           cli_cmd_flag_sensitive,
2813           "<UUID> <PIN> = add an Enrollee PIN to External Registrar" },
2814         { "wps_er_pbc", wpa_cli_cmd_wps_er_pbc, NULL,
2815           cli_cmd_flag_none,
2816           "<UUID> = accept an Enrollee PBC using External Registrar" },
2817         { "wps_er_learn", wpa_cli_cmd_wps_er_learn, NULL,
2818           cli_cmd_flag_sensitive,
2819           "<UUID> <PIN> = learn AP configuration" },
2820         { "wps_er_set_config", wpa_cli_cmd_wps_er_set_config, NULL,
2821           cli_cmd_flag_none,
2822           "<UUID> <network id> = set AP configuration for enrolling" },
2823         { "wps_er_config", wpa_cli_cmd_wps_er_config, NULL,
2824           cli_cmd_flag_sensitive,
2825           "<UUID> <PIN> <SSID> <auth> <encr> <key> = configure AP" },
2826 #ifdef CONFIG_WPS_NFC
2827         { "wps_er_nfc_config_token", wpa_cli_cmd_wps_er_nfc_config_token, NULL,
2828           cli_cmd_flag_none,
2829           "<WPS/NDEF> <UUID> = build NFC configuration token" },
2830 #endif /* CONFIG_WPS_NFC */
2831         { "ibss_rsn", wpa_cli_cmd_ibss_rsn, NULL,
2832           cli_cmd_flag_none,
2833           "<addr> = request RSN authentication with <addr> in IBSS" },
2834 #ifdef CONFIG_AP
2835         { "sta", wpa_cli_cmd_sta, NULL,
2836           cli_cmd_flag_none,
2837           "<addr> = get information about an associated station (AP)" },
2838         { "all_sta", wpa_cli_cmd_all_sta, NULL,
2839           cli_cmd_flag_none,
2840           "= get information about all associated stations (AP)" },
2841         { "deauthenticate", wpa_cli_cmd_deauthenticate, NULL,
2842           cli_cmd_flag_none,
2843           "<addr> = deauthenticate a station" },
2844         { "disassociate", wpa_cli_cmd_disassociate, NULL,
2845           cli_cmd_flag_none,
2846           "<addr> = disassociate a station" },
2847         { "chan_switch", wpa_cli_cmd_chanswitch, NULL,
2848           cli_cmd_flag_none,
2849           "<cs_count> <freq> [sec_channel_offset=] [center_freq1=]"
2850           " [center_freq2=] [bandwidth=] [blocktx] [ht|vht]"
2851           " = CSA parameters" },
2852 #endif /* CONFIG_AP */
2853         { "suspend", wpa_cli_cmd_suspend, NULL, cli_cmd_flag_none,
2854           "= notification of suspend/hibernate" },
2855         { "resume", wpa_cli_cmd_resume, NULL, cli_cmd_flag_none,
2856           "= notification of resume/thaw" },
2857 #ifdef CONFIG_TESTING_OPTIONS
2858         { "drop_sa", wpa_cli_cmd_drop_sa, NULL, cli_cmd_flag_none,
2859           "= drop SA without deauth/disassoc (test command)" },
2860 #endif /* CONFIG_TESTING_OPTIONS */
2861         { "roam", wpa_cli_cmd_roam, wpa_cli_complete_bss,
2862           cli_cmd_flag_none,
2863           "<addr> = roam to the specified BSS" },
2864 #ifdef CONFIG_MESH
2865         { "mesh_interface_add", wpa_cli_cmd_mesh_interface_add, NULL,
2866           cli_cmd_flag_none,
2867           "[ifname] = Create a new mesh interface" },
2868         { "mesh_group_add", wpa_cli_cmd_mesh_group_add, NULL,
2869           cli_cmd_flag_none,
2870           "<network id> = join a mesh network (disable others)" },
2871         { "mesh_group_remove", wpa_cli_cmd_mesh_group_remove, NULL,
2872           cli_cmd_flag_none,
2873           "<ifname> = Remove mesh group interface" },
2874 #endif /* CONFIG_MESH */
2875 #ifdef CONFIG_P2P
2876         { "p2p_find", wpa_cli_cmd_p2p_find, wpa_cli_complete_p2p_find,
2877           cli_cmd_flag_none,
2878           "[timeout] [type=*] = find P2P Devices for up-to timeout seconds" },
2879         { "p2p_stop_find", wpa_cli_cmd_p2p_stop_find, NULL, cli_cmd_flag_none,
2880           "= stop P2P Devices search" },
2881         { "p2p_connect", wpa_cli_cmd_p2p_connect, wpa_cli_complete_p2p_connect,
2882           cli_cmd_flag_none,
2883           "<addr> <\"pbc\"|PIN> [ht40] = connect to a P2P Device" },
2884         { "p2p_listen", wpa_cli_cmd_p2p_listen, NULL, cli_cmd_flag_none,
2885           "[timeout] = listen for P2P Devices for up-to timeout seconds" },
2886         { "p2p_group_remove", wpa_cli_cmd_p2p_group_remove,
2887           wpa_cli_complete_p2p_group_remove, cli_cmd_flag_none,
2888           "<ifname> = remove P2P group interface (terminate group if GO)" },
2889         { "p2p_group_add", wpa_cli_cmd_p2p_group_add, NULL, cli_cmd_flag_none,
2890           "[ht40] = add a new P2P group (local end as GO)" },
2891         { "p2p_prov_disc", wpa_cli_cmd_p2p_prov_disc,
2892           wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
2893           "<addr> <method> = request provisioning discovery" },
2894         { "p2p_get_passphrase", wpa_cli_cmd_p2p_get_passphrase, NULL,
2895           cli_cmd_flag_none,
2896           "= get the passphrase for a group (GO only)" },
2897         { "p2p_serv_disc_req", wpa_cli_cmd_p2p_serv_disc_req,
2898           wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
2899           "<addr> <TLVs> = schedule service discovery request" },
2900         { "p2p_serv_disc_cancel_req", wpa_cli_cmd_p2p_serv_disc_cancel_req,
2901           NULL, cli_cmd_flag_none,
2902           "<id> = cancel pending service discovery request" },
2903         { "p2p_serv_disc_resp", wpa_cli_cmd_p2p_serv_disc_resp, NULL,
2904           cli_cmd_flag_none,
2905           "<freq> <addr> <dialog token> <TLVs> = service discovery response" },
2906         { "p2p_service_update", wpa_cli_cmd_p2p_service_update, NULL,
2907           cli_cmd_flag_none,
2908           "= indicate change in local services" },
2909         { "p2p_serv_disc_external", wpa_cli_cmd_p2p_serv_disc_external, NULL,
2910           cli_cmd_flag_none,
2911           "<external> = set external processing of service discovery" },
2912         { "p2p_service_flush", wpa_cli_cmd_p2p_service_flush, NULL,
2913           cli_cmd_flag_none,
2914           "= remove all stored service entries" },
2915         { "p2p_service_add", wpa_cli_cmd_p2p_service_add, NULL,
2916           cli_cmd_flag_none,
2917           "<bonjour|upnp> <query|version> <response|service> = add a local "
2918           "service" },
2919         { "p2p_service_del", wpa_cli_cmd_p2p_service_del, NULL,
2920           cli_cmd_flag_none,
2921           "<bonjour|upnp> <query|version> [|service] = remove a local "
2922           "service" },
2923         { "p2p_reject", wpa_cli_cmd_p2p_reject, wpa_cli_complete_p2p_peer,
2924           cli_cmd_flag_none,
2925           "<addr> = reject connection attempts from a specific peer" },
2926         { "p2p_invite", wpa_cli_cmd_p2p_invite, NULL,
2927           cli_cmd_flag_none,
2928           "<cmd> [peer=addr] = invite peer" },
2929         { "p2p_peers", wpa_cli_cmd_p2p_peers, NULL, cli_cmd_flag_none,
2930           "[discovered] = list known (optionally, only fully discovered) P2P "
2931           "peers" },
2932         { "p2p_peer", wpa_cli_cmd_p2p_peer, wpa_cli_complete_p2p_peer,
2933           cli_cmd_flag_none,
2934           "<address> = show information about known P2P peer" },
2935         { "p2p_set", wpa_cli_cmd_p2p_set, wpa_cli_complete_p2p_set,
2936           cli_cmd_flag_none,
2937           "<field> <value> = set a P2P parameter" },
2938         { "p2p_flush", wpa_cli_cmd_p2p_flush, NULL, cli_cmd_flag_none,
2939           "= flush P2P state" },
2940         { "p2p_cancel", wpa_cli_cmd_p2p_cancel, NULL, cli_cmd_flag_none,
2941           "= cancel P2P group formation" },
2942         { "p2p_unauthorize", wpa_cli_cmd_p2p_unauthorize,
2943           wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
2944           "<address> = unauthorize a peer" },
2945         { "p2p_presence_req", wpa_cli_cmd_p2p_presence_req, NULL,
2946           cli_cmd_flag_none,
2947           "[<duration> <interval>] [<duration> <interval>] = request GO "
2948           "presence" },
2949         { "p2p_ext_listen", wpa_cli_cmd_p2p_ext_listen, NULL,
2950           cli_cmd_flag_none,
2951           "[<period> <interval>] = set extended listen timing" },
2952         { "p2p_remove_client", wpa_cli_cmd_p2p_remove_client,
2953           wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
2954           "<address|iface=address> = remove a peer from all groups" },
2955 #endif /* CONFIG_P2P */
2956 #ifdef CONFIG_WIFI_DISPLAY
2957         { "wfd_subelem_set", wpa_cli_cmd_wfd_subelem_set, NULL,
2958           cli_cmd_flag_none,
2959           "<subelem> [contents] = set Wi-Fi Display subelement" },
2960         { "wfd_subelem_get", wpa_cli_cmd_wfd_subelem_get, NULL,
2961           cli_cmd_flag_none,
2962           "<subelem> = get Wi-Fi Display subelement" },
2963 #endif /* CONFIG_WIFI_DISPLAY */
2964 #ifdef CONFIG_INTERWORKING
2965         { "fetch_anqp", wpa_cli_cmd_fetch_anqp, NULL, cli_cmd_flag_none,
2966           "= fetch ANQP information for all APs" },
2967         { "stop_fetch_anqp", wpa_cli_cmd_stop_fetch_anqp, NULL,
2968           cli_cmd_flag_none,
2969           "= stop fetch_anqp operation" },
2970         { "interworking_select", wpa_cli_cmd_interworking_select, NULL,
2971           cli_cmd_flag_none,
2972           "[auto] = perform Interworking network selection" },
2973         { "interworking_connect", wpa_cli_cmd_interworking_connect,
2974           wpa_cli_complete_bss, cli_cmd_flag_none,
2975           "<BSSID> = connect using Interworking credentials" },
2976         { "anqp_get", wpa_cli_cmd_anqp_get, wpa_cli_complete_bss,
2977           cli_cmd_flag_none,
2978           "<addr> <info id>[,<info id>]... = request ANQP information" },
2979         { "gas_request", wpa_cli_cmd_gas_request, wpa_cli_complete_bss,
2980           cli_cmd_flag_none,
2981           "<addr> <AdvProtoID> [QueryReq] = GAS request" },
2982         { "gas_response_get", wpa_cli_cmd_gas_response_get,
2983           wpa_cli_complete_bss, cli_cmd_flag_none,
2984           "<addr> <dialog token> [start,len] = Fetch last GAS response" },
2985 #endif /* CONFIG_INTERWORKING */
2986 #ifdef CONFIG_HS20
2987         { "hs20_anqp_get", wpa_cli_cmd_hs20_anqp_get, wpa_cli_complete_bss,
2988           cli_cmd_flag_none,
2989           "<addr> <subtype>[,<subtype>]... = request HS 2.0 ANQP information"
2990         },
2991         { "nai_home_realm_list", wpa_cli_cmd_get_nai_home_realm_list,
2992           wpa_cli_complete_bss, cli_cmd_flag_none,
2993           "<addr> <home realm> = get HS20 nai home realm list" },
2994         { "hs20_icon_request", wpa_cli_cmd_hs20_icon_request,
2995           wpa_cli_complete_bss, cli_cmd_flag_none,
2996           "<addr> <icon name> = get Hotspot 2.0 OSU icon" },
2997         { "fetch_osu", wpa_cli_cmd_fetch_osu, NULL, cli_cmd_flag_none,
2998           "= fetch OSU provider information from all APs" },
2999         { "cancel_fetch_osu", wpa_cli_cmd_cancel_fetch_osu, NULL,
3000           cli_cmd_flag_none,
3001           "= cancel fetch_osu command" },
3002 #endif /* CONFIG_HS20 */
3003         { "sta_autoconnect", wpa_cli_cmd_sta_autoconnect, NULL,
3004           cli_cmd_flag_none,
3005           "<0/1> = disable/enable automatic reconnection" },
3006         { "tdls_discover", wpa_cli_cmd_tdls_discover, NULL,
3007           cli_cmd_flag_none,
3008           "<addr> = request TDLS discovery with <addr>" },
3009         { "tdls_setup", wpa_cli_cmd_tdls_setup, NULL,
3010           cli_cmd_flag_none,
3011           "<addr> = request TDLS setup with <addr>" },
3012         { "tdls_teardown", wpa_cli_cmd_tdls_teardown, NULL,
3013           cli_cmd_flag_none,
3014           "<addr> = tear down TDLS with <addr>" },
3015         { "wmm_ac_addts", wpa_cli_cmd_wmm_ac_addts, NULL,
3016           cli_cmd_flag_none,
3017           "<uplink/downlink/bidi> <tsid=0..7> <up=0..7> [nominal_msdu_size=#] "
3018           "[mean_data_rate=#] [min_phy_rate=#] [sba=#] [fixed_nominal_msdu] "
3019           "= add WMM-AC traffic stream" },
3020         { "wmm_ac_delts", wpa_cli_cmd_wmm_ac_delts, NULL,
3021           cli_cmd_flag_none,
3022           "<tsid> = delete WMM-AC traffic stream" },
3023         { "wmm_ac_status", wpa_cli_cmd_wmm_ac_status, NULL,
3024           cli_cmd_flag_none,
3025           "= show status for Wireless Multi-Media Admission-Control" },
3026         { "tdls_chan_switch", wpa_cli_cmd_tdls_chan_switch, NULL,
3027           cli_cmd_flag_none,
3028           "<addr> <oper class> <freq> [sec_channel_offset=] [center_freq1=] "
3029           "[center_freq2=] [bandwidth=] [ht|vht] = enable channel switching "
3030           "with TDLS peer" },
3031         { "tdls_cancel_chan_switch", wpa_cli_cmd_tdls_cancel_chan_switch, NULL,
3032           cli_cmd_flag_none,
3033           "<addr> = disable channel switching with TDLS peer <addr>" },
3034         { "signal_poll", wpa_cli_cmd_signal_poll, NULL,
3035           cli_cmd_flag_none,
3036           "= get signal parameters" },
3037         { "pktcnt_poll", wpa_cli_cmd_pktcnt_poll, NULL,
3038           cli_cmd_flag_none,
3039           "= get TX/RX packet counters" },
3040         { "reauthenticate", wpa_cli_cmd_reauthenticate, NULL,
3041           cli_cmd_flag_none,
3042           "= trigger IEEE 802.1X/EAPOL reauthentication" },
3043 #ifdef CONFIG_AUTOSCAN
3044         { "autoscan", wpa_cli_cmd_autoscan, NULL, cli_cmd_flag_none,
3045           "[params] = Set or unset (if none) autoscan parameters" },
3046 #endif /* CONFIG_AUTOSCAN */
3047 #ifdef CONFIG_WNM
3048         { "wnm_sleep", wpa_cli_cmd_wnm_sleep, NULL, cli_cmd_flag_none,
3049           "<enter/exit> [interval=#] = enter/exit WNM-Sleep mode" },
3050         { "wnm_bss_query", wpa_cli_cmd_wnm_bss_query, NULL, cli_cmd_flag_none,
3051           "<query reason> = Send BSS Transition Management Query" },
3052 #endif /* CONFIG_WNM */
3053         { "raw", wpa_cli_cmd_raw, NULL, cli_cmd_flag_sensitive,
3054           "<params..> = Sent unprocessed command" },
3055         { "flush", wpa_cli_cmd_flush, NULL, cli_cmd_flag_none,
3056           "= flush wpa_supplicant state" },
3057 #ifdef ANDROID
3058         { "driver", wpa_cli_cmd_driver, NULL, cli_cmd_flag_none,
3059           "<command> = driver private commands" },
3060 #endif /* ANDROID */
3061         { "radio_work", wpa_cli_cmd_radio_work, NULL, cli_cmd_flag_none,
3062           "= radio_work <show/add/done>" },
3063         { "vendor", wpa_cli_cmd_vendor, NULL, cli_cmd_flag_none,
3064           "<vendor id> <command id> [<hex formatted command argument>] = Send vendor command"
3065         },
3066         { "neighbor_rep_request",
3067           wpa_cli_cmd_neighbor_rep_request, NULL, cli_cmd_flag_none,
3068           "[ssid=<SSID>] = Trigger request to AP for neighboring AP report "
3069           "(with optional given SSID, default: current SSID)"
3070         },
3071         { "erp_flush", wpa_cli_cmd_erp_flush, NULL, cli_cmd_flag_none,
3072           "= flush ERP keys" },
3073         { "mac_rand_scan",
3074           wpa_cli_cmd_mac_rand_scan, NULL, cli_cmd_flag_none,
3075           "<scan|sched|pno|all> enable=<0/1> [addr=mac-address "
3076           "mask=mac-address-mask] = scan MAC randomization"
3077         },
3078         { NULL, NULL, NULL, cli_cmd_flag_none, NULL }
3079 };
3080
3081
3082 /*
3083  * Prints command usage, lines are padded with the specified string.
3084  */
3085 static void print_cmd_help(struct wpa_cli_cmd *cmd, const char *pad)
3086 {
3087         char c;
3088         size_t n;
3089
3090         printf("%s%s ", pad, cmd->cmd);
3091         for (n = 0; (c = cmd->usage[n]); n++) {
3092                 printf("%c", c);
3093                 if (c == '\n')
3094                         printf("%s", pad);
3095         }
3096         printf("\n");
3097 }
3098
3099
3100 static void print_help(const char *cmd)
3101 {
3102         int n;
3103         printf("commands:\n");
3104         for (n = 0; wpa_cli_commands[n].cmd; n++) {
3105                 if (cmd == NULL || str_starts(wpa_cli_commands[n].cmd, cmd))
3106                         print_cmd_help(&wpa_cli_commands[n], "  ");
3107         }
3108 }
3109
3110
3111 static int wpa_cli_edit_filter_history_cb(void *ctx, const char *cmd)
3112 {
3113         const char *c, *delim;
3114         int n;
3115         size_t len;
3116
3117         delim = os_strchr(cmd, ' ');
3118         if (delim)
3119                 len = delim - cmd;
3120         else
3121                 len = os_strlen(cmd);
3122
3123         for (n = 0; (c = wpa_cli_commands[n].cmd); n++) {
3124                 if (os_strncasecmp(cmd, c, len) == 0 && len == os_strlen(c))
3125                         return (wpa_cli_commands[n].flags &
3126                                 cli_cmd_flag_sensitive);
3127         }
3128         return 0;
3129 }
3130
3131
3132 static char ** wpa_list_cmd_list(void)
3133 {
3134         char **res;
3135         int i, count;
3136         struct cli_txt_entry *e;
3137
3138         count = ARRAY_SIZE(wpa_cli_commands);
3139         count += dl_list_len(&p2p_groups);
3140         count += dl_list_len(&ifnames);
3141         res = os_calloc(count + 1, sizeof(char *));
3142         if (res == NULL)
3143                 return NULL;
3144
3145         for (i = 0; wpa_cli_commands[i].cmd; i++) {
3146                 res[i] = os_strdup(wpa_cli_commands[i].cmd);
3147                 if (res[i] == NULL)
3148                         break;
3149         }
3150
3151         dl_list_for_each(e, &p2p_groups, struct cli_txt_entry, list) {
3152                 size_t len = 8 + os_strlen(e->txt);
3153                 res[i] = os_malloc(len);
3154                 if (res[i] == NULL)
3155                         break;
3156                 os_snprintf(res[i], len, "ifname=%s", e->txt);
3157                 i++;
3158         }
3159
3160         dl_list_for_each(e, &ifnames, struct cli_txt_entry, list) {
3161                 res[i] = os_strdup(e->txt);
3162                 if (res[i] == NULL)
3163                         break;
3164                 i++;
3165         }
3166
3167         return res;
3168 }
3169
3170
3171 static char ** wpa_cli_cmd_completion(const char *cmd, const char *str,
3172                                       int pos)
3173 {
3174         int i;
3175
3176         for (i = 0; wpa_cli_commands[i].cmd; i++) {
3177                 if (os_strcasecmp(wpa_cli_commands[i].cmd, cmd) == 0) {
3178                         if (wpa_cli_commands[i].completion)
3179                                 return wpa_cli_commands[i].completion(str,
3180                                                                       pos);
3181                         edit_clear_line();
3182                         printf("\r%s\n", wpa_cli_commands[i].usage);
3183                         edit_redraw();
3184                         break;
3185                 }
3186         }
3187
3188         return NULL;
3189 }
3190
3191
3192 static char ** wpa_cli_edit_completion_cb(void *ctx, const char *str, int pos)
3193 {
3194         char **res;
3195         const char *end;
3196         char *cmd;
3197
3198         if (pos > 7 && os_strncasecmp(str, "IFNAME=", 7) == 0) {
3199                 end = os_strchr(str, ' ');
3200                 if (end && pos > end - str) {
3201                         pos -= end - str + 1;
3202                         str = end + 1;
3203                 }
3204         }
3205
3206         end = os_strchr(str, ' ');
3207         if (end == NULL || str + pos < end)
3208                 return wpa_list_cmd_list();
3209
3210         cmd = os_malloc(pos + 1);
3211         if (cmd == NULL)
3212                 return NULL;
3213         os_memcpy(cmd, str, pos);
3214         cmd[end - str] = '\0';
3215         res = wpa_cli_cmd_completion(cmd, str, pos);
3216         os_free(cmd);
3217         return res;
3218 }
3219
3220
3221 static int wpa_request(struct wpa_ctrl *ctrl, int argc, char *argv[])
3222 {
3223         struct wpa_cli_cmd *cmd, *match = NULL;
3224         int count;
3225         int ret = 0;
3226
3227         if (argc > 1 && os_strncasecmp(argv[0], "IFNAME=", 7) == 0) {
3228                 ifname_prefix = argv[0] + 7;
3229                 argv = &argv[1];
3230                 argc--;
3231         } else
3232                 ifname_prefix = NULL;
3233
3234         if (argc == 0)
3235                 return -1;
3236
3237         count = 0;
3238         cmd = wpa_cli_commands;
3239         while (cmd->cmd) {
3240                 if (os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0)
3241                 {
3242                         match = cmd;
3243                         if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
3244                                 /* we have an exact match */
3245                                 count = 1;
3246                                 break;
3247                         }
3248                         count++;
3249                 }
3250                 cmd++;
3251         }
3252
3253         if (count > 1) {
3254                 printf("Ambiguous command '%s'; possible commands:", argv[0]);
3255                 cmd = wpa_cli_commands;
3256                 while (cmd->cmd) {
3257                         if (os_strncasecmp(cmd->cmd, argv[0],
3258                                            os_strlen(argv[0])) == 0) {
3259                                 printf(" %s", cmd->cmd);
3260                         }
3261                         cmd++;
3262                 }
3263                 printf("\n");
3264                 ret = 1;
3265         } else if (count == 0) {
3266                 printf("Unknown command '%s'\n", argv[0]);
3267                 ret = 1;
3268         } else {
3269                 ret = match->handler(ctrl, argc - 1, &argv[1]);
3270         }
3271
3272         return ret;
3273 }
3274
3275
3276 static int str_match(const char *a, const char *b)
3277 {
3278         return os_strncmp(a, b, os_strlen(b)) == 0;
3279 }
3280
3281
3282 static int wpa_cli_exec(const char *program, const char *arg1,
3283                         const char *arg2)
3284 {
3285         char *arg;
3286         size_t len;
3287         int res;
3288
3289         len = os_strlen(arg1) + os_strlen(arg2) + 2;
3290         arg = os_malloc(len);
3291         if (arg == NULL)
3292                 return -1;
3293         os_snprintf(arg, len, "%s %s", arg1, arg2);
3294         res = os_exec(program, arg, 1);
3295         os_free(arg);
3296
3297         return res;
3298 }
3299
3300
3301 static void wpa_cli_action_process(const char *msg)
3302 {
3303         const char *pos;
3304         char *copy = NULL, *id, *pos2;
3305         const char *ifname = ctrl_ifname;
3306         char ifname_buf[100];
3307
3308         pos = msg;
3309         if (os_strncmp(pos, "IFNAME=", 7) == 0) {
3310                 const char *end;
3311                 end = os_strchr(pos + 7, ' ');
3312                 if (end && (unsigned int) (end - pos) < sizeof(ifname_buf)) {
3313                         pos += 7;
3314                         os_memcpy(ifname_buf, pos, end - pos);
3315                         ifname_buf[end - pos] = '\0';
3316                         ifname = ifname_buf;
3317                         pos = end + 1;
3318                 }
3319         }
3320         if (*pos == '<') {
3321                 const char *prev = pos;
3322                 /* skip priority */
3323                 pos = os_strchr(pos, '>');
3324                 if (pos)
3325                         pos++;
3326                 else
3327                         pos = prev;
3328         }
3329
3330         if (str_match(pos, WPA_EVENT_CONNECTED)) {
3331                 int new_id = -1;
3332                 os_unsetenv("WPA_ID");
3333                 os_unsetenv("WPA_ID_STR");
3334                 os_unsetenv("WPA_CTRL_DIR");
3335
3336                 pos = os_strstr(pos, "[id=");
3337                 if (pos)
3338                         copy = os_strdup(pos + 4);
3339
3340                 if (copy) {
3341                         pos2 = id = copy;
3342                         while (*pos2 && *pos2 != ' ')
3343                                 pos2++;
3344                         *pos2++ = '\0';
3345                         new_id = atoi(id);
3346                         os_setenv("WPA_ID", id, 1);
3347                         while (*pos2 && *pos2 != '=')
3348                                 pos2++;
3349                         if (*pos2 == '=')
3350                                 pos2++;
3351                         id = pos2;
3352                         while (*pos2 && *pos2 != ']')
3353                                 pos2++;
3354                         *pos2 = '\0';
3355                         os_setenv("WPA_ID_STR", id, 1);
3356                         os_free(copy);
3357                 }
3358
3359                 os_setenv("WPA_CTRL_DIR", ctrl_iface_dir, 1);
3360
3361                 if (wpa_cli_connected <= 0 || new_id != wpa_cli_last_id) {
3362                         wpa_cli_connected = 1;
3363                         wpa_cli_last_id = new_id;
3364                         wpa_cli_exec(action_file, ifname, "CONNECTED");
3365                 }
3366         } else if (str_match(pos, WPA_EVENT_DISCONNECTED)) {
3367                 if (wpa_cli_connected) {
3368                         wpa_cli_connected = 0;
3369                         wpa_cli_exec(action_file, ifname, "DISCONNECTED");
3370                 }
3371         } else if (str_match(pos, MESH_GROUP_STARTED)) {
3372                 wpa_cli_exec(action_file, ctrl_ifname, pos);
3373         } else if (str_match(pos, MESH_GROUP_REMOVED)) {
3374                 wpa_cli_exec(action_file, ctrl_ifname, pos);
3375         } else if (str_match(pos, MESH_PEER_CONNECTED)) {
3376                 wpa_cli_exec(action_file, ctrl_ifname, pos);
3377         } else if (str_match(pos, MESH_PEER_DISCONNECTED)) {
3378                 wpa_cli_exec(action_file, ctrl_ifname, pos);
3379         } else if (str_match(pos, P2P_EVENT_GROUP_STARTED)) {
3380                 wpa_cli_exec(action_file, ifname, pos);
3381         } else if (str_match(pos, P2P_EVENT_GROUP_REMOVED)) {
3382                 wpa_cli_exec(action_file, ifname, pos);
3383         } else if (str_match(pos, P2P_EVENT_CROSS_CONNECT_ENABLE)) {
3384                 wpa_cli_exec(action_file, ifname, pos);
3385         } else if (str_match(pos, P2P_EVENT_CROSS_CONNECT_DISABLE)) {
3386                 wpa_cli_exec(action_file, ifname, pos);
3387         } else if (str_match(pos, P2P_EVENT_GO_NEG_FAILURE)) {
3388                 wpa_cli_exec(action_file, ifname, pos);
3389         } else if (str_match(pos, WPS_EVENT_SUCCESS)) {
3390                 wpa_cli_exec(action_file, ifname, pos);
3391         } else if (str_match(pos, WPS_EVENT_FAIL)) {
3392                 wpa_cli_exec(action_file, ifname, pos);
3393         } else if (str_match(pos, AP_STA_CONNECTED)) {
3394                 wpa_cli_exec(action_file, ifname, pos);
3395         } else if (str_match(pos, AP_STA_DISCONNECTED)) {
3396                 wpa_cli_exec(action_file, ifname, pos);
3397         } else if (str_match(pos, ESS_DISASSOC_IMMINENT)) {
3398                 wpa_cli_exec(action_file, ifname, pos);
3399         } else if (str_match(pos, HS20_SUBSCRIPTION_REMEDIATION)) {
3400                 wpa_cli_exec(action_file, ifname, pos);
3401         } else if (str_match(pos, HS20_DEAUTH_IMMINENT_NOTICE)) {
3402                 wpa_cli_exec(action_file, ifname, pos);
3403         } else if (str_match(pos, WPA_EVENT_TERMINATING)) {
3404                 printf("wpa_supplicant is terminating - stop monitoring\n");
3405                 wpa_cli_quit = 1;
3406         }
3407 }
3408
3409
3410 #ifndef CONFIG_ANSI_C_EXTRA
3411 static void wpa_cli_action_cb(char *msg, size_t len)
3412 {
3413         wpa_cli_action_process(msg);
3414 }
3415 #endif /* CONFIG_ANSI_C_EXTRA */
3416
3417
3418 static void wpa_cli_reconnect(void)
3419 {
3420         wpa_cli_close_connection();
3421         if (wpa_cli_open_connection(ctrl_ifname, 1) < 0)
3422                 return;
3423
3424         if (interactive) {
3425                 edit_clear_line();
3426                 printf("\rConnection to wpa_supplicant re-established\n");
3427                 edit_redraw();
3428         }
3429 }
3430
3431
3432 static void cli_event(const char *str)
3433 {
3434         const char *start, *s;
3435
3436         start = os_strchr(str, '>');
3437         if (start == NULL)
3438                 return;
3439
3440         start++;
3441
3442         if (str_starts(start, WPA_EVENT_BSS_ADDED)) {
3443                 s = os_strchr(start, ' ');
3444                 if (s == NULL)
3445                         return;
3446                 s = os_strchr(s + 1, ' ');
3447                 if (s == NULL)
3448                         return;
3449                 cli_txt_list_add(&bsses, s + 1);
3450                 return;
3451         }
3452
3453         if (str_starts(start, WPA_EVENT_BSS_REMOVED)) {
3454                 s = os_strchr(start, ' ');
3455                 if (s == NULL)
3456                         return;
3457                 s = os_strchr(s + 1, ' ');
3458                 if (s == NULL)
3459                         return;
3460                 cli_txt_list_del_addr(&bsses, s + 1);
3461                 return;
3462         }
3463
3464 #ifdef CONFIG_P2P
3465         if (str_starts(start, P2P_EVENT_DEVICE_FOUND)) {
3466                 s = os_strstr(start, " p2p_dev_addr=");
3467                 if (s == NULL)
3468                         return;
3469                 cli_txt_list_add_addr(&p2p_peers, s + 14);
3470                 return;
3471         }
3472
3473         if (str_starts(start, P2P_EVENT_DEVICE_LOST)) {
3474                 s = os_strstr(start, " p2p_dev_addr=");
3475                 if (s == NULL)
3476                         return;
3477                 cli_txt_list_del_addr(&p2p_peers, s + 14);
3478                 return;
3479         }
3480
3481         if (str_starts(start, P2P_EVENT_GROUP_STARTED)) {
3482                 s = os_strchr(start, ' ');
3483                 if (s == NULL)
3484                         return;
3485                 cli_txt_list_add_word(&p2p_groups, s + 1);
3486                 return;
3487         }
3488
3489         if (str_starts(start, P2P_EVENT_GROUP_REMOVED)) {
3490                 s = os_strchr(start, ' ');
3491                 if (s == NULL)
3492                         return;
3493                 cli_txt_list_del_word(&p2p_groups, s + 1);
3494                 return;
3495         }
3496 #endif /* CONFIG_P2P */
3497 }
3498
3499
3500 static int check_terminating(const char *msg)
3501 {
3502         const char *pos = msg;
3503
3504         if (*pos == '<') {
3505                 /* skip priority */
3506                 pos = os_strchr(pos, '>');
3507                 if (pos)
3508                         pos++;
3509                 else
3510                         pos = msg;
3511         }
3512
3513         if (str_match(pos, WPA_EVENT_TERMINATING) && ctrl_conn) {
3514                 edit_clear_line();
3515                 printf("\rConnection to wpa_supplicant lost - trying to "
3516                        "reconnect\n");
3517                 edit_redraw();
3518                 wpa_cli_attached = 0;
3519                 wpa_cli_close_connection();
3520                 return 1;
3521         }
3522
3523         return 0;
3524 }
3525
3526
3527 static void wpa_cli_recv_pending(struct wpa_ctrl *ctrl, int action_monitor)
3528 {
3529         if (ctrl_conn == NULL) {
3530                 wpa_cli_reconnect();
3531                 return;
3532         }
3533         while (wpa_ctrl_pending(ctrl) > 0) {
3534                 char buf[4096];
3535                 size_t len = sizeof(buf) - 1;
3536                 if (wpa_ctrl_recv(ctrl, buf, &len) == 0) {
3537                         buf[len] = '\0';
3538                         if (action_monitor)
3539                                 wpa_cli_action_process(buf);
3540                         else {
3541                                 cli_event(buf);
3542                                 if (wpa_cli_show_event(buf)) {
3543                                         edit_clear_line();
3544                                         printf("\r%s\n", buf);
3545                                         edit_redraw();
3546                                 }
3547
3548                                 if (interactive && check_terminating(buf) > 0)
3549                                         return;
3550                         }
3551                 } else {
3552                         printf("Could not read pending message.\n");
3553                         break;
3554                 }
3555         }
3556
3557         if (wpa_ctrl_pending(ctrl) < 0) {
3558                 printf("Connection to wpa_supplicant lost - trying to "
3559                        "reconnect\n");
3560                 wpa_cli_reconnect();
3561         }
3562 }
3563
3564 #define max_args 10
3565
3566 static int tokenize_cmd(char *cmd, char *argv[])
3567 {
3568         char *pos;
3569         int argc = 0;
3570
3571         pos = cmd;
3572         for (;;) {
3573                 while (*pos == ' ')
3574                         pos++;
3575                 if (*pos == '\0')
3576                         break;
3577                 argv[argc] = pos;
3578                 argc++;
3579                 if (argc == max_args)
3580                         break;
3581                 if (*pos == '"') {
3582                         char *pos2 = os_strrchr(pos, '"');
3583                         if (pos2)
3584                                 pos = pos2 + 1;
3585                 }
3586                 while (*pos != '\0' && *pos != ' ')
3587                         pos++;
3588                 if (*pos == ' ')
3589                         *pos++ = '\0';
3590         }
3591
3592         return argc;
3593 }
3594
3595
3596 static void wpa_cli_ping(void *eloop_ctx, void *timeout_ctx)
3597 {
3598         if (ctrl_conn) {
3599                 int res;
3600                 char *prefix = ifname_prefix;
3601
3602                 ifname_prefix = NULL;
3603                 res = _wpa_ctrl_command(ctrl_conn, "PING", 0);
3604                 ifname_prefix = prefix;
3605                 if (res) {
3606                         printf("Connection to wpa_supplicant lost - trying to "
3607                                "reconnect\n");
3608                         wpa_cli_close_connection();
3609                 }
3610         }
3611         if (!ctrl_conn)
3612                 wpa_cli_reconnect();
3613         eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
3614 }
3615
3616
3617 static void wpa_cli_mon_receive(int sock, void *eloop_ctx, void *sock_ctx)
3618 {
3619         wpa_cli_recv_pending(mon_conn, 0);
3620 }
3621
3622
3623 static void wpa_cli_edit_cmd_cb(void *ctx, char *cmd)
3624 {
3625         char *argv[max_args];
3626         int argc;
3627         argc = tokenize_cmd(cmd, argv);
3628         if (argc)
3629                 wpa_request(ctrl_conn, argc, argv);
3630 }
3631
3632
3633 static void wpa_cli_edit_eof_cb(void *ctx)
3634 {
3635         eloop_terminate();
3636 }
3637
3638
3639 static int warning_displayed = 0;
3640 static char *hfile = NULL;
3641 static int edit_started = 0;
3642
3643 static void start_edit(void)
3644 {
3645         char *home;
3646         char *ps = NULL;
3647
3648 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
3649         ps = wpa_ctrl_get_remote_ifname(ctrl_conn);
3650 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
3651
3652         home = getenv("HOME");
3653         if (home) {
3654                 const char *fname = ".wpa_cli_history";
3655                 int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
3656                 hfile = os_malloc(hfile_len);
3657                 if (hfile)
3658                         os_snprintf(hfile, hfile_len, "%s/%s", home, fname);
3659         }
3660
3661         if (edit_init(wpa_cli_edit_cmd_cb, wpa_cli_edit_eof_cb,
3662                       wpa_cli_edit_completion_cb, NULL, hfile, ps) < 0) {
3663                 eloop_terminate();
3664                 return;
3665         }
3666
3667         edit_started = 1;
3668         eloop_register_timeout(ping_interval, 0, wpa_cli_ping, NULL, NULL);
3669 }
3670
3671
3672 static void update_bssid_list(struct wpa_ctrl *ctrl)
3673 {
3674         char buf[4096];
3675         size_t len = sizeof(buf);
3676         int ret;
3677         char *cmd = "BSS RANGE=ALL MASK=0x2";
3678         char *pos, *end;
3679
3680         if (ctrl == NULL)
3681                 return;
3682         ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
3683         if (ret < 0)
3684                 return;
3685         buf[len] = '\0';
3686
3687         pos = buf;
3688         while (pos) {
3689                 pos = os_strstr(pos, "bssid=");
3690                 if (pos == NULL)
3691                         break;
3692                 pos += 6;
3693                 end = os_strchr(pos, '\n');
3694                 if (end == NULL)
3695                         break;
3696                 *end = '\0';
3697                 cli_txt_list_add(&bsses, pos);
3698                 pos = end + 1;
3699         }
3700 }
3701
3702
3703 static void update_ifnames(struct wpa_ctrl *ctrl)
3704 {
3705         char buf[4096];
3706         size_t len = sizeof(buf);
3707         int ret;
3708         char *cmd = "INTERFACES";
3709         char *pos, *end;
3710         char txt[200];
3711
3712         cli_txt_list_flush(&ifnames);
3713
3714         if (ctrl == NULL)
3715                 return;
3716         ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len, NULL);
3717         if (ret < 0)
3718                 return;
3719         buf[len] = '\0';
3720
3721         pos = buf;
3722         while (pos) {
3723                 end = os_strchr(pos, '\n');
3724                 if (end == NULL)
3725                         break;
3726                 *end = '\0';
3727                 ret = os_snprintf(txt, sizeof(txt), "ifname=%s", pos);
3728                 if (!os_snprintf_error(sizeof(txt), ret))
3729                         cli_txt_list_add(&ifnames, txt);
3730                 pos = end + 1;
3731         }
3732 }
3733
3734
3735 static void try_connection(void *eloop_ctx, void *timeout_ctx)
3736 {
3737         if (ctrl_conn)
3738                 goto done;
3739
3740         if (ctrl_ifname == NULL)
3741                 ctrl_ifname = wpa_cli_get_default_ifname();
3742
3743         if (!wpa_cli_open_connection(ctrl_ifname, 1) == 0) {
3744                 if (!warning_displayed) {
3745                         printf("Could not connect to wpa_supplicant: "
3746                                "%s - re-trying\n", ctrl_ifname);
3747                         warning_displayed = 1;
3748                 }
3749                 eloop_register_timeout(1, 0, try_connection, NULL, NULL);
3750                 return;
3751         }
3752
3753         update_bssid_list(ctrl_conn);
3754
3755         if (warning_displayed)
3756                 printf("Connection established.\n");
3757
3758 done:
3759         start_edit();
3760 }
3761
3762
3763 static void wpa_cli_interactive(void)
3764 {
3765         printf("\nInteractive mode\n\n");
3766
3767         eloop_register_timeout(0, 0, try_connection, NULL, NULL);
3768         eloop_run();
3769         eloop_cancel_timeout(try_connection, NULL, NULL);
3770
3771         cli_txt_list_flush(&p2p_peers);
3772         cli_txt_list_flush(&p2p_groups);
3773         cli_txt_list_flush(&bsses);
3774         cli_txt_list_flush(&ifnames);
3775         if (edit_started)
3776                 edit_deinit(hfile, wpa_cli_edit_filter_history_cb);
3777         os_free(hfile);
3778         eloop_cancel_timeout(wpa_cli_ping, NULL, NULL);
3779         wpa_cli_close_connection();
3780 }
3781
3782
3783 static void wpa_cli_action(struct wpa_ctrl *ctrl)
3784 {
3785 #ifdef CONFIG_ANSI_C_EXTRA
3786         /* TODO: ANSI C version(?) */
3787         printf("Action processing not supported in ANSI C build.\n");
3788 #else /* CONFIG_ANSI_C_EXTRA */
3789         fd_set rfds;
3790         int fd, res;
3791         struct timeval tv;
3792         char buf[256]; /* note: large enough to fit in unsolicited messages */
3793         size_t len;
3794
3795         fd = wpa_ctrl_get_fd(ctrl);
3796
3797         while (!wpa_cli_quit) {
3798                 FD_ZERO(&rfds);
3799                 FD_SET(fd, &rfds);
3800                 tv.tv_sec = ping_interval;
3801                 tv.tv_usec = 0;
3802                 res = select(fd + 1, &rfds, NULL, NULL, &tv);
3803                 if (res < 0 && errno != EINTR) {
3804                         perror("select");
3805                         break;
3806                 }
3807
3808                 if (FD_ISSET(fd, &rfds))
3809                         wpa_cli_recv_pending(ctrl, 1);
3810                 else {
3811                         /* verify that connection is still working */
3812                         len = sizeof(buf) - 1;
3813                         if (wpa_ctrl_request(ctrl, "PING", 4, buf, &len,
3814                                              wpa_cli_action_cb) < 0 ||
3815                             len < 4 || os_memcmp(buf, "PONG", 4) != 0) {
3816                                 printf("wpa_supplicant did not reply to PING "
3817                                        "command - exiting\n");
3818                                 break;
3819                         }
3820                 }
3821         }
3822 #endif /* CONFIG_ANSI_C_EXTRA */
3823 }
3824
3825
3826 static void wpa_cli_cleanup(void)
3827 {
3828         wpa_cli_close_connection();
3829         if (pid_file)
3830                 os_daemonize_terminate(pid_file);
3831
3832         os_program_deinit();
3833 }
3834
3835
3836 static void wpa_cli_terminate(int sig, void *ctx)
3837 {
3838         eloop_terminate();
3839 }
3840
3841
3842 static char * wpa_cli_get_default_ifname(void)
3843 {
3844         char *ifname = NULL;
3845
3846 #ifdef CONFIG_CTRL_IFACE_UNIX
3847         struct dirent *dent;
3848         DIR *dir = opendir(ctrl_iface_dir);
3849         if (!dir) {
3850 #ifdef ANDROID
3851                 char ifprop[PROPERTY_VALUE_MAX];
3852                 if (property_get("wifi.interface", ifprop, NULL) != 0) {
3853                         ifname = os_strdup(ifprop);
3854                         printf("Using interface '%s'\n", ifname);
3855                         return ifname;
3856                 }
3857 #endif /* ANDROID */
3858                 return NULL;
3859         }
3860         while ((dent = readdir(dir))) {
3861 #ifdef _DIRENT_HAVE_D_TYPE
3862                 /*
3863                  * Skip the file if it is not a socket. Also accept
3864                  * DT_UNKNOWN (0) in case the C library or underlying
3865                  * file system does not support d_type.
3866                  */
3867                 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN)
3868                         continue;
3869 #endif /* _DIRENT_HAVE_D_TYPE */
3870                 if (os_strcmp(dent->d_name, ".") == 0 ||
3871                     os_strcmp(dent->d_name, "..") == 0)
3872                         continue;
3873                 printf("Selected interface '%s'\n", dent->d_name);
3874                 ifname = os_strdup(dent->d_name);
3875                 break;
3876         }
3877         closedir(dir);
3878 #endif /* CONFIG_CTRL_IFACE_UNIX */
3879
3880 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
3881         char buf[4096], *pos;
3882         size_t len;
3883         struct wpa_ctrl *ctrl;
3884         int ret;
3885
3886         ctrl = wpa_ctrl_open(NULL);
3887         if (ctrl == NULL)
3888                 return NULL;
3889
3890         len = sizeof(buf) - 1;
3891         ret = wpa_ctrl_request(ctrl, "INTERFACES", 10, buf, &len, NULL);
3892         if (ret >= 0) {
3893                 buf[len] = '\0';
3894                 pos = os_strchr(buf, '\n');
3895                 if (pos)
3896                         *pos = '\0';
3897                 ifname = os_strdup(buf);
3898         }
3899         wpa_ctrl_close(ctrl);
3900 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3901
3902         return ifname;
3903 }
3904
3905
3906 int main(int argc, char *argv[])
3907 {
3908         int c;
3909         int daemonize = 0;
3910         int ret = 0;
3911         const char *global = NULL;
3912
3913         if (os_program_init())
3914                 return -1;
3915
3916         for (;;) {
3917                 c = getopt(argc, argv, "a:Bg:G:hi:p:P:v");
3918                 if (c < 0)
3919                         break;
3920                 switch (c) {
3921                 case 'a':
3922                         action_file = optarg;
3923                         break;
3924                 case 'B':
3925                         daemonize = 1;
3926                         break;
3927                 case 'g':
3928                         global = optarg;
3929                         break;
3930                 case 'G':
3931                         ping_interval = atoi(optarg);
3932                         break;
3933                 case 'h':
3934                         usage();
3935                         return 0;
3936                 case 'v':
3937                         printf("%s\n", wpa_cli_version);
3938                         return 0;
3939                 case 'i':
3940                         os_free(ctrl_ifname);
3941                         ctrl_ifname = os_strdup(optarg);
3942                         break;
3943                 case 'p':
3944                         ctrl_iface_dir = optarg;
3945                         break;
3946                 case 'P':
3947                         pid_file = optarg;
3948                         break;
3949                 default:
3950                         usage();
3951                         return -1;
3952                 }
3953         }
3954
3955         interactive = (argc == optind) && (action_file == NULL);
3956
3957         if (interactive)
3958                 printf("%s\n\n%s\n\n", wpa_cli_version, wpa_cli_license);
3959
3960         if (eloop_init())
3961                 return -1;
3962
3963         if (global) {
3964 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
3965                 ctrl_conn = wpa_ctrl_open(NULL);
3966 #else /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3967                 ctrl_conn = wpa_ctrl_open(global);
3968 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
3969                 if (ctrl_conn == NULL) {
3970                         fprintf(stderr, "Failed to connect to wpa_supplicant "
3971                                 "global interface: %s  error: %s\n",
3972                                 global, strerror(errno));
3973                         return -1;
3974                 }
3975
3976                 if (interactive) {
3977                         update_ifnames(ctrl_conn);
3978                         mon_conn = wpa_ctrl_open(global);
3979                         if (mon_conn) {
3980                                 if (wpa_ctrl_attach(mon_conn) == 0) {
3981                                         wpa_cli_attached = 1;
3982                                         eloop_register_read_sock(
3983                                                 wpa_ctrl_get_fd(mon_conn),
3984                                                 wpa_cli_mon_receive,
3985                                                 NULL, NULL);
3986                                 } else {
3987                                         printf("Failed to open monitor "
3988                                                "connection through global "
3989                                                "control interface\n");
3990                                 }
3991                         }
3992                 }
3993         }
3994
3995         eloop_register_signal_terminate(wpa_cli_terminate, NULL);
3996
3997         if (ctrl_ifname == NULL)
3998                 ctrl_ifname = wpa_cli_get_default_ifname();
3999
4000         if (interactive) {
4001                 wpa_cli_interactive();
4002         } else {
4003                 if (!global &&
4004                     wpa_cli_open_connection(ctrl_ifname, 0) < 0) {
4005                         fprintf(stderr, "Failed to connect to non-global "
4006                                 "ctrl_ifname: %s  error: %s\n",
4007                                 ctrl_ifname, strerror(errno));
4008                         return -1;
4009                 }
4010
4011                 if (action_file) {
4012                         if (wpa_ctrl_attach(ctrl_conn) == 0) {
4013                                 wpa_cli_attached = 1;
4014                         } else {
4015                                 printf("Warning: Failed to attach to "
4016                                        "wpa_supplicant.\n");
4017                                 return -1;
4018                         }
4019                 }
4020
4021                 if (daemonize && os_daemonize(pid_file))
4022                         return -1;
4023
4024                 if (action_file)
4025                         wpa_cli_action(ctrl_conn);
4026                 else
4027                         ret = wpa_request(ctrl_conn, argc - optind,
4028                                           &argv[optind]);
4029         }
4030
4031         os_free(ctrl_ifname);
4032         eloop_destroy();
4033         wpa_cli_cleanup();
4034
4035         return ret;
4036 }
4037
4038 #else /* CONFIG_CTRL_IFACE */
4039 int main(int argc, char *argv[])
4040 {
4041         printf("CONFIG_CTRL_IFACE not defined - wpa_cli disabled\n");
4042         return -1;
4043 }
4044 #endif /* CONFIG_CTRL_IFACE */