wpa_supplicant/ctrl_iface.c

   1 /*
   2  * WPA Supplicant / Control interface (shared code for all backends)
   3  * Copyright (c) 2004-2012, 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 "utils/includes.h"
  10
  11 #include "utils/common.h"
  12 #include "utils/eloop.h"
  13 #include "common/version.h"
  14 #include "common/ieee802_11_defs.h"
  15 #include "common/ieee802_11_common.h"
  16 #include "common/wpa_ctrl.h"
  17 #include "eap_peer/eap.h"
  18 #include "eapol_supp/eapol_supp_sm.h"
  19 #include "rsn_supp/wpa.h"
  20 #include "rsn_supp/preauth.h"
  21 #include "rsn_supp/pmksa_cache.h"
  22 #include "l2_packet/l2_packet.h"
  23 #include "wps/wps.h"
  24 #include "config.h"
  25 #include "wpa_supplicant_i.h"
  26 #include "driver_i.h"
  27 #include "wps_supplicant.h"
  28 #include "ibss_rsn.h"
  29 #include "ap.h"
  30 #include "p2p_supplicant.h"
  31 #include "p2p/p2p.h"
  32 #include "hs20_supplicant.h"
  33 #include "wifi_display.h"
  34 #include "notify.h"
  35 #include "bss.h"
  36 #include "scan.h"
  37 #include "ctrl_iface.h"
  38 #include "interworking.h"
  39 #include "blacklist.h"
  40 #include "autoscan.h"
  41 #include "wnm_sta.h"
  42
  43 extern struct wpa_driver_ops *wpa_drivers[];
  44
  45 static int wpa_supplicant_global_iface_list(struct wpa_global *global,
  46                                             char *buf, int len);
  47 static int wpa_supplicant_global_iface_interfaces(struct wpa_global *global,
  48                                                   char *buf, int len);
  49
  50
  51 static int pno_start(struct wpa_supplicant *wpa_s)
  52 {
  53         int ret;
  54         size_t i, num_ssid;
  55         struct wpa_ssid *ssid;
  56         struct wpa_driver_scan_params params;
  57
  58         if (wpa_s->pno)
  59                 return 0;
  60
  61         os_memset(&params, 0, sizeof(params));
  62
  63         num_ssid = 0;
  64         ssid = wpa_s->conf->ssid;
  65         while (ssid) {
  66                 if (!wpas_network_disabled(wpa_s, ssid))
  67                         num_ssid++;
  68                 ssid = ssid->next;
  69         }
  70         if (num_ssid > WPAS_MAX_SCAN_SSIDS) {
  71                 wpa_printf(MSG_DEBUG, "PNO: Use only the first %u SSIDs from "
  72                            "%u", WPAS_MAX_SCAN_SSIDS, (unsigned int) num_ssid);
  73                 num_ssid = WPAS_MAX_SCAN_SSIDS;
  74         }
  75
  76         if (num_ssid == 0) {
  77                 wpa_printf(MSG_DEBUG, "PNO: No configured SSIDs");
  78                 return -1;
  79         }
  80
  81         params.filter_ssids = os_malloc(sizeof(struct wpa_driver_scan_filter) *
  82                                         num_ssid);
  83         if (params.filter_ssids == NULL)
  84                 return -1;
  85         i = 0;
  86         ssid = wpa_s->conf->ssid;
  87         while (ssid) {
  88                 if (!wpas_network_disabled(wpa_s, ssid)) {
  89                         params.ssids[i].ssid = ssid->ssid;
  90                         params.ssids[i].ssid_len = ssid->ssid_len;
  91                         params.num_ssids++;
  92                         os_memcpy(params.filter_ssids[i].ssid, ssid->ssid,
  93                                   ssid->ssid_len);
  94                         params.filter_ssids[i].ssid_len = ssid->ssid_len;
  95                         params.num_filter_ssids++;
  96                         i++;
  97                         if (i == num_ssid)
  98                                 break;
  99                 }
 100                 ssid = ssid->next;
 101         }
 102
 103         if (wpa_s->conf->filter_rssi)
 104                 params.filter_rssi = wpa_s->conf->filter_rssi;
 105
 106         ret = wpa_drv_sched_scan(wpa_s, &params, 10 * 1000);
 107         os_free(params.filter_ssids);
 108         if (ret == 0)
 109                 wpa_s->pno = 1;
 110         return ret;
 111 }
 112
 113
 114 static int pno_stop(struct wpa_supplicant *wpa_s)
 115 {
 116         if (wpa_s->pno) {
 117                 wpa_s->pno = 0;
 118                 return wpa_drv_stop_sched_scan(wpa_s);
 119         }
 120         return 0;
 121 }
 122
 123
 124 static int set_bssid_filter(struct wpa_supplicant *wpa_s, char *val)
 125 {
 126         char *pos;
 127         u8 addr[ETH_ALEN], *filter = NULL, *n;
 128         size_t count = 0;
 129
 130         pos = val;
 131         while (pos) {
 132                 if (*pos == '\0')
 133                         break;
 134                 if (hwaddr_aton(pos, addr)) {
 135                         os_free(filter);
 136                         return -1;
 137                 }
 138                 n = os_realloc_array(filter, count + 1, ETH_ALEN);
 139                 if (n == NULL) {
 140                         os_free(filter);
 141                         return -1;
 142                 }
 143                 filter = n;
 144                 os_memcpy(filter + count * ETH_ALEN, addr, ETH_ALEN);
 145                 count++;
 146
 147                 pos = os_strchr(pos, ' ');
 148                 if (pos)
 149                         pos++;
 150         }
 151
 152         wpa_hexdump(MSG_DEBUG, "bssid_filter", filter, count * ETH_ALEN);
 153         os_free(wpa_s->bssid_filter);
 154         wpa_s->bssid_filter = filter;
 155         wpa_s->bssid_filter_count = count;
 156
 157         return 0;
 158 }
 159
 160
 161 static int set_disallow_aps(struct wpa_supplicant *wpa_s, char *val)
 162 {
 163         char *pos;
 164         u8 addr[ETH_ALEN], *bssid = NULL, *n;
 165         struct wpa_ssid_value *ssid = NULL, *ns;
 166         size_t count = 0, ssid_count = 0;
 167         struct wpa_ssid *c;
 168
 169         /*
 170          * disallow_list ::= <ssid_spec> | <bssid_spec> | <disallow_list> | “”
 171          * SSID_SPEC ::= ssid <SSID_HEX>
 172          * BSSID_SPEC ::= bssid <BSSID_HEX>
 173          */
 174
 175         pos = val;
 176         while (pos) {
 177                 if (*pos == '\0')
 178                         break;
 179                 if (os_strncmp(pos, "bssid ", 6) == 0) {
 180                         int res;
 181                         pos += 6;
 182                         res = hwaddr_aton2(pos, addr);
 183                         if (res < 0) {
 184                                 os_free(ssid);
 185                                 os_free(bssid);
 186                                 wpa_printf(MSG_DEBUG, "Invalid disallow_aps "
 187                                            "BSSID value '%s'", pos);
 188                                 return -1;
 189                         }
 190                         pos += res;
 191                         n = os_realloc_array(bssid, count + 1, ETH_ALEN);
 192                         if (n == NULL) {
 193                                 os_free(ssid);
 194                                 os_free(bssid);
 195                                 return -1;
 196                         }
 197                         bssid = n;
 198                         os_memcpy(bssid + count * ETH_ALEN, addr, ETH_ALEN);
 199                         count++;
 200                 } else if (os_strncmp(pos, "ssid ", 5) == 0) {
 201                         char *end;
 202                         pos += 5;
 203
 204                         end = pos;
 205                         while (*end) {
 206                                 if (*end == '\0' || *end == ' ')
 207                                         break;
 208                                 end++;
 209                         }
 210
 211                         ns = os_realloc_array(ssid, ssid_count + 1,
 212                                               sizeof(struct wpa_ssid_value));
 213                         if (ns == NULL) {
 214                                 os_free(ssid);
 215                                 os_free(bssid);
 216                                 return -1;
 217                         }
 218                         ssid = ns;
 219
 220                         if ((end - pos) & 0x01 || end - pos > 2 * 32 ||
 221                             hexstr2bin(pos, ssid[ssid_count].ssid,
 222                                        (end - pos) / 2) < 0) {
 223                                 os_free(ssid);
 224                                 os_free(bssid);
 225                                 wpa_printf(MSG_DEBUG, "Invalid disallow_aps "
 226                                            "SSID value '%s'", pos);
 227                                 return -1;
 228                         }
 229                         ssid[ssid_count].ssid_len = (end - pos) / 2;
 230                         wpa_hexdump_ascii(MSG_DEBUG, "disallow_aps SSID",
 231                                           ssid[ssid_count].ssid,
 232                                           ssid[ssid_count].ssid_len);
 233                         ssid_count++;
 234                         pos = end;
 235                 } else {
 236                         wpa_printf(MSG_DEBUG, "Unexpected disallow_aps value "
 237                                    "'%s'", pos);
 238                         os_free(ssid);
 239                         os_free(bssid);
 240                         return -1;
 241                 }
 242
 243                 pos = os_strchr(pos, ' ');
 244                 if (pos)
 245                         pos++;
 246         }
 247
 248         wpa_hexdump(MSG_DEBUG, "disallow_aps_bssid", bssid, count * ETH_ALEN);
 249         os_free(wpa_s->disallow_aps_bssid);
 250         wpa_s->disallow_aps_bssid = bssid;
 251         wpa_s->disallow_aps_bssid_count = count;
 252
 253         wpa_printf(MSG_DEBUG, "disallow_aps_ssid_count %d", (int) ssid_count);
 254         os_free(wpa_s->disallow_aps_ssid);
 255         wpa_s->disallow_aps_ssid = ssid;
 256         wpa_s->disallow_aps_ssid_count = ssid_count;
 257
 258         if (!wpa_s->current_ssid || wpa_s->wpa_state < WPA_AUTHENTICATING)
 259                 return 0;
 260
 261         c = wpa_s->current_ssid;
 262         if (c->mode != WPAS_MODE_INFRA && c->mode != WPAS_MODE_IBSS)
 263                 return 0;
 264
 265         if (!disallowed_bssid(wpa_s, wpa_s->bssid) &&
 266             !disallowed_ssid(wpa_s, c->ssid, c->ssid_len))
 267                 return 0;
 268
 269         wpa_printf(MSG_DEBUG, "Disconnect and try to find another network "
 270                    "because current AP was marked disallowed");
 271
 272 #ifdef CONFIG_SME
 273         wpa_s->sme.prev_bssid_set = 0;
 274 #endif /* CONFIG_SME */
 275         wpa_s->reassociate = 1;
 276         wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
 277         wpa_supplicant_req_scan(wpa_s, 0, 0);
 278
 279         return 0;
 280 }
 281
 282
 283 static int wpa_supplicant_ctrl_iface_set(struct wpa_supplicant *wpa_s,
 284                                          char *cmd)
 285 {
 286         char *value;
 287         int ret = 0;
 288
 289         value = os_strchr(cmd, ' ');
 290         if (value == NULL)
 291                 return -1;
 292         *value++ = '\0';
 293
 294         wpa_printf(MSG_DEBUG, "CTRL_IFACE SET '%s'='%s'", cmd, value);
 295         if (os_strcasecmp(cmd, "EAPOL::heldPeriod") == 0) {
 296                 eapol_sm_configure(wpa_s->eapol,
 297                                    atoi(value), -1, -1, -1);
 298         } else if (os_strcasecmp(cmd, "EAPOL::authPeriod") == 0) {
 299                 eapol_sm_configure(wpa_s->eapol,
 300                                    -1, atoi(value), -1, -1);
 301         } else if (os_strcasecmp(cmd, "EAPOL::startPeriod") == 0) {
 302                 eapol_sm_configure(wpa_s->eapol,
 303                                    -1, -1, atoi(value), -1);
 304         } else if (os_strcasecmp(cmd, "EAPOL::maxStart") == 0) {
 305                 eapol_sm_configure(wpa_s->eapol,
 306                                    -1, -1, -1, atoi(value));
 307         } else if (os_strcasecmp(cmd, "dot11RSNAConfigPMKLifetime") == 0) {
 308                 if (wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
 309                                      atoi(value)))
 310                         ret = -1;
 311         } else if (os_strcasecmp(cmd, "dot11RSNAConfigPMKReauthThreshold") ==
 312                    0) {
 313                 if (wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
 314                                      atoi(value)))
 315                         ret = -1;
 316         } else if (os_strcasecmp(cmd, "dot11RSNAConfigSATimeout") == 0) {
 317                 if (wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT, atoi(value)))
 318                         ret = -1;
 319         } else if (os_strcasecmp(cmd, "wps_fragment_size") == 0) {
 320                 wpa_s->wps_fragment_size = atoi(value);
 321 #ifdef CONFIG_WPS_TESTING
 322         } else if (os_strcasecmp(cmd, "wps_version_number") == 0) {
 323                 long int val;
 324                 val = strtol(value, NULL, 0);
 325                 if (val < 0 || val > 0xff) {
 326                         ret = -1;
 327                         wpa_printf(MSG_DEBUG, "WPS: Invalid "
 328                                    "wps_version_number %ld", val);
 329                 } else {
 330                         wps_version_number = val;
 331                         wpa_printf(MSG_DEBUG, "WPS: Testing - force WPS "
 332                                    "version %u.%u",
 333                                    (wps_version_number & 0xf0) >> 4,
 334                                    wps_version_number & 0x0f);
 335                 }
 336         } else if (os_strcasecmp(cmd, "wps_testing_dummy_cred") == 0) {
 337                 wps_testing_dummy_cred = atoi(value);
 338                 wpa_printf(MSG_DEBUG, "WPS: Testing - dummy_cred=%d",
 339                            wps_testing_dummy_cred);
 340 #endif /* CONFIG_WPS_TESTING */
 341         } else if (os_strcasecmp(cmd, "ampdu") == 0) {
 342                 if (wpa_drv_ampdu(wpa_s, atoi(value)) < 0)
 343                         ret = -1;
 344 #ifdef CONFIG_TDLS_TESTING
 345         } else if (os_strcasecmp(cmd, "tdls_testing") == 0) {
 346                 extern unsigned int tdls_testing;
 347                 tdls_testing = strtol(value, NULL, 0);
 348                 wpa_printf(MSG_DEBUG, "TDLS: tdls_testing=0x%x", tdls_testing);
 349 #endif /* CONFIG_TDLS_TESTING */
 350 #ifdef CONFIG_TDLS
 351         } else if (os_strcasecmp(cmd, "tdls_disabled") == 0) {
 352                 int disabled = atoi(value);
 353                 wpa_printf(MSG_DEBUG, "TDLS: tdls_disabled=%d", disabled);
 354                 if (disabled) {
 355                         if (wpa_drv_tdls_oper(wpa_s, TDLS_DISABLE, NULL) < 0)
 356                                 ret = -1;
 357                 } else if (wpa_drv_tdls_oper(wpa_s, TDLS_ENABLE, NULL) < 0)
 358                         ret = -1;
 359                 wpa_tdls_enable(wpa_s->wpa, !disabled);
 360 #endif /* CONFIG_TDLS */
 361         } else if (os_strcasecmp(cmd, "pno") == 0) {
 362                 if (atoi(value))
 363                         ret = pno_start(wpa_s);
 364                 else
 365                         ret = pno_stop(wpa_s);
 366         } else if (os_strcasecmp(cmd, "radio_disabled") == 0) {
 367                 int disabled = atoi(value);
 368                 if (wpa_drv_radio_disable(wpa_s, disabled) < 0)
 369                         ret = -1;
 370                 else if (disabled)
 371                         wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
 372         } else if (os_strcasecmp(cmd, "uapsd") == 0) {
 373                 if (os_strcmp(value, "disable") == 0)
 374                         wpa_s->set_sta_uapsd = 0;
 375                 else {
 376                         int be, bk, vi, vo;
 377                         char *pos;
 378                         /* format: BE,BK,VI,VO;max SP Length */
 379                         be = atoi(value);
 380                         pos = os_strchr(value, ',');
 381                         if (pos == NULL)
 382                                 return -1;
 383                         pos++;
 384                         bk = atoi(pos);
 385                         pos = os_strchr(pos, ',');
 386                         if (pos == NULL)
 387                                 return -1;
 388                         pos++;
 389                         vi = atoi(pos);
 390                         pos = os_strchr(pos, ',');
 391                         if (pos == NULL)
 392                                 return -1;
 393                         pos++;
 394                         vo = atoi(pos);
 395                         /* ignore max SP Length for now */
 396
 397                         wpa_s->set_sta_uapsd = 1;
 398                         wpa_s->sta_uapsd = 0;
 399                         if (be)
 400                                 wpa_s->sta_uapsd |= BIT(0);
 401                         if (bk)
 402                                 wpa_s->sta_uapsd |= BIT(1);
 403                         if (vi)
 404                                 wpa_s->sta_uapsd |= BIT(2);
 405                         if (vo)
 406                                 wpa_s->sta_uapsd |= BIT(3);
 407                 }
 408         } else if (os_strcasecmp(cmd, "ps") == 0) {
 409                 ret = wpa_drv_set_p2p_powersave(wpa_s, atoi(value), -1, -1);
 410 #ifdef CONFIG_WIFI_DISPLAY
 411         } else if (os_strcasecmp(cmd, "wifi_display") == 0) {
 412                 wifi_display_enable(wpa_s->global, !!atoi(value));
 413 #endif /* CONFIG_WIFI_DISPLAY */
 414         } else if (os_strcasecmp(cmd, "bssid_filter") == 0) {
 415                 ret = set_bssid_filter(wpa_s, value);
 416         } else if (os_strcasecmp(cmd, "disallow_aps") == 0) {
 417                 ret = set_disallow_aps(wpa_s, value);
 418         } else {
 419                 value[-1] = '=';
 420                 ret = wpa_config_process_global(wpa_s->conf, cmd, -1);
 421                 if (ret == 0)
 422                         wpa_supplicant_update_config(wpa_s);
 423         }
 424
 425         return ret;
 426 }
 427
 428
 429 static int wpa_supplicant_ctrl_iface_get(struct wpa_supplicant *wpa_s,
 430                                          char *cmd, char *buf, size_t buflen)
 431 {
 432         int res = -1;
 433
 434         wpa_printf(MSG_DEBUG, "CTRL_IFACE GET '%s'", cmd);
 435
 436         if (os_strcmp(cmd, "version") == 0) {
 437                 res = os_snprintf(buf, buflen, "%s", VERSION_STR);
 438         } else if (os_strcasecmp(cmd, "country") == 0) {
 439                 if (wpa_s->conf->country[0] && wpa_s->conf->country[1])
 440                         res = os_snprintf(buf, buflen, "%c%c",
 441                                           wpa_s->conf->country[0],
 442                                           wpa_s->conf->country[1]);
 443 #ifdef CONFIG_WIFI_DISPLAY
 444         } else if (os_strcasecmp(cmd, "wifi_display") == 0) {
 445                 res = os_snprintf(buf, buflen, "%d",
 446                                   wpa_s->global->wifi_display);
 447                 if (res < 0 || (unsigned int) res >= buflen)
 448                         return -1;
 449                 return res;
 450 #endif /* CONFIG_WIFI_DISPLAY */
 451         }
 452
 453         if (res < 0 || (unsigned int) res >= buflen)
 454                 return -1;
 455         return res;
 456 }
 457
 458
 459 #ifdef IEEE8021X_EAPOL
 460 static int wpa_supplicant_ctrl_iface_preauth(struct wpa_supplicant *wpa_s,
 461                                              char *addr)
 462 {
 463         u8 bssid[ETH_ALEN];
 464         struct wpa_ssid *ssid = wpa_s->current_ssid;
 465
 466         if (hwaddr_aton(addr, bssid)) {
 467                 wpa_printf(MSG_DEBUG, "CTRL_IFACE PREAUTH: invalid address "
 468                            "'%s'", addr);
 469                 return -1;
 470         }
 471
 472         wpa_printf(MSG_DEBUG, "CTRL_IFACE PREAUTH " MACSTR, MAC2STR(bssid));
 473         rsn_preauth_deinit(wpa_s->wpa);
 474         if (rsn_preauth_init(wpa_s->wpa, bssid, ssid ? &ssid->eap : NULL))
 475                 return -1;
 476
 477         return 0;
 478 }
 479 #endif /* IEEE8021X_EAPOL */
 480
 481
 482 #ifdef CONFIG_PEERKEY
 483 /* MLME-STKSTART.request(peer) */
 484 static int wpa_supplicant_ctrl_iface_stkstart(
 485         struct wpa_supplicant *wpa_s, char *addr)
 486 {
 487         u8 peer[ETH_ALEN];
 488
 489         if (hwaddr_aton(addr, peer)) {
 490                 wpa_printf(MSG_DEBUG, "CTRL_IFACE STKSTART: invalid "
 491                            "address '%s'", addr);
 492                 return -1;
 493         }
 494
 495         wpa_printf(MSG_DEBUG, "CTRL_IFACE STKSTART " MACSTR,
 496                    MAC2STR(peer));
 497
 498         return wpa_sm_stkstart(wpa_s->wpa, peer);
 499 }
 500 #endif /* CONFIG_PEERKEY */
 501
 502
 503 #ifdef CONFIG_TDLS
 504
 505 static int wpa_supplicant_ctrl_iface_tdls_discover(
 506         struct wpa_supplicant *wpa_s, char *addr)
 507 {
 508         u8 peer[ETH_ALEN];
 509         int ret;
 510
 511         if (hwaddr_aton(addr, peer)) {
 512                 wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_DISCOVER: invalid "
 513                            "address '%s'", addr);
 514                 return -1;
 515         }
 516
 517         wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_DISCOVER " MACSTR,
 518                    MAC2STR(peer));
 519
 520         if (wpa_tdls_is_external_setup(wpa_s->wpa))
 521                 ret = wpa_tdls_send_discovery_request(wpa_s->wpa, peer);
 522         else
 523                 ret = wpa_drv_tdls_oper(wpa_s, TDLS_DISCOVERY_REQ, peer);
 524
 525         return ret;
 526 }
 527
 528
 529 static int wpa_supplicant_ctrl_iface_tdls_setup(
 530         struct wpa_supplicant *wpa_s, char *addr)
 531 {
 532         u8 peer[ETH_ALEN];
 533         int ret;
 534
 535         if (hwaddr_aton(addr, peer)) {
 536                 wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_SETUP: invalid "
 537                            "address '%s'", addr);
 538                 return -1;
 539         }
 540
 541         wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_SETUP " MACSTR,
 542                    MAC2STR(peer));
 543
 544         ret = wpa_tdls_reneg(wpa_s->wpa, peer);
 545         if (ret) {
 546                 if (wpa_tdls_is_external_setup(wpa_s->wpa))
 547                         ret = wpa_tdls_start(wpa_s->wpa, peer);
 548                 else
 549                         ret = wpa_drv_tdls_oper(wpa_s, TDLS_SETUP, peer);
 550         }
 551
 552         return ret;
 553 }
 554
 555
 556 static int wpa_supplicant_ctrl_iface_tdls_teardown(
 557         struct wpa_supplicant *wpa_s, char *addr)
 558 {
 559         u8 peer[ETH_ALEN];
 560
 561         if (hwaddr_aton(addr, peer)) {
 562                 wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_TEARDOWN: invalid "
 563                            "address '%s'", addr);
 564                 return -1;
 565         }
 566
 567         wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_TEARDOWN " MACSTR,
 568                    MAC2STR(peer));
 569
 570         return wpa_tdls_teardown_link(wpa_s->wpa, peer,
 571                                       WLAN_REASON_TDLS_TEARDOWN_UNSPECIFIED);
 572 }
 573
 574 #endif /* CONFIG_TDLS */
 575
 576
 577 #ifdef CONFIG_IEEE80211R
 578 static int wpa_supplicant_ctrl_iface_ft_ds(
 579         struct wpa_supplicant *wpa_s, char *addr)
 580 {
 581         u8 target_ap[ETH_ALEN];
 582         struct wpa_bss *bss;
 583         const u8 *mdie;
 584
 585         if (hwaddr_aton(addr, target_ap)) {
 586                 wpa_printf(MSG_DEBUG, "CTRL_IFACE FT_DS: invalid "
 587                            "address '%s'", addr);
 588                 return -1;
 589         }
 590
 591         wpa_printf(MSG_DEBUG, "CTRL_IFACE FT_DS " MACSTR, MAC2STR(target_ap));
 592
 593         bss = wpa_bss_get_bssid(wpa_s, target_ap);
 594         if (bss)
 595                 mdie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
 596         else
 597                 mdie = NULL;
 598
 599         return wpa_ft_start_over_ds(wpa_s->wpa, target_ap, mdie);
 600 }
 601 #endif /* CONFIG_IEEE80211R */
 602
 603
 604 #ifdef CONFIG_WPS
 605 static int wpa_supplicant_ctrl_iface_wps_pbc(struct wpa_supplicant *wpa_s,
 606                                              char *cmd)
 607 {
 608         u8 bssid[ETH_ALEN], *_bssid = bssid;
 609 #ifdef CONFIG_P2P
 610         u8 p2p_dev_addr[ETH_ALEN];
 611 #endif /* CONFIG_P2P */
 612 #ifdef CONFIG_AP
 613         u8 *_p2p_dev_addr = NULL;
 614 #endif /* CONFIG_AP */
 615
 616         if (cmd == NULL || os_strcmp(cmd, "any") == 0) {
 617                 _bssid = NULL;
 618 #ifdef CONFIG_P2P
 619         } else if (os_strncmp(cmd, "p2p_dev_addr=", 13) == 0) {
 620                 if (hwaddr_aton(cmd + 13, p2p_dev_addr)) {
 621                         wpa_printf(MSG_DEBUG, "CTRL_IFACE WPS_PBC: invalid "
 622                                    "P2P Device Address '%s'",
 623                                    cmd + 13);
 624                         return -1;
 625                 }
 626                 _p2p_dev_addr = p2p_dev_addr;
 627 #endif /* CONFIG_P2P */
 628         } else if (hwaddr_aton(cmd, bssid)) {
 629                 wpa_printf(MSG_DEBUG, "CTRL_IFACE WPS_PBC: invalid BSSID '%s'",
 630                            cmd);
 631                 return -1;
 632         }
 633
 634 #ifdef CONFIG_AP
 635         if (wpa_s->ap_iface)
 636                 return wpa_supplicant_ap_wps_pbc(wpa_s, _bssid, _p2p_dev_addr);
 637 #endif /* CONFIG_AP */
 638
 639         return wpas_wps_start_pbc(wpa_s, _bssid, 0);
 640 }
 641
 642
 643 static int wpa_supplicant_ctrl_iface_wps_pin(struct wpa_supplicant *wpa_s,
 644                                              char *cmd, char *buf,
 645                                              size_t buflen)
 646 {
 647         u8 bssid[ETH_ALEN], *_bssid = bssid;
 648         char *pin;
 649         int ret;
 650
 651         pin = os_strchr(cmd, ' ');
 652         if (pin)
 653                 *pin++ = '\0';
 654
 655         if (os_strcmp(cmd, "any") == 0)
 656                 _bssid = NULL;
 657         else if (os_strcmp(cmd, "get") == 0) {
 658                 ret = wps_generate_pin();
 659                 goto done;
 660         } else if (hwaddr_aton(cmd, bssid)) {
 661                 wpa_printf(MSG_DEBUG, "CTRL_IFACE WPS_PIN: invalid BSSID '%s'",
 662                            cmd);
 663                 return -1;
 664         }
 665
 666 #ifdef CONFIG_AP
 667         if (wpa_s->ap_iface) {
 668                 int timeout = 0;
 669                 char *pos;
 670
 671                 if (pin) {
 672                         pos = os_strchr(pin, ' ');
 673                         if (pos) {
 674                                 *pos++ = '\0';
 675                                 timeout = atoi(pos);
 676                         }
 677                 }
 678
 679                 return wpa_supplicant_ap_wps_pin(wpa_s, _bssid, pin,
 680                                                  buf, buflen, timeout);
 681         }
 682 #endif /* CONFIG_AP */
 683
 684         if (pin) {
 685                 ret = wpas_wps_start_pin(wpa_s, _bssid, pin, 0,
 686                                          DEV_PW_DEFAULT);
 687                 if (ret < 0)
 688                         return -1;
 689                 ret = os_snprintf(buf, buflen, "%s", pin);
 690                 if (ret < 0 || (size_t) ret >= buflen)
 691                         return -1;
 692                 return ret;
 693         }
 694
 695         ret = wpas_wps_start_pin(wpa_s, _bssid, NULL, 0, DEV_PW_DEFAULT);
 696         if (ret < 0)
 697                 return -1;
 698
 699 done:
 700         /* Return the generated PIN */
 701         ret = os_snprintf(buf, buflen, "%08d", ret);
 702         if (ret < 0 || (size_t) ret >= buflen)
 703                 return -1;
 704         return ret;
 705 }
 706
 707
 708 static int wpa_supplicant_ctrl_iface_wps_check_pin(
 709         struct wpa_supplicant *wpa_s, char *cmd, char *buf, size_t buflen)
 710 {
 711         char pin[9];
 712         size_t len;
 713         char *pos;
 714         int ret;
 715
 716         wpa_hexdump_ascii_key(MSG_DEBUG, "WPS_CHECK_PIN",
 717                               (u8 *) cmd, os_strlen(cmd));
 718         for (pos = cmd, len = 0; *pos != '\0'; pos++) {
 719                 if (*pos < '0' || *pos > '9')
 720                         continue;
 721                 pin[len++] = *pos;
 722                 if (len == 9) {
 723                         wpa_printf(MSG_DEBUG, "WPS: Too long PIN");
 724                         return -1;
 725                 }
 726         }
 727         if (len != 4 && len != 8) {
 728                 wpa_printf(MSG_DEBUG, "WPS: Invalid PIN length %d", (int) len);
 729                 return -1;
 730         }
 731         pin[len] = '\0';
 732
 733         if (len == 8) {
 734                 unsigned int pin_val;
 735                 pin_val = atoi(pin);
 736                 if (!wps_pin_valid(pin_val)) {
 737                         wpa_printf(MSG_DEBUG, "WPS: Invalid checksum digit");
 738                         ret = os_snprintf(buf, buflen, "FAIL-CHECKSUM\n");
 739                         if (ret < 0 || (size_t) ret >= buflen)
 740                                 return -1;
 741                         return ret;
 742                 }
 743         }
 744
 745         ret = os_snprintf(buf, buflen, "%s", pin);
 746         if (ret < 0 || (size_t) ret >= buflen)
 747                 return -1;
 748
 749         return ret;
 750 }
 751
 752
 753 #ifdef CONFIG_WPS_NFC
 754
 755 static int wpa_supplicant_ctrl_iface_wps_nfc(struct wpa_supplicant *wpa_s,
 756                                              char *cmd)
 757 {
 758         u8 bssid[ETH_ALEN], *_bssid = bssid;
 759
 760         if (cmd == NULL || cmd[0] == '\0')
 761                 _bssid = NULL;
 762         else if (hwaddr_aton(cmd, bssid))
 763                 return -1;
 764
 765         return wpas_wps_start_nfc(wpa_s, _bssid);
 766 }
 767
 768
 769 static int wpa_supplicant_ctrl_iface_wps_nfc_token(
 770         struct wpa_supplicant *wpa_s, char *cmd, char *reply, size_t max_len)
 771 {
 772         int ndef;
 773         struct wpabuf *buf;
 774         int res;
 775
 776         if (os_strcmp(cmd, "WPS") == 0)
 777                 ndef = 0;
 778         else if (os_strcmp(cmd, "NDEF") == 0)
 779                 ndef = 1;
 780         else
 781                 return -1;
 782
 783         buf = wpas_wps_nfc_token(wpa_s, ndef);
 784         if (buf == NULL)
 785                 return -1;
 786
 787         res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
 788                                          wpabuf_len(buf));
 789         reply[res++] = '\n';
 790         reply[res] = '\0';
 791
 792         wpabuf_free(buf);
 793
 794         return res;
 795 }
 796
 797
 798 static int wpa_supplicant_ctrl_iface_wps_nfc_tag_read(
 799         struct wpa_supplicant *wpa_s, char *pos)
 800 {
 801         size_t len;
 802         struct wpabuf *buf;
 803         int ret;
 804
 805         len = os_strlen(pos);
 806         if (len & 0x01)
 807                 return -1;
 808         len /= 2;
 809
 810         buf = wpabuf_alloc(len);
 811         if (buf == NULL)
 812                 return -1;
 813         if (hexstr2bin(pos, wpabuf_put(buf, len), len) < 0) {
 814                 wpabuf_free(buf);
 815                 return -1;
 816         }
 817
 818         ret = wpas_wps_nfc_tag_read(wpa_s, buf);
 819         wpabuf_free(buf);
 820
 821         return ret;
 822 }
 823
 824
 825 static int wpas_ctrl_nfc_get_handover_req_wps(struct wpa_supplicant *wpa_s,
 826                                               char *reply, size_t max_len)
 827 {
 828         struct wpabuf *buf;
 829         int res;
 830
 831         buf = wpas_wps_nfc_handover_req(wpa_s);
 832         if (buf == NULL)
 833                 return -1;
 834
 835         res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
 836                                          wpabuf_len(buf));
 837         reply[res++] = '\n';
 838         reply[res] = '\0';
 839
 840         wpabuf_free(buf);
 841
 842         return res;
 843 }
 844
 845
 846 static int wpas_ctrl_nfc_get_handover_req(struct wpa_supplicant *wpa_s,
 847                                           char *cmd, char *reply,
 848                                           size_t max_len)
 849 {
 850         char *pos;
 851
 852         pos = os_strchr(cmd, ' ');
 853         if (pos == NULL)
 854                 return -1;
 855         *pos++ = '\0';
 856
 857         if (os_strcmp(cmd, "NDEF") != 0)
 858                 return -1;
 859
 860         if (os_strcmp(pos, "WPS") == 0) {
 861                 return wpas_ctrl_nfc_get_handover_req_wps(wpa_s, reply,
 862                                                           max_len);
 863         }
 864
 865         return -1;
 866 }
 867
 868
 869 static int wpas_ctrl_nfc_get_handover_sel_wps(struct wpa_supplicant *wpa_s,
 870                                               char *reply, size_t max_len)
 871 {
 872         struct wpabuf *buf;
 873         int res;
 874
 875         buf = wpas_wps_nfc_handover_sel(wpa_s);
 876         if (buf == NULL)
 877                 return -1;
 878
 879         res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
 880                                          wpabuf_len(buf));
 881         reply[res++] = '\n';
 882         reply[res] = '\0';
 883
 884         wpabuf_free(buf);
 885
 886         return res;
 887 }
 888
 889
 890 static int wpas_ctrl_nfc_get_handover_sel(struct wpa_supplicant *wpa_s,
 891                                           char *cmd, char *reply,
 892                                           size_t max_len)
 893 {
 894         char *pos;
 895
 896         pos = os_strchr(cmd, ' ');
 897         if (pos == NULL)
 898                 return -1;
 899         *pos++ = '\0';
 900
 901         if (os_strcmp(cmd, "NDEF") != 0)
 902                 return -1;
 903
 904         if (os_strcmp(pos, "WPS") == 0) {
 905                 return wpas_ctrl_nfc_get_handover_sel_wps(wpa_s, reply,
 906                                                           max_len);
 907         }
 908
 909         return -1;
 910 }
 911
 912
 913 static int wpas_ctrl_nfc_rx_handover_req(struct wpa_supplicant *wpa_s,
 914                                          char *cmd, char *reply,
 915                                          size_t max_len)
 916 {
 917         size_t len;
 918         struct wpabuf *buf;
 919         int ret;
 920
 921         len = os_strlen(cmd);
 922         if (len & 0x01)
 923                 return -1;
 924         len /= 2;
 925
 926         buf = wpabuf_alloc(len);
 927         if (buf == NULL)
 928                 return -1;
 929         if (hexstr2bin(cmd, wpabuf_put(buf, len), len) < 0) {
 930                 wpabuf_free(buf);
 931                 return -1;
 932         }
 933
 934         ret = wpas_wps_nfc_rx_handover_req(wpa_s, buf);
 935         wpabuf_free(buf);
 936
 937         return ret;
 938 }
 939
 940
 941 static int wpas_ctrl_nfc_rx_handover_sel(struct wpa_supplicant *wpa_s,
 942                                          char *cmd)
 943 {
 944         size_t len;
 945         struct wpabuf *buf;
 946         int ret;
 947
 948         len = os_strlen(cmd);
 949         if (len & 0x01)
 950                 return -1;
 951         len /= 2;
 952
 953         buf = wpabuf_alloc(len);
 954         if (buf == NULL)
 955                 return -1;
 956         if (hexstr2bin(cmd, wpabuf_put(buf, len), len) < 0) {
 957                 wpabuf_free(buf);
 958                 return -1;
 959         }
 960
 961         ret = wpas_wps_nfc_rx_handover_sel(wpa_s, buf);
 962         wpabuf_free(buf);
 963
 964         return ret;
 965 }
 966
 967 #endif /* CONFIG_WPS_NFC */
 968
 969
 970 static int wpa_supplicant_ctrl_iface_wps_reg(struct wpa_supplicant *wpa_s,
 971                                              char *cmd)
 972 {
 973         u8 bssid[ETH_ALEN];
 974         char *pin;
 975         char *new_ssid;
 976         char *new_auth;
 977         char *new_encr;
 978         char *new_key;
 979         struct wps_new_ap_settings ap;
 980
 981         pin = os_strchr(cmd, ' ');
 982         if (pin == NULL)
 983                 return -1;
 984         *pin++ = '\0';
 985
 986         if (hwaddr_aton(cmd, bssid)) {
 987                 wpa_printf(MSG_DEBUG, "CTRL_IFACE WPS_REG: invalid BSSID '%s'",
 988                            cmd);
 989                 return -1;
 990         }
 991
 992         new_ssid = os_strchr(pin, ' ');
 993         if (new_ssid == NULL)
 994                 return wpas_wps_start_reg(wpa_s, bssid, pin, NULL);
 995         *new_ssid++ = '\0';
 996
 997         new_auth = os_strchr(new_ssid, ' ');
 998         if (new_auth == NULL)
 999                 return -1;
1000         *new_auth++ = '\0';
1001
1002         new_encr = os_strchr(new_auth, ' ');
1003         if (new_encr == NULL)
1004                 return -1;
1005         *new_encr++ = '\0';
1006
1007         new_key = os_strchr(new_encr, ' ');
1008         if (new_key == NULL)
1009                 return -1;
1010         *new_key++ = '\0';
1011
1012         os_memset(&ap, 0, sizeof(ap));
1013         ap.ssid_hex = new_ssid;
1014         ap.auth = new_auth;
1015         ap.encr = new_encr;
1016         ap.key_hex = new_key;
1017         return wpas_wps_start_reg(wpa_s, bssid, pin, &ap);
1018 }
1019
1020
1021 #ifdef CONFIG_AP
1022 static int wpa_supplicant_ctrl_iface_wps_ap_pin(struct wpa_supplicant *wpa_s,
1023                                                 char *cmd, char *buf,
1024                                                 size_t buflen)
1025 {
1026         int timeout = 300;
1027         char *pos;
1028         const char *pin_txt;
1029
1030         if (!wpa_s->ap_iface)
1031                 return -1;
1032
1033         pos = os_strchr(cmd, ' ');
1034         if (pos)
1035                 *pos++ = '\0';
1036
1037         if (os_strcmp(cmd, "disable") == 0) {
1038                 wpas_wps_ap_pin_disable(wpa_s);
1039                 return os_snprintf(buf, buflen, "OK\n");
1040         }
1041
1042         if (os_strcmp(cmd, "random") == 0) {
1043                 if (pos)
1044                         timeout = atoi(pos);
1045                 pin_txt = wpas_wps_ap_pin_random(wpa_s, timeout);
1046                 if (pin_txt == NULL)
1047                         return -1;
1048                 return os_snprintf(buf, buflen, "%s", pin_txt);
1049         }
1050
1051         if (os_strcmp(cmd, "get") == 0) {
1052                 pin_txt = wpas_wps_ap_pin_get(wpa_s);
1053                 if (pin_txt == NULL)
1054                         return -1;
1055                 return os_snprintf(buf, buflen, "%s", pin_txt);
1056         }
1057
1058         if (os_strcmp(cmd, "set") == 0) {
1059                 char *pin;
1060                 if (pos == NULL)
1061                         return -1;
1062                 pin = pos;
1063                 pos = os_strchr(pos, ' ');
1064                 if (pos) {
1065                         *pos++ = '\0';
1066                         timeout = atoi(pos);
1067                 }
1068                 if (os_strlen(pin) > buflen)
1069                         return -1;
1070                 if (wpas_wps_ap_pin_set(wpa_s, pin, timeout) < 0)
1071                         return -1;
1072                 return os_snprintf(buf, buflen, "%s", pin);
1073         }
1074
1075         return -1;
1076 }
1077 #endif /* CONFIG_AP */
1078
1079
1080 #ifdef CONFIG_WPS_ER
1081 static int wpa_supplicant_ctrl_iface_wps_er_pin(struct wpa_supplicant *wpa_s,
1082                                                 char *cmd)
1083 {
1084         char *uuid = cmd, *pin, *pos;
1085         u8 addr_buf[ETH_ALEN], *addr = NULL;
1086         pin = os_strchr(uuid, ' ');
1087         if (pin == NULL)
1088                 return -1;
1089         *pin++ = '\0';
1090         pos = os_strchr(pin, ' ');
1091         if (pos) {
1092                 *pos++ = '\0';
1093                 if (hwaddr_aton(pos, addr_buf) == 0)
1094                         addr = addr_buf;
1095         }
1096         return wpas_wps_er_add_pin(wpa_s, addr, uuid, pin);
1097 }
1098
1099
1100 static int wpa_supplicant_ctrl_iface_wps_er_learn(struct wpa_supplicant *wpa_s,
1101                                                   char *cmd)
1102 {
1103         char *uuid = cmd, *pin;
1104         pin = os_strchr(uuid, ' ');
1105         if (pin == NULL)
1106                 return -1;
1107         *pin++ = '\0';
1108         return wpas_wps_er_learn(wpa_s, uuid, pin);
1109 }
1110
1111
1112 static int wpa_supplicant_ctrl_iface_wps_er_set_config(
1113         struct wpa_supplicant *wpa_s, char *cmd)
1114 {
1115         char *uuid = cmd, *id;
1116         id = os_strchr(uuid, ' ');
1117         if (id == NULL)
1118                 return -1;
1119         *id++ = '\0';
1120         return wpas_wps_er_set_config(wpa_s, uuid, atoi(id));
1121 }
1122
1123
1124 static int wpa_supplicant_ctrl_iface_wps_er_config(
1125         struct wpa_supplicant *wpa_s, char *cmd)
1126 {
1127         char *pin;
1128         char *new_ssid;
1129         char *new_auth;
1130         char *new_encr;
1131         char *new_key;
1132         struct wps_new_ap_settings ap;
1133
1134         pin = os_strchr(cmd, ' ');
1135         if (pin == NULL)
1136                 return -1;
1137         *pin++ = '\0';
1138
1139         new_ssid = os_strchr(pin, ' ');
1140         if (new_ssid == NULL)
1141                 return -1;
1142         *new_ssid++ = '\0';
1143
1144         new_auth = os_strchr(new_ssid, ' ');
1145         if (new_auth == NULL)
1146                 return -1;
1147         *new_auth++ = '\0';
1148
1149         new_encr = os_strchr(new_auth, ' ');
1150         if (new_encr == NULL)
1151                 return -1;
1152         *new_encr++ = '\0';
1153
1154         new_key = os_strchr(new_encr, ' ');
1155         if (new_key == NULL)
1156                 return -1;
1157         *new_key++ = '\0';
1158
1159         os_memset(&ap, 0, sizeof(ap));
1160         ap.ssid_hex = new_ssid;
1161         ap.auth = new_auth;
1162         ap.encr = new_encr;
1163         ap.key_hex = new_key;
1164         return wpas_wps_er_config(wpa_s, cmd, pin, &ap);
1165 }
1166
1167
1168 #ifdef CONFIG_WPS_NFC
1169 static int wpa_supplicant_ctrl_iface_wps_er_nfc_config_token(
1170         struct wpa_supplicant *wpa_s, char *cmd, char *reply, size_t max_len)
1171 {
1172         int ndef;
1173         struct wpabuf *buf;
1174         int res;
1175         char *uuid;
1176
1177         uuid = os_strchr(cmd, ' ');
1178         if (uuid == NULL)
1179                 return -1;
1180         *uuid++ = '\0';
1181
1182         if (os_strcmp(cmd, "WPS") == 0)
1183                 ndef = 0;
1184         else if (os_strcmp(cmd, "NDEF") == 0)
1185                 ndef = 1;
1186         else
1187                 return -1;
1188
1189         buf = wpas_wps_er_nfc_config_token(wpa_s, ndef, uuid);
1190         if (buf == NULL)
1191                 return -1;
1192
1193         res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
1194                                          wpabuf_len(buf));
1195         reply[res++] = '\n';
1196         reply[res] = '\0';
1197
1198         wpabuf_free(buf);
1199
1200         return res;
1201 }
1202 #endif /* CONFIG_WPS_NFC */
1203 #endif /* CONFIG_WPS_ER */
1204
1205 #endif /* CONFIG_WPS */
1206
1207
1208 #ifdef CONFIG_IBSS_RSN
1209 static int wpa_supplicant_ctrl_iface_ibss_rsn(
1210         struct wpa_supplicant *wpa_s, char *addr)
1211 {
1212         u8 peer[ETH_ALEN];
1213
1214         if (hwaddr_aton(addr, peer)) {
1215                 wpa_printf(MSG_DEBUG, "CTRL_IFACE IBSS_RSN: invalid "
1216                            "address '%s'", addr);
1217                 return -1;
1218         }
1219
1220         wpa_printf(MSG_DEBUG, "CTRL_IFACE IBSS_RSN " MACSTR,
1221                    MAC2STR(peer));
1222
1223         return ibss_rsn_start(wpa_s->ibss_rsn, peer);
1224 }
1225 #endif /* CONFIG_IBSS_RSN */
1226
1227
1228 static int wpa_supplicant_ctrl_iface_ctrl_rsp(struct wpa_supplicant *wpa_s,
1229                                               char *rsp)
1230 {
1231 #ifdef IEEE8021X_EAPOL
1232         char *pos, *id_pos;
1233         int id;
1234         struct wpa_ssid *ssid;
1235
1236         pos = os_strchr(rsp, '-');
1237         if (pos == NULL)
1238                 return -1;
1239         *pos++ = '\0';
1240         id_pos = pos;
1241         pos = os_strchr(pos, ':');
1242         if (pos == NULL)
1243                 return -1;
1244         *pos++ = '\0';
1245         id = atoi(id_pos);
1246         wpa_printf(MSG_DEBUG, "CTRL_IFACE: field=%s id=%d", rsp, id);
1247         wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: value",
1248                               (u8 *) pos, os_strlen(pos));
1249
1250         ssid = wpa_config_get_network(wpa_s->conf, id);
1251         if (ssid == NULL) {
1252                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find SSID id=%d "
1253                            "to update", id);
1254                 return -1;
1255         }
1256
1257         return wpa_supplicant_ctrl_iface_ctrl_rsp_handle(wpa_s, ssid, rsp,
1258                                                          pos);
1259 #else /* IEEE8021X_EAPOL */
1260         wpa_printf(MSG_DEBUG, "CTRL_IFACE: 802.1X not included");
1261         return -1;
1262 #endif /* IEEE8021X_EAPOL */
1263 }
1264
1265
1266 static int wpa_supplicant_ctrl_iface_status(struct wpa_supplicant *wpa_s,
1267                                             const char *params,
1268                                             char *buf, size_t buflen)
1269 {
1270         char *pos, *end, tmp[30];
1271         int res, verbose, wps, ret;
1272
1273         verbose = os_strcmp(params, "-VERBOSE") == 0;
1274         wps = os_strcmp(params, "-WPS") == 0;
1275         pos = buf;
1276         end = buf + buflen;
1277         if (wpa_s->wpa_state >= WPA_ASSOCIATED) {
1278                 struct wpa_ssid *ssid = wpa_s->current_ssid;
1279                 ret = os_snprintf(pos, end - pos, "bssid=" MACSTR "\n",
1280                                   MAC2STR(wpa_s->bssid));
1281                 if (ret < 0 || ret >= end - pos)
1282                         return pos - buf;
1283                 pos += ret;
1284                 if (ssid) {
1285                         u8 *_ssid = ssid->ssid;
1286                         size_t ssid_len = ssid->ssid_len;
1287                         u8 ssid_buf[MAX_SSID_LEN];
1288                         if (ssid_len == 0) {
1289                                 int _res = wpa_drv_get_ssid(wpa_s, ssid_buf);
1290                                 if (_res < 0)
1291                                         ssid_len = 0;
1292                                 else
1293                                         ssid_len = _res;
1294                                 _ssid = ssid_buf;
1295                         }
1296                         ret = os_snprintf(pos, end - pos, "ssid=%s\nid=%d\n",
1297                                           wpa_ssid_txt(_ssid, ssid_len),
1298                                           ssid->id);
1299                         if (ret < 0 || ret >= end - pos)
1300                                 return pos - buf;
1301                         pos += ret;
1302
1303                         if (wps && ssid->passphrase &&
1304                             wpa_key_mgmt_wpa_psk(ssid->key_mgmt) &&
1305                             (ssid->mode == WPAS_MODE_AP ||
1306                              ssid->mode == WPAS_MODE_P2P_GO)) {
1307                                 ret = os_snprintf(pos, end - pos,
1308                                                   "passphrase=%s\n",
1309                                                   ssid->passphrase);
1310                                 if (ret < 0 || ret >= end - pos)
1311                                         return pos - buf;
1312                                 pos += ret;
1313                         }
1314                         if (ssid->id_str) {
1315                                 ret = os_snprintf(pos, end - pos,
1316                                                   "id_str=%s\n",
1317                                                   ssid->id_str);
1318                                 if (ret < 0 || ret >= end - pos)
1319                                         return pos - buf;
1320                                 pos += ret;
1321                         }
1322
1323                         switch (ssid->mode) {
1324                         case WPAS_MODE_INFRA:
1325                                 ret = os_snprintf(pos, end - pos,
1326                                                   "mode=station\n");
1327                                 break;
1328                         case WPAS_MODE_IBSS:
1329                                 ret = os_snprintf(pos, end - pos,
1330                                                   "mode=IBSS\n");
1331                                 break;
1332                         case WPAS_MODE_AP:
1333                                 ret = os_snprintf(pos, end - pos,
1334                                                   "mode=AP\n");
1335                                 break;
1336                         case WPAS_MODE_P2P_GO:
1337                                 ret = os_snprintf(pos, end - pos,
1338                                                   "mode=P2P GO\n");
1339                                 break;
1340                         case WPAS_MODE_P2P_GROUP_FORMATION:
1341                                 ret = os_snprintf(pos, end - pos,
1342                                                   "mode=P2P GO - group "
1343                                                   "formation\n");
1344                                 break;
1345                         default:
1346                                 ret = 0;
1347                                 break;
1348                         }
1349                         if (ret < 0 || ret >= end - pos)
1350                                 return pos - buf;
1351                         pos += ret;
1352                 }
1353
1354 #ifdef CONFIG_AP
1355                 if (wpa_s->ap_iface) {
1356                         pos += ap_ctrl_iface_wpa_get_status(wpa_s, pos,
1357                                                             end - pos,
1358                                                             verbose);
1359                 } else
1360 #endif /* CONFIG_AP */
1361                 pos += wpa_sm_get_status(wpa_s->wpa, pos, end - pos, verbose);
1362         }
1363         ret = os_snprintf(pos, end - pos, "wpa_state=%s\n",
1364                           wpa_supplicant_state_txt(wpa_s->wpa_state));
1365         if (ret < 0 || ret >= end - pos)
1366                 return pos - buf;
1367         pos += ret;
1368
1369         if (wpa_s->l2 &&
1370             l2_packet_get_ip_addr(wpa_s->l2, tmp, sizeof(tmp)) >= 0) {
1371                 ret = os_snprintf(pos, end - pos, "ip_address=%s\n", tmp);
1372                 if (ret < 0 || ret >= end - pos)
1373                         return pos - buf;
1374                 pos += ret;
1375         }
1376
1377 #ifdef CONFIG_P2P
1378         if (wpa_s->global->p2p) {
1379                 ret = os_snprintf(pos, end - pos, "p2p_device_address=" MACSTR
1380                                   "\n", MAC2STR(wpa_s->global->p2p_dev_addr));
1381                 if (ret < 0 || ret >= end - pos)
1382                         return pos - buf;
1383                 pos += ret;
1384         }
1385 #endif /* CONFIG_P2P */
1386
1387         ret = os_snprintf(pos, end - pos, "address=" MACSTR "\n",
1388                           MAC2STR(wpa_s->own_addr));
1389         if (ret < 0 || ret >= end - pos)
1390                 return pos - buf;
1391         pos += ret;
1392
1393 #ifdef CONFIG_HS20
1394         if (wpa_s->current_bss &&
1395             wpa_bss_get_vendor_ie(wpa_s->current_bss, HS20_IE_VENDOR_TYPE) &&
1396             wpa_s->wpa_proto == WPA_PROTO_RSN &&
1397             wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
1398                 ret = os_snprintf(pos, end - pos, "hs20=1\n");
1399                 if (ret < 0 || ret >= end - pos)
1400                         return pos - buf;
1401                 pos += ret;
1402         }
1403
1404         if (wpa_s->current_ssid) {
1405                 struct wpa_cred *cred;
1406                 char *type;
1407
1408                 for (cred = wpa_s->conf->cred; cred; cred = cred->next) {
1409                         if (wpa_s->current_ssid->parent_cred != cred)
1410                                 continue;
1411                         if (!cred->domain)
1412                                 continue;
1413
1414                         ret = os_snprintf(pos, end - pos, "home_sp=%s\n",
1415                                           cred->domain);
1416                         if (ret < 0 || ret >= end - pos)
1417                                 return pos - buf;
1418                         pos += ret;
1419
1420                         if (wpa_s->current_bss == NULL ||
1421                             wpa_s->current_bss->anqp == NULL)
1422                                 res = -1;
1423                         else
1424                                 res = interworking_home_sp_cred(
1425                                         wpa_s, cred,
1426                                         wpa_s->current_bss->anqp->domain_name);
1427                         if (res > 0)
1428                                 type = "home";
1429                         else if (res == 0)
1430                                 type = "roaming";
1431                         else
1432                                 type = "unknown";
1433
1434                         ret = os_snprintf(pos, end - pos, "sp_type=%s\n", type);
1435                         if (ret < 0 || ret >= end - pos)
1436                                 return pos - buf;
1437                         pos += ret;
1438
1439                         break;
1440                 }
1441         }
1442 #endif /* CONFIG_HS20 */
1443
1444         if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
1445             wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1446                 res = eapol_sm_get_status(wpa_s->eapol, pos, end - pos,
1447                                           verbose);
1448                 if (res >= 0)
1449                         pos += res;
1450         }
1451
1452         res = rsn_preauth_get_status(wpa_s->wpa, pos, end - pos, verbose);
1453         if (res >= 0)
1454                 pos += res;
1455
1456         return pos - buf;
1457 }
1458
1459
1460 static int wpa_supplicant_ctrl_iface_bssid(struct wpa_supplicant *wpa_s,
1461                                            char *cmd)
1462 {
1463         char *pos;
1464         int id;
1465         struct wpa_ssid *ssid;
1466         u8 bssid[ETH_ALEN];
1467
1468         /* cmd: "<network id> <BSSID>" */
1469         pos = os_strchr(cmd, ' ');
1470         if (pos == NULL)
1471                 return -1;
1472         *pos++ = '\0';
1473         id = atoi(cmd);
1474         wpa_printf(MSG_DEBUG, "CTRL_IFACE: id=%d bssid='%s'", id, pos);
1475         if (hwaddr_aton(pos, bssid)) {
1476                 wpa_printf(MSG_DEBUG ,"CTRL_IFACE: invalid BSSID '%s'", pos);
1477                 return -1;
1478         }
1479
1480         ssid = wpa_config_get_network(wpa_s->conf, id);
1481         if (ssid == NULL) {
1482                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find SSID id=%d "
1483                            "to update", id);
1484                 return -1;
1485         }
1486
1487         os_memcpy(ssid->bssid, bssid, ETH_ALEN);
1488         ssid->bssid_set = !is_zero_ether_addr(bssid);
1489
1490         return 0;
1491 }
1492
1493
1494 static int wpa_supplicant_ctrl_iface_blacklist(struct wpa_supplicant *wpa_s,
1495                                                char *cmd, char *buf,
1496                                                size_t buflen)
1497 {
1498         u8 bssid[ETH_ALEN];
1499         struct wpa_blacklist *e;
1500         char *pos, *end;
1501         int ret;
1502
1503         /* cmd: "BLACKLIST [<BSSID>]" */
1504         if (*cmd == '\0') {
1505                 pos = buf;
1506                 end = buf + buflen;
1507                 e = wpa_s->blacklist;
1508                 while (e) {
1509                         ret = os_snprintf(pos, end - pos, MACSTR "\n",
1510                                           MAC2STR(e->bssid));
1511                         if (ret < 0 || ret >= end - pos)
1512                                 return pos - buf;
1513                         pos += ret;
1514                         e = e->next;
1515                 }
1516                 return pos - buf;
1517         }
1518
1519         cmd++;
1520         if (os_strncmp(cmd, "clear", 5) == 0) {
1521                 wpa_blacklist_clear(wpa_s);
1522                 os_memcpy(buf, "OK\n", 3);
1523                 return 3;
1524         }
1525
1526         wpa_printf(MSG_DEBUG, "CTRL_IFACE: BLACKLIST bssid='%s'", cmd);
1527         if (hwaddr_aton(cmd, bssid)) {
1528                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: invalid BSSID '%s'", cmd);
1529                 return -1;
1530         }
1531
1532         /*
1533          * Add the BSSID twice, so its count will be 2, causing it to be
1534          * skipped when processing scan results.
1535          */
1536         ret = wpa_blacklist_add(wpa_s, bssid);
1537         if (ret != 0)
1538                 return -1;
1539         ret = wpa_blacklist_add(wpa_s, bssid);
1540         if (ret != 0)
1541                 return -1;
1542         os_memcpy(buf, "OK\n", 3);
1543         return 3;
1544 }
1545
1546
1547 extern int wpa_debug_level;
1548 extern int wpa_debug_timestamp;
1549
1550 static const char * debug_level_str(int level)
1551 {
1552         switch (level) {
1553         case MSG_EXCESSIVE:
1554                 return "EXCESSIVE";
1555         case MSG_MSGDUMP:
1556                 return "MSGDUMP";
1557         case MSG_DEBUG:
1558                 return "DEBUG";
1559         case MSG_INFO:
1560                 return "INFO";
1561         case MSG_WARNING:
1562                 return "WARNING";
1563         case MSG_ERROR:
1564                 return "ERROR";
1565         default:
1566                 return "?";
1567         }
1568 }
1569
1570
1571 static int str_to_debug_level(const char *s)
1572 {
1573         if (os_strcasecmp(s, "EXCESSIVE") == 0)
1574                 return MSG_EXCESSIVE;
1575         if (os_strcasecmp(s, "MSGDUMP") == 0)
1576                 return MSG_MSGDUMP;
1577         if (os_strcasecmp(s, "DEBUG") == 0)
1578                 return MSG_DEBUG;
1579         if (os_strcasecmp(s, "INFO") == 0)
1580                 return MSG_INFO;
1581         if (os_strcasecmp(s, "WARNING") == 0)
1582                 return MSG_WARNING;
1583         if (os_strcasecmp(s, "ERROR") == 0)
1584                 return MSG_ERROR;
1585         return -1;
1586 }
1587
1588
1589 static int wpa_supplicant_ctrl_iface_log_level(struct wpa_supplicant *wpa_s,
1590                                                char *cmd, char *buf,
1591                                                size_t buflen)
1592 {
1593         char *pos, *end, *stamp;
1594         int ret;
1595
1596         if (cmd == NULL) {
1597                 return -1;
1598         }
1599
1600         /* cmd: "LOG_LEVEL [<level>]" */
1601         if (*cmd == '\0') {
1602                 pos = buf;
1603                 end = buf + buflen;
1604                 ret = os_snprintf(pos, end - pos, "Current level: %s\n"
1605                                   "Timestamp: %d\n",
1606                                   debug_level_str(wpa_debug_level),
1607                                   wpa_debug_timestamp);
1608                 if (ret < 0 || ret >= end - pos)
1609                         ret = 0;
1610
1611                 return ret;
1612         }
1613
1614         while (*cmd == ' ')
1615                 cmd++;
1616
1617         stamp = os_strchr(cmd, ' ');
1618         if (stamp) {
1619                 *stamp++ = '\0';
1620                 while (*stamp == ' ') {
1621                         stamp++;
1622                 }
1623         }
1624
1625         if (cmd && os_strlen(cmd)) {
1626                 int level = str_to_debug_level(cmd);
1627                 if (level < 0)
1628                         return -1;
1629                 wpa_debug_level = level;
1630         }
1631
1632         if (stamp && os_strlen(stamp))
1633                 wpa_debug_timestamp = atoi(stamp);
1634
1635         os_memcpy(buf, "OK\n", 3);
1636         return 3;
1637 }
1638
1639
1640 static int wpa_supplicant_ctrl_iface_list_networks(
1641         struct wpa_supplicant *wpa_s, char *buf, size_t buflen)
1642 {
1643         char *pos, *end;
1644         struct wpa_ssid *ssid;
1645         int ret;
1646
1647         pos = buf;
1648         end = buf + buflen;
1649         ret = os_snprintf(pos, end - pos,
1650                           "network id / ssid / bssid / flags\n");
1651         if (ret < 0 || ret >= end - pos)
1652                 return pos - buf;
1653         pos += ret;
1654
1655         ssid = wpa_s->conf->ssid;
1656         while (ssid) {
1657                 ret = os_snprintf(pos, end - pos, "%d\t%s",
1658                                   ssid->id,
1659                                   wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
1660                 if (ret < 0 || ret >= end - pos)
1661                         return pos - buf;
1662                 pos += ret;
1663                 if (ssid->bssid_set) {
1664                         ret = os_snprintf(pos, end - pos, "\t" MACSTR,
1665                                           MAC2STR(ssid->bssid));
1666                 } else {
1667                         ret = os_snprintf(pos, end - pos, "\tany");
1668                 }
1669                 if (ret < 0 || ret >= end - pos)
1670                         return pos - buf;
1671                 pos += ret;
1672                 ret = os_snprintf(pos, end - pos, "\t%s%s%s%s",
1673                                   ssid == wpa_s->current_ssid ?
1674                                   "[CURRENT]" : "",
1675                                   ssid->disabled ? "[DISABLED]" : "",
1676                                   ssid->disabled_until.sec ?
1677                                   "[TEMP-DISABLED]" : "",
1678                                   ssid->disabled == 2 ? "[P2P-PERSISTENT]" :
1679                                   "");
1680                 if (ret < 0 || ret >= end - pos)
1681                         return pos - buf;
1682                 pos += ret;
1683                 ret = os_snprintf(pos, end - pos, "\n");
1684                 if (ret < 0 || ret >= end - pos)
1685                         return pos - buf;
1686                 pos += ret;
1687
1688                 ssid = ssid->next;
1689         }
1690
1691         return pos - buf;
1692 }
1693
1694
1695 static char * wpa_supplicant_cipher_txt(char *pos, char *end, int cipher)
1696 {
1697         int first = 1, ret;
1698         ret = os_snprintf(pos, end - pos, "-");
1699         if (ret < 0 || ret >= end - pos)
1700                 return pos;
1701         pos += ret;
1702         if (cipher & WPA_CIPHER_NONE) {
1703                 ret = os_snprintf(pos, end - pos, "%sNONE", first ? "" : "+");
1704                 if (ret < 0 || ret >= end - pos)
1705                         return pos;
1706                 pos += ret;
1707                 first = 0;
1708         }
1709         if (cipher & WPA_CIPHER_WEP40) {
1710                 ret = os_snprintf(pos, end - pos, "%sWEP40", first ? "" : "+");
1711                 if (ret < 0 || ret >= end - pos)
1712                         return pos;
1713                 pos += ret;
1714                 first = 0;
1715         }
1716         if (cipher & WPA_CIPHER_WEP104) {
1717                 ret = os_snprintf(pos, end - pos, "%sWEP104",
1718                                   first ? "" : "+");
1719                 if (ret < 0 || ret >= end - pos)
1720                         return pos;
1721                 pos += ret;
1722                 first = 0;
1723         }
1724         if (cipher & WPA_CIPHER_TKIP) {
1725                 ret = os_snprintf(pos, end - pos, "%sTKIP", first ? "" : "+");
1726                 if (ret < 0 || ret >= end - pos)
1727                         return pos;
1728                 pos += ret;
1729                 first = 0;
1730         }
1731         if (cipher & WPA_CIPHER_CCMP) {
1732                 ret = os_snprintf(pos, end - pos, "%sCCMP", first ? "" : "+");
1733                 if (ret < 0 || ret >= end - pos)
1734                         return pos;
1735                 pos += ret;
1736                 first = 0;
1737         }
1738         if (cipher & WPA_CIPHER_GCMP) {
1739                 ret = os_snprintf(pos, end - pos, "%sGCMP", first ? "" : "+");
1740                 if (ret < 0 || ret >= end - pos)
1741                         return pos;
1742                 pos += ret;
1743                 first = 0;
1744         }
1745         return pos;
1746 }
1747
1748
1749 static char * wpa_supplicant_ie_txt(char *pos, char *end, const char *proto,
1750                                     const u8 *ie, size_t ie_len)
1751 {
1752         struct wpa_ie_data data;
1753         int first, ret;
1754
1755         ret = os_snprintf(pos, end - pos, "[%s-", proto);
1756         if (ret < 0 || ret >= end - pos)
1757                 return pos;
1758         pos += ret;
1759
1760         if (wpa_parse_wpa_ie(ie, ie_len, &data) < 0) {
1761                 ret = os_snprintf(pos, end - pos, "?]");
1762                 if (ret < 0 || ret >= end - pos)
1763                         return pos;
1764                 pos += ret;
1765                 return pos;
1766         }
1767
1768         first = 1;
1769         if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
1770                 ret = os_snprintf(pos, end - pos, "%sEAP", first ? "" : "+");
1771                 if (ret < 0 || ret >= end - pos)
1772                         return pos;
1773                 pos += ret;
1774                 first = 0;
1775         }
1776         if (data.key_mgmt & WPA_KEY_MGMT_PSK) {
1777                 ret = os_snprintf(pos, end - pos, "%sPSK", first ? "" : "+");
1778                 if (ret < 0 || ret >= end - pos)
1779                         return pos;
1780                 pos += ret;
1781                 first = 0;
1782         }
1783         if (data.key_mgmt & WPA_KEY_MGMT_WPA_NONE) {
1784                 ret = os_snprintf(pos, end - pos, "%sNone", first ? "" : "+");
1785                 if (ret < 0 || ret >= end - pos)
1786                         return pos;
1787                 pos += ret;
1788                 first = 0;
1789         }
1790 #ifdef CONFIG_IEEE80211R
1791         if (data.key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X) {
1792                 ret = os_snprintf(pos, end - pos, "%sFT/EAP",
1793                                   first ? "" : "+");
1794                 if (ret < 0 || ret >= end - pos)
1795                         return pos;
1796                 pos += ret;
1797                 first = 0;
1798         }
1799         if (data.key_mgmt & WPA_KEY_MGMT_FT_PSK) {
1800                 ret = os_snprintf(pos, end - pos, "%sFT/PSK",
1801                                   first ? "" : "+");
1802                 if (ret < 0 || ret >= end - pos)
1803                         return pos;
1804                 pos += ret;
1805                 first = 0;
1806         }
1807 #endif /* CONFIG_IEEE80211R */
1808 #ifdef CONFIG_IEEE80211W
1809         if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256) {
1810                 ret = os_snprintf(pos, end - pos, "%sEAP-SHA256",
1811                                   first ? "" : "+");
1812                 if (ret < 0 || ret >= end - pos)
1813                         return pos;
1814                 pos += ret;
1815                 first = 0;
1816         }
1817         if (data.key_mgmt & WPA_KEY_MGMT_PSK_SHA256) {
1818                 ret = os_snprintf(pos, end - pos, "%sPSK-SHA256",
1819                                   first ? "" : "+");
1820                 if (ret < 0 || ret >= end - pos)
1821                         return pos;
1822                 pos += ret;
1823                 first = 0;
1824         }
1825 #endif /* CONFIG_IEEE80211W */
1826
1827         pos = wpa_supplicant_cipher_txt(pos, end, data.pairwise_cipher);
1828
1829         if (data.capabilities & WPA_CAPABILITY_PREAUTH) {
1830                 ret = os_snprintf(pos, end - pos, "-preauth");
1831                 if (ret < 0 || ret >= end - pos)
1832                         return pos;
1833                 pos += ret;
1834         }
1835
1836         ret = os_snprintf(pos, end - pos, "]");
1837         if (ret < 0 || ret >= end - pos)
1838                 return pos;
1839         pos += ret;
1840
1841         return pos;
1842 }
1843
1844
1845 #ifdef CONFIG_WPS
1846 static char * wpa_supplicant_wps_ie_txt_buf(struct wpa_supplicant *wpa_s,
1847                                             char *pos, char *end,
1848                                             struct wpabuf *wps_ie)
1849 {
1850         int ret;
1851         const char *txt;
1852
1853         if (wps_ie == NULL)
1854                 return pos;
1855         if (wps_is_selected_pbc_registrar(wps_ie))
1856                 txt = "[WPS-PBC]";
1857 #ifdef CONFIG_WPS2
1858         else if (wps_is_addr_authorized(wps_ie, wpa_s->own_addr, 0))
1859                 txt = "[WPS-AUTH]";
1860 #endif /* CONFIG_WPS2 */
1861         else if (wps_is_selected_pin_registrar(wps_ie))
1862                 txt = "[WPS-PIN]";
1863         else
1864                 txt = "[WPS]";
1865
1866         ret = os_snprintf(pos, end - pos, "%s", txt);
1867         if (ret >= 0 && ret < end - pos)
1868                 pos += ret;
1869         wpabuf_free(wps_ie);
1870         return pos;
1871 }
1872 #endif /* CONFIG_WPS */
1873
1874
1875 static char * wpa_supplicant_wps_ie_txt(struct wpa_supplicant *wpa_s,
1876                                         char *pos, char *end,
1877                                         const struct wpa_bss *bss)
1878 {
1879 #ifdef CONFIG_WPS
1880         struct wpabuf *wps_ie;
1881         wps_ie = wpa_bss_get_vendor_ie_multi(bss, WPS_IE_VENDOR_TYPE);
1882         return wpa_supplicant_wps_ie_txt_buf(wpa_s, pos, end, wps_ie);
1883 #else /* CONFIG_WPS */
1884         return pos;
1885 #endif /* CONFIG_WPS */
1886 }
1887
1888
1889 /* Format one result on one text line into a buffer. */
1890 static int wpa_supplicant_ctrl_iface_scan_result(
1891         struct wpa_supplicant *wpa_s,
1892         const struct wpa_bss *bss, char *buf, size_t buflen)
1893 {
1894         char *pos, *end;
1895         int ret;
1896         const u8 *ie, *ie2, *p2p;
1897
1898         p2p = wpa_bss_get_vendor_ie(bss, P2P_IE_VENDOR_TYPE);
1899         if (p2p && bss->ssid_len == P2P_WILDCARD_SSID_LEN &&
1900             os_memcmp(bss->ssid, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN) ==
1901             0)
1902                 return 0; /* Do not show P2P listen discovery results here */
1903
1904         pos = buf;
1905         end = buf + buflen;
1906
1907         ret = os_snprintf(pos, end - pos, MACSTR "\t%d\t%d\t",
1908                           MAC2STR(bss->bssid), bss->freq, bss->level);
1909         if (ret < 0 || ret >= end - pos)
1910                 return -1;
1911         pos += ret;
1912         ie = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
1913         if (ie)
1914                 pos = wpa_supplicant_ie_txt(pos, end, "WPA", ie, 2 + ie[1]);
1915         ie2 = wpa_bss_get_ie(bss, WLAN_EID_RSN);
1916         if (ie2)
1917                 pos = wpa_supplicant_ie_txt(pos, end, "WPA2", ie2, 2 + ie2[1]);
1918         pos = wpa_supplicant_wps_ie_txt(wpa_s, pos, end, bss);
1919         if (!ie && !ie2 && bss->caps & IEEE80211_CAP_PRIVACY) {
1920                 ret = os_snprintf(pos, end - pos, "[WEP]");
1921                 if (ret < 0 || ret >= end - pos)
1922                         return -1;
1923                 pos += ret;
1924         }
1925         if (bss->caps & IEEE80211_CAP_IBSS) {
1926                 ret = os_snprintf(pos, end - pos, "[IBSS]");
1927                 if (ret < 0 || ret >= end - pos)
1928                         return -1;
1929                 pos += ret;
1930         }
1931         if (bss->caps & IEEE80211_CAP_ESS) {
1932                 ret = os_snprintf(pos, end - pos, "[ESS]");
1933                 if (ret < 0 || ret >= end - pos)
1934                         return -1;
1935                 pos += ret;
1936         }
1937         if (p2p) {
1938                 ret = os_snprintf(pos, end - pos, "[P2P]");
1939                 if (ret < 0 || ret >= end - pos)
1940                         return -1;
1941                 pos += ret;
1942         }
1943 #ifdef CONFIG_HS20
1944         if (wpa_bss_get_vendor_ie(bss, HS20_IE_VENDOR_TYPE) && ie2) {
1945                 ret = os_snprintf(pos, end - pos, "[HS20]");
1946                 if (ret < 0 || ret >= end - pos)
1947                         return -1;
1948                 pos += ret;
1949         }
1950 #endif /* CONFIG_HS20 */
1951
1952         ret = os_snprintf(pos, end - pos, "\t%s",
1953                           wpa_ssid_txt(bss->ssid, bss->ssid_len));
1954         if (ret < 0 || ret >= end - pos)
1955                 return -1;
1956         pos += ret;
1957
1958         ret = os_snprintf(pos, end - pos, "\n");
1959         if (ret < 0 || ret >= end - pos)
1960                 return -1;
1961         pos += ret;
1962
1963         return pos - buf;
1964 }
1965
1966
1967 static int wpa_supplicant_ctrl_iface_scan_results(
1968         struct wpa_supplicant *wpa_s, char *buf, size_t buflen)
1969 {
1970         char *pos, *end;
1971         struct wpa_bss *bss;
1972         int ret;
1973
1974         pos = buf;
1975         end = buf + buflen;
1976         ret = os_snprintf(pos, end - pos, "bssid / frequency / signal level / "
1977                           "flags / ssid\n");
1978         if (ret < 0 || ret >= end - pos)
1979                 return pos - buf;
1980         pos += ret;
1981
1982         dl_list_for_each(bss, &wpa_s->bss_id, struct wpa_bss, list_id) {
1983                 ret = wpa_supplicant_ctrl_iface_scan_result(wpa_s, bss, pos,
1984                                                             end - pos);
1985                 if (ret < 0 || ret >= end - pos)
1986                         return pos - buf;
1987                 pos += ret;
1988         }
1989
1990         return pos - buf;
1991 }
1992
1993
1994 static int wpa_supplicant_ctrl_iface_select_network(
1995         struct wpa_supplicant *wpa_s, char *cmd)
1996 {
1997         int id;
1998         struct wpa_ssid *ssid;
1999
2000         /* cmd: "<network id>" or "any" */
2001         if (os_strcmp(cmd, "any") == 0) {
2002                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: SELECT_NETWORK any");
2003                 ssid = NULL;
2004         } else {
2005                 id = atoi(cmd);
2006                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: SELECT_NETWORK id=%d", id);
2007
2008                 ssid = wpa_config_get_network(wpa_s->conf, id);
2009                 if (ssid == NULL) {
2010                         wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find "
2011                                    "network id=%d", id);
2012                         return -1;
2013                 }
2014                 if (ssid->disabled == 2) {
2015                         wpa_printf(MSG_DEBUG, "CTRL_IFACE: Cannot use "
2016                                    "SELECT_NETWORK with persistent P2P group");
2017                         return -1;
2018                 }
2019         }
2020
2021         wpa_supplicant_select_network(wpa_s, ssid);
2022
2023         return 0;
2024 }
2025
2026
2027 static int wpa_supplicant_ctrl_iface_enable_network(
2028         struct wpa_supplicant *wpa_s, char *cmd)
2029 {
2030         int id;
2031         struct wpa_ssid *ssid;
2032
2033         /* cmd: "<network id>" or "all" */
2034         if (os_strcmp(cmd, "all") == 0) {
2035                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: ENABLE_NETWORK all");
2036                 ssid = NULL;
2037         } else {
2038                 id = atoi(cmd);
2039                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: ENABLE_NETWORK id=%d", id);
2040
2041                 ssid = wpa_config_get_network(wpa_s->conf, id);
2042                 if (ssid == NULL) {
2043                         wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find "
2044                                    "network id=%d", id);
2045                         return -1;
2046                 }
2047                 if (ssid->disabled == 2) {
2048                         wpa_printf(MSG_DEBUG, "CTRL_IFACE: Cannot use "
2049                                    "ENABLE_NETWORK with persistent P2P group");
2050                         return -1;
2051                 }
2052
2053                 if (os_strstr(cmd, " no-connect")) {
2054                         ssid->disabled = 0;
2055                         return 0;
2056                 }
2057         }
2058         wpa_supplicant_enable_network(wpa_s, ssid);
2059
2060         return 0;
2061 }
2062
2063
2064 static int wpa_supplicant_ctrl_iface_disable_network(
2065         struct wpa_supplicant *wpa_s, char *cmd)
2066 {
2067         int id;
2068         struct wpa_ssid *ssid;
2069
2070         /* cmd: "<network id>" or "all" */
2071         if (os_strcmp(cmd, "all") == 0) {
2072                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: DISABLE_NETWORK all");
2073                 ssid = NULL;
2074         } else {
2075                 id = atoi(cmd);
2076                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: DISABLE_NETWORK id=%d", id);
2077
2078                 ssid = wpa_config_get_network(wpa_s->conf, id);
2079                 if (ssid == NULL) {
2080                         wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find "
2081                                    "network id=%d", id);
2082                         return -1;
2083                 }
2084                 if (ssid->disabled == 2) {
2085                         wpa_printf(MSG_DEBUG, "CTRL_IFACE: Cannot use "
2086                                    "DISABLE_NETWORK with persistent P2P "
2087                                    "group");
2088                         return -1;
2089                 }
2090         }
2091         wpa_supplicant_disable_network(wpa_s, ssid);
2092
2093         return 0;
2094 }
2095
2096
2097 static int wpa_supplicant_ctrl_iface_add_network(
2098         struct wpa_supplicant *wpa_s, char *buf, size_t buflen)
2099 {
2100         struct wpa_ssid *ssid;
2101         int ret;
2102
2103         wpa_printf(MSG_DEBUG, "CTRL_IFACE: ADD_NETWORK");
2104
2105         ssid = wpa_config_add_network(wpa_s->conf);
2106         if (ssid == NULL)
2107                 return -1;
2108
2109         wpas_notify_network_added(wpa_s, ssid);
2110
2111         ssid->disabled = 1;
2112         wpa_config_set_network_defaults(ssid);
2113
2114         ret = os_snprintf(buf, buflen, "%d\n", ssid->id);
2115         if (ret < 0 || (size_t) ret >= buflen)
2116                 return -1;
2117         return ret;
2118 }
2119
2120
2121 static int wpa_supplicant_ctrl_iface_remove_network(
2122         struct wpa_supplicant *wpa_s, char *cmd)
2123 {
2124         int id;
2125         struct wpa_ssid *ssid;
2126
2127         /* cmd: "<network id>" or "all" */
2128         if (os_strcmp(cmd, "all") == 0) {
2129                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: REMOVE_NETWORK all");
2130                 ssid = wpa_s->conf->ssid;
2131                 while (ssid) {
2132                         struct wpa_ssid *remove_ssid = ssid;
2133                         id = ssid->id;
2134                         ssid = ssid->next;
2135                         wpas_notify_network_removed(wpa_s, remove_ssid);
2136                         wpa_config_remove_network(wpa_s->conf, id);
2137                 }
2138                 eapol_sm_invalidate_cached_session(wpa_s->eapol);
2139                 if (wpa_s->current_ssid) {
2140 #ifdef CONFIG_SME
2141                         wpa_s->sme.prev_bssid_set = 0;
2142 #endif /* CONFIG_SME */
2143                         wpa_sm_set_config(wpa_s->wpa, NULL);
2144                         eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2145                         wpa_supplicant_deauthenticate(
2146                                 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2147                 }
2148                 return 0;
2149         }
2150
2151         id = atoi(cmd);
2152         wpa_printf(MSG_DEBUG, "CTRL_IFACE: REMOVE_NETWORK id=%d", id);
2153
2154         ssid = wpa_config_get_network(wpa_s->conf, id);
2155         if (ssid)
2156                 wpas_notify_network_removed(wpa_s, ssid);
2157         if (ssid == NULL) {
2158                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find network "
2159                            "id=%d", id);
2160                 return -1;
2161         }
2162
2163         if (ssid == wpa_s->current_ssid || wpa_s->current_ssid == NULL) {
2164 #ifdef CONFIG_SME
2165                 wpa_s->sme.prev_bssid_set = 0;
2166 #endif /* CONFIG_SME */
2167                 /*
2168                  * Invalidate the EAP session cache if the current or
2169                  * previously used network is removed.
2170                  */
2171                 eapol_sm_invalidate_cached_session(wpa_s->eapol);
2172         }
2173
2174         if (ssid == wpa_s->current_ssid) {
2175                 wpa_sm_set_config(wpa_s->wpa, NULL);
2176                 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2177
2178                 wpa_supplicant_deauthenticate(wpa_s,
2179                                               WLAN_REASON_DEAUTH_LEAVING);
2180         }
2181
2182         if (wpa_config_remove_network(wpa_s->conf, id) < 0) {
2183                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Not able to remove the "
2184                            "network id=%d", id);
2185                 return -1;
2186         }
2187
2188         return 0;
2189 }
2190
2191
2192 static int wpa_supplicant_ctrl_iface_set_network(
2193         struct wpa_supplicant *wpa_s, char *cmd)
2194 {
2195         int id;
2196         struct wpa_ssid *ssid;
2197         char *name, *value;
2198
2199         /* cmd: "<network id> <variable name> <value>" */
2200         name = os_strchr(cmd, ' ');
2201         if (name == NULL)
2202                 return -1;
2203         *name++ = '\0';
2204
2205         value = os_strchr(name, ' ');
2206         if (value == NULL)
2207                 return -1;
2208         *value++ = '\0';
2209
2210         id = atoi(cmd);
2211         wpa_printf(MSG_DEBUG, "CTRL_IFACE: SET_NETWORK id=%d name='%s'",
2212                    id, name);
2213         wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: value",
2214                               (u8 *) value, os_strlen(value));
2215
2216         ssid = wpa_config_get_network(wpa_s->conf, id);
2217         if (ssid == NULL) {
2218                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find network "
2219                            "id=%d", id);
2220                 return -1;
2221         }
2222
2223         if (wpa_config_set(ssid, name, value, 0) < 0) {
2224                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Failed to set network "
2225                            "variable '%s'", name);
2226                 return -1;
2227         }
2228
2229         if (os_strcmp(name, "bssid") != 0 &&
2230             os_strcmp(name, "priority") != 0)
2231                 wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid);
2232
2233         if (wpa_s->current_ssid == ssid || wpa_s->current_ssid == NULL) {
2234                 /*
2235                  * Invalidate the EAP session cache if anything in the current
2236                  * or previously used configuration changes.
2237                  */
2238                 eapol_sm_invalidate_cached_session(wpa_s->eapol);
2239         }
2240
2241         if ((os_strcmp(name, "psk") == 0 &&
2242              value[0] == '"' && ssid->ssid_len) ||
2243             (os_strcmp(name, "ssid") == 0 && ssid->passphrase))
2244                 wpa_config_update_psk(ssid);
2245         else if (os_strcmp(name, "priority") == 0)
2246                 wpa_config_update_prio_list(wpa_s->conf);
2247
2248         return 0;
2249 }
2250
2251
2252 static int wpa_supplicant_ctrl_iface_get_network(
2253         struct wpa_supplicant *wpa_s, char *cmd, char *buf, size_t buflen)
2254 {
2255         int id;
2256         size_t res;
2257         struct wpa_ssid *ssid;
2258         char *name, *value;
2259
2260         /* cmd: "<network id> <variable name>" */
2261         name = os_strchr(cmd, ' ');
2262         if (name == NULL || buflen == 0)
2263                 return -1;
2264         *name++ = '\0';
2265
2266         id = atoi(cmd);
2267         wpa_printf(MSG_DEBUG, "CTRL_IFACE: GET_NETWORK id=%d name='%s'",
2268                    id, name);
2269
2270         ssid = wpa_config_get_network(wpa_s->conf, id);
2271         if (ssid == NULL) {
2272                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find network "
2273                            "id=%d", id);
2274                 return -1;
2275         }
2276
2277         value = wpa_config_get_no_key(ssid, name);
2278         if (value == NULL) {
2279                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Failed to get network "
2280                            "variable '%s'", name);
2281                 return -1;
2282         }
2283
2284         res = os_strlcpy(buf, value, buflen);
2285         if (res >= buflen) {
2286                 os_free(value);
2287                 return -1;
2288         }
2289
2290         os_free(value);
2291
2292         return res;
2293 }
2294
2295
2296 static int wpa_supplicant_ctrl_iface_list_creds(struct wpa_supplicant *wpa_s,
2297                                                 char *buf, size_t buflen)
2298 {
2299         char *pos, *end;
2300         struct wpa_cred *cred;
2301         int ret;
2302
2303         pos = buf;
2304         end = buf + buflen;
2305         ret = os_snprintf(pos, end - pos,
2306                           "cred id / realm / username / domain / imsi\n");
2307         if (ret < 0 || ret >= end - pos)
2308                 return pos - buf;
2309         pos += ret;
2310
2311         cred = wpa_s->conf->cred;
2312         while (cred) {
2313                 ret = os_snprintf(pos, end - pos, "%d\t%s\t%s\t%s\t%s\n",
2314                                   cred->id, cred->realm ? cred->realm : "",
2315                                   cred->username ? cred->username : "",
2316                                   cred->domain ? cred->domain : "",
2317                                   cred->imsi ? cred->imsi : "");
2318                 if (ret < 0 || ret >= end - pos)
2319                         return pos - buf;
2320                 pos += ret;
2321
2322                 cred = cred->next;
2323         }
2324
2325         return pos - buf;
2326 }
2327
2328
2329 static int wpa_supplicant_ctrl_iface_add_cred(struct wpa_supplicant *wpa_s,
2330                                               char *buf, size_t buflen)
2331 {
2332         struct wpa_cred *cred;
2333         int ret;
2334
2335         wpa_printf(MSG_DEBUG, "CTRL_IFACE: ADD_CRED");
2336
2337         cred = wpa_config_add_cred(wpa_s->conf);
2338         if (cred == NULL)
2339                 return -1;
2340
2341         ret = os_snprintf(buf, buflen, "%d\n", cred->id);
2342         if (ret < 0 || (size_t) ret >= buflen)
2343                 return -1;
2344         return ret;
2345 }
2346
2347
2348 static int wpas_ctrl_remove_cred(struct wpa_supplicant *wpa_s,
2349                                  struct wpa_cred *cred)
2350 {
2351         struct wpa_ssid *ssid;
2352         char str[20];
2353
2354         if (cred == NULL || wpa_config_remove_cred(wpa_s->conf, cred->id) < 0) {
2355                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find cred");
2356                 return -1;
2357         }
2358
2359         /* Remove any network entry created based on the removed credential */
2360         ssid = wpa_s->conf->ssid;
2361         while (ssid) {
2362                 if (ssid->parent_cred == cred) {
2363                         wpa_printf(MSG_DEBUG, "Remove network id %d since it "
2364                                    "used the removed credential", ssid->id);
2365                         os_snprintf(str, sizeof(str), "%d", ssid->id);
2366                         ssid = ssid->next;
2367                         wpa_supplicant_ctrl_iface_remove_network(wpa_s, str);
2368                 } else
2369                         ssid = ssid->next;
2370         }
2371
2372         return 0;
2373 }
2374
2375
2376 static int wpa_supplicant_ctrl_iface_remove_cred(struct wpa_supplicant *wpa_s,
2377                                                  char *cmd)
2378 {
2379         int id;
2380         struct wpa_cred *cred, *prev;
2381
2382         /* cmd: "<cred id>", "all", or "sp_fqdn=<FQDN>" */
2383         if (os_strcmp(cmd, "all") == 0) {
2384                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: REMOVE_CRED all");
2385                 cred = wpa_s->conf->cred;
2386                 while (cred) {
2387                         prev = cred;
2388                         cred = cred->next;
2389                         wpas_ctrl_remove_cred(wpa_s, prev);
2390                 }
2391                 return 0;
2392         }
2393
2394         if (os_strncmp(cmd, "sp_fqdn=", 8) == 0) {
2395                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: REMOVE_CRED SP FQDN '%s'",
2396                            cmd + 8);
2397                 cred = wpa_s->conf->cred;
2398                 while (cred) {
2399                         prev = cred;
2400                         cred = cred->next;
2401                         if (prev->domain &&
2402                             os_strcmp(prev->domain, cmd + 8) == 0)
2403                                 wpas_ctrl_remove_cred(wpa_s, prev);
2404                 }
2405                 return 0;
2406         }
2407
2408         id = atoi(cmd);
2409         wpa_printf(MSG_DEBUG, "CTRL_IFACE: REMOVE_CRED id=%d", id);
2410
2411         cred = wpa_config_get_cred(wpa_s->conf, id);
2412         return wpas_ctrl_remove_cred(wpa_s, cred);
2413 }
2414
2415
2416 static int wpa_supplicant_ctrl_iface_set_cred(struct wpa_supplicant *wpa_s,
2417                                               char *cmd)
2418 {
2419         int id;
2420         struct wpa_cred *cred;
2421         char *name, *value;
2422
2423         /* cmd: "<cred id> <variable name> <value>" */
2424         name = os_strchr(cmd, ' ');
2425         if (name == NULL)
2426                 return -1;
2427         *name++ = '\0';
2428
2429         value = os_strchr(name, ' ');
2430         if (value == NULL)
2431                 return -1;
2432         *value++ = '\0';
2433
2434         id = atoi(cmd);
2435         wpa_printf(MSG_DEBUG, "CTRL_IFACE: SET_CRED id=%d name='%s'",
2436                    id, name);
2437         wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: value",
2438                               (u8 *) value, os_strlen(value));
2439
2440         cred = wpa_config_get_cred(wpa_s->conf, id);
2441         if (cred == NULL) {
2442                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find cred id=%d",
2443                            id);
2444                 return -1;
2445         }
2446
2447         if (wpa_config_set_cred(cred, name, value, 0) < 0) {
2448                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Failed to set cred "
2449                            "variable '%s'", name);
2450                 return -1;
2451         }
2452
2453         return 0;
2454 }
2455
2456
2457 #ifndef CONFIG_NO_CONFIG_WRITE
2458 static int wpa_supplicant_ctrl_iface_save_config(struct wpa_supplicant *wpa_s)
2459 {
2460         int ret;
2461
2462         if (!wpa_s->conf->update_config) {
2463                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: SAVE_CONFIG - Not allowed "
2464                            "to update configuration (update_config=0)");
2465                 return -1;
2466         }
2467
2468         ret = wpa_config_write(wpa_s->confname, wpa_s->conf);
2469         if (ret) {
2470                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: SAVE_CONFIG - Failed to "
2471                            "update configuration");
2472         } else {
2473                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: SAVE_CONFIG - Configuration"
2474                            " updated");
2475         }
2476
2477         return ret;
2478 }
2479 #endif /* CONFIG_NO_CONFIG_WRITE */
2480
2481
2482 static int ctrl_iface_get_capability_pairwise(int res, char *strict,
2483                                               struct wpa_driver_capa *capa,
2484                                               char *buf, size_t buflen)
2485 {
2486         int ret, first = 1;
2487         char *pos, *end;
2488         size_t len;
2489
2490         pos = buf;
2491         end = pos + buflen;
2492
2493         if (res < 0) {
2494                 if (strict)
2495                         return 0;
2496                 len = os_strlcpy(buf, "CCMP TKIP NONE", buflen);
2497                 if (len >= buflen)
2498                         return -1;
2499                 return len;
2500         }
2501
2502         if (capa->enc & WPA_DRIVER_CAPA_ENC_CCMP) {
2503                 ret = os_snprintf(pos, end - pos, "%sCCMP", first ? "" : " ");
2504                 if (ret < 0 || ret >= end - pos)
2505                         return pos - buf;
2506                 pos += ret;
2507                 first = 0;
2508         }
2509
2510         if (capa->enc & WPA_DRIVER_CAPA_ENC_GCMP) {
2511                 ret = os_snprintf(pos, end - pos, "%sGCMP", first ? "" : " ");
2512                 if (ret < 0 || ret >= end - pos)
2513                         return pos - buf;
2514                 pos += ret;
2515                 first = 0;
2516         }
2517
2518         if (capa->enc & WPA_DRIVER_CAPA_ENC_TKIP) {
2519                 ret = os_snprintf(pos, end - pos, "%sTKIP", first ? "" : " ");
2520                 if (ret < 0 || ret >= end - pos)
2521                         return pos - buf;
2522                 pos += ret;
2523                 first = 0;
2524         }
2525
2526         if (capa->key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE) {
2527                 ret = os_snprintf(pos, end - pos, "%sNONE", first ? "" : " ");
2528                 if (ret < 0 || ret >= end - pos)
2529                         return pos - buf;
2530                 pos += ret;
2531                 first = 0;
2532         }
2533
2534         return pos - buf;
2535 }
2536
2537
2538 static int ctrl_iface_get_capability_group(int res, char *strict,
2539                                            struct wpa_driver_capa *capa,
2540                                            char *buf, size_t buflen)
2541 {
2542         int ret, first = 1;
2543         char *pos, *end;
2544         size_t len;
2545
2546         pos = buf;
2547         end = pos + buflen;
2548
2549         if (res < 0) {
2550                 if (strict)
2551                         return 0;
2552                 len = os_strlcpy(buf, "CCMP TKIP WEP104 WEP40", buflen);
2553                 if (len >= buflen)
2554                         return -1;
2555                 return len;
2556         }
2557
2558         if (capa->enc & WPA_DRIVER_CAPA_ENC_CCMP) {
2559                 ret = os_snprintf(pos, end - pos, "%sCCMP", first ? "" : " ");
2560                 if (ret < 0 || ret >= end - pos)
2561                         return pos - buf;
2562                 pos += ret;
2563                 first = 0;
2564         }
2565
2566         if (capa->enc & WPA_DRIVER_CAPA_ENC_GCMP) {
2567                 ret = os_snprintf(pos, end - pos, "%sGCMP", first ? "" : " ");
2568                 if (ret < 0 || ret >= end - pos)
2569                         return pos - buf;
2570                 pos += ret;
2571                 first = 0;
2572         }
2573
2574         if (capa->enc & WPA_DRIVER_CAPA_ENC_TKIP) {
2575                 ret = os_snprintf(pos, end - pos, "%sTKIP", first ? "" : " ");
2576                 if (ret < 0 || ret >= end - pos)
2577                         return pos - buf;
2578                 pos += ret;
2579                 first = 0;
2580         }
2581
2582         if (capa->enc & WPA_DRIVER_CAPA_ENC_WEP104) {
2583                 ret = os_snprintf(pos, end - pos, "%sWEP104",
2584                                   first ? "" : " ");
2585                 if (ret < 0 || ret >= end - pos)
2586                         return pos - buf;
2587                 pos += ret;
2588                 first = 0;
2589         }
2590
2591         if (capa->enc & WPA_DRIVER_CAPA_ENC_WEP40) {
2592                 ret = os_snprintf(pos, end - pos, "%sWEP40", first ? "" : " ");
2593                 if (ret < 0 || ret >= end - pos)
2594                         return pos - buf;
2595                 pos += ret;
2596                 first = 0;
2597         }
2598
2599         return pos - buf;
2600 }
2601
2602
2603 static int ctrl_iface_get_capability_key_mgmt(int res, char *strict,
2604                                               struct wpa_driver_capa *capa,
2605                                               char *buf, size_t buflen)
2606 {
2607         int ret;
2608         char *pos, *end;
2609         size_t len;
2610
2611         pos = buf;
2612         end = pos + buflen;
2613
2614         if (res < 0) {
2615                 if (strict)
2616                         return 0;
2617                 len = os_strlcpy(buf, "WPA-PSK WPA-EAP IEEE8021X WPA-NONE "
2618                                  "NONE", buflen);
2619                 if (len >= buflen)
2620                         return -1;
2621                 return len;
2622         }
2623
2624         ret = os_snprintf(pos, end - pos, "NONE IEEE8021X");
2625         if (ret < 0 || ret >= end - pos)
2626                 return pos - buf;
2627         pos += ret;
2628
2629         if (capa->key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
2630                               WPA_DRIVER_CAPA_KEY_MGMT_WPA2)) {
2631                 ret = os_snprintf(pos, end - pos, " WPA-EAP");
2632                 if (ret < 0 || ret >= end - pos)
2633                         return pos - buf;
2634                 pos += ret;
2635         }
2636
2637         if (capa->key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK |
2638                               WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) {
2639                 ret = os_snprintf(pos, end - pos, " WPA-PSK");
2640                 if (ret < 0 || ret >= end - pos)
2641                         return pos - buf;
2642                 pos += ret;
2643         }
2644
2645         if (capa->key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE) {
2646                 ret = os_snprintf(pos, end - pos, " WPA-NONE");
2647                 if (ret < 0 || ret >= end - pos)
2648                         return pos - buf;
2649                 pos += ret;
2650         }
2651
2652         return pos - buf;
2653 }
2654
2655
2656 static int ctrl_iface_get_capability_proto(int res, char *strict,
2657                                            struct wpa_driver_capa *capa,
2658                                            char *buf, size_t buflen)
2659 {
2660         int ret, first = 1;
2661         char *pos, *end;
2662         size_t len;
2663
2664         pos = buf;
2665         end = pos + buflen;
2666
2667         if (res < 0) {
2668                 if (strict)
2669                         return 0;
2670                 len = os_strlcpy(buf, "RSN WPA", buflen);
2671                 if (len >= buflen)
2672                         return -1;
2673                 return len;
2674         }
2675
2676         if (capa->key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
2677                               WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) {
2678                 ret = os_snprintf(pos, end - pos, "%sRSN", first ? "" : " ");
2679                 if (ret < 0 || ret >= end - pos)
2680                         return pos - buf;
2681                 pos += ret;
2682                 first = 0;
2683         }
2684
2685         if (capa->key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
2686                               WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK)) {
2687                 ret = os_snprintf(pos, end - pos, "%sWPA", first ? "" : " ");
2688                 if (ret < 0 || ret >= end - pos)
2689                         return pos - buf;
2690                 pos += ret;
2691                 first = 0;
2692         }
2693
2694         return pos - buf;
2695 }
2696
2697
2698 static int ctrl_iface_get_capability_auth_alg(int res, char *strict,
2699                                               struct wpa_driver_capa *capa,
2700                                               char *buf, size_t buflen)
2701 {
2702         int ret, first = 1;
2703         char *pos, *end;
2704         size_t len;
2705
2706         pos = buf;
2707         end = pos + buflen;
2708
2709         if (res < 0) {
2710                 if (strict)
2711                         return 0;
2712                 len = os_strlcpy(buf, "OPEN SHARED LEAP", buflen);
2713                 if (len >= buflen)
2714                         return -1;
2715                 return len;
2716         }
2717
2718         if (capa->auth & (WPA_DRIVER_AUTH_OPEN)) {
2719                 ret = os_snprintf(pos, end - pos, "%sOPEN", first ? "" : " ");
2720                 if (ret < 0 || ret >= end - pos)
2721                         return pos - buf;
2722                 pos += ret;
2723                 first = 0;
2724         }
2725
2726         if (capa->auth & (WPA_DRIVER_AUTH_SHARED)) {
2727                 ret = os_snprintf(pos, end - pos, "%sSHARED",
2728                                   first ? "" : " ");
2729                 if (ret < 0 || ret >= end - pos)
2730                         return pos - buf;
2731                 pos += ret;
2732                 first = 0;
2733         }
2734
2735         if (capa->auth & (WPA_DRIVER_AUTH_LEAP)) {
2736                 ret = os_snprintf(pos, end - pos, "%sLEAP", first ? "" : " ");
2737                 if (ret < 0 || ret >= end - pos)
2738                         return pos - buf;
2739                 pos += ret;
2740                 first = 0;
2741         }
2742
2743         return pos - buf;
2744 }
2745
2746
2747 static int ctrl_iface_get_capability_channels(struct wpa_supplicant *wpa_s,
2748                                               char *buf, size_t buflen)
2749 {
2750         struct hostapd_channel_data *chnl;
2751         int ret, i, j;
2752         char *pos, *end, *hmode;
2753
2754         pos = buf;
2755         end = pos + buflen;
2756
2757         for (j = 0; j < wpa_s->hw.num_modes; j++) {
2758                 switch (wpa_s->hw.modes[j].mode) {
2759                 case HOSTAPD_MODE_IEEE80211B:
2760                         hmode = "B";
2761                         break;
2762                 case HOSTAPD_MODE_IEEE80211G:
2763                         hmode = "G";
2764                         break;
2765                 case HOSTAPD_MODE_IEEE80211A:
2766                         hmode = "A";
2767                         break;
2768                 case HOSTAPD_MODE_IEEE80211AD:
2769                         hmode = "AD";
2770                         break;
2771                 default:
2772                         continue;
2773                 }
2774                 ret = os_snprintf(pos, end - pos, "Mode[%s] Channels:", hmode);
2775                 if (ret < 0 || ret >= end - pos)
2776                         return pos - buf;
2777                 pos += ret;
2778                 chnl = wpa_s->hw.modes[j].channels;
2779                 for (i = 0; i < wpa_s->hw.modes[j].num_channels; i++) {
2780                         if (chnl[i].flag & HOSTAPD_CHAN_DISABLED)
2781                                 continue;
2782                         ret = os_snprintf(pos, end - pos, " %d", chnl[i].chan);
2783                         if (ret < 0 || ret >= end - pos)
2784                                 return pos - buf;
2785                         pos += ret;
2786                 }
2787                 ret = os_snprintf(pos, end - pos, "\n");
2788                 if (ret < 0 || ret >= end - pos)
2789                         return pos - buf;
2790                 pos += ret;
2791         }
2792
2793         return pos - buf;
2794 }
2795
2796
2797 static int wpa_supplicant_ctrl_iface_get_capability(
2798         struct wpa_supplicant *wpa_s, const char *_field, char *buf,
2799         size_t buflen)
2800 {
2801         struct wpa_driver_capa capa;
2802         int res;
2803         char *strict;
2804         char field[30];
2805         size_t len;
2806
2807         /* Determine whether or not strict checking was requested */
2808         len = os_strlcpy(field, _field, sizeof(field));
2809         if (len >= sizeof(field))
2810                 return -1;
2811         strict = os_strchr(field, ' ');
2812         if (strict != NULL) {
2813                 *strict++ = '\0';
2814                 if (os_strcmp(strict, "strict") != 0)
2815                         return -1;
2816         }
2817
2818         wpa_printf(MSG_DEBUG, "CTRL_IFACE: GET_CAPABILITY '%s' %s",
2819                 field, strict ? strict : "");
2820
2821         if (os_strcmp(field, "eap") == 0) {
2822                 return eap_get_names(buf, buflen);
2823         }
2824
2825         res = wpa_drv_get_capa(wpa_s, &capa);
2826
2827         if (os_strcmp(field, "pairwise") == 0)
2828                 return ctrl_iface_get_capability_pairwise(res, strict, &capa,
2829                                                           buf, buflen);
2830
2831         if (os_strcmp(field, "group") == 0)
2832                 return ctrl_iface_get_capability_group(res, strict, &capa,
2833                                                        buf, buflen);
2834
2835         if (os_strcmp(field, "key_mgmt") == 0)
2836                 return ctrl_iface_get_capability_key_mgmt(res, strict, &capa,
2837                                                           buf, buflen);
2838
2839         if (os_strcmp(field, "proto") == 0)
2840                 return ctrl_iface_get_capability_proto(res, strict, &capa,
2841                                                        buf, buflen);
2842
2843         if (os_strcmp(field, "auth_alg") == 0)
2844                 return ctrl_iface_get_capability_auth_alg(res, strict, &capa,
2845                                                           buf, buflen);
2846
2847         if (os_strcmp(field, "channels") == 0)
2848                 return ctrl_iface_get_capability_channels(wpa_s, buf, buflen);
2849
2850         wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown GET_CAPABILITY field '%s'",
2851                    field);
2852
2853         return -1;
2854 }
2855
2856
2857 #ifdef CONFIG_INTERWORKING
2858 static char * anqp_add_hex(char *pos, char *end, const char *title,
2859                            struct wpabuf *data)
2860 {
2861         char *start = pos;
2862         size_t i;
2863         int ret;
2864         const u8 *d;
2865
2866         if (data == NULL)
2867                 return start;
2868
2869         ret = os_snprintf(pos, end - pos, "%s=", title);
2870         if (ret < 0 || ret >= end - pos)
2871                 return start;
2872         pos += ret;
2873
2874         d = wpabuf_head_u8(data);
2875         for (i = 0; i < wpabuf_len(data); i++) {
2876                 ret = os_snprintf(pos, end - pos, "%02x", *d++);
2877                 if (ret < 0 || ret >= end - pos)
2878                         return start;
2879                 pos += ret;
2880         }
2881
2882         ret = os_snprintf(pos, end - pos, "\n");
2883         if (ret < 0 || ret >= end - pos)
2884                 return start;
2885         pos += ret;
2886
2887         return pos;
2888 }
2889 #endif /* CONFIG_INTERWORKING */
2890
2891
2892 static int print_bss_info(struct wpa_supplicant *wpa_s, struct wpa_bss *bss,
2893                           unsigned long mask, char *buf, size_t buflen)
2894 {
2895         size_t i;
2896         int ret;
2897         char *pos, *end;
2898         const u8 *ie, *ie2;
2899
2900         pos = buf;
2901         end = buf + buflen;
2902
2903         if (mask & WPA_BSS_MASK_ID) {
2904                 ret = os_snprintf(pos, end - pos, "id=%u\n", bss->id);
2905                 if (ret < 0 || ret >= end - pos)
2906                         return 0;
2907                 pos += ret;
2908         }
2909
2910         if (mask & WPA_BSS_MASK_BSSID) {
2911                 ret = os_snprintf(pos, end - pos, "bssid=" MACSTR "\n",
2912                                   MAC2STR(bss->bssid));
2913                 if (ret < 0 || ret >= end - pos)
2914                         return 0;
2915                 pos += ret;
2916         }
2917
2918         if (mask & WPA_BSS_MASK_FREQ) {
2919                 ret = os_snprintf(pos, end - pos, "freq=%d\n", bss->freq);
2920                 if (ret < 0 || ret >= end - pos)
2921                         return 0;
2922                 pos += ret;
2923         }
2924
2925         if (mask & WPA_BSS_MASK_BEACON_INT) {
2926                 ret = os_snprintf(pos, end - pos, "beacon_int=%d\n",
2927                                   bss->beacon_int);
2928                 if (ret < 0 || ret >= end - pos)
2929                         return 0;
2930                 pos += ret;
2931         }
2932
2933         if (mask & WPA_BSS_MASK_CAPABILITIES) {
2934                 ret = os_snprintf(pos, end - pos, "capabilities=0x%04x\n",
2935                                   bss->caps);
2936                 if (ret < 0 || ret >= end - pos)
2937                         return 0;
2938                 pos += ret;
2939         }
2940
2941         if (mask & WPA_BSS_MASK_QUAL) {
2942                 ret = os_snprintf(pos, end - pos, "qual=%d\n", bss->qual);
2943                 if (ret < 0 || ret >= end - pos)
2944                         return 0;
2945                 pos += ret;
2946         }
2947
2948         if (mask & WPA_BSS_MASK_NOISE) {
2949                 ret = os_snprintf(pos, end - pos, "noise=%d\n", bss->noise);
2950                 if (ret < 0 || ret >= end - pos)
2951                         return 0;
2952                 pos += ret;
2953         }
2954
2955         if (mask & WPA_BSS_MASK_LEVEL) {
2956                 ret = os_snprintf(pos, end - pos, "level=%d\n", bss->level);
2957                 if (ret < 0 || ret >= end - pos)
2958                         return 0;
2959                 pos += ret;
2960         }
2961
2962         if (mask & WPA_BSS_MASK_TSF) {
2963                 ret = os_snprintf(pos, end - pos, "tsf=%016llu\n",
2964                                   (unsigned long long) bss->tsf);
2965                 if (ret < 0 || ret >= end - pos)
2966                         return 0;
2967                 pos += ret;
2968         }
2969
2970         if (mask & WPA_BSS_MASK_AGE) {
2971                 struct os_time now;
2972
2973                 os_get_time(&now);
2974                 ret = os_snprintf(pos, end - pos, "age=%d\n",
2975                                   (int) (now.sec - bss->last_update.sec));
2976                 if (ret < 0 || ret >= end - pos)
2977                         return 0;
2978                 pos += ret;
2979         }
2980
2981         if (mask & WPA_BSS_MASK_IE) {
2982                 ret = os_snprintf(pos, end - pos, "ie=");
2983                 if (ret < 0 || ret >= end - pos)
2984                         return 0;
2985                 pos += ret;
2986
2987                 ie = (const u8 *) (bss + 1);
2988                 for (i = 0; i < bss->ie_len; i++) {
2989                         ret = os_snprintf(pos, end - pos, "%02x", *ie++);
2990                         if (ret < 0 || ret >= end - pos)
2991                                 return 0;
2992                         pos += ret;
2993                 }
2994
2995                 ret = os_snprintf(pos, end - pos, "\n");
2996                 if (ret < 0 || ret >= end - pos)
2997                         return 0;
2998                 pos += ret;
2999         }
3000
3001         if (mask & WPA_BSS_MASK_FLAGS) {
3002                 ret = os_snprintf(pos, end - pos, "flags=");
3003                 if (ret < 0 || ret >= end - pos)
3004                         return 0;
3005                 pos += ret;
3006
3007                 ie = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
3008                 if (ie)
3009                         pos = wpa_supplicant_ie_txt(pos, end, "WPA", ie,
3010                                                     2 + ie[1]);
3011                 ie2 = wpa_bss_get_ie(bss, WLAN_EID_RSN);
3012                 if (ie2)
3013                         pos = wpa_supplicant_ie_txt(pos, end, "WPA2", ie2,
3014                                                     2 + ie2[1]);
3015                 pos = wpa_supplicant_wps_ie_txt(wpa_s, pos, end, bss);
3016                 if (!ie && !ie2 && bss->caps & IEEE80211_CAP_PRIVACY) {
3017                         ret = os_snprintf(pos, end - pos, "[WEP]");
3018                         if (ret < 0 || ret >= end - pos)
3019                                 return 0;
3020                         pos += ret;
3021                 }
3022                 if (bss->caps & IEEE80211_CAP_IBSS) {
3023                         ret = os_snprintf(pos, end - pos, "[IBSS]");
3024                         if (ret < 0 || ret >= end - pos)
3025                                 return 0;
3026                         pos += ret;
3027                 }
3028                 if (bss->caps & IEEE80211_CAP_ESS) {
3029                         ret = os_snprintf(pos, end - pos, "[ESS]");
3030                         if (ret < 0 || ret >= end - pos)
3031                                 return 0;
3032                         pos += ret;
3033                 }
3034                 if (wpa_bss_get_vendor_ie(bss, P2P_IE_VENDOR_TYPE)) {
3035                         ret = os_snprintf(pos, end - pos, "[P2P]");
3036                         if (ret < 0 || ret >= end - pos)
3037                                 return 0;
3038                         pos += ret;
3039                 }
3040 #ifdef CONFIG_HS20
3041                 if (wpa_bss_get_vendor_ie(bss, HS20_IE_VENDOR_TYPE)) {
3042                         ret = os_snprintf(pos, end - pos, "[HS20]");
3043                         if (ret < 0 || ret >= end - pos)
3044                                 return -1;
3045                         pos += ret;
3046                 }
3047 #endif /* CONFIG_HS20 */
3048
3049                 ret = os_snprintf(pos, end - pos, "\n");
3050                 if (ret < 0 || ret >= end - pos)
3051                         return 0;
3052                 pos += ret;
3053         }
3054
3055         if (mask & WPA_BSS_MASK_SSID) {
3056                 ret = os_snprintf(pos, end - pos, "ssid=%s\n",
3057                                   wpa_ssid_txt(bss->ssid, bss->ssid_len));
3058                 if (ret < 0 || ret >= end - pos)
3059                         return 0;
3060                 pos += ret;
3061         }
3062
3063 #ifdef CONFIG_WPS
3064         if (mask & WPA_BSS_MASK_WPS_SCAN) {
3065                 ie = (const u8 *) (bss + 1);
3066                 ret = wpas_wps_scan_result_text(ie, bss->ie_len, pos, end);
3067                 if (ret < 0 || ret >= end - pos)
3068                         return 0;
3069                 pos += ret;
3070         }
3071 #endif /* CONFIG_WPS */
3072
3073 #ifdef CONFIG_P2P
3074         if (mask & WPA_BSS_MASK_P2P_SCAN) {
3075                 ie = (const u8 *) (bss + 1);
3076                 ret = wpas_p2p_scan_result_text(ie, bss->ie_len, pos, end);
3077                 if (ret < 0 || ret >= end - pos)
3078                         return 0;
3079                 pos += ret;
3080         }
3081 #endif /* CONFIG_P2P */
3082
3083 #ifdef CONFIG_WIFI_DISPLAY
3084         if (mask & WPA_BSS_MASK_WIFI_DISPLAY) {
3085                 struct wpabuf *wfd;
3086                 ie = (const u8 *) (bss + 1);
3087                 wfd = ieee802_11_vendor_ie_concat(ie, bss->ie_len,
3088                                                   WFD_IE_VENDOR_TYPE);
3089                 if (wfd) {
3090                         ret = os_snprintf(pos, end - pos, "wfd_subelems=");
3091                         if (ret < 0 || ret >= end - pos)
3092                                 return pos - buf;
3093                         pos += ret;
3094
3095                         pos += wpa_snprintf_hex(pos, end - pos,
3096                                                 wpabuf_head(wfd),
3097                                                 wpabuf_len(wfd));
3098                         wpabuf_free(wfd);
3099
3100                         ret = os_snprintf(pos, end - pos, "\n");
3101                         if (ret < 0 || ret >= end - pos)
3102                                 return pos - buf;
3103                         pos += ret;
3104                 }
3105         }
3106 #endif /* CONFIG_WIFI_DISPLAY */
3107
3108 #ifdef CONFIG_INTERWORKING
3109         if ((mask & WPA_BSS_MASK_INTERNETW) && bss->anqp) {
3110                 struct wpa_bss_anqp *anqp = bss->anqp;
3111                 pos = anqp_add_hex(pos, end, "anqp_venue_name",
3112                                    anqp->venue_name);
3113                 pos = anqp_add_hex(pos, end, "anqp_network_auth_type",
3114                                    anqp->network_auth_type);
3115                 pos = anqp_add_hex(pos, end, "anqp_roaming_consortium",
3116                                    anqp->roaming_consortium);
3117                 pos = anqp_add_hex(pos, end, "anqp_ip_addr_type_availability",
3118                                    anqp->ip_addr_type_availability);
3119                 pos = anqp_add_hex(pos, end, "anqp_nai_realm",
3120                                    anqp->nai_realm);
3121                 pos = anqp_add_hex(pos, end, "anqp_3gpp", anqp->anqp_3gpp);
3122                 pos = anqp_add_hex(pos, end, "anqp_domain_name",
3123                                    anqp->domain_name);
3124 #ifdef CONFIG_HS20
3125                 pos = anqp_add_hex(pos, end, "hs20_operator_friendly_name",
3126                                    anqp->hs20_operator_friendly_name);
3127                 pos = anqp_add_hex(pos, end, "hs20_wan_metrics",
3128                                    anqp->hs20_wan_metrics);
3129                 pos = anqp_add_hex(pos, end, "hs20_connection_capability",
3130                                    anqp->hs20_connection_capability);
3131 #endif /* CONFIG_HS20 */
3132         }
3133 #endif /* CONFIG_INTERWORKING */
3134
3135         return pos - buf;
3136 }
3137
3138
3139 static int wpa_supplicant_ctrl_iface_bss(struct wpa_supplicant *wpa_s,
3140                                          const char *cmd, char *buf,
3141                                          size_t buflen)
3142 {
3143         u8 bssid[ETH_ALEN];
3144         size_t i;
3145         struct wpa_bss *bss;
3146         struct wpa_bss *bsslast = NULL;
3147         struct dl_list *next;
3148         int ret = 0;
3149         int len;
3150         char *ctmp;
3151         unsigned long mask = WPA_BSS_MASK_ALL;
3152
3153         if (os_strncmp(cmd, "RANGE=", 6) == 0) {
3154                 if (os_strncmp(cmd + 6, "ALL", 3) == 0) {
3155                         bss = dl_list_first(&wpa_s->bss_id, struct wpa_bss,
3156                                             list_id);
3157                         bsslast = dl_list_last(&wpa_s->bss_id, struct wpa_bss,
3158                                                list_id);
3159                 } else { /* N1-N2 */
3160                         unsigned int id1, id2;
3161
3162                         if ((ctmp = os_strchr(cmd + 6, '-')) == NULL) {
3163                                 wpa_printf(MSG_INFO, "Wrong BSS range "
3164                                            "format");
3165                                 return 0;
3166                         }
3167
3168                         id1 = atoi(cmd + 6);
3169                         bss = wpa_bss_get_id(wpa_s, id1);
3170                         id2 = atoi(ctmp + 1);
3171                         if (id2 == 0)
3172                                 bsslast = dl_list_last(&wpa_s->bss_id,
3173                                                        struct wpa_bss,
3174                                                        list_id);
3175                         else {
3176                                 bsslast = wpa_bss_get_id(wpa_s, id2);
3177                                 if (bsslast == NULL && bss && id2 > id1) {
3178                                         struct wpa_bss *tmp = bss;
3179                                         for (;;) {
3180                                                 next = tmp->list_id.next;
3181                                                 if (next == &wpa_s->bss_id)
3182                                                         break;
3183                                                 tmp = dl_list_entry(
3184                                                         next, struct wpa_bss,
3185                                                         list_id);
3186                                                 if (tmp->id > id2)
3187                                                         break;
3188                                                 bsslast = tmp;
3189                                         }
3190                                 }
3191                         }
3192                 }
3193         } else if (os_strcmp(cmd, "FIRST") == 0)
3194                 bss = dl_list_first(&wpa_s->bss_id, struct wpa_bss, list_id);
3195         else if (os_strncmp(cmd, "ID-", 3) == 0) {
3196                 i = atoi(cmd + 3);
3197                 bss = wpa_bss_get_id(wpa_s, i);
3198         } else if (os_strncmp(cmd, "NEXT-", 5) == 0) {
3199                 i = atoi(cmd + 5);
3200                 bss = wpa_bss_get_id(wpa_s, i);
3201                 if (bss) {
3202                         next = bss->list_id.next;
3203                         if (next == &wpa_s->bss_id)
3204                                 bss = NULL;
3205                         else
3206                                 bss = dl_list_entry(next, struct wpa_bss,
3207                                                     list_id);
3208                 }
3209 #ifdef CONFIG_P2P
3210         } else if (os_strncmp(cmd, "p2p_dev_addr=", 13) == 0) {
3211                 if (hwaddr_aton(cmd + 13, bssid) == 0)
3212                         bss = wpa_bss_get_p2p_dev_addr(wpa_s, bssid);
3213                 else
3214                         bss = NULL;
3215 #endif /* CONFIG_P2P */
3216         } else if (hwaddr_aton(cmd, bssid) == 0)
3217                 bss = wpa_bss_get_bssid(wpa_s, bssid);
3218         else {
3219                 struct wpa_bss *tmp;
3220                 i = atoi(cmd);
3221                 bss = NULL;
3222                 dl_list_for_each(tmp, &wpa_s->bss_id, struct wpa_bss, list_id)
3223                 {
3224                         if (i-- == 0) {
3225                                 bss = tmp;
3226                                 break;
3227                         }
3228                 }
3229         }
3230
3231         if ((ctmp = os_strstr(cmd, "MASK=")) != NULL) {
3232                 mask = strtoul(ctmp + 5, NULL, 0x10);
3233                 if (mask == 0)
3234                         mask = WPA_BSS_MASK_ALL;
3235         }
3236
3237         if (bss == NULL)
3238                 return 0;
3239
3240         if (bsslast == NULL)
3241                 bsslast = bss;
3242         do {
3243                 len = print_bss_info(wpa_s, bss, mask, buf, buflen);
3244                 ret += len;
3245                 buf += len;
3246                 buflen -= len;
3247                 if (bss == bsslast)
3248                         break;
3249                 next = bss->list_id.next;
3250                 if (next == &wpa_s->bss_id)
3251                         break;
3252                 bss = dl_list_entry(next, struct wpa_bss, list_id);
3253         } while (bss && len);
3254
3255         return ret;
3256 }
3257
3258
3259 static int wpa_supplicant_ctrl_iface_ap_scan(
3260         struct wpa_supplicant *wpa_s, char *cmd)
3261 {
3262         int ap_scan = atoi(cmd);
3263         return wpa_supplicant_set_ap_scan(wpa_s, ap_scan);
3264 }
3265
3266
3267 static int wpa_supplicant_ctrl_iface_scan_interval(
3268         struct wpa_supplicant *wpa_s, char *cmd)
3269 {
3270         int scan_int = atoi(cmd);
3271         return wpa_supplicant_set_scan_interval(wpa_s, scan_int);
3272 }
3273
3274
3275 static int wpa_supplicant_ctrl_iface_bss_expire_age(
3276         struct wpa_supplicant *wpa_s, char *cmd)
3277 {
3278         int expire_age = atoi(cmd);
3279         return wpa_supplicant_set_bss_expiration_age(wpa_s, expire_age);
3280 }
3281
3282
3283 static int wpa_supplicant_ctrl_iface_bss_expire_count(
3284         struct wpa_supplicant *wpa_s, char *cmd)
3285 {
3286         int expire_count = atoi(cmd);
3287         return wpa_supplicant_set_bss_expiration_count(wpa_s, expire_count);
3288 }
3289
3290
3291 static int wpa_supplicant_ctrl_iface_bss_flush(
3292         struct wpa_supplicant *wpa_s, char *cmd)
3293 {
3294         int flush_age = atoi(cmd);
3295
3296         if (flush_age == 0)
3297                 wpa_bss_flush(wpa_s);
3298         else
3299                 wpa_bss_flush_by_age(wpa_s, flush_age);
3300         return 0;
3301 }
3302
3303
3304 static void wpa_supplicant_ctrl_iface_drop_sa(struct wpa_supplicant *wpa_s)
3305 {
3306         wpa_printf(MSG_DEBUG, "Dropping SA without deauthentication");
3307         /* MLME-DELETEKEYS.request */
3308         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 0, 0, NULL, 0, NULL, 0);
3309         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 1, 0, NULL, 0, NULL, 0);
3310         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 2, 0, NULL, 0, NULL, 0);
3311         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 3, 0, NULL, 0, NULL, 0);
3312 #ifdef CONFIG_IEEE80211W
3313         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 4, 0, NULL, 0, NULL, 0);
3314         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 5, 0, NULL, 0, NULL, 0);
3315 #endif /* CONFIG_IEEE80211W */
3316
3317         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, wpa_s->bssid, 0, 0, NULL, 0, NULL,
3318                         0);
3319         /* MLME-SETPROTECTION.request(None) */
3320         wpa_drv_mlme_setprotection(wpa_s, wpa_s->bssid,
3321                                    MLME_SETPROTECTION_PROTECT_TYPE_NONE,
3322                                    MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
3323         wpa_sm_drop_sa(wpa_s->wpa);
3324 }
3325
3326
3327 static int wpa_supplicant_ctrl_iface_roam(struct wpa_supplicant *wpa_s,
3328                                           char *addr)
3329 {
3330 #ifdef CONFIG_NO_SCAN_PROCESSING
3331         return -1;
3332 #else /* CONFIG_NO_SCAN_PROCESSING */
3333         u8 bssid[ETH_ALEN];
3334         struct wpa_bss *bss;
3335         struct wpa_ssid *ssid = wpa_s->current_ssid;
3336
3337         if (hwaddr_aton(addr, bssid)) {
3338                 wpa_printf(MSG_DEBUG, "CTRL_IFACE ROAM: invalid "
3339                            "address '%s'", addr);
3340                 return -1;
3341         }
3342
3343         wpa_printf(MSG_DEBUG, "CTRL_IFACE ROAM " MACSTR, MAC2STR(bssid));
3344
3345         bss = wpa_bss_get_bssid(wpa_s, bssid);
3346         if (!bss) {
3347                 wpa_printf(MSG_DEBUG, "CTRL_IFACE ROAM: Target AP not found "
3348                            "from BSS table");
3349                 return -1;
3350         }
3351
3352         /*
3353          * TODO: Find best network configuration block from configuration to
3354          * allow roaming to other networks
3355          */
3356
3357         if (!ssid) {
3358                 wpa_printf(MSG_DEBUG, "CTRL_IFACE ROAM: No network "
3359                            "configuration known for the target AP");
3360                 return -1;
3361         }
3362
3363         wpa_s->reassociate = 1;
3364         wpa_supplicant_connect(wpa_s, bss, ssid);
3365
3366         return 0;
3367 #endif /* CONFIG_NO_SCAN_PROCESSING */
3368 }
3369
3370
3371 #ifdef CONFIG_P2P
3372 static int p2p_ctrl_find(struct wpa_supplicant *wpa_s, char *cmd)
3373 {
3374         unsigned int timeout = atoi(cmd);
3375         enum p2p_discovery_type type = P2P_FIND_START_WITH_FULL;
3376         u8 dev_id[ETH_ALEN], *_dev_id = NULL;
3377         char *pos;
3378         unsigned int search_delay;
3379
3380         if (os_strstr(cmd, "type=social"))
3381                 type = P2P_FIND_ONLY_SOCIAL;
3382         else if (os_strstr(cmd, "type=progressive"))
3383                 type = P2P_FIND_PROGRESSIVE;
3384
3385         pos = os_strstr(cmd, "dev_id=");
3386         if (pos) {
3387                 pos += 7;
3388                 if (hwaddr_aton(pos, dev_id))
3389                         return -1;
3390                 _dev_id = dev_id;
3391         }
3392
3393         pos = os_strstr(cmd, "delay=");
3394         if (pos) {
3395                 pos += 6;
3396                 search_delay = atoi(pos);
3397         } else
3398                 search_delay = wpas_p2p_search_delay(wpa_s);
3399
3400         return wpas_p2p_find(wpa_s, timeout, type, 0, NULL, _dev_id,
3401                              search_delay);
3402 }
3403
3404
3405 static int p2p_ctrl_connect(struct wpa_supplicant *wpa_s, char *cmd,
3406                             char *buf, size_t buflen)
3407 {
3408         u8 addr[ETH_ALEN];
3409         char *pos, *pos2;
3410         char *pin = NULL;
3411         enum p2p_wps_method wps_method;
3412         int new_pin;
3413         int ret;
3414         int persistent_group, persistent_id = -1;
3415         int join;
3416         int auth;
3417         int automatic;
3418         int go_intent = -1;
3419         int freq = 0;
3420         int pd;
3421         int ht40;
3422
3423         /* <addr> <"pbc" | "pin" | PIN> [label|display|keypad]
3424          * [persistent|persistent=<network id>]
3425          * [join] [auth] [go_intent=<0..15>] [freq=<in MHz>] [provdisc]
3426          * [ht40] */
3427
3428         if (hwaddr_aton(cmd, addr))
3429                 return -1;
3430
3431         pos = cmd + 17;
3432         if (*pos != ' ')
3433                 return -1;
3434         pos++;
3435
3436         persistent_group = os_strstr(pos, " persistent") != NULL;
3437         pos2 = os_strstr(pos, " persistent=");
3438         if (pos2) {
3439                 struct wpa_ssid *ssid;
3440                 persistent_id = atoi(pos2 + 12);
3441                 ssid = wpa_config_get_network(wpa_s->conf, persistent_id);
3442                 if (ssid == NULL || ssid->disabled != 2 ||
3443                     ssid->mode != WPAS_MODE_P2P_GO) {
3444                         wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find "
3445                                    "SSID id=%d for persistent P2P group (GO)",
3446                                    persistent_id);
3447                         return -1;
3448                 }
3449         }
3450         join = os_strstr(pos, " join") != NULL;
3451         auth = os_strstr(pos, " auth") != NULL;
3452         automatic = os_strstr(pos, " auto") != NULL;
3453         pd = os_strstr(pos, " provdisc") != NULL;
3454         ht40 = (os_strstr(cmd, " ht40") != NULL) || wpa_s->conf->p2p_go_ht40;
3455
3456         pos2 = os_strstr(pos, " go_intent=");
3457         if (pos2) {
3458                 pos2 += 11;
3459                 go_intent = atoi(pos2);
3460                 if (go_intent < 0 || go_intent > 15)
3461                         return -1;
3462         }
3463
3464         pos2 = os_strstr(pos, " freq=");
3465         if (pos2) {
3466                 pos2 += 6;
3467                 freq = atoi(pos2);
3468                 if (freq <= 0)
3469                         return -1;
3470         }
3471
3472         if (os_strncmp(pos, "pin", 3) == 0) {
3473                 /* Request random PIN (to be displayed) and enable the PIN */
3474                 wps_method = WPS_PIN_DISPLAY;
3475         } else if (os_strncmp(pos, "pbc", 3) == 0) {
3476                 wps_method = WPS_PBC;
3477         } else {
3478                 pin = pos;
3479                 pos = os_strchr(pin, ' ');
3480                 wps_method = WPS_PIN_KEYPAD;
3481                 if (pos) {
3482                         *pos++ = '\0';
3483                         if (os_strncmp(pos, "display", 7) == 0)
3484                                 wps_method = WPS_PIN_DISPLAY;
3485                 }
3486                 if (!wps_pin_str_valid(pin)) {
3487                         os_memcpy(buf, "FAIL-INVALID-PIN\n", 17);
3488                         return 17;
3489                 }
3490         }
3491
3492         new_pin = wpas_p2p_connect(wpa_s, addr, pin, wps_method,
3493                                    persistent_group, automatic, join,
3494                                    auth, go_intent, freq, persistent_id, pd,
3495                                    ht40);
3496         if (new_pin == -2) {
3497                 os_memcpy(buf, "FAIL-CHANNEL-UNAVAILABLE\n", 25);
3498                 return 25;
3499         }
3500         if (new_pin == -3) {
3501                 os_memcpy(buf, "FAIL-CHANNEL-UNSUPPORTED\n", 25);
3502                 return 25;
3503         }
3504         if (new_pin < 0)
3505                 return -1;
3506         if (wps_method == WPS_PIN_DISPLAY && pin == NULL) {
3507                 ret = os_snprintf(buf, buflen, "%08d", new_pin);
3508                 if (ret < 0 || (size_t) ret >= buflen)
3509                         return -1;
3510                 return ret;
3511         }
3512
3513         os_memcpy(buf, "OK\n", 3);
3514         return 3;
3515 }
3516
3517
3518 static int p2p_ctrl_listen(struct wpa_supplicant *wpa_s, char *cmd)
3519 {
3520         unsigned int timeout = atoi(cmd);
3521         return wpas_p2p_listen(wpa_s, timeout);
3522 }
3523
3524
3525 static int p2p_ctrl_prov_disc(struct wpa_supplicant *wpa_s, char *cmd)
3526 {
3527         u8 addr[ETH_ALEN];
3528         char *pos;
3529         enum wpas_p2p_prov_disc_use use = WPAS_P2P_PD_FOR_GO_NEG;
3530
3531         /* <addr> <config method> [join|auto] */
3532
3533         if (hwaddr_aton(cmd, addr))
3534                 return -1;
3535
3536         pos = cmd + 17;
3537         if (*pos != ' ')
3538                 return -1;
3539         pos++;
3540
3541         if (os_strstr(pos, " join") != NULL)
3542                 use = WPAS_P2P_PD_FOR_JOIN;
3543         else if (os_strstr(pos, " auto") != NULL)
3544                 use = WPAS_P2P_PD_AUTO;
3545
3546         return wpas_p2p_prov_disc(wpa_s, addr, pos, use);
3547 }
3548
3549
3550 static int p2p_get_passphrase(struct wpa_supplicant *wpa_s, char *buf,
3551                               size_t buflen)
3552 {
3553         struct wpa_ssid *ssid = wpa_s->current_ssid;
3554
3555         if (ssid == NULL || ssid->mode != WPAS_MODE_P2P_GO ||
3556             ssid->passphrase == NULL)
3557                 return -1;
3558
3559         os_strlcpy(buf, ssid->passphrase, buflen);
3560         return os_strlen(buf);
3561 }
3562
3563
3564 static int p2p_ctrl_serv_disc_req(struct wpa_supplicant *wpa_s, char *cmd,
3565                                   char *buf, size_t buflen)
3566 {
3567         u64 ref;
3568         int res;
3569         u8 dst_buf[ETH_ALEN], *dst;
3570         struct wpabuf *tlvs;
3571         char *pos;
3572         size_t len;
3573
3574         if (hwaddr_aton(cmd, dst_buf))
3575                 return -1;
3576         dst = dst_buf;
3577         if (dst[0] == 0 && dst[1] == 0 && dst[2] == 0 &&
3578             dst[3] == 0 && dst[4] == 0 && dst[5] == 0)
3579                 dst = NULL;
3580         pos = cmd + 17;
3581         if (*pos != ' ')
3582                 return -1;
3583         pos++;
3584
3585         if (os_strncmp(pos, "upnp ", 5) == 0) {
3586                 u8 version;
3587                 pos += 5;
3588                 if (hexstr2bin(pos, &version, 1) < 0)
3589                         return -1;
3590                 pos += 2;
3591                 if (*pos != ' ')
3592                         return -1;
3593                 pos++;
3594                 ref = wpas_p2p_sd_request_upnp(wpa_s, dst, version, pos);
3595 #ifdef CONFIG_WIFI_DISPLAY
3596         } else if (os_strncmp(pos, "wifi-display ", 13) == 0) {
3597                 ref = wpas_p2p_sd_request_wifi_display(wpa_s, dst, pos + 13);
3598 #endif /* CONFIG_WIFI_DISPLAY */
3599         } else {
3600                 len = os_strlen(pos);
3601                 if (len & 1)
3602                         return -1;
3603                 len /= 2;
3604                 tlvs = wpabuf_alloc(len);
3605                 if (tlvs == NULL)
3606                         return -1;
3607                 if (hexstr2bin(pos, wpabuf_put(tlvs, len), len) < 0) {
3608                         wpabuf_free(tlvs);
3609                         return -1;
3610                 }
3611
3612                 ref = wpas_p2p_sd_request(wpa_s, dst, tlvs);
3613                 wpabuf_free(tlvs);
3614         }
3615         if (ref == 0)
3616                 return -1;
3617         res = os_snprintf(buf, buflen, "%llx", (long long unsigned) ref);
3618         if (res < 0 || (unsigned) res >= buflen)
3619                 return -1;
3620         return res;
3621 }
3622
3623
3624 static int p2p_ctrl_serv_disc_cancel_req(struct wpa_supplicant *wpa_s,
3625                                          char *cmd)
3626 {
3627         long long unsigned val;
3628         u64 req;
3629         if (sscanf(cmd, "%llx", &val) != 1)
3630                 return -1;
3631         req = val;
3632         return wpas_p2p_sd_cancel_request(wpa_s, req);
3633 }
3634
3635
3636 static int p2p_ctrl_serv_disc_resp(struct wpa_supplicant *wpa_s, char *cmd)
3637 {
3638         int freq;
3639         u8 dst[ETH_ALEN];
3640         u8 dialog_token;
3641         struct wpabuf *resp_tlvs;
3642         char *pos, *pos2;
3643         size_t len;
3644
3645         pos = os_strchr(cmd, ' ');
3646         if (pos == NULL)
3647                 return -1;
3648         *pos++ = '\0';
3649         freq = atoi(cmd);
3650         if (freq == 0)
3651                 return -1;
3652
3653         if (hwaddr_aton(pos, dst))
3654                 return -1;
3655         pos += 17;
3656         if (*pos != ' ')
3657                 return -1;
3658         pos++;
3659
3660         pos2 = os_strchr(pos, ' ');
3661         if (pos2 == NULL)
3662                 return -1;
3663         *pos2++ = '\0';
3664         dialog_token = atoi(pos);
3665
3666         len = os_strlen(pos2);
3667         if (len & 1)
3668                 return -1;
3669         len /= 2;
3670         resp_tlvs = wpabuf_alloc(len);
3671         if (resp_tlvs == NULL)
3672                 return -1;
3673         if (hexstr2bin(pos2, wpabuf_put(resp_tlvs, len), len) < 0) {
3674                 wpabuf_free(resp_tlvs);
3675                 return -1;
3676         }
3677
3678         wpas_p2p_sd_response(wpa_s, freq, dst, dialog_token, resp_tlvs);
3679         wpabuf_free(resp_tlvs);
3680         return 0;
3681 }
3682
3683
3684 static int p2p_ctrl_serv_disc_external(struct wpa_supplicant *wpa_s,
3685                                        char *cmd)
3686 {
3687         if (os_strcmp(cmd, "0") && os_strcmp(cmd, "1"))
3688                 return -1;
3689         wpa_s->p2p_sd_over_ctrl_iface = atoi(cmd);
3690         return 0;
3691 }
3692
3693
3694 static int p2p_ctrl_service_add_bonjour(struct wpa_supplicant *wpa_s,
3695                                         char *cmd)
3696 {
3697         char *pos;
3698         size_t len;
3699         struct wpabuf *query, *resp;
3700
3701         pos = os_strchr(cmd, ' ');
3702         if (pos == NULL)
3703                 return -1;
3704         *pos++ = '\0';
3705
3706         len = os_strlen(cmd);
3707         if (len & 1)
3708                 return -1;
3709         len /= 2;
3710         query = wpabuf_alloc(len);
3711         if (query == NULL)
3712                 return -1;
3713         if (hexstr2bin(cmd, wpabuf_put(query, len), len) < 0) {
3714                 wpabuf_free(query);
3715                 return -1;
3716         }
3717
3718         len = os_strlen(pos);
3719         if (len & 1) {
3720                 wpabuf_free(query);
3721                 return -1;
3722         }
3723         len /= 2;
3724         resp = wpabuf_alloc(len);
3725         if (resp == NULL) {
3726                 wpabuf_free(query);
3727                 return -1;
3728         }
3729         if (hexstr2bin(pos, wpabuf_put(resp, len), len) < 0) {
3730                 wpabuf_free(query);
3731                 wpabuf_free(resp);
3732                 return -1;
3733         }
3734
3735         if (wpas_p2p_service_add_bonjour(wpa_s, query, resp) < 0) {
3736                 wpabuf_free(query);
3737                 wpabuf_free(resp);
3738                 return -1;
3739         }
3740         return 0;
3741 }
3742
3743
3744 static int p2p_ctrl_service_add_upnp(struct wpa_supplicant *wpa_s, char *cmd)
3745 {
3746         char *pos;
3747         u8 version;
3748
3749         pos = os_strchr(cmd, ' ');
3750         if (pos == NULL)
3751                 return -1;
3752         *pos++ = '\0';
3753
3754         if (hexstr2bin(cmd, &version, 1) < 0)
3755                 return -1;
3756
3757         return wpas_p2p_service_add_upnp(wpa_s, version, pos);
3758 }
3759
3760
3761 static int p2p_ctrl_service_add(struct wpa_supplicant *wpa_s, char *cmd)
3762 {
3763         char *pos;
3764
3765         pos = os_strchr(cmd, ' ');
3766         if (pos == NULL)
3767                 return -1;
3768         *pos++ = '\0';
3769
3770         if (os_strcmp(cmd, "bonjour") == 0)
3771                 return p2p_ctrl_service_add_bonjour(wpa_s, pos);
3772         if (os_strcmp(cmd, "upnp") == 0)
3773                 return p2p_ctrl_service_add_upnp(wpa_s, pos);
3774         wpa_printf(MSG_DEBUG, "Unknown service '%s'", cmd);
3775         return -1;
3776 }
3777
3778
3779 static int p2p_ctrl_service_del_bonjour(struct wpa_supplicant *wpa_s,
3780                                         char *cmd)
3781 {
3782         size_t len;
3783         struct wpabuf *query;
3784         int ret;
3785
3786         len = os_strlen(cmd);
3787         if (len & 1)
3788                 return -1;
3789         len /= 2;
3790         query = wpabuf_alloc(len);
3791         if (query == NULL)
3792                 return -1;
3793         if (hexstr2bin(cmd, wpabuf_put(query, len), len) < 0) {
3794                 wpabuf_free(query);
3795                 return -1;
3796         }
3797
3798         ret = wpas_p2p_service_del_bonjour(wpa_s, query);
3799         wpabuf_free(query);
3800         return ret;
3801 }
3802
3803
3804 static int p2p_ctrl_service_del_upnp(struct wpa_supplicant *wpa_s, char *cmd)
3805 {
3806         char *pos;
3807         u8 version;
3808
3809         pos = os_strchr(cmd, ' ');
3810         if (pos == NULL)
3811                 return -1;
3812         *pos++ = '\0';
3813
3814         if (hexstr2bin(cmd, &version, 1) < 0)
3815                 return -1;
3816
3817         return wpas_p2p_service_del_upnp(wpa_s, version, pos);
3818 }
3819
3820
3821 static int p2p_ctrl_service_del(struct wpa_supplicant *wpa_s, char *cmd)
3822 {
3823         char *pos;
3824
3825         pos = os_strchr(cmd, ' ');
3826         if (pos == NULL)
3827                 return -1;
3828         *pos++ = '\0';
3829
3830         if (os_strcmp(cmd, "bonjour") == 0)
3831                 return p2p_ctrl_service_del_bonjour(wpa_s, pos);
3832         if (os_strcmp(cmd, "upnp") == 0)
3833                 return p2p_ctrl_service_del_upnp(wpa_s, pos);
3834         wpa_printf(MSG_DEBUG, "Unknown service '%s'", cmd);
3835         return -1;
3836 }
3837
3838
3839 static int p2p_ctrl_reject(struct wpa_supplicant *wpa_s, char *cmd)
3840 {
3841         u8 addr[ETH_ALEN];
3842
3843         /* <addr> */
3844
3845         if (hwaddr_aton(cmd, addr))
3846                 return -1;
3847
3848         return wpas_p2p_reject(wpa_s, addr);
3849 }
3850
3851
3852 static int p2p_ctrl_invite_persistent(struct wpa_supplicant *wpa_s, char *cmd)
3853 {
3854         char *pos;
3855         int id;
3856         struct wpa_ssid *ssid;
3857         u8 *_peer = NULL, peer[ETH_ALEN];
3858         int freq = 0;
3859         int ht40;
3860
3861         id = atoi(cmd);
3862         pos = os_strstr(cmd, " peer=");
3863         if (pos) {
3864                 pos += 6;
3865                 if (hwaddr_aton(pos, peer))
3866                         return -1;
3867                 _peer = peer;
3868         }
3869         ssid = wpa_config_get_network(wpa_s->conf, id);
3870         if (ssid == NULL || ssid->disabled != 2) {
3871                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find SSID id=%d "
3872                            "for persistent P2P group",
3873                            id);
3874                 return -1;
3875         }
3876
3877         pos = os_strstr(cmd, " freq=");
3878         if (pos) {
3879                 pos += 6;
3880                 freq = atoi(pos);
3881                 if (freq <= 0)
3882                         return -1;
3883         }
3884
3885         ht40 = (os_strstr(cmd, " ht40") != NULL) || wpa_s->conf->p2p_go_ht40;
3886
3887         return wpas_p2p_invite(wpa_s, _peer, ssid, NULL, freq, ht40);
3888 }
3889
3890
3891 static int p2p_ctrl_invite_group(struct wpa_supplicant *wpa_s, char *cmd)
3892 {
3893         char *pos;
3894         u8 peer[ETH_ALEN], go_dev_addr[ETH_ALEN], *go_dev = NULL;
3895
3896         pos = os_strstr(cmd, " peer=");
3897         if (!pos)
3898                 return -1;
3899
3900         *pos = '\0';
3901         pos += 6;
3902         if (hwaddr_aton(pos, peer)) {
3903                 wpa_printf(MSG_DEBUG, "P2P: Invalid MAC address '%s'", pos);
3904                 return -1;
3905         }
3906
3907         pos = os_strstr(pos, " go_dev_addr=");
3908         if (pos) {
3909                 pos += 13;
3910                 if (hwaddr_aton(pos, go_dev_addr)) {
3911                         wpa_printf(MSG_DEBUG, "P2P: Invalid MAC address '%s'",
3912                                    pos);
3913                         return -1;
3914                 }
3915                 go_dev = go_dev_addr;
3916         }
3917
3918         return wpas_p2p_invite_group(wpa_s, cmd, peer, go_dev);
3919 }
3920
3921
3922 static int p2p_ctrl_invite(struct wpa_supplicant *wpa_s, char *cmd)
3923 {
3924         if (os_strncmp(cmd, "persistent=", 11) == 0)
3925                 return p2p_ctrl_invite_persistent(wpa_s, cmd + 11);
3926         if (os_strncmp(cmd, "group=", 6) == 0)
3927                 return p2p_ctrl_invite_group(wpa_s, cmd + 6);
3928
3929         return -1;
3930 }
3931
3932
3933 static int p2p_ctrl_group_add_persistent(struct wpa_supplicant *wpa_s,
3934                                          char *cmd, int freq, int ht40)
3935 {
3936         int id;
3937         struct wpa_ssid *ssid;
3938
3939         id = atoi(cmd);
3940         ssid = wpa_config_get_network(wpa_s->conf, id);
3941         if (ssid == NULL || ssid->disabled != 2) {
3942                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find SSID id=%d "
3943                            "for persistent P2P group",
3944                            id);
3945                 return -1;
3946         }
3947
3948         return wpas_p2p_group_add_persistent(wpa_s, ssid, 0, freq, ht40);
3949 }
3950
3951
3952 static int p2p_ctrl_group_add(struct wpa_supplicant *wpa_s, char *cmd)
3953 {
3954         int freq = 0, ht40;
3955         char *pos;
3956
3957         pos = os_strstr(cmd, "freq=");
3958         if (pos)
3959                 freq = atoi(pos + 5);
3960
3961         ht40 = (os_strstr(cmd, "ht40") != NULL) || wpa_s->conf->p2p_go_ht40;
3962
3963         if (os_strncmp(cmd, "persistent=", 11) == 0)
3964                 return p2p_ctrl_group_add_persistent(wpa_s, cmd + 11, freq,
3965                                                      ht40);
3966         if (os_strcmp(cmd, "persistent") == 0 ||
3967             os_strncmp(cmd, "persistent ", 11) == 0)
3968                 return wpas_p2p_group_add(wpa_s, 1, freq, ht40);
3969         if (os_strncmp(cmd, "freq=", 5) == 0)
3970                 return wpas_p2p_group_add(wpa_s, 0, freq, ht40);
3971         if (ht40)
3972                 return wpas_p2p_group_add(wpa_s, 0, freq, ht40);
3973
3974         wpa_printf(MSG_DEBUG, "CTRL: Invalid P2P_GROUP_ADD parameters '%s'",
3975                    cmd);
3976         return -1;
3977 }
3978
3979
3980 static int p2p_ctrl_peer(struct wpa_supplicant *wpa_s, char *cmd,
3981                          char *buf, size_t buflen)
3982 {
3983         u8 addr[ETH_ALEN], *addr_ptr;
3984         int next, res;
3985         const struct p2p_peer_info *info;
3986         char *pos, *end;
3987         char devtype[WPS_DEV_TYPE_BUFSIZE];
3988         struct wpa_ssid *ssid;
3989         size_t i;
3990
3991         if (!wpa_s->global->p2p)
3992                 return -1;
3993
3994         if (os_strcmp(cmd, "FIRST") == 0) {
3995                 addr_ptr = NULL;
3996                 next = 0;
3997         } else if (os_strncmp(cmd, "NEXT-", 5) == 0) {
3998                 if (hwaddr_aton(cmd + 5, addr) < 0)
3999                         return -1;
4000                 addr_ptr = addr;
4001                 next = 1;
4002         } else {
4003                 if (hwaddr_aton(cmd, addr) < 0)
4004                         return -1;
4005                 addr_ptr = addr;
4006                 next = 0;
4007         }
4008
4009         info = p2p_get_peer_info(wpa_s->global->p2p, addr_ptr, next);
4010         if (info == NULL)
4011                 return -1;
4012
4013         pos = buf;
4014         end = buf + buflen;
4015
4016         res = os_snprintf(pos, end - pos, MACSTR "\n"
4017                           "pri_dev_type=%s\n"
4018                           "device_name=%s\n"
4019                           "manufacturer=%s\n"
4020                           "model_name=%s\n"
4021                           "model_number=%s\n"
4022                           "serial_number=%s\n"
4023                           "config_methods=0x%x\n"
4024                           "dev_capab=0x%x\n"
4025                           "group_capab=0x%x\n"
4026                           "level=%d\n",
4027                           MAC2STR(info->p2p_device_addr),
4028                           wps_dev_type_bin2str(info->pri_dev_type,
4029                                                devtype, sizeof(devtype)),
4030                           info->device_name,
4031                           info->manufacturer,
4032                           info->model_name,
4033                           info->model_number,
4034                           info->serial_number,
4035                           info->config_methods,
4036                           info->dev_capab,
4037                           info->group_capab,
4038                           info->level);
4039         if (res < 0 || res >= end - pos)
4040                 return pos - buf;
4041         pos += res;
4042
4043         for (i = 0; i < info->wps_sec_dev_type_list_len / WPS_DEV_TYPE_LEN; i++)
4044         {
4045                 const u8 *t;
4046                 t = &info->wps_sec_dev_type_list[i * WPS_DEV_TYPE_LEN];
4047                 res = os_snprintf(pos, end - pos, "sec_dev_type=%s\n",
4048                                   wps_dev_type_bin2str(t, devtype,
4049                                                        sizeof(devtype)));
4050                 if (res < 0 || res >= end - pos)
4051                         return pos - buf;
4052                 pos += res;
4053         }
4054
4055         ssid = wpas_p2p_get_persistent(wpa_s, info->p2p_device_addr, NULL, 0);
4056         if (ssid) {
4057                 res = os_snprintf(pos, end - pos, "persistent=%d\n", ssid->id);
4058                 if (res < 0 || res >= end - pos)
4059                         return pos - buf;
4060                 pos += res;
4061         }
4062
4063         res = p2p_get_peer_info_txt(info, pos, end - pos);
4064         if (res < 0)
4065                 return pos - buf;
4066         pos += res;
4067
4068         return pos - buf;
4069 }
4070
4071
4072 static int p2p_ctrl_disallow_freq(struct wpa_supplicant *wpa_s,
4073                                   const char *param)
4074 {
4075         struct wpa_freq_range *freq = NULL, *n;
4076         unsigned int count = 0, i;
4077         const char *pos, *pos2, *pos3;
4078
4079         if (wpa_s->global->p2p == NULL)
4080                 return -1;
4081
4082         /*
4083          * param includes comma separated frequency range.
4084          * For example: 2412-2432,2462,5000-6000
4085          */
4086         pos = param;
4087         while (pos && pos[0]) {
4088                 n = os_realloc_array(freq, count + 1,
4089                                      sizeof(struct wpa_freq_range));
4090                 if (n == NULL) {
4091                         os_free(freq);
4092                         return -1;
4093                 }
4094                 freq = n;
4095                 freq[count].min = atoi(pos);
4096                 pos2 = os_strchr(pos, '-');
4097                 pos3 = os_strchr(pos, ',');
4098                 if (pos2 && (!pos3 || pos2 < pos3)) {
4099                         pos2++;
4100                         freq[count].max = atoi(pos2);
4101                 } else
4102                         freq[count].max = freq[count].min;
4103                 pos = pos3;
4104                 if (pos)
4105                         pos++;
4106                 count++;
4107         }
4108
4109         for (i = 0; i < count; i++) {
4110                 wpa_printf(MSG_DEBUG, "P2P: Disallowed frequency range %u-%u",
4111                            freq[i].min, freq[i].max);
4112         }
4113
4114         os_free(wpa_s->global->p2p_disallow_freq);
4115         wpa_s->global->p2p_disallow_freq = freq;
4116         wpa_s->global->num_p2p_disallow_freq = count;
4117         wpas_p2p_update_channel_list(wpa_s);
4118         return 0;
4119 }
4120
4121
4122 static int p2p_ctrl_set(struct wpa_supplicant *wpa_s, char *cmd)
4123 {
4124         char *param;
4125
4126         if (wpa_s->global->p2p == NULL)
4127                 return -1;
4128
4129         param = os_strchr(cmd, ' ');
4130         if (param == NULL)
4131                 return -1;
4132         *param++ = '\0';
4133
4134         if (os_strcmp(cmd, "discoverability") == 0) {
4135                 p2p_set_client_discoverability(wpa_s->global->p2p,
4136                                                atoi(param));
4137                 return 0;
4138         }
4139
4140         if (os_strcmp(cmd, "managed") == 0) {
4141                 p2p_set_managed_oper(wpa_s->global->p2p, atoi(param));
4142                 return 0;
4143         }
4144
4145         if (os_strcmp(cmd, "listen_channel") == 0) {
4146                 return p2p_set_listen_channel(wpa_s->global->p2p, 81,
4147                                               atoi(param));
4148         }
4149
4150         if (os_strcmp(cmd, "ssid_postfix") == 0) {
4151                 return p2p_set_ssid_postfix(wpa_s->global->p2p, (u8 *) param,
4152                                             os_strlen(param));
4153         }
4154
4155         if (os_strcmp(cmd, "noa") == 0) {
4156                 char *pos;
4157                 int count, start, duration;
4158                 /* GO NoA parameters: count,start_offset(ms),duration(ms) */
4159                 count = atoi(param);
4160                 pos = os_strchr(param, ',');
4161                 if (pos == NULL)
4162                         return -1;
4163                 pos++;
4164                 start = atoi(pos);
4165                 pos = os_strchr(pos, ',');
4166                 if (pos == NULL)
4167                         return -1;
4168                 pos++;
4169                 duration = atoi(pos);
4170                 if (count < 0 || count > 255 || start < 0 || duration < 0)
4171                         return -1;
4172                 if (count == 0 && duration > 0)
4173                         return -1;
4174                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: P2P_SET GO NoA: count=%d "
4175                            "start=%d duration=%d", count, start, duration);
4176                 return wpas_p2p_set_noa(wpa_s, count, start, duration);
4177         }
4178
4179         if (os_strcmp(cmd, "ps") == 0)
4180                 return wpa_drv_set_p2p_powersave(wpa_s, atoi(param), -1, -1);
4181
4182         if (os_strcmp(cmd, "oppps") == 0)
4183                 return wpa_drv_set_p2p_powersave(wpa_s, -1, atoi(param), -1);
4184
4185         if (os_strcmp(cmd, "ctwindow") == 0)
4186                 return wpa_drv_set_p2p_powersave(wpa_s, -1, -1, atoi(param));
4187
4188         if (os_strcmp(cmd, "disabled") == 0) {
4189                 wpa_s->global->p2p_disabled = atoi(param);
4190                 wpa_printf(MSG_DEBUG, "P2P functionality %s",
4191                            wpa_s->global->p2p_disabled ?
4192                            "disabled" : "enabled");
4193                 if (wpa_s->global->p2p_disabled) {
4194                         wpas_p2p_stop_find(wpa_s);
4195                         os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
4196                         p2p_flush(wpa_s->global->p2p);
4197                 }
4198                 return 0;
4199         }
4200
4201         if (os_strcmp(cmd, "conc_pref") == 0) {
4202                 if (os_strcmp(param, "sta") == 0)
4203                         wpa_s->global->conc_pref = WPA_CONC_PREF_STA;
4204                 else if (os_strcmp(param, "p2p") == 0)
4205                         wpa_s->global->conc_pref = WPA_CONC_PREF_P2P;
4206                 else {
4207                         wpa_printf(MSG_INFO, "Invalid conc_pref value");
4208                         return -1;
4209                 }
4210                 wpa_printf(MSG_DEBUG, "Single channel concurrency preference: "
4211                            "%s", param);
4212                 return 0;
4213         }
4214
4215         if (os_strcmp(cmd, "force_long_sd") == 0) {
4216                 wpa_s->force_long_sd = atoi(param);
4217                 return 0;
4218         }
4219
4220         if (os_strcmp(cmd, "peer_filter") == 0) {
4221                 u8 addr[ETH_ALEN];
4222                 if (hwaddr_aton(param, addr))
4223                         return -1;
4224                 p2p_set_peer_filter(wpa_s->global->p2p, addr);
4225                 return 0;
4226         }
4227
4228         if (os_strcmp(cmd, "cross_connect") == 0)
4229                 return wpas_p2p_set_cross_connect(wpa_s, atoi(param));
4230
4231         if (os_strcmp(cmd, "go_apsd") == 0) {
4232                 if (os_strcmp(param, "disable") == 0)
4233                         wpa_s->set_ap_uapsd = 0;
4234                 else {
4235                         wpa_s->set_ap_uapsd = 1;
4236                         wpa_s->ap_uapsd = atoi(param);
4237                 }
4238                 return 0;
4239         }
4240
4241         if (os_strcmp(cmd, "client_apsd") == 0) {
4242                 if (os_strcmp(param, "disable") == 0)
4243                         wpa_s->set_sta_uapsd = 0;
4244                 else {
4245                         int be, bk, vi, vo;
4246                         char *pos;
4247                         /* format: BE,BK,VI,VO;max SP Length */
4248                         be = atoi(param);
4249                         pos = os_strchr(param, ',');
4250                         if (pos == NULL)
4251                                 return -1;
4252                         pos++;
4253                         bk = atoi(pos);
4254                         pos = os_strchr(pos, ',');
4255                         if (pos == NULL)
4256                                 return -1;
4257                         pos++;
4258                         vi = atoi(pos);
4259                         pos = os_strchr(pos, ',');
4260                         if (pos == NULL)
4261                                 return -1;
4262                         pos++;
4263                         vo = atoi(pos);
4264                         /* ignore max SP Length for now */
4265
4266                         wpa_s->set_sta_uapsd = 1;
4267                         wpa_s->sta_uapsd = 0;
4268                         if (be)
4269                                 wpa_s->sta_uapsd |= BIT(0);
4270                         if (bk)
4271                                 wpa_s->sta_uapsd |= BIT(1);
4272                         if (vi)
4273                                 wpa_s->sta_uapsd |= BIT(2);
4274                         if (vo)
4275                                 wpa_s->sta_uapsd |= BIT(3);
4276                 }
4277                 return 0;
4278         }
4279
4280         if (os_strcmp(cmd, "disallow_freq") == 0)
4281                 return p2p_ctrl_disallow_freq(wpa_s, param);
4282
4283         if (os_strcmp(cmd, "disc_int") == 0) {
4284                 int min_disc_int, max_disc_int, max_disc_tu;
4285                 char *pos;
4286
4287                 pos = param;
4288
4289                 min_disc_int = atoi(pos);
4290                 pos = os_strchr(pos, ' ');
4291                 if (pos == NULL)
4292                         return -1;
4293                 *pos++ = '\0';
4294
4295                 max_disc_int = atoi(pos);
4296                 pos = os_strchr(pos, ' ');
4297                 if (pos == NULL)
4298                         return -1;
4299                 *pos++ = '\0';
4300
4301                 max_disc_tu = atoi(pos);
4302
4303                 return p2p_set_disc_int(wpa_s->global->p2p, min_disc_int,
4304                                         max_disc_int, max_disc_tu);
4305         }
4306
4307         wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown P2P_SET field value '%s'",
4308                    cmd);
4309
4310         return -1;
4311 }
4312
4313
4314 static int p2p_ctrl_presence_req(struct wpa_supplicant *wpa_s, char *cmd)
4315 {
4316         char *pos, *pos2;
4317         unsigned int dur1 = 0, int1 = 0, dur2 = 0, int2 = 0;
4318
4319         if (cmd[0]) {
4320                 pos = os_strchr(cmd, ' ');
4321                 if (pos == NULL)
4322                         return -1;
4323                 *pos++ = '\0';
4324                 dur1 = atoi(cmd);
4325
4326                 pos2 = os_strchr(pos, ' ');
4327                 if (pos2)
4328                         *pos2++ = '\0';
4329                 int1 = atoi(pos);
4330         } else
4331                 pos2 = NULL;
4332
4333         if (pos2) {
4334                 pos = os_strchr(pos2, ' ');
4335                 if (pos == NULL)
4336                         return -1;
4337                 *pos++ = '\0';
4338                 dur2 = atoi(pos2);
4339                 int2 = atoi(pos);
4340         }
4341
4342         return wpas_p2p_presence_req(wpa_s, dur1, int1, dur2, int2);
4343 }
4344
4345
4346 static int p2p_ctrl_ext_listen(struct wpa_supplicant *wpa_s, char *cmd)
4347 {
4348         char *pos;
4349         unsigned int period = 0, interval = 0;
4350
4351         if (cmd[0]) {
4352                 pos = os_strchr(cmd, ' ');
4353                 if (pos == NULL)
4354                         return -1;
4355                 *pos++ = '\0';
4356                 period = atoi(cmd);
4357                 interval = atoi(pos);
4358         }
4359
4360         return wpas_p2p_ext_listen(wpa_s, period, interval);
4361 }
4362
4363 #endif /* CONFIG_P2P */
4364
4365
4366 #ifdef CONFIG_INTERWORKING
4367 static int ctrl_interworking_connect(struct wpa_supplicant *wpa_s, char *dst)
4368 {
4369         u8 bssid[ETH_ALEN];
4370         struct wpa_bss *bss;
4371
4372         if (hwaddr_aton(dst, bssid)) {
4373                 wpa_printf(MSG_DEBUG, "Invalid BSSID '%s'", dst);
4374                 return -1;
4375         }
4376
4377         bss = wpa_bss_get_bssid(wpa_s, bssid);
4378         if (bss == NULL) {
4379                 wpa_printf(MSG_DEBUG, "Could not find BSS " MACSTR,
4380                            MAC2STR(bssid));
4381                 return -1;
4382         }
4383
4384         return interworking_connect(wpa_s, bss);
4385 }
4386
4387
4388 static int get_anqp(struct wpa_supplicant *wpa_s, char *dst)
4389 {
4390         u8 dst_addr[ETH_ALEN];
4391         int used;
4392         char *pos;
4393 #define MAX_ANQP_INFO_ID 100
4394         u16 id[MAX_ANQP_INFO_ID];
4395         size_t num_id = 0;
4396
4397         used = hwaddr_aton2(dst, dst_addr);
4398         if (used < 0)
4399                 return -1;
4400         pos = dst + used;
4401         while (num_id < MAX_ANQP_INFO_ID) {
4402                 id[num_id] = atoi(pos);
4403                 if (id[num_id])
4404                         num_id++;
4405                 pos = os_strchr(pos + 1, ',');
4406                 if (pos == NULL)
4407                         break;
4408                 pos++;
4409         }
4410
4411         if (num_id == 0)
4412                 return -1;
4413
4414         return anqp_send_req(wpa_s, dst_addr, id, num_id);
4415 }
4416
4417
4418 static int gas_request(struct wpa_supplicant *wpa_s, char *cmd)
4419 {
4420         u8 dst_addr[ETH_ALEN];
4421         struct wpabuf *advproto, *query = NULL;
4422         int used, ret = -1;
4423         char *pos, *end;
4424         size_t len;
4425
4426         used = hwaddr_aton2(cmd, dst_addr);
4427         if (used < 0)
4428                 return -1;
4429
4430         pos = cmd + used;
4431         while (*pos == ' ')
4432                 pos++;
4433
4434         /* Advertisement Protocol ID */
4435         end = os_strchr(pos, ' ');
4436         if (end)
4437                 len = end - pos;
4438         else
4439                 len = os_strlen(pos);
4440         if (len & 0x01)
4441                 return -1;
4442         len /= 2;
4443         if (len == 0)
4444                 return -1;
4445         advproto = wpabuf_alloc(len);
4446         if (advproto == NULL)
4447                 return -1;
4448         if (hexstr2bin(pos, wpabuf_put(advproto, len), len) < 0)
4449                 goto fail;
4450
4451         if (end) {
4452                 /* Optional Query Request */
4453                 pos = end + 1;
4454                 while (*pos == ' ')
4455                         pos++;
4456
4457                 len = os_strlen(pos);
4458                 if (len) {
4459                         if (len & 0x01)
4460                                 goto fail;
4461                         len /= 2;
4462                         if (len == 0)
4463                                 goto fail;
4464                         query = wpabuf_alloc(len);
4465                         if (query == NULL)
4466                                 goto fail;
4467                         if (hexstr2bin(pos, wpabuf_put(query, len), len) < 0)
4468                                 goto fail;
4469                 }
4470         }
4471
4472         ret = gas_send_request(wpa_s, dst_addr, advproto, query);
4473
4474 fail:
4475         wpabuf_free(advproto);
4476         wpabuf_free(query);
4477
4478         return ret;
4479 }
4480
4481
4482 static int gas_response_get(struct wpa_supplicant *wpa_s, char *cmd, char *buf,
4483                             size_t buflen)
4484 {
4485         u8 addr[ETH_ALEN];
4486         int dialog_token;
4487         int used;
4488         char *pos;
4489         size_t resp_len, start, requested_len;
4490
4491         if (!wpa_s->last_gas_resp)
4492                 return -1;
4493
4494         used = hwaddr_aton2(cmd, addr);
4495         if (used < 0)
4496                 return -1;
4497
4498         pos = cmd + used;
4499         while (*pos == ' ')
4500                 pos++;
4501         dialog_token = atoi(pos);
4502
4503         if (os_memcmp(addr, wpa_s->last_gas_addr, ETH_ALEN) != 0 ||
4504             dialog_token != wpa_s->last_gas_dialog_token)
4505                 return -1;
4506
4507         resp_len = wpabuf_len(wpa_s->last_gas_resp);
4508         start = 0;
4509         requested_len = resp_len;
4510
4511         pos = os_strchr(pos, ' ');
4512         if (pos) {
4513                 start = atoi(pos);
4514                 if (start > resp_len)
4515                         return os_snprintf(buf, buflen, "FAIL-Invalid range");
4516                 pos = os_strchr(pos, ',');
4517                 if (pos == NULL)
4518                         return -1;
4519                 pos++;
4520                 requested_len = atoi(pos);
4521                 if (start + requested_len > resp_len)
4522                         return os_snprintf(buf, buflen, "FAIL-Invalid range");
4523         }
4524
4525         if (requested_len * 2 + 1 > buflen)
4526                 return os_snprintf(buf, buflen, "FAIL-Too long response");
4527
4528         return wpa_snprintf_hex(buf, buflen,
4529                                 wpabuf_head_u8(wpa_s->last_gas_resp) + start,
4530                                 requested_len);
4531 }
4532 #endif /* CONFIG_INTERWORKING */
4533
4534
4535 #ifdef CONFIG_HS20
4536
4537 static int get_hs20_anqp(struct wpa_supplicant *wpa_s, char *dst)
4538 {
4539         u8 dst_addr[ETH_ALEN];
4540         int used;
4541         char *pos;
4542         u32 subtypes = 0;
4543
4544         used = hwaddr_aton2(dst, dst_addr);
4545         if (used < 0)
4546                 return -1;
4547         pos = dst + used;
4548         for (;;) {
4549                 int num = atoi(pos);
4550                 if (num <= 0 || num > 31)
4551                         return -1;
4552                 subtypes |= BIT(num);
4553                 pos = os_strchr(pos + 1, ',');
4554                 if (pos == NULL)
4555                         break;
4556                 pos++;
4557         }
4558
4559         if (subtypes == 0)
4560                 return -1;
4561
4562         return hs20_anqp_send_req(wpa_s, dst_addr, subtypes, NULL, 0);
4563 }
4564
4565
4566 static int hs20_nai_home_realm_list(struct wpa_supplicant *wpa_s,
4567                                     const u8 *addr, const char *realm)
4568 {
4569         u8 *buf;
4570         size_t rlen, len;
4571         int ret;
4572
4573         rlen = os_strlen(realm);
4574         len = 3 + rlen;
4575         buf = os_malloc(len);
4576         if (buf == NULL)
4577                 return -1;
4578         buf[0] = 1; /* NAI Home Realm Count */
4579         buf[1] = 0; /* Formatted in accordance with RFC 4282 */
4580         buf[2] = rlen;
4581         os_memcpy(buf + 3, realm, rlen);
4582
4583         ret = hs20_anqp_send_req(wpa_s, addr,
4584                                  BIT(HS20_STYPE_NAI_HOME_REALM_QUERY),
4585                                  buf, len);
4586
4587         os_free(buf);
4588
4589         return ret;
4590 }
4591
4592
4593 static int hs20_get_nai_home_realm_list(struct wpa_supplicant *wpa_s,
4594                                         char *dst)
4595 {
4596         struct wpa_cred *cred = wpa_s->conf->cred;
4597         u8 dst_addr[ETH_ALEN];
4598         int used;
4599         u8 *buf;
4600         size_t len;
4601         int ret;
4602
4603         used = hwaddr_aton2(dst, dst_addr);
4604         if (used < 0)
4605                 return -1;
4606
4607         while (dst[used] == ' ')
4608                 used++;
4609         if (os_strncmp(dst + used, "realm=", 6) == 0)
4610                 return hs20_nai_home_realm_list(wpa_s, dst_addr,
4611                                                 dst + used + 6);
4612
4613         len = os_strlen(dst + used);
4614
4615         if (len == 0 && cred && cred->realm)
4616                 return hs20_nai_home_realm_list(wpa_s, dst_addr, cred->realm);
4617
4618         if (len % 1)
4619                 return -1;
4620         len /= 2;
4621         buf = os_malloc(len);
4622         if (buf == NULL)
4623                 return -1;
4624         if (hexstr2bin(dst + used, buf, len) < 0) {
4625                 os_free(buf);
4626                 return -1;
4627         }
4628
4629         ret = hs20_anqp_send_req(wpa_s, dst_addr,
4630                                  BIT(HS20_STYPE_NAI_HOME_REALM_QUERY),
4631                                  buf, len);
4632         os_free(buf);
4633
4634         return ret;
4635 }
4636
4637 #endif /* CONFIG_HS20 */
4638
4639
4640 static int wpa_supplicant_ctrl_iface_sta_autoconnect(
4641         struct wpa_supplicant *wpa_s, char *cmd)
4642 {
4643         wpa_s->auto_reconnect_disabled = atoi(cmd) == 0 ? 1 : 0;
4644         return 0;
4645 }
4646
4647
4648 #ifdef CONFIG_AUTOSCAN
4649
4650 static int wpa_supplicant_ctrl_iface_autoscan(struct wpa_supplicant *wpa_s,
4651                                               char *cmd)
4652 {
4653         enum wpa_states state = wpa_s->wpa_state;
4654         char *new_params = NULL;
4655
4656         if (os_strlen(cmd) > 0) {
4657                 new_params = os_strdup(cmd);
4658                 if (new_params == NULL)
4659                         return -1;
4660         }
4661
4662         os_free(wpa_s->conf->autoscan);
4663         wpa_s->conf->autoscan = new_params;
4664
4665         if (wpa_s->conf->autoscan == NULL)
4666                 autoscan_deinit(wpa_s);
4667         else if (state == WPA_DISCONNECTED || state == WPA_INACTIVE)
4668                 autoscan_init(wpa_s, 1);
4669         else if (state == WPA_SCANNING)
4670                 wpa_supplicant_reinit_autoscan(wpa_s);
4671
4672         return 0;
4673 }
4674
4675 #endif /* CONFIG_AUTOSCAN */
4676
4677
4678 #ifdef CONFIG_WNM
4679
4680 static int wpas_ctrl_iface_wnm_sleep(struct wpa_supplicant *wpa_s, char *cmd)
4681 {
4682         int enter;
4683         int intval = 0;
4684         char *pos;
4685         int ret;
4686         struct wpabuf *tfs_req = NULL;
4687
4688         if (os_strncmp(cmd, "enter", 5) == 0)
4689                 enter = 1;
4690         else if (os_strncmp(cmd, "exit", 4) == 0)
4691                 enter = 0;
4692         else
4693                 return -1;
4694
4695         pos = os_strstr(cmd, " interval=");
4696         if (pos)
4697                 intval = atoi(pos + 10);
4698
4699         pos = os_strstr(cmd, " tfs_req=");
4700         if (pos) {
4701                 char *end;
4702                 size_t len;
4703                 pos += 9;
4704                 end = os_strchr(pos, ' ');
4705                 if (end)
4706                         len = end - pos;
4707                 else
4708                         len = os_strlen(pos);
4709                 if (len & 1)
4710                         return -1;
4711                 len /= 2;
4712                 tfs_req = wpabuf_alloc(len);
4713                 if (tfs_req == NULL)
4714                         return -1;
4715                 if (hexstr2bin(pos, wpabuf_put(tfs_req, len), len) < 0) {
4716                         wpabuf_free(tfs_req);
4717                         return -1;
4718                 }
4719         }
4720
4721         ret = ieee802_11_send_wnmsleep_req(wpa_s, enter ? WNM_SLEEP_MODE_ENTER :
4722                                            WNM_SLEEP_MODE_EXIT, intval,
4723                                            tfs_req);
4724         wpabuf_free(tfs_req);
4725
4726         return ret;
4727 }
4728
4729 #endif /* CONFIG_WNM */
4730
4731
4732 static int wpa_supplicant_signal_poll(struct wpa_supplicant *wpa_s, char *buf,
4733                                       size_t buflen)
4734 {
4735         struct wpa_signal_info si;
4736         int ret;
4737
4738         ret = wpa_drv_signal_poll(wpa_s, &si);
4739         if (ret)
4740                 return -1;
4741
4742         ret = os_snprintf(buf, buflen, "RSSI=%d\nLINKSPEED=%d\n"
4743                           "NOISE=%d\nFREQUENCY=%u\n",
4744                           si.current_signal, si.current_txrate / 1000,
4745                           si.current_noise, si.frequency);
4746         if (ret < 0 || (unsigned int) ret > buflen)
4747                 return -1;
4748         return ret;
4749 }
4750
4751
4752 static int wpa_supplicant_pktcnt_poll(struct wpa_supplicant *wpa_s, char *buf,
4753                                       size_t buflen)
4754 {
4755         struct hostap_sta_driver_data sta;
4756         int ret;
4757
4758         ret = wpa_drv_pktcnt_poll(wpa_s, &sta);
4759         if (ret)
4760                 return -1;
4761
4762         ret = os_snprintf(buf, buflen, "TXGOOD=%lu\nTXBAD=%lu\nRXGOOD=%lu\n",
4763                           sta.tx_packets, sta.tx_retry_failed, sta.rx_packets);
4764         if (ret < 0 || (size_t) ret > buflen)
4765                 return -1;
4766         return ret;
4767 }
4768
4769
4770 char * wpa_supplicant_ctrl_iface_process(struct wpa_supplicant *wpa_s,
4771                                          char *buf, size_t *resp_len)
4772 {
4773         char *reply;
4774         const int reply_size = 4096;
4775         int ctrl_rsp = 0;
4776         int reply_len;
4777
4778         if (os_strncmp(buf, WPA_CTRL_RSP, os_strlen(WPA_CTRL_RSP)) == 0 ||
4779             os_strncmp(buf, "SET_NETWORK ", 12) == 0 ||
4780             os_strncmp(buf, "WPS_NFC_TAG_READ", 16) == 0 ||
4781             os_strncmp(buf, "NFC_RX_HANDOVER_SEL", 19) == 0) {
4782                 wpa_hexdump_ascii_key(MSG_DEBUG, "RX ctrl_iface",
4783                                       (const u8 *) buf, os_strlen(buf));
4784         } else {
4785                 int level = MSG_DEBUG;
4786                 if (os_strcmp(buf, "PING") == 0)
4787                         level = MSG_EXCESSIVE;
4788                 wpa_hexdump_ascii(level, "RX ctrl_iface",
4789                                   (const u8 *) buf, os_strlen(buf));
4790                 wpa_dbg(wpa_s, level, "Control interface command '%s'", buf);
4791         }
4792
4793         reply = os_malloc(reply_size);
4794         if (reply == NULL) {
4795                 *resp_len = 1;
4796                 return NULL;
4797         }
4798
4799         os_memcpy(reply, "OK\n", 3);
4800         reply_len = 3;
4801
4802         if (os_strcmp(buf, "PING") == 0) {
4803                 os_memcpy(reply, "PONG\n", 5);
4804                 reply_len = 5;
4805         } else if (os_strcmp(buf, "IFNAME") == 0) {
4806                 reply_len = os_strlen(wpa_s->ifname);
4807                 os_memcpy(reply, wpa_s->ifname, reply_len);
4808         } else if (os_strncmp(buf, "RELOG", 5) == 0) {
4809                 if (wpa_debug_reopen_file() < 0)
4810                         reply_len = -1;
4811         } else if (os_strncmp(buf, "NOTE ", 5) == 0) {
4812                 wpa_printf(MSG_INFO, "NOTE: %s", buf + 5);
4813         } else if (os_strcmp(buf, "MIB") == 0) {
4814                 reply_len = wpa_sm_get_mib(wpa_s->wpa, reply, reply_size);
4815                 if (reply_len >= 0) {
4816                         int res;
4817                         res = eapol_sm_get_mib(wpa_s->eapol, reply + reply_len,
4818                                                reply_size - reply_len);
4819                         if (res < 0)
4820                                 reply_len = -1;
4821                         else
4822                                 reply_len += res;
4823                 }
4824         } else if (os_strncmp(buf, "STATUS", 6) == 0) {
4825                 reply_len = wpa_supplicant_ctrl_iface_status(
4826                         wpa_s, buf + 6, reply, reply_size);
4827         } else if (os_strcmp(buf, "PMKSA") == 0) {
4828                 reply_len = wpa_sm_pmksa_cache_list(wpa_s->wpa, reply,
4829                                                     reply_size);
4830         } else if (os_strncmp(buf, "SET ", 4) == 0) {
4831                 if (wpa_supplicant_ctrl_iface_set(wpa_s, buf + 4))
4832                         reply_len = -1;
4833         } else if (os_strncmp(buf, "GET ", 4) == 0) {
4834                 reply_len = wpa_supplicant_ctrl_iface_get(wpa_s, buf + 4,
4835                                                           reply, reply_size);
4836         } else if (os_strcmp(buf, "LOGON") == 0) {
4837                 eapol_sm_notify_logoff(wpa_s->eapol, FALSE);
4838         } else if (os_strcmp(buf, "LOGOFF") == 0) {
4839                 eapol_sm_notify_logoff(wpa_s->eapol, TRUE);
4840         } else if (os_strcmp(buf, "REASSOCIATE") == 0) {
4841                 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
4842                         reply_len = -1;
4843                 else
4844                         wpas_request_connection(wpa_s);
4845         } else if (os_strcmp(buf, "RECONNECT") == 0) {
4846                 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
4847                         reply_len = -1;
4848                 else if (wpa_s->disconnected)
4849                         wpas_request_connection(wpa_s);
4850 #ifdef IEEE8021X_EAPOL
4851         } else if (os_strncmp(buf, "PREAUTH ", 8) == 0) {
4852                 if (wpa_supplicant_ctrl_iface_preauth(wpa_s, buf + 8))
4853                         reply_len = -1;
4854 #endif /* IEEE8021X_EAPOL */
4855 #ifdef CONFIG_PEERKEY
4856         } else if (os_strncmp(buf, "STKSTART ", 9) == 0) {
4857                 if (wpa_supplicant_ctrl_iface_stkstart(wpa_s, buf + 9))
4858                         reply_len = -1;
4859 #endif /* CONFIG_PEERKEY */
4860 #ifdef CONFIG_IEEE80211R
4861         } else if (os_strncmp(buf, "FT_DS ", 6) == 0) {
4862                 if (wpa_supplicant_ctrl_iface_ft_ds(wpa_s, buf + 6))
4863                         reply_len = -1;
4864 #endif /* CONFIG_IEEE80211R */
4865 #ifdef CONFIG_WPS
4866         } else if (os_strcmp(buf, "WPS_PBC") == 0) {
4867                 int res = wpa_supplicant_ctrl_iface_wps_pbc(wpa_s, NULL);
4868                 if (res == -2) {
4869                         os_memcpy(reply, "FAIL-PBC-OVERLAP\n", 17);
4870                         reply_len = 17;
4871                 } else if (res)
4872                         reply_len = -1;
4873         } else if (os_strncmp(buf, "WPS_PBC ", 8) == 0) {
4874                 int res = wpa_supplicant_ctrl_iface_wps_pbc(wpa_s, buf + 8);
4875                 if (res == -2) {
4876                         os_memcpy(reply, "FAIL-PBC-OVERLAP\n", 17);
4877                         reply_len = 17;
4878                 } else if (res)
4879                         reply_len = -1;
4880         } else if (os_strncmp(buf, "WPS_PIN ", 8) == 0) {
4881                 reply_len = wpa_supplicant_ctrl_iface_wps_pin(wpa_s, buf + 8,
4882                                                               reply,
4883                                                               reply_size);
4884         } else if (os_strncmp(buf, "WPS_CHECK_PIN ", 14) == 0) {
4885                 reply_len = wpa_supplicant_ctrl_iface_wps_check_pin(
4886                         wpa_s, buf + 14, reply, reply_size);
4887         } else if (os_strcmp(buf, "WPS_CANCEL") == 0) {
4888                 if (wpas_wps_cancel(wpa_s))
4889                         reply_len = -1;
4890 #ifdef CONFIG_WPS_NFC
4891         } else if (os_strcmp(buf, "WPS_NFC") == 0) {
4892                 if (wpa_supplicant_ctrl_iface_wps_nfc(wpa_s, NULL))
4893                         reply_len = -1;
4894         } else if (os_strncmp(buf, "WPS_NFC ", 8) == 0) {
4895                 if (wpa_supplicant_ctrl_iface_wps_nfc(wpa_s, buf + 8))
4896                         reply_len = -1;
4897         } else if (os_strncmp(buf, "WPS_NFC_TOKEN ", 14) == 0) {
4898                 reply_len = wpa_supplicant_ctrl_iface_wps_nfc_token(
4899                         wpa_s, buf + 14, reply, reply_size);
4900         } else if (os_strncmp(buf, "WPS_NFC_TAG_READ ", 17) == 0) {
4901                 if (wpa_supplicant_ctrl_iface_wps_nfc_tag_read(wpa_s,
4902                                                                buf + 17))
4903                         reply_len = -1;
4904         } else if (os_strncmp(buf, "NFC_GET_HANDOVER_REQ ", 21) == 0) {
4905                 reply_len = wpas_ctrl_nfc_get_handover_req(
4906                         wpa_s, buf + 21, reply, reply_size);
4907         } else if (os_strncmp(buf, "NFC_GET_HANDOVER_SEL ", 21) == 0) {
4908                 reply_len = wpas_ctrl_nfc_get_handover_sel(
4909                         wpa_s, buf + 21, reply, reply_size);
4910         } else if (os_strncmp(buf, "NFC_RX_HANDOVER_REQ ", 20) == 0) {
4911                 reply_len = wpas_ctrl_nfc_rx_handover_req(
4912                         wpa_s, buf + 20, reply, reply_size);
4913         } else if (os_strncmp(buf, "NFC_RX_HANDOVER_SEL ", 20) == 0) {
4914                 if (wpas_ctrl_nfc_rx_handover_sel(wpa_s, buf + 20))
4915                         reply_len = -1;
4916 #endif /* CONFIG_WPS_NFC */
4917         } else if (os_strncmp(buf, "WPS_REG ", 8) == 0) {
4918                 if (wpa_supplicant_ctrl_iface_wps_reg(wpa_s, buf + 8))
4919                         reply_len = -1;
4920 #ifdef CONFIG_AP
4921         } else if (os_strncmp(buf, "WPS_AP_PIN ", 11) == 0) {
4922                 reply_len = wpa_supplicant_ctrl_iface_wps_ap_pin(
4923                         wpa_s, buf + 11, reply, reply_size);
4924 #endif /* CONFIG_AP */
4925 #ifdef CONFIG_WPS_ER
4926         } else if (os_strcmp(buf, "WPS_ER_START") == 0) {
4927                 if (wpas_wps_er_start(wpa_s, NULL))
4928                         reply_len = -1;
4929         } else if (os_strncmp(buf, "WPS_ER_START ", 13) == 0) {
4930                 if (wpas_wps_er_start(wpa_s, buf + 13))
4931                         reply_len = -1;
4932         } else if (os_strcmp(buf, "WPS_ER_STOP") == 0) {
4933                 if (wpas_wps_er_stop(wpa_s))
4934                         reply_len = -1;
4935         } else if (os_strncmp(buf, "WPS_ER_PIN ", 11) == 0) {
4936                 if (wpa_supplicant_ctrl_iface_wps_er_pin(wpa_s, buf + 11))
4937                         reply_len = -1;
4938         } else if (os_strncmp(buf, "WPS_ER_PBC ", 11) == 0) {
4939                 int ret = wpas_wps_er_pbc(wpa_s, buf + 11);
4940                 if (ret == -2) {
4941                         os_memcpy(reply, "FAIL-PBC-OVERLAP\n", 17);
4942                         reply_len = 17;
4943                 } else if (ret == -3) {
4944                         os_memcpy(reply, "FAIL-UNKNOWN-UUID\n", 18);
4945                         reply_len = 18;
4946                 } else if (ret == -4) {
4947                         os_memcpy(reply, "FAIL-NO-AP-SETTINGS\n", 20);
4948                         reply_len = 20;
4949                 } else if (ret)
4950                         reply_len = -1;
4951         } else if (os_strncmp(buf, "WPS_ER_LEARN ", 13) == 0) {
4952                 if (wpa_supplicant_ctrl_iface_wps_er_learn(wpa_s, buf + 13))
4953                         reply_len = -1;
4954         } else if (os_strncmp(buf, "WPS_ER_SET_CONFIG ", 18) == 0) {
4955                 if (wpa_supplicant_ctrl_iface_wps_er_set_config(wpa_s,
4956                                                                 buf + 18))
4957                         reply_len = -1;
4958         } else if (os_strncmp(buf, "WPS_ER_CONFIG ", 14) == 0) {
4959                 if (wpa_supplicant_ctrl_iface_wps_er_config(wpa_s, buf + 14))
4960                         reply_len = -1;
4961 #ifdef CONFIG_WPS_NFC
4962         } else if (os_strncmp(buf, "WPS_ER_NFC_CONFIG_TOKEN ", 24) == 0) {
4963                 reply_len = wpa_supplicant_ctrl_iface_wps_er_nfc_config_token(
4964                         wpa_s, buf + 24, reply, reply_size);
4965 #endif /* CONFIG_WPS_NFC */
4966 #endif /* CONFIG_WPS_ER */
4967 #endif /* CONFIG_WPS */
4968 #ifdef CONFIG_IBSS_RSN
4969         } else if (os_strncmp(buf, "IBSS_RSN ", 9) == 0) {
4970                 if (wpa_supplicant_ctrl_iface_ibss_rsn(wpa_s, buf + 9))
4971                         reply_len = -1;
4972 #endif /* CONFIG_IBSS_RSN */
4973 #ifdef CONFIG_P2P
4974         } else if (os_strncmp(buf, "P2P_FIND ", 9) == 0) {
4975                 if (p2p_ctrl_find(wpa_s, buf + 9))
4976                         reply_len = -1;
4977         } else if (os_strcmp(buf, "P2P_FIND") == 0) {
4978                 if (p2p_ctrl_find(wpa_s, ""))
4979                         reply_len = -1;
4980         } else if (os_strcmp(buf, "P2P_STOP_FIND") == 0) {
4981                 wpas_p2p_stop_find(wpa_s);
4982         } else if (os_strncmp(buf, "P2P_CONNECT ", 12) == 0) {
4983                 reply_len = p2p_ctrl_connect(wpa_s, buf + 12, reply,
4984                                              reply_size);
4985         } else if (os_strncmp(buf, "P2P_LISTEN ", 11) == 0) {
4986                 if (p2p_ctrl_listen(wpa_s, buf + 11))
4987                         reply_len = -1;
4988         } else if (os_strcmp(buf, "P2P_LISTEN") == 0) {
4989                 if (p2p_ctrl_listen(wpa_s, ""))
4990                         reply_len = -1;
4991         } else if (os_strncmp(buf, "P2P_GROUP_REMOVE ", 17) == 0) {
4992                 if (wpas_p2p_group_remove(wpa_s, buf + 17))
4993                         reply_len = -1;
4994         } else if (os_strcmp(buf, "P2P_GROUP_ADD") == 0) {
4995                 if (wpas_p2p_group_add(wpa_s, 0, 0, 0))
4996                         reply_len = -1;
4997         } else if (os_strncmp(buf, "P2P_GROUP_ADD ", 14) == 0) {
4998                 if (p2p_ctrl_group_add(wpa_s, buf + 14))
4999                         reply_len = -1;
5000         } else if (os_strncmp(buf, "P2P_PROV_DISC ", 14) == 0) {
5001                 if (p2p_ctrl_prov_disc(wpa_s, buf + 14))
5002                         reply_len = -1;
5003         } else if (os_strcmp(buf, "P2P_GET_PASSPHRASE") == 0) {
5004                 reply_len = p2p_get_passphrase(wpa_s, reply, reply_size);
5005         } else if (os_strncmp(buf, "P2P_SERV_DISC_REQ ", 18) == 0) {
5006                 reply_len = p2p_ctrl_serv_disc_req(wpa_s, buf + 18, reply,
5007                                                    reply_size);
5008         } else if (os_strncmp(buf, "P2P_SERV_DISC_CANCEL_REQ ", 25) == 0) {
5009                 if (p2p_ctrl_serv_disc_cancel_req(wpa_s, buf + 25) < 0)
5010                         reply_len = -1;
5011         } else if (os_strncmp(buf, "P2P_SERV_DISC_RESP ", 19) == 0) {
5012                 if (p2p_ctrl_serv_disc_resp(wpa_s, buf + 19) < 0)
5013                         reply_len = -1;
5014         } else if (os_strcmp(buf, "P2P_SERVICE_UPDATE") == 0) {
5015                 wpas_p2p_sd_service_update(wpa_s);
5016         } else if (os_strncmp(buf, "P2P_SERV_DISC_EXTERNAL ", 23) == 0) {
5017                 if (p2p_ctrl_serv_disc_external(wpa_s, buf + 23) < 0)
5018                         reply_len = -1;
5019         } else if (os_strcmp(buf, "P2P_SERVICE_FLUSH") == 0) {
5020                 wpas_p2p_service_flush(wpa_s);
5021         } else if (os_strncmp(buf, "P2P_SERVICE_ADD ", 16) == 0) {
5022                 if (p2p_ctrl_service_add(wpa_s, buf + 16) < 0)
5023                         reply_len = -1;
5024         } else if (os_strncmp(buf, "P2P_SERVICE_DEL ", 16) == 0) {
5025                 if (p2p_ctrl_service_del(wpa_s, buf + 16) < 0)
5026                         reply_len = -1;
5027         } else if (os_strncmp(buf, "P2P_REJECT ", 11) == 0) {
5028                 if (p2p_ctrl_reject(wpa_s, buf + 11) < 0)
5029                         reply_len = -1;
5030         } else if (os_strncmp(buf, "P2P_INVITE ", 11) == 0) {
5031                 if (p2p_ctrl_invite(wpa_s, buf + 11) < 0)
5032                         reply_len = -1;
5033         } else if (os_strncmp(buf, "P2P_PEER ", 9) == 0) {
5034                 reply_len = p2p_ctrl_peer(wpa_s, buf + 9, reply,
5035                                               reply_size);
5036         } else if (os_strncmp(buf, "P2P_SET ", 8) == 0) {
5037                 if (p2p_ctrl_set(wpa_s, buf + 8) < 0)
5038                         reply_len = -1;
5039         } else if (os_strcmp(buf, "P2P_FLUSH") == 0) {
5040                 os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
5041                 wpa_s->force_long_sd = 0;
5042                 if (wpa_s->global->p2p)
5043                         p2p_flush(wpa_s->global->p2p);
5044         } else if (os_strncmp(buf, "P2P_UNAUTHORIZE ", 16) == 0) {
5045                 if (wpas_p2p_unauthorize(wpa_s, buf + 16) < 0)
5046                         reply_len = -1;
5047         } else if (os_strcmp(buf, "P2P_CANCEL") == 0) {
5048                 if (wpas_p2p_cancel(wpa_s))
5049                         reply_len = -1;
5050         } else if (os_strncmp(buf, "P2P_PRESENCE_REQ ", 17) == 0) {
5051                 if (p2p_ctrl_presence_req(wpa_s, buf + 17) < 0)
5052                         reply_len = -1;
5053         } else if (os_strcmp(buf, "P2P_PRESENCE_REQ") == 0) {
5054                 if (p2p_ctrl_presence_req(wpa_s, "") < 0)
5055                         reply_len = -1;
5056         } else if (os_strncmp(buf, "P2P_EXT_LISTEN ", 15) == 0) {
5057                 if (p2p_ctrl_ext_listen(wpa_s, buf + 15) < 0)
5058                         reply_len = -1;
5059         } else if (os_strcmp(buf, "P2P_EXT_LISTEN") == 0) {
5060                 if (p2p_ctrl_ext_listen(wpa_s, "") < 0)
5061                         reply_len = -1;
5062 #endif /* CONFIG_P2P */
5063 #ifdef CONFIG_WIFI_DISPLAY
5064         } else if (os_strncmp(buf, "WFD_SUBELEM_SET ", 16) == 0) {
5065                 if (wifi_display_subelem_set(wpa_s->global, buf + 16) < 0)
5066                         reply_len = -1;
5067         } else if (os_strncmp(buf, "WFD_SUBELEM_GET ", 16) == 0) {
5068                 reply_len = wifi_display_subelem_get(wpa_s->global, buf + 16,
5069                                                      reply, reply_size);
5070 #endif /* CONFIG_WIFI_DISPLAY */
5071 #ifdef CONFIG_INTERWORKING
5072         } else if (os_strcmp(buf, "FETCH_ANQP") == 0) {
5073                 if (interworking_fetch_anqp(wpa_s) < 0)
5074                         reply_len = -1;
5075         } else if (os_strcmp(buf, "STOP_FETCH_ANQP") == 0) {
5076                 interworking_stop_fetch_anqp(wpa_s);
5077         } else if (os_strncmp(buf, "INTERWORKING_SELECT", 19) == 0) {
5078                 if (interworking_select(wpa_s, os_strstr(buf + 19, "auto") !=
5079                                         NULL) < 0)
5080                         reply_len = -1;
5081         } else if (os_strncmp(buf, "INTERWORKING_CONNECT ", 21) == 0) {
5082                 if (ctrl_interworking_connect(wpa_s, buf + 21) < 0)
5083                         reply_len = -1;
5084         } else if (os_strncmp(buf, "ANQP_GET ", 9) == 0) {
5085                 if (get_anqp(wpa_s, buf + 9) < 0)
5086                         reply_len = -1;
5087         } else if (os_strncmp(buf, "GAS_REQUEST ", 12) == 0) {
5088                 if (gas_request(wpa_s, buf + 12) < 0)
5089                         reply_len = -1;
5090         } else if (os_strncmp(buf, "GAS_RESPONSE_GET ", 17) == 0) {
5091                 reply_len = gas_response_get(wpa_s, buf + 17, reply,
5092                                              reply_size);
5093 #endif /* CONFIG_INTERWORKING */
5094 #ifdef CONFIG_HS20
5095         } else if (os_strncmp(buf, "HS20_ANQP_GET ", 14) == 0) {
5096                 if (get_hs20_anqp(wpa_s, buf + 14) < 0)
5097                         reply_len = -1;
5098         } else if (os_strncmp(buf, "HS20_GET_NAI_HOME_REALM_LIST ", 29) == 0) {
5099                 if (hs20_get_nai_home_realm_list(wpa_s, buf + 29) < 0)
5100                         reply_len = -1;
5101 #endif /* CONFIG_HS20 */
5102         } else if (os_strncmp(buf, WPA_CTRL_RSP, os_strlen(WPA_CTRL_RSP)) == 0)
5103         {
5104                 if (wpa_supplicant_ctrl_iface_ctrl_rsp(
5105                             wpa_s, buf + os_strlen(WPA_CTRL_RSP)))
5106                         reply_len = -1;
5107                 else
5108                         ctrl_rsp = 1;
5109         } else if (os_strcmp(buf, "RECONFIGURE") == 0) {
5110                 if (wpa_supplicant_reload_configuration(wpa_s))
5111                         reply_len = -1;
5112         } else if (os_strcmp(buf, "TERMINATE") == 0) {
5113                 wpa_supplicant_terminate_proc(wpa_s->global);
5114         } else if (os_strncmp(buf, "BSSID ", 6) == 0) {
5115                 if (wpa_supplicant_ctrl_iface_bssid(wpa_s, buf + 6))
5116                         reply_len = -1;
5117         } else if (os_strncmp(buf, "BLACKLIST", 9) == 0) {
5118                 reply_len = wpa_supplicant_ctrl_iface_blacklist(
5119                         wpa_s, buf + 9, reply, reply_size);
5120         } else if (os_strncmp(buf, "LOG_LEVEL", 9) == 0) {
5121                 reply_len = wpa_supplicant_ctrl_iface_log_level(
5122                         wpa_s, buf + 9, reply, reply_size);
5123         } else if (os_strcmp(buf, "LIST_NETWORKS") == 0) {
5124                 reply_len = wpa_supplicant_ctrl_iface_list_networks(
5125                         wpa_s, reply, reply_size);
5126         } else if (os_strcmp(buf, "DISCONNECT") == 0) {
5127 #ifdef CONFIG_SME
5128                 wpa_s->sme.prev_bssid_set = 0;
5129 #endif /* CONFIG_SME */
5130                 wpa_s->reassociate = 0;
5131                 wpa_s->disconnected = 1;
5132                 wpa_supplicant_cancel_sched_scan(wpa_s);
5133                 wpa_supplicant_cancel_scan(wpa_s);
5134                 wpa_supplicant_deauthenticate(wpa_s,
5135                                               WLAN_REASON_DEAUTH_LEAVING);
5136         } else if (os_strcmp(buf, "SCAN") == 0) {
5137                 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
5138                         reply_len = -1;
5139                 else {
5140                         if (!wpa_s->scanning &&
5141                             ((wpa_s->wpa_state <= WPA_SCANNING) ||
5142                              (wpa_s->wpa_state == WPA_COMPLETED))) {
5143                                 wpa_s->normal_scans = 0;
5144                                 wpa_s->scan_req = MANUAL_SCAN_REQ;
5145                                 wpa_supplicant_req_scan(wpa_s, 0, 0);
5146                         } else if (wpa_s->sched_scanning) {
5147                                 wpa_printf(MSG_DEBUG, "Stop ongoing "
5148                                            "sched_scan to allow requested "
5149                                            "full scan to proceed");
5150                                 wpa_supplicant_cancel_sched_scan(wpa_s);
5151                                 wpa_s->scan_req = MANUAL_SCAN_REQ;
5152                                 wpa_supplicant_req_scan(wpa_s, 0, 0);
5153                         } else {
5154                                 wpa_printf(MSG_DEBUG, "Ongoing scan action - "
5155                                            "reject new request");
5156                                 reply_len = os_snprintf(reply, reply_size,
5157                                                         "FAIL-BUSY\n");
5158                         }
5159                 }
5160         } else if (os_strcmp(buf, "SCAN_RESULTS") == 0) {
5161                 reply_len = wpa_supplicant_ctrl_iface_scan_results(
5162                         wpa_s, reply, reply_size);
5163         } else if (os_strncmp(buf, "SELECT_NETWORK ", 15) == 0) {
5164                 if (wpa_supplicant_ctrl_iface_select_network(wpa_s, buf + 15))
5165                         reply_len = -1;
5166         } else if (os_strncmp(buf, "ENABLE_NETWORK ", 15) == 0) {
5167                 if (wpa_supplicant_ctrl_iface_enable_network(wpa_s, buf + 15))
5168                         reply_len = -1;
5169         } else if (os_strncmp(buf, "DISABLE_NETWORK ", 16) == 0) {
5170                 if (wpa_supplicant_ctrl_iface_disable_network(wpa_s, buf + 16))
5171                         reply_len = -1;
5172         } else if (os_strcmp(buf, "ADD_NETWORK") == 0) {
5173                 reply_len = wpa_supplicant_ctrl_iface_add_network(
5174                         wpa_s, reply, reply_size);
5175         } else if (os_strncmp(buf, "REMOVE_NETWORK ", 15) == 0) {
5176                 if (wpa_supplicant_ctrl_iface_remove_network(wpa_s, buf + 15))
5177                         reply_len = -1;
5178         } else if (os_strncmp(buf, "SET_NETWORK ", 12) == 0) {
5179                 if (wpa_supplicant_ctrl_iface_set_network(wpa_s, buf + 12))
5180                         reply_len = -1;
5181         } else if (os_strncmp(buf, "GET_NETWORK ", 12) == 0) {
5182                 reply_len = wpa_supplicant_ctrl_iface_get_network(
5183                         wpa_s, buf + 12, reply, reply_size);
5184         } else if (os_strcmp(buf, "LIST_CREDS") == 0) {
5185                 reply_len = wpa_supplicant_ctrl_iface_list_creds(
5186                         wpa_s, reply, reply_size);
5187         } else if (os_strcmp(buf, "ADD_CRED") == 0) {
5188                 reply_len = wpa_supplicant_ctrl_iface_add_cred(
5189                         wpa_s, reply, reply_size);
5190         } else if (os_strncmp(buf, "REMOVE_CRED ", 12) == 0) {
5191                 if (wpa_supplicant_ctrl_iface_remove_cred(wpa_s, buf + 12))
5192                         reply_len = -1;
5193         } else if (os_strncmp(buf, "SET_CRED ", 9) == 0) {
5194                 if (wpa_supplicant_ctrl_iface_set_cred(wpa_s, buf + 9))
5195                         reply_len = -1;
5196 #ifndef CONFIG_NO_CONFIG_WRITE
5197         } else if (os_strcmp(buf, "SAVE_CONFIG") == 0) {
5198                 if (wpa_supplicant_ctrl_iface_save_config(wpa_s))
5199                         reply_len = -1;
5200 #endif /* CONFIG_NO_CONFIG_WRITE */
5201         } else if (os_strncmp(buf, "GET_CAPABILITY ", 15) == 0) {
5202                 reply_len = wpa_supplicant_ctrl_iface_get_capability(
5203                         wpa_s, buf + 15, reply, reply_size);
5204         } else if (os_strncmp(buf, "AP_SCAN ", 8) == 0) {
5205                 if (wpa_supplicant_ctrl_iface_ap_scan(wpa_s, buf + 8))
5206                         reply_len = -1;
5207         } else if (os_strncmp(buf, "SCAN_INTERVAL ", 14) == 0) {
5208                 if (wpa_supplicant_ctrl_iface_scan_interval(wpa_s, buf + 14))
5209                         reply_len = -1;
5210         } else if (os_strcmp(buf, "INTERFACE_LIST") == 0) {
5211                 reply_len = wpa_supplicant_global_iface_list(
5212                         wpa_s->global, reply, reply_size);
5213         } else if (os_strcmp(buf, "INTERFACES") == 0) {
5214                 reply_len = wpa_supplicant_global_iface_interfaces(
5215                         wpa_s->global, reply, reply_size);
5216         } else if (os_strncmp(buf, "BSS ", 4) == 0) {
5217                 reply_len = wpa_supplicant_ctrl_iface_bss(
5218                         wpa_s, buf + 4, reply, reply_size);
5219 #ifdef CONFIG_AP
5220         } else if (os_strcmp(buf, "STA-FIRST") == 0) {
5221                 reply_len = ap_ctrl_iface_sta_first(wpa_s, reply, reply_size);
5222         } else if (os_strncmp(buf, "STA ", 4) == 0) {
5223                 reply_len = ap_ctrl_iface_sta(wpa_s, buf + 4, reply,
5224                                               reply_size);
5225         } else if (os_strncmp(buf, "STA-NEXT ", 9) == 0) {
5226                 reply_len = ap_ctrl_iface_sta_next(wpa_s, buf + 9, reply,
5227                                                    reply_size);
5228         } else if (os_strncmp(buf, "DEAUTHENTICATE ", 15) == 0) {
5229                 if (ap_ctrl_iface_sta_deauthenticate(wpa_s, buf + 15))
5230                         reply_len = -1;
5231         } else if (os_strncmp(buf, "DISASSOCIATE ", 13) == 0) {
5232                 if (ap_ctrl_iface_sta_disassociate(wpa_s, buf + 13))
5233                         reply_len = -1;
5234 #endif /* CONFIG_AP */
5235         } else if (os_strcmp(buf, "SUSPEND") == 0) {
5236                 wpas_notify_suspend(wpa_s->global);
5237         } else if (os_strcmp(buf, "RESUME") == 0) {
5238                 wpas_notify_resume(wpa_s->global);
5239         } else if (os_strcmp(buf, "DROP_SA") == 0) {
5240                 wpa_supplicant_ctrl_iface_drop_sa(wpa_s);
5241         } else if (os_strncmp(buf, "ROAM ", 5) == 0) {
5242                 if (wpa_supplicant_ctrl_iface_roam(wpa_s, buf + 5))
5243                         reply_len = -1;
5244         } else if (os_strncmp(buf, "STA_AUTOCONNECT ", 16) == 0) {
5245                 if (wpa_supplicant_ctrl_iface_sta_autoconnect(wpa_s, buf + 16))
5246                         reply_len = -1;
5247         } else if (os_strncmp(buf, "BSS_EXPIRE_AGE ", 15) == 0) {
5248                 if (wpa_supplicant_ctrl_iface_bss_expire_age(wpa_s, buf + 15))
5249                         reply_len = -1;
5250         } else if (os_strncmp(buf, "BSS_EXPIRE_COUNT ", 17) == 0) {
5251                 if (wpa_supplicant_ctrl_iface_bss_expire_count(wpa_s,
5252                                                                buf + 17))
5253                         reply_len = -1;
5254         } else if (os_strncmp(buf, "BSS_FLUSH ", 10) == 0) {
5255                 if (wpa_supplicant_ctrl_iface_bss_flush(wpa_s, buf + 10))
5256                         reply_len = -1;
5257 #ifdef CONFIG_TDLS
5258         } else if (os_strncmp(buf, "TDLS_DISCOVER ", 14) == 0) {
5259                 if (wpa_supplicant_ctrl_iface_tdls_discover(wpa_s, buf + 14))
5260                         reply_len = -1;
5261         } else if (os_strncmp(buf, "TDLS_SETUP ", 11) == 0) {
5262                 if (wpa_supplicant_ctrl_iface_tdls_setup(wpa_s, buf + 11))
5263                         reply_len = -1;
5264         } else if (os_strncmp(buf, "TDLS_TEARDOWN ", 14) == 0) {
5265                 if (wpa_supplicant_ctrl_iface_tdls_teardown(wpa_s, buf + 14))
5266                         reply_len = -1;
5267 #endif /* CONFIG_TDLS */
5268         } else if (os_strncmp(buf, "SIGNAL_POLL", 11) == 0) {
5269                 reply_len = wpa_supplicant_signal_poll(wpa_s, reply,
5270                                                        reply_size);
5271         } else if (os_strncmp(buf, "PKTCNT_POLL", 11) == 0) {
5272                 reply_len = wpa_supplicant_pktcnt_poll(wpa_s, reply,
5273                                                        reply_size);
5274 #ifdef CONFIG_AUTOSCAN
5275         } else if (os_strncmp(buf, "AUTOSCAN ", 9) == 0) {
5276                 if (wpa_supplicant_ctrl_iface_autoscan(wpa_s, buf + 9))
5277                         reply_len = -1;
5278 #endif /* CONFIG_AUTOSCAN */
5279         } else if (os_strcmp(buf, "REAUTHENTICATE") == 0) {
5280                 pmksa_cache_clear_current(wpa_s->wpa);
5281                 eapol_sm_request_reauth(wpa_s->eapol);
5282 #ifdef CONFIG_WNM
5283         } else if (os_strncmp(buf, "WNM_SLEEP ", 10) == 0) {
5284                 if (wpas_ctrl_iface_wnm_sleep(wpa_s, buf + 10))
5285                         reply_len = -1;
5286 #endif /* CONFIG_WNM */
5287         } else {
5288                 os_memcpy(reply, "UNKNOWN COMMAND\n", 16);
5289                 reply_len = 16;
5290         }
5291
5292         if (reply_len < 0) {
5293                 os_memcpy(reply, "FAIL\n", 5);
5294                 reply_len = 5;
5295         }
5296
5297         if (ctrl_rsp)
5298                 eapol_sm_notify_ctrl_response(wpa_s->eapol);
5299
5300         *resp_len = reply_len;
5301         return reply;
5302 }
5303
5304
5305 static int wpa_supplicant_global_iface_add(struct wpa_global *global,
5306                                            char *cmd)
5307 {
5308         struct wpa_interface iface;
5309         char *pos;
5310
5311         /*
5312          * <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB<driver_param>
5313          * TAB<bridge_ifname>
5314          */
5315         wpa_printf(MSG_DEBUG, "CTRL_IFACE GLOBAL INTERFACE_ADD '%s'", cmd);
5316
5317         os_memset(&iface, 0, sizeof(iface));
5318
5319         do {
5320                 iface.ifname = pos = cmd;
5321                 pos = os_strchr(pos, '\t');
5322                 if (pos)
5323                         *pos++ = '\0';
5324                 if (iface.ifname[0] == '\0')
5325                         return -1;
5326                 if (pos == NULL)
5327                         break;
5328
5329                 iface.confname = pos;
5330                 pos = os_strchr(pos, '\t');
5331                 if (pos)
5332                         *pos++ = '\0';
5333                 if (iface.confname[0] == '\0')
5334                         iface.confname = NULL;
5335                 if (pos == NULL)
5336                         break;
5337
5338                 iface.driver = pos;
5339                 pos = os_strchr(pos, '\t');
5340                 if (pos)
5341                         *pos++ = '\0';
5342                 if (iface.driver[0] == '\0')
5343                         iface.driver = NULL;
5344                 if (pos == NULL)
5345                         break;
5346
5347                 iface.ctrl_interface = pos;
5348                 pos = os_strchr(pos, '\t');
5349                 if (pos)
5350                         *pos++ = '\0';
5351                 if (iface.ctrl_interface[0] == '\0')
5352                         iface.ctrl_interface = NULL;
5353                 if (pos == NULL)
5354                         break;
5355
5356                 iface.driver_param = pos;
5357                 pos = os_strchr(pos, '\t');
5358                 if (pos)
5359                         *pos++ = '\0';
5360                 if (iface.driver_param[0] == '\0')
5361                         iface.driver_param = NULL;
5362                 if (pos == NULL)
5363                         break;
5364
5365                 iface.bridge_ifname = pos;
5366                 pos = os_strchr(pos, '\t');
5367                 if (pos)
5368                         *pos++ = '\0';
5369                 if (iface.bridge_ifname[0] == '\0')
5370                         iface.bridge_ifname = NULL;
5371                 if (pos == NULL)
5372                         break;
5373         } while (0);
5374
5375         if (wpa_supplicant_get_iface(global, iface.ifname))
5376                 return -1;
5377
5378         return wpa_supplicant_add_iface(global, &iface) ? 0 : -1;
5379 }
5380
5381
5382 static int wpa_supplicant_global_iface_remove(struct wpa_global *global,
5383                                               char *cmd)
5384 {
5385         struct wpa_supplicant *wpa_s;
5386
5387         wpa_printf(MSG_DEBUG, "CTRL_IFACE GLOBAL INTERFACE_REMOVE '%s'", cmd);
5388
5389         wpa_s = wpa_supplicant_get_iface(global, cmd);
5390         if (wpa_s == NULL)
5391                 return -1;
5392         return wpa_supplicant_remove_iface(global, wpa_s, 0);
5393 }
5394
5395
5396 static void wpa_free_iface_info(struct wpa_interface_info *iface)
5397 {
5398         struct wpa_interface_info *prev;
5399
5400         while (iface) {
5401                 prev = iface;
5402                 iface = iface->next;
5403
5404                 os_free(prev->ifname);
5405                 os_free(prev->desc);
5406                 os_free(prev);
5407         }
5408 }
5409
5410
5411 static int wpa_supplicant_global_iface_list(struct wpa_global *global,
5412                                             char *buf, int len)
5413 {
5414         int i, res;
5415         struct wpa_interface_info *iface = NULL, *last = NULL, *tmp;
5416         char *pos, *end;
5417
5418         for (i = 0; wpa_drivers[i]; i++) {
5419                 struct wpa_driver_ops *drv = wpa_drivers[i];
5420                 if (drv->get_interfaces == NULL)
5421                         continue;
5422                 tmp = drv->get_interfaces(global->drv_priv[i]);
5423                 if (tmp == NULL)
5424                         continue;
5425
5426                 if (last == NULL)
5427                         iface = last = tmp;
5428                 else
5429                         last->next = tmp;
5430                 while (last->next)
5431                         last = last->next;
5432         }
5433
5434         pos = buf;
5435         end = buf + len;
5436         for (tmp = iface; tmp; tmp = tmp->next) {
5437                 res = os_snprintf(pos, end - pos, "%s\t%s\t%s\n",
5438                                   tmp->drv_name, tmp->ifname,
5439                                   tmp->desc ? tmp->desc : "");
5440                 if (res < 0 || res >= end - pos) {
5441                         *pos = '\0';
5442                         break;
5443                 }
5444                 pos += res;
5445         }
5446
5447         wpa_free_iface_info(iface);
5448
5449         return pos - buf;
5450 }
5451
5452
5453 static int wpa_supplicant_global_iface_interfaces(struct wpa_global *global,
5454                                                   char *buf, int len)
5455 {
5456         int res;
5457         char *pos, *end;
5458         struct wpa_supplicant *wpa_s;
5459
5460         wpa_s = global->ifaces;
5461         pos = buf;
5462         end = buf + len;
5463
5464         while (wpa_s) {
5465                 res = os_snprintf(pos, end - pos, "%s\n", wpa_s->ifname);
5466                 if (res < 0 || res >= end - pos) {
5467                         *pos = '\0';
5468                         break;
5469                 }
5470                 pos += res;
5471                 wpa_s = wpa_s->next;
5472         }
5473         return pos - buf;
5474 }
5475
5476
5477 char * wpa_supplicant_global_ctrl_iface_process(struct wpa_global *global,
5478                                                 char *buf, size_t *resp_len)
5479 {
5480         char *reply;
5481         const int reply_size = 2048;
5482         int reply_len;
5483         int level = MSG_DEBUG;
5484
5485         if (os_strcmp(buf, "PING") == 0)
5486                 level = MSG_EXCESSIVE;
5487         wpa_hexdump_ascii(level, "RX global ctrl_iface",
5488                           (const u8 *) buf, os_strlen(buf));
5489
5490         reply = os_malloc(reply_size);
5491         if (reply == NULL) {
5492                 *resp_len = 1;
5493                 return NULL;
5494         }
5495
5496         os_memcpy(reply, "OK\n", 3);
5497         reply_len = 3;
5498
5499         if (os_strcmp(buf, "PING") == 0) {
5500                 os_memcpy(reply, "PONG\n", 5);
5501                 reply_len = 5;
5502         } else if (os_strncmp(buf, "INTERFACE_ADD ", 14) == 0) {
5503                 if (wpa_supplicant_global_iface_add(global, buf + 14))
5504                         reply_len = -1;
5505         } else if (os_strncmp(buf, "INTERFACE_REMOVE ", 17) == 0) {
5506                 if (wpa_supplicant_global_iface_remove(global, buf + 17))
5507                         reply_len = -1;
5508         } else if (os_strcmp(buf, "INTERFACE_LIST") == 0) {
5509                 reply_len = wpa_supplicant_global_iface_list(
5510                         global, reply, reply_size);
5511         } else if (os_strcmp(buf, "INTERFACES") == 0) {
5512                 reply_len = wpa_supplicant_global_iface_interfaces(
5513                         global, reply, reply_size);
5514         } else if (os_strcmp(buf, "TERMINATE") == 0) {
5515                 wpa_supplicant_terminate_proc(global);
5516         } else if (os_strcmp(buf, "SUSPEND") == 0) {
5517                 wpas_notify_suspend(global);
5518         } else if (os_strcmp(buf, "RESUME") == 0) {
5519                 wpas_notify_resume(global);
5520         } else {
5521                 os_memcpy(reply, "UNKNOWN COMMAND\n", 16);
5522                 reply_len = 16;
5523         }
5524
5525         if (reply_len < 0) {
5526                 os_memcpy(reply, "FAIL\n", 5);
5527                 reply_len = 5;
5528         }
5529
5530         *resp_len = reply_len;
5531         return reply;
5532 }