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