wpa_supplicant/wpa_cli.c

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