libeap/wpa_supplicant/wpa_cli.c

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