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