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