wpa_supplicant/wpa_cli.c

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