wpa_supplicant/wpa_cli.c

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