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 "wpas_glue.h"
  41 #include "autoscan.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                 default:
2769                         continue;
2770                 }
2771                 ret = os_snprintf(pos, end - pos, "Mode[%s] Channels:", hmode);
2772                 if (ret < 0 || ret >= end - pos)
2773                         return pos - buf;
2774                 pos += ret;
2775                 chnl = wpa_s->hw.modes[j].channels;
2776                 for (i = 0; i < wpa_s->hw.modes[j].num_channels; i++) {
2777                         if (chnl[i].flag & HOSTAPD_CHAN_DISABLED)
2778                                 continue;
2779                         ret = os_snprintf(pos, end - pos, " %d", chnl[i].chan);
2780                         if (ret < 0 || ret >= end - pos)
2781                                 return pos - buf;
2782                         pos += ret;
2783                 }
2784                 ret = os_snprintf(pos, end - pos, "\n");
2785                 if (ret < 0 || ret >= end - pos)
2786                         return pos - buf;
2787                 pos += ret;
2788         }
2789
2790         return pos - buf;
2791 }
2792
2793
2794 static int wpa_supplicant_ctrl_iface_get_capability(
2795         struct wpa_supplicant *wpa_s, const char *_field, char *buf,
2796         size_t buflen)
2797 {
2798         struct wpa_driver_capa capa;
2799         int res;
2800         char *strict;
2801         char field[30];
2802         size_t len;
2803
2804         /* Determine whether or not strict checking was requested */
2805         len = os_strlcpy(field, _field, sizeof(field));
2806         if (len >= sizeof(field))
2807                 return -1;
2808         strict = os_strchr(field, ' ');
2809         if (strict != NULL) {
2810                 *strict++ = '\0';
2811                 if (os_strcmp(strict, "strict") != 0)
2812                         return -1;
2813         }
2814
2815         wpa_printf(MSG_DEBUG, "CTRL_IFACE: GET_CAPABILITY '%s' %s",
2816                 field, strict ? strict : "");
2817
2818         if (os_strcmp(field, "eap") == 0) {
2819                 return eap_get_names(buf, buflen);
2820         }
2821
2822         res = wpa_drv_get_capa(wpa_s, &capa);
2823
2824         if (os_strcmp(field, "pairwise") == 0)
2825                 return ctrl_iface_get_capability_pairwise(res, strict, &capa,
2826                                                           buf, buflen);
2827
2828         if (os_strcmp(field, "group") == 0)
2829                 return ctrl_iface_get_capability_group(res, strict, &capa,
2830                                                        buf, buflen);
2831
2832         if (os_strcmp(field, "key_mgmt") == 0)
2833                 return ctrl_iface_get_capability_key_mgmt(res, strict, &capa,
2834                                                           buf, buflen);
2835
2836         if (os_strcmp(field, "proto") == 0)
2837                 return ctrl_iface_get_capability_proto(res, strict, &capa,
2838                                                        buf, buflen);
2839
2840         if (os_strcmp(field, "auth_alg") == 0)
2841                 return ctrl_iface_get_capability_auth_alg(res, strict, &capa,
2842                                                           buf, buflen);
2843
2844         if (os_strcmp(field, "channels") == 0)
2845                 return ctrl_iface_get_capability_channels(wpa_s, buf, buflen);
2846
2847         wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown GET_CAPABILITY field '%s'",
2848                    field);
2849
2850         return -1;
2851 }
2852
2853
2854 #ifdef CONFIG_INTERWORKING
2855 static char * anqp_add_hex(char *pos, char *end, const char *title,
2856                            struct wpabuf *data)
2857 {
2858         char *start = pos;
2859         size_t i;
2860         int ret;
2861         const u8 *d;
2862
2863         if (data == NULL)
2864                 return start;
2865
2866         ret = os_snprintf(pos, end - pos, "%s=", title);
2867         if (ret < 0 || ret >= end - pos)
2868                 return start;
2869         pos += ret;
2870
2871         d = wpabuf_head_u8(data);
2872         for (i = 0; i < wpabuf_len(data); i++) {
2873                 ret = os_snprintf(pos, end - pos, "%02x", *d++);
2874                 if (ret < 0 || ret >= end - pos)
2875                         return start;
2876                 pos += ret;
2877         }
2878
2879         ret = os_snprintf(pos, end - pos, "\n");
2880         if (ret < 0 || ret >= end - pos)
2881                 return start;
2882         pos += ret;
2883
2884         return pos;
2885 }
2886 #endif /* CONFIG_INTERWORKING */
2887
2888
2889 static int print_bss_info(struct wpa_supplicant *wpa_s, struct wpa_bss *bss,
2890                           unsigned long mask, char *buf, size_t buflen)
2891 {
2892         size_t i;
2893         int ret;
2894         char *pos, *end;
2895         const u8 *ie, *ie2;
2896
2897         pos = buf;
2898         end = buf + buflen;
2899
2900         if (mask & WPA_BSS_MASK_ID) {
2901                 ret = os_snprintf(pos, end - pos, "id=%u\n", bss->id);
2902                 if (ret < 0 || ret >= end - pos)
2903                         return 0;
2904                 pos += ret;
2905         }
2906
2907         if (mask & WPA_BSS_MASK_BSSID) {
2908                 ret = os_snprintf(pos, end - pos, "bssid=" MACSTR "\n",
2909                                   MAC2STR(bss->bssid));
2910                 if (ret < 0 || ret >= end - pos)
2911                         return 0;
2912                 pos += ret;
2913         }
2914
2915         if (mask & WPA_BSS_MASK_FREQ) {
2916                 ret = os_snprintf(pos, end - pos, "freq=%d\n", bss->freq);
2917                 if (ret < 0 || ret >= end - pos)
2918                         return 0;
2919                 pos += ret;
2920         }
2921
2922         if (mask & WPA_BSS_MASK_BEACON_INT) {
2923                 ret = os_snprintf(pos, end - pos, "beacon_int=%d\n",
2924                                   bss->beacon_int);
2925                 if (ret < 0 || ret >= end - pos)
2926                         return 0;
2927                 pos += ret;
2928         }
2929
2930         if (mask & WPA_BSS_MASK_CAPABILITIES) {
2931                 ret = os_snprintf(pos, end - pos, "capabilities=0x%04x\n",
2932                                   bss->caps);
2933                 if (ret < 0 || ret >= end - pos)
2934                         return 0;
2935                 pos += ret;
2936         }
2937
2938         if (mask & WPA_BSS_MASK_QUAL) {
2939                 ret = os_snprintf(pos, end - pos, "qual=%d\n", bss->qual);
2940                 if (ret < 0 || ret >= end - pos)
2941                         return 0;
2942                 pos += ret;
2943         }
2944
2945         if (mask & WPA_BSS_MASK_NOISE) {
2946                 ret = os_snprintf(pos, end - pos, "noise=%d\n", bss->noise);
2947                 if (ret < 0 || ret >= end - pos)
2948                         return 0;
2949                 pos += ret;
2950         }
2951
2952         if (mask & WPA_BSS_MASK_LEVEL) {
2953                 ret = os_snprintf(pos, end - pos, "level=%d\n", bss->level);
2954                 if (ret < 0 || ret >= end - pos)
2955                         return 0;
2956                 pos += ret;
2957         }
2958
2959         if (mask & WPA_BSS_MASK_TSF) {
2960                 ret = os_snprintf(pos, end - pos, "tsf=%016llu\n",
2961                                   (unsigned long long) bss->tsf);
2962                 if (ret < 0 || ret >= end - pos)
2963                         return 0;
2964                 pos += ret;
2965         }
2966
2967         if (mask & WPA_BSS_MASK_AGE) {
2968                 struct os_time now;
2969
2970                 os_get_time(&now);
2971                 ret = os_snprintf(pos, end - pos, "age=%d\n",
2972                                   (int) (now.sec - bss->last_update.sec));
2973                 if (ret < 0 || ret >= end - pos)
2974                         return 0;
2975                 pos += ret;
2976         }
2977
2978         if (mask & WPA_BSS_MASK_IE) {
2979                 ret = os_snprintf(pos, end - pos, "ie=");
2980                 if (ret < 0 || ret >= end - pos)
2981                         return 0;
2982                 pos += ret;
2983
2984                 ie = (const u8 *) (bss + 1);
2985                 for (i = 0; i < bss->ie_len; i++) {
2986                         ret = os_snprintf(pos, end - pos, "%02x", *ie++);
2987                         if (ret < 0 || ret >= end - pos)
2988                                 return 0;
2989                         pos += ret;
2990                 }
2991
2992                 ret = os_snprintf(pos, end - pos, "\n");
2993                 if (ret < 0 || ret >= end - pos)
2994                         return 0;
2995                 pos += ret;
2996         }
2997
2998         if (mask & WPA_BSS_MASK_FLAGS) {
2999                 ret = os_snprintf(pos, end - pos, "flags=");
3000                 if (ret < 0 || ret >= end - pos)
3001                         return 0;
3002                 pos += ret;
3003
3004                 ie = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
3005                 if (ie)
3006                         pos = wpa_supplicant_ie_txt(pos, end, "WPA", ie,
3007                                                     2 + ie[1]);
3008                 ie2 = wpa_bss_get_ie(bss, WLAN_EID_RSN);
3009                 if (ie2)
3010                         pos = wpa_supplicant_ie_txt(pos, end, "WPA2", ie2,
3011                                                     2 + ie2[1]);
3012                 pos = wpa_supplicant_wps_ie_txt(wpa_s, pos, end, bss);
3013                 if (!ie && !ie2 && bss->caps & IEEE80211_CAP_PRIVACY) {
3014                         ret = os_snprintf(pos, end - pos, "[WEP]");
3015                         if (ret < 0 || ret >= end - pos)
3016                                 return 0;
3017                         pos += ret;
3018                 }
3019                 if (bss->caps & IEEE80211_CAP_IBSS) {
3020                         ret = os_snprintf(pos, end - pos, "[IBSS]");
3021                         if (ret < 0 || ret >= end - pos)
3022                                 return 0;
3023                         pos += ret;
3024                 }
3025                 if (bss->caps & IEEE80211_CAP_ESS) {
3026                         ret = os_snprintf(pos, end - pos, "[ESS]");
3027                         if (ret < 0 || ret >= end - pos)
3028                                 return 0;
3029                         pos += ret;
3030                 }
3031                 if (wpa_bss_get_vendor_ie(bss, P2P_IE_VENDOR_TYPE)) {
3032                         ret = os_snprintf(pos, end - pos, "[P2P]");
3033                         if (ret < 0 || ret >= end - pos)
3034                                 return 0;
3035                         pos += ret;
3036                 }
3037 #ifdef CONFIG_HS20
3038                 if (wpa_bss_get_vendor_ie(bss, HS20_IE_VENDOR_TYPE)) {
3039                         ret = os_snprintf(pos, end - pos, "[HS20]");
3040                         if (ret < 0 || ret >= end - pos)
3041                                 return -1;
3042                         pos += ret;
3043                 }
3044 #endif /* CONFIG_HS20 */
3045
3046                 ret = os_snprintf(pos, end - pos, "\n");
3047                 if (ret < 0 || ret >= end - pos)
3048                         return 0;
3049                 pos += ret;
3050         }
3051
3052         if (mask & WPA_BSS_MASK_SSID) {
3053                 ret = os_snprintf(pos, end - pos, "ssid=%s\n",
3054                                   wpa_ssid_txt(bss->ssid, bss->ssid_len));
3055                 if (ret < 0 || ret >= end - pos)
3056                         return 0;
3057                 pos += ret;
3058         }
3059
3060 #ifdef CONFIG_WPS
3061         if (mask & WPA_BSS_MASK_WPS_SCAN) {
3062                 ie = (const u8 *) (bss + 1);
3063                 ret = wpas_wps_scan_result_text(ie, bss->ie_len, pos, end);
3064                 if (ret < 0 || ret >= end - pos)
3065                         return 0;
3066                 pos += ret;
3067         }
3068 #endif /* CONFIG_WPS */
3069
3070 #ifdef CONFIG_P2P
3071         if (mask & WPA_BSS_MASK_P2P_SCAN) {
3072                 ie = (const u8 *) (bss + 1);
3073                 ret = wpas_p2p_scan_result_text(ie, bss->ie_len, pos, end);
3074                 if (ret < 0 || ret >= end - pos)
3075                         return 0;
3076                 pos += ret;
3077         }
3078 #endif /* CONFIG_P2P */
3079
3080 #ifdef CONFIG_WIFI_DISPLAY
3081         if (mask & WPA_BSS_MASK_WIFI_DISPLAY) {
3082                 struct wpabuf *wfd;
3083                 ie = (const u8 *) (bss + 1);
3084                 wfd = ieee802_11_vendor_ie_concat(ie, bss->ie_len,
3085                                                   WFD_IE_VENDOR_TYPE);
3086                 if (wfd) {
3087                         ret = os_snprintf(pos, end - pos, "wfd_subelems=");
3088                         if (ret < 0 || ret >= end - pos)
3089                                 return pos - buf;
3090                         pos += ret;
3091
3092                         pos += wpa_snprintf_hex(pos, end - pos,
3093                                                 wpabuf_head(wfd),
3094                                                 wpabuf_len(wfd));
3095                         wpabuf_free(wfd);
3096
3097                         ret = os_snprintf(pos, end - pos, "\n");
3098                         if (ret < 0 || ret >= end - pos)
3099                                 return pos - buf;
3100                         pos += ret;
3101                 }
3102         }
3103 #endif /* CONFIG_WIFI_DISPLAY */
3104
3105 #ifdef CONFIG_INTERWORKING
3106         if ((mask & WPA_BSS_MASK_INTERNETW) && bss->anqp) {
3107                 struct wpa_bss_anqp *anqp = bss->anqp;
3108                 pos = anqp_add_hex(pos, end, "anqp_venue_name",
3109                                    anqp->venue_name);
3110                 pos = anqp_add_hex(pos, end, "anqp_network_auth_type",
3111                                    anqp->network_auth_type);
3112                 pos = anqp_add_hex(pos, end, "anqp_roaming_consortium",
3113                                    anqp->roaming_consortium);
3114                 pos = anqp_add_hex(pos, end, "anqp_ip_addr_type_availability",
3115                                    anqp->ip_addr_type_availability);
3116                 pos = anqp_add_hex(pos, end, "anqp_nai_realm",
3117                                    anqp->nai_realm);
3118                 pos = anqp_add_hex(pos, end, "anqp_3gpp", anqp->anqp_3gpp);
3119                 pos = anqp_add_hex(pos, end, "anqp_domain_name",
3120                                    anqp->domain_name);
3121 #ifdef CONFIG_HS20
3122                 pos = anqp_add_hex(pos, end, "hs20_operator_friendly_name",
3123                                    anqp->hs20_operator_friendly_name);
3124                 pos = anqp_add_hex(pos, end, "hs20_wan_metrics",
3125                                    anqp->hs20_wan_metrics);
3126                 pos = anqp_add_hex(pos, end, "hs20_connection_capability",
3127                                    anqp->hs20_connection_capability);
3128 #endif /* CONFIG_HS20 */
3129         }
3130 #endif /* CONFIG_INTERWORKING */
3131
3132         return pos - buf;
3133 }
3134
3135
3136 static int wpa_supplicant_ctrl_iface_bss(struct wpa_supplicant *wpa_s,
3137                                          const char *cmd, char *buf,
3138                                          size_t buflen)
3139 {
3140         u8 bssid[ETH_ALEN];
3141         size_t i;
3142         struct wpa_bss *bss;
3143         struct wpa_bss *bsslast = NULL;
3144         struct dl_list *next;
3145         int ret = 0;
3146         int len;
3147         char *ctmp;
3148         unsigned long mask = WPA_BSS_MASK_ALL;
3149
3150         if (os_strncmp(cmd, "RANGE=", 6) == 0) {
3151                 if (os_strncmp(cmd + 6, "ALL", 3) == 0) {
3152                         bss = dl_list_first(&wpa_s->bss_id, struct wpa_bss,
3153                                             list_id);
3154                         bsslast = dl_list_last(&wpa_s->bss_id, struct wpa_bss,
3155                                                list_id);
3156                 } else { /* N1-N2 */
3157                         unsigned int id1, id2;
3158
3159                         if ((ctmp = os_strchr(cmd + 6, '-')) == NULL) {
3160                                 wpa_printf(MSG_INFO, "Wrong BSS range "
3161                                            "format");
3162                                 return 0;
3163                         }
3164
3165                         id1 = atoi(cmd + 6);
3166                         bss = wpa_bss_get_id(wpa_s, id1);
3167                         id2 = atoi(ctmp + 1);
3168                         if (id2 == 0)
3169                                 bsslast = dl_list_last(&wpa_s->bss_id,
3170                                                        struct wpa_bss,
3171                                                        list_id);
3172                         else {
3173                                 bsslast = wpa_bss_get_id(wpa_s, id2);
3174                                 if (bsslast == NULL && bss && id2 > id1) {
3175                                         struct wpa_bss *tmp = bss;
3176                                         for (;;) {
3177                                                 next = tmp->list_id.next;
3178                                                 if (next == &wpa_s->bss_id)
3179                                                         break;
3180                                                 tmp = dl_list_entry(
3181                                                         next, struct wpa_bss,
3182                                                         list_id);
3183                                                 if (tmp->id > id2)
3184                                                         break;
3185                                                 bsslast = tmp;
3186                                         }
3187                                 }
3188                         }
3189                 }
3190         } else if (os_strcmp(cmd, "FIRST") == 0)
3191                 bss = dl_list_first(&wpa_s->bss_id, struct wpa_bss, list_id);
3192         else if (os_strncmp(cmd, "ID-", 3) == 0) {
3193                 i = atoi(cmd + 3);
3194                 bss = wpa_bss_get_id(wpa_s, i);
3195         } else if (os_strncmp(cmd, "NEXT-", 5) == 0) {
3196                 i = atoi(cmd + 5);
3197                 bss = wpa_bss_get_id(wpa_s, i);
3198                 if (bss) {
3199                         next = bss->list_id.next;
3200                         if (next == &wpa_s->bss_id)
3201                                 bss = NULL;
3202                         else
3203                                 bss = dl_list_entry(next, struct wpa_bss,
3204                                                     list_id);
3205                 }
3206 #ifdef CONFIG_P2P
3207         } else if (os_strncmp(cmd, "p2p_dev_addr=", 13) == 0) {
3208                 if (hwaddr_aton(cmd + 13, bssid) == 0)
3209                         bss = wpa_bss_get_p2p_dev_addr(wpa_s, bssid);
3210                 else
3211                         bss = NULL;
3212 #endif /* CONFIG_P2P */
3213         } else if (hwaddr_aton(cmd, bssid) == 0)
3214                 bss = wpa_bss_get_bssid(wpa_s, bssid);
3215         else {
3216                 struct wpa_bss *tmp;
3217                 i = atoi(cmd);
3218                 bss = NULL;
3219                 dl_list_for_each(tmp, &wpa_s->bss_id, struct wpa_bss, list_id)
3220                 {
3221                         if (i-- == 0) {
3222                                 bss = tmp;
3223                                 break;
3224                         }
3225                 }
3226         }
3227
3228         if ((ctmp = os_strstr(cmd, "MASK=")) != NULL) {
3229                 mask = strtoul(ctmp + 5, NULL, 0x10);
3230                 if (mask == 0)
3231                         mask = WPA_BSS_MASK_ALL;
3232         }
3233
3234         if (bss == NULL)
3235                 return 0;
3236
3237         if (bsslast == NULL)
3238                 bsslast = bss;
3239         do {
3240                 len = print_bss_info(wpa_s, bss, mask, buf, buflen);
3241                 ret += len;
3242                 buf += len;
3243                 buflen -= len;
3244                 if (bss == bsslast)
3245                         break;
3246                 next = bss->list_id.next;
3247                 if (next == &wpa_s->bss_id)
3248                         break;
3249                 bss = dl_list_entry(next, struct wpa_bss, list_id);
3250         } while (bss && len);
3251
3252         return ret;
3253 }
3254
3255
3256 static int wpa_supplicant_ctrl_iface_ap_scan(
3257         struct wpa_supplicant *wpa_s, char *cmd)
3258 {
3259         int ap_scan = atoi(cmd);
3260         return wpa_supplicant_set_ap_scan(wpa_s, ap_scan);
3261 }
3262
3263
3264 static int wpa_supplicant_ctrl_iface_scan_interval(
3265         struct wpa_supplicant *wpa_s, char *cmd)
3266 {
3267         int scan_int = atoi(cmd);
3268         return wpa_supplicant_set_scan_interval(wpa_s, scan_int);
3269 }
3270
3271
3272 static int wpa_supplicant_ctrl_iface_bss_expire_age(
3273         struct wpa_supplicant *wpa_s, char *cmd)
3274 {
3275         int expire_age = atoi(cmd);
3276         return wpa_supplicant_set_bss_expiration_age(wpa_s, expire_age);
3277 }
3278
3279
3280 static int wpa_supplicant_ctrl_iface_bss_expire_count(
3281         struct wpa_supplicant *wpa_s, char *cmd)
3282 {
3283         int expire_count = atoi(cmd);
3284         return wpa_supplicant_set_bss_expiration_count(wpa_s, expire_count);
3285 }
3286
3287
3288 static int wpa_supplicant_ctrl_iface_bss_flush(
3289         struct wpa_supplicant *wpa_s, char *cmd)
3290 {
3291         int flush_age = atoi(cmd);
3292
3293         if (flush_age == 0)
3294                 wpa_bss_flush(wpa_s);
3295         else
3296                 wpa_bss_flush_by_age(wpa_s, flush_age);
3297         return 0;
3298 }
3299
3300
3301 static void wpa_supplicant_ctrl_iface_drop_sa(struct wpa_supplicant *wpa_s)
3302 {
3303         wpa_printf(MSG_DEBUG, "Dropping SA without deauthentication");
3304         /* MLME-DELETEKEYS.request */
3305         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 0, 0, NULL, 0, NULL, 0);
3306         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 1, 0, NULL, 0, NULL, 0);
3307         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 2, 0, NULL, 0, NULL, 0);
3308         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 3, 0, NULL, 0, NULL, 0);
3309 #ifdef CONFIG_IEEE80211W
3310         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 4, 0, NULL, 0, NULL, 0);
3311         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 5, 0, NULL, 0, NULL, 0);
3312 #endif /* CONFIG_IEEE80211W */
3313
3314         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, wpa_s->bssid, 0, 0, NULL, 0, NULL,
3315                         0);
3316         /* MLME-SETPROTECTION.request(None) */
3317         wpa_drv_mlme_setprotection(wpa_s, wpa_s->bssid,
3318                                    MLME_SETPROTECTION_PROTECT_TYPE_NONE,
3319                                    MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
3320         wpa_sm_drop_sa(wpa_s->wpa);
3321 }
3322
3323
3324 static int wpa_supplicant_ctrl_iface_roam(struct wpa_supplicant *wpa_s,
3325                                           char *addr)
3326 {
3327 #ifdef CONFIG_NO_SCAN_PROCESSING
3328         return -1;
3329 #else /* CONFIG_NO_SCAN_PROCESSING */
3330         u8 bssid[ETH_ALEN];
3331         struct wpa_bss *bss;
3332         struct wpa_ssid *ssid = wpa_s->current_ssid;
3333
3334         if (hwaddr_aton(addr, bssid)) {
3335                 wpa_printf(MSG_DEBUG, "CTRL_IFACE ROAM: invalid "
3336                            "address '%s'", addr);
3337                 return -1;
3338         }
3339
3340         wpa_printf(MSG_DEBUG, "CTRL_IFACE ROAM " MACSTR, MAC2STR(bssid));
3341
3342         bss = wpa_bss_get_bssid(wpa_s, bssid);
3343         if (!bss) {
3344                 wpa_printf(MSG_DEBUG, "CTRL_IFACE ROAM: Target AP not found "
3345                            "from BSS table");
3346                 return -1;
3347         }
3348
3349         /*
3350          * TODO: Find best network configuration block from configuration to
3351          * allow roaming to other networks
3352          */
3353
3354         if (!ssid) {
3355                 wpa_printf(MSG_DEBUG, "CTRL_IFACE ROAM: No network "
3356                            "configuration known for the target AP");
3357                 return -1;
3358         }
3359
3360         wpa_s->reassociate = 1;
3361         wpa_supplicant_connect(wpa_s, bss, ssid);
3362
3363         return 0;
3364 #endif /* CONFIG_NO_SCAN_PROCESSING */
3365 }
3366
3367
3368 #ifdef CONFIG_P2P
3369 static int p2p_ctrl_find(struct wpa_supplicant *wpa_s, char *cmd)
3370 {
3371         unsigned int timeout = atoi(cmd);
3372         enum p2p_discovery_type type = P2P_FIND_START_WITH_FULL;
3373         u8 dev_id[ETH_ALEN], *_dev_id = NULL;
3374         char *pos;
3375         unsigned int search_delay;
3376
3377         if (os_strstr(cmd, "type=social"))
3378                 type = P2P_FIND_ONLY_SOCIAL;
3379         else if (os_strstr(cmd, "type=progressive"))
3380                 type = P2P_FIND_PROGRESSIVE;
3381
3382         pos = os_strstr(cmd, "dev_id=");
3383         if (pos) {
3384                 pos += 7;
3385                 if (hwaddr_aton(pos, dev_id))
3386                         return -1;
3387                 _dev_id = dev_id;
3388         }
3389
3390         pos = os_strstr(cmd, "delay=");
3391         if (pos) {
3392                 pos += 6;
3393                 search_delay = atoi(pos);
3394         } else
3395                 search_delay = wpas_p2p_search_delay(wpa_s);
3396
3397         return wpas_p2p_find(wpa_s, timeout, type, 0, NULL, _dev_id,
3398                              search_delay);
3399 }
3400
3401
3402 static int p2p_ctrl_connect(struct wpa_supplicant *wpa_s, char *cmd,
3403                             char *buf, size_t buflen)
3404 {
3405         u8 addr[ETH_ALEN];
3406         char *pos, *pos2;
3407         char *pin = NULL;
3408         enum p2p_wps_method wps_method;
3409         int new_pin;
3410         int ret;
3411         int persistent_group, persistent_id = -1;
3412         int join;
3413         int auth;
3414         int automatic;
3415         int go_intent = -1;
3416         int freq = 0;
3417         int pd;
3418         int ht40;
3419
3420         /* <addr> <"pbc" | "pin" | PIN> [label|display|keypad]
3421          * [persistent|persistent=<network id>]
3422          * [join] [auth] [go_intent=<0..15>] [freq=<in MHz>] [provdisc]
3423          * [ht40] */
3424
3425         if (hwaddr_aton(cmd, addr))
3426                 return -1;
3427
3428         pos = cmd + 17;
3429         if (*pos != ' ')
3430                 return -1;
3431         pos++;
3432
3433         persistent_group = os_strstr(pos, " persistent") != NULL;
3434         pos2 = os_strstr(pos, " persistent=");
3435         if (pos2) {
3436                 struct wpa_ssid *ssid;
3437                 persistent_id = atoi(pos2 + 12);
3438                 ssid = wpa_config_get_network(wpa_s->conf, persistent_id);
3439                 if (ssid == NULL || ssid->disabled != 2 ||
3440                     ssid->mode != WPAS_MODE_P2P_GO) {
3441                         wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find "
3442                                    "SSID id=%d for persistent P2P group (GO)",
3443                                    persistent_id);
3444                         return -1;
3445                 }
3446         }
3447         join = os_strstr(pos, " join") != NULL;
3448         auth = os_strstr(pos, " auth") != NULL;
3449         automatic = os_strstr(pos, " auto") != NULL;
3450         pd = os_strstr(pos, " provdisc") != NULL;
3451         ht40 = (os_strstr(cmd, " ht40") != NULL) || wpa_s->conf->p2p_go_ht40;
3452
3453         pos2 = os_strstr(pos, " go_intent=");
3454         if (pos2) {
3455                 pos2 += 11;
3456                 go_intent = atoi(pos2);
3457                 if (go_intent < 0 || go_intent > 15)
3458                         return -1;
3459         }
3460
3461         pos2 = os_strstr(pos, " freq=");
3462         if (pos2) {
3463                 pos2 += 6;
3464                 freq = atoi(pos2);
3465                 if (freq <= 0)
3466                         return -1;
3467         }
3468
3469         if (os_strncmp(pos, "pin", 3) == 0) {
3470                 /* Request random PIN (to be displayed) and enable the PIN */
3471                 wps_method = WPS_PIN_DISPLAY;
3472         } else if (os_strncmp(pos, "pbc", 3) == 0) {
3473                 wps_method = WPS_PBC;
3474         } else {
3475                 pin = pos;
3476                 pos = os_strchr(pin, ' ');
3477                 wps_method = WPS_PIN_KEYPAD;
3478                 if (pos) {
3479                         *pos++ = '\0';
3480                         if (os_strncmp(pos, "display", 7) == 0)
3481                                 wps_method = WPS_PIN_DISPLAY;
3482                 }
3483                 if (!wps_pin_str_valid(pin)) {
3484                         os_memcpy(buf, "FAIL-INVALID-PIN\n", 17);
3485                         return 17;
3486                 }
3487         }
3488
3489         new_pin = wpas_p2p_connect(wpa_s, addr, pin, wps_method,
3490                                    persistent_group, automatic, join,
3491                                    auth, go_intent, freq, persistent_id, pd,
3492                                    ht40);
3493         if (new_pin == -2) {
3494                 os_memcpy(buf, "FAIL-CHANNEL-UNAVAILABLE\n", 25);
3495                 return 25;
3496         }
3497         if (new_pin == -3) {
3498                 os_memcpy(buf, "FAIL-CHANNEL-UNSUPPORTED\n", 25);
3499                 return 25;
3500         }
3501         if (new_pin < 0)
3502                 return -1;
3503         if (wps_method == WPS_PIN_DISPLAY && pin == NULL) {
3504                 ret = os_snprintf(buf, buflen, "%08d", new_pin);
3505                 if (ret < 0 || (size_t) ret >= buflen)
3506                         return -1;
3507                 return ret;
3508         }
3509
3510         os_memcpy(buf, "OK\n", 3);
3511         return 3;
3512 }
3513
3514
3515 static int p2p_ctrl_listen(struct wpa_supplicant *wpa_s, char *cmd)
3516 {
3517         unsigned int timeout = atoi(cmd);
3518         return wpas_p2p_listen(wpa_s, timeout);
3519 }
3520
3521
3522 static int p2p_ctrl_prov_disc(struct wpa_supplicant *wpa_s, char *cmd)
3523 {
3524         u8 addr[ETH_ALEN];
3525         char *pos;
3526         enum wpas_p2p_prov_disc_use use = WPAS_P2P_PD_FOR_GO_NEG;
3527
3528         /* <addr> <config method> [join|auto] */
3529
3530         if (hwaddr_aton(cmd, addr))
3531                 return -1;
3532
3533         pos = cmd + 17;
3534         if (*pos != ' ')
3535                 return -1;
3536         pos++;
3537
3538         if (os_strstr(pos, " join") != NULL)
3539                 use = WPAS_P2P_PD_FOR_JOIN;
3540         else if (os_strstr(pos, " auto") != NULL)
3541                 use = WPAS_P2P_PD_AUTO;
3542
3543         return wpas_p2p_prov_disc(wpa_s, addr, pos, use);
3544 }
3545
3546
3547 static int p2p_get_passphrase(struct wpa_supplicant *wpa_s, char *buf,
3548                               size_t buflen)
3549 {
3550         struct wpa_ssid *ssid = wpa_s->current_ssid;
3551
3552         if (ssid == NULL || ssid->mode != WPAS_MODE_P2P_GO ||
3553             ssid->passphrase == NULL)
3554                 return -1;
3555
3556         os_strlcpy(buf, ssid->passphrase, buflen);
3557         return os_strlen(buf);
3558 }
3559
3560
3561 static int p2p_ctrl_serv_disc_req(struct wpa_supplicant *wpa_s, char *cmd,
3562                                   char *buf, size_t buflen)
3563 {
3564         u64 ref;
3565         int res;
3566         u8 dst_buf[ETH_ALEN], *dst;
3567         struct wpabuf *tlvs;
3568         char *pos;
3569         size_t len;
3570
3571         if (hwaddr_aton(cmd, dst_buf))
3572                 return -1;
3573         dst = dst_buf;
3574         if (dst[0] == 0 && dst[1] == 0 && dst[2] == 0 &&
3575             dst[3] == 0 && dst[4] == 0 && dst[5] == 0)
3576                 dst = NULL;
3577         pos = cmd + 17;
3578         if (*pos != ' ')
3579                 return -1;
3580         pos++;
3581
3582         if (os_strncmp(pos, "upnp ", 5) == 0) {
3583                 u8 version;
3584                 pos += 5;
3585                 if (hexstr2bin(pos, &version, 1) < 0)
3586                         return -1;
3587                 pos += 2;
3588                 if (*pos != ' ')
3589                         return -1;
3590                 pos++;
3591                 ref = wpas_p2p_sd_request_upnp(wpa_s, dst, version, pos);
3592 #ifdef CONFIG_WIFI_DISPLAY
3593         } else if (os_strncmp(pos, "wifi-display ", 13) == 0) {
3594                 ref = wpas_p2p_sd_request_wifi_display(wpa_s, dst, pos + 13);
3595 #endif /* CONFIG_WIFI_DISPLAY */
3596         } else {
3597                 len = os_strlen(pos);
3598                 if (len & 1)
3599                         return -1;
3600                 len /= 2;
3601                 tlvs = wpabuf_alloc(len);
3602                 if (tlvs == NULL)
3603                         return -1;
3604                 if (hexstr2bin(pos, wpabuf_put(tlvs, len), len) < 0) {
3605                         wpabuf_free(tlvs);
3606                         return -1;
3607                 }
3608
3609                 ref = wpas_p2p_sd_request(wpa_s, dst, tlvs);
3610                 wpabuf_free(tlvs);
3611         }
3612         if (ref == 0)
3613                 return -1;
3614         res = os_snprintf(buf, buflen, "%llx", (long long unsigned) ref);
3615         if (res < 0 || (unsigned) res >= buflen)
3616                 return -1;
3617         return res;
3618 }
3619
3620
3621 static int p2p_ctrl_serv_disc_cancel_req(struct wpa_supplicant *wpa_s,
3622                                          char *cmd)
3623 {
3624         long long unsigned val;
3625         u64 req;
3626         if (sscanf(cmd, "%llx", &val) != 1)
3627                 return -1;
3628         req = val;
3629         return wpas_p2p_sd_cancel_request(wpa_s, req);
3630 }
3631
3632
3633 static int p2p_ctrl_serv_disc_resp(struct wpa_supplicant *wpa_s, char *cmd)
3634 {
3635         int freq;
3636         u8 dst[ETH_ALEN];
3637         u8 dialog_token;
3638         struct wpabuf *resp_tlvs;
3639         char *pos, *pos2;
3640         size_t len;
3641
3642         pos = os_strchr(cmd, ' ');
3643         if (pos == NULL)
3644                 return -1;
3645         *pos++ = '\0';
3646         freq = atoi(cmd);
3647         if (freq == 0)
3648                 return -1;
3649
3650         if (hwaddr_aton(pos, dst))
3651                 return -1;
3652         pos += 17;
3653         if (*pos != ' ')
3654                 return -1;
3655         pos++;
3656
3657         pos2 = os_strchr(pos, ' ');
3658         if (pos2 == NULL)
3659                 return -1;
3660         *pos2++ = '\0';
3661         dialog_token = atoi(pos);
3662
3663         len = os_strlen(pos2);
3664         if (len & 1)
3665                 return -1;
3666         len /= 2;
3667         resp_tlvs = wpabuf_alloc(len);
3668         if (resp_tlvs == NULL)
3669                 return -1;
3670         if (hexstr2bin(pos2, wpabuf_put(resp_tlvs, len), len) < 0) {
3671                 wpabuf_free(resp_tlvs);
3672                 return -1;
3673         }
3674
3675         wpas_p2p_sd_response(wpa_s, freq, dst, dialog_token, resp_tlvs);
3676         wpabuf_free(resp_tlvs);
3677         return 0;
3678 }
3679
3680
3681 static int p2p_ctrl_serv_disc_external(struct wpa_supplicant *wpa_s,
3682                                        char *cmd)
3683 {
3684         if (os_strcmp(cmd, "0") && os_strcmp(cmd, "1"))
3685                 return -1;
3686         wpa_s->p2p_sd_over_ctrl_iface = atoi(cmd);
3687         return 0;
3688 }
3689
3690
3691 static int p2p_ctrl_service_add_bonjour(struct wpa_supplicant *wpa_s,
3692                                         char *cmd)
3693 {
3694         char *pos;
3695         size_t len;
3696         struct wpabuf *query, *resp;
3697
3698         pos = os_strchr(cmd, ' ');
3699         if (pos == NULL)
3700                 return -1;
3701         *pos++ = '\0';
3702
3703         len = os_strlen(cmd);
3704         if (len & 1)
3705                 return -1;
3706         len /= 2;
3707         query = wpabuf_alloc(len);
3708         if (query == NULL)
3709                 return -1;
3710         if (hexstr2bin(cmd, wpabuf_put(query, len), len) < 0) {
3711                 wpabuf_free(query);
3712                 return -1;
3713         }
3714
3715         len = os_strlen(pos);
3716         if (len & 1) {
3717                 wpabuf_free(query);
3718                 return -1;
3719         }
3720         len /= 2;
3721         resp = wpabuf_alloc(len);
3722         if (resp == NULL) {
3723                 wpabuf_free(query);
3724                 return -1;
3725         }
3726         if (hexstr2bin(pos, wpabuf_put(resp, len), len) < 0) {
3727                 wpabuf_free(query);
3728                 wpabuf_free(resp);
3729                 return -1;
3730         }
3731
3732         if (wpas_p2p_service_add_bonjour(wpa_s, query, resp) < 0) {
3733                 wpabuf_free(query);
3734                 wpabuf_free(resp);
3735                 return -1;
3736         }
3737         return 0;
3738 }
3739
3740
3741 static int p2p_ctrl_service_add_upnp(struct wpa_supplicant *wpa_s, char *cmd)
3742 {
3743         char *pos;
3744         u8 version;
3745
3746         pos = os_strchr(cmd, ' ');
3747         if (pos == NULL)
3748                 return -1;
3749         *pos++ = '\0';
3750
3751         if (hexstr2bin(cmd, &version, 1) < 0)
3752                 return -1;
3753
3754         return wpas_p2p_service_add_upnp(wpa_s, version, pos);
3755 }
3756
3757
3758 static int p2p_ctrl_service_add(struct wpa_supplicant *wpa_s, char *cmd)
3759 {
3760         char *pos;
3761
3762         pos = os_strchr(cmd, ' ');
3763         if (pos == NULL)
3764                 return -1;
3765         *pos++ = '\0';
3766
3767         if (os_strcmp(cmd, "bonjour") == 0)
3768                 return p2p_ctrl_service_add_bonjour(wpa_s, pos);
3769         if (os_strcmp(cmd, "upnp") == 0)
3770                 return p2p_ctrl_service_add_upnp(wpa_s, pos);
3771         wpa_printf(MSG_DEBUG, "Unknown service '%s'", cmd);
3772         return -1;
3773 }
3774
3775
3776 static int p2p_ctrl_service_del_bonjour(struct wpa_supplicant *wpa_s,
3777                                         char *cmd)
3778 {
3779         size_t len;
3780         struct wpabuf *query;
3781         int ret;
3782
3783         len = os_strlen(cmd);
3784         if (len & 1)
3785                 return -1;
3786         len /= 2;
3787         query = wpabuf_alloc(len);
3788         if (query == NULL)
3789                 return -1;
3790         if (hexstr2bin(cmd, wpabuf_put(query, len), len) < 0) {
3791                 wpabuf_free(query);
3792                 return -1;
3793         }
3794
3795         ret = wpas_p2p_service_del_bonjour(wpa_s, query);
3796         wpabuf_free(query);
3797         return ret;
3798 }
3799
3800
3801 static int p2p_ctrl_service_del_upnp(struct wpa_supplicant *wpa_s, char *cmd)
3802 {
3803         char *pos;
3804         u8 version;
3805
3806         pos = os_strchr(cmd, ' ');
3807         if (pos == NULL)
3808                 return -1;
3809         *pos++ = '\0';
3810
3811         if (hexstr2bin(cmd, &version, 1) < 0)
3812                 return -1;
3813
3814         return wpas_p2p_service_del_upnp(wpa_s, version, pos);
3815 }
3816
3817
3818 static int p2p_ctrl_service_del(struct wpa_supplicant *wpa_s, char *cmd)
3819 {
3820         char *pos;
3821
3822         pos = os_strchr(cmd, ' ');
3823         if (pos == NULL)
3824                 return -1;
3825         *pos++ = '\0';
3826
3827         if (os_strcmp(cmd, "bonjour") == 0)
3828                 return p2p_ctrl_service_del_bonjour(wpa_s, pos);
3829         if (os_strcmp(cmd, "upnp") == 0)
3830                 return p2p_ctrl_service_del_upnp(wpa_s, pos);
3831         wpa_printf(MSG_DEBUG, "Unknown service '%s'", cmd);
3832         return -1;
3833 }
3834
3835
3836 static int p2p_ctrl_reject(struct wpa_supplicant *wpa_s, char *cmd)
3837 {
3838         u8 addr[ETH_ALEN];
3839
3840         /* <addr> */
3841
3842         if (hwaddr_aton(cmd, addr))
3843                 return -1;
3844
3845         return wpas_p2p_reject(wpa_s, addr);
3846 }
3847
3848
3849 static int p2p_ctrl_invite_persistent(struct wpa_supplicant *wpa_s, char *cmd)
3850 {
3851         char *pos;
3852         int id;
3853         struct wpa_ssid *ssid;
3854         u8 *_peer = NULL, peer[ETH_ALEN];
3855         int freq = 0;
3856         int ht40;
3857
3858         id = atoi(cmd);
3859         pos = os_strstr(cmd, " peer=");
3860         if (pos) {
3861                 pos += 6;
3862                 if (hwaddr_aton(pos, peer))
3863                         return -1;
3864                 _peer = peer;
3865         }
3866         ssid = wpa_config_get_network(wpa_s->conf, id);
3867         if (ssid == NULL || ssid->disabled != 2) {
3868                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find SSID id=%d "
3869                            "for persistent P2P group",
3870                            id);
3871                 return -1;
3872         }
3873
3874         pos = os_strstr(cmd, " freq=");
3875         if (pos) {
3876                 pos += 6;
3877                 freq = atoi(pos);
3878                 if (freq <= 0)
3879                         return -1;
3880         }
3881
3882         ht40 = (os_strstr(cmd, " ht40") != NULL) || wpa_s->conf->p2p_go_ht40;
3883
3884         return wpas_p2p_invite(wpa_s, _peer, ssid, NULL, freq, ht40);
3885 }
3886
3887
3888 static int p2p_ctrl_invite_group(struct wpa_supplicant *wpa_s, char *cmd)
3889 {
3890         char *pos;
3891         u8 peer[ETH_ALEN], go_dev_addr[ETH_ALEN], *go_dev = NULL;
3892
3893         pos = os_strstr(cmd, " peer=");
3894         if (!pos)
3895                 return -1;
3896
3897         *pos = '\0';
3898         pos += 6;
3899         if (hwaddr_aton(pos, peer)) {
3900                 wpa_printf(MSG_DEBUG, "P2P: Invalid MAC address '%s'", pos);
3901                 return -1;
3902         }
3903
3904         pos = os_strstr(pos, " go_dev_addr=");
3905         if (pos) {
3906                 pos += 13;
3907                 if (hwaddr_aton(pos, go_dev_addr)) {
3908                         wpa_printf(MSG_DEBUG, "P2P: Invalid MAC address '%s'",
3909                                    pos);
3910                         return -1;
3911                 }
3912                 go_dev = go_dev_addr;
3913         }
3914
3915         return wpas_p2p_invite_group(wpa_s, cmd, peer, go_dev);
3916 }
3917
3918
3919 static int p2p_ctrl_invite(struct wpa_supplicant *wpa_s, char *cmd)
3920 {
3921         if (os_strncmp(cmd, "persistent=", 11) == 0)
3922                 return p2p_ctrl_invite_persistent(wpa_s, cmd + 11);
3923         if (os_strncmp(cmd, "group=", 6) == 0)
3924                 return p2p_ctrl_invite_group(wpa_s, cmd + 6);
3925
3926         return -1;
3927 }
3928
3929
3930 static int p2p_ctrl_group_add_persistent(struct wpa_supplicant *wpa_s,
3931                                          char *cmd, int freq, int ht40)
3932 {
3933         int id;
3934         struct wpa_ssid *ssid;
3935
3936         id = atoi(cmd);
3937         ssid = wpa_config_get_network(wpa_s->conf, id);
3938         if (ssid == NULL || ssid->disabled != 2) {
3939                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find SSID id=%d "
3940                            "for persistent P2P group",
3941                            id);
3942                 return -1;
3943         }
3944
3945         return wpas_p2p_group_add_persistent(wpa_s, ssid, 0, freq, ht40);
3946 }
3947
3948
3949 static int p2p_ctrl_group_add(struct wpa_supplicant *wpa_s, char *cmd)
3950 {
3951         int freq = 0, ht40;
3952         char *pos;
3953
3954         pos = os_strstr(cmd, "freq=");
3955         if (pos)
3956                 freq = atoi(pos + 5);
3957
3958         ht40 = (os_strstr(cmd, "ht40") != NULL) || wpa_s->conf->p2p_go_ht40;
3959
3960         if (os_strncmp(cmd, "persistent=", 11) == 0)
3961                 return p2p_ctrl_group_add_persistent(wpa_s, cmd + 11, freq,
3962                                                      ht40);
3963         if (os_strcmp(cmd, "persistent") == 0 ||
3964             os_strncmp(cmd, "persistent ", 11) == 0)
3965                 return wpas_p2p_group_add(wpa_s, 1, freq, ht40);
3966         if (os_strncmp(cmd, "freq=", 5) == 0)
3967                 return wpas_p2p_group_add(wpa_s, 0, freq, ht40);
3968         if (ht40)
3969                 return wpas_p2p_group_add(wpa_s, 0, freq, ht40);
3970
3971         wpa_printf(MSG_DEBUG, "CTRL: Invalid P2P_GROUP_ADD parameters '%s'",
3972                    cmd);
3973         return -1;
3974 }
3975
3976
3977 static int p2p_ctrl_peer(struct wpa_supplicant *wpa_s, char *cmd,
3978                          char *buf, size_t buflen)
3979 {
3980         u8 addr[ETH_ALEN], *addr_ptr;
3981         int next, res;
3982         const struct p2p_peer_info *info;
3983         char *pos, *end;
3984         char devtype[WPS_DEV_TYPE_BUFSIZE];
3985         struct wpa_ssid *ssid;
3986         size_t i;
3987
3988         if (!wpa_s->global->p2p)
3989                 return -1;
3990
3991         if (os_strcmp(cmd, "FIRST") == 0) {
3992                 addr_ptr = NULL;
3993                 next = 0;
3994         } else if (os_strncmp(cmd, "NEXT-", 5) == 0) {
3995                 if (hwaddr_aton(cmd + 5, addr) < 0)
3996                         return -1;
3997                 addr_ptr = addr;
3998                 next = 1;
3999         } else {
4000                 if (hwaddr_aton(cmd, addr) < 0)
4001                         return -1;
4002                 addr_ptr = addr;
4003                 next = 0;
4004         }
4005
4006         info = p2p_get_peer_info(wpa_s->global->p2p, addr_ptr, next);
4007         if (info == NULL)
4008                 return -1;
4009
4010         pos = buf;
4011         end = buf + buflen;
4012
4013         res = os_snprintf(pos, end - pos, MACSTR "\n"
4014                           "pri_dev_type=%s\n"
4015                           "device_name=%s\n"
4016                           "manufacturer=%s\n"
4017                           "model_name=%s\n"
4018                           "model_number=%s\n"
4019                           "serial_number=%s\n"
4020                           "config_methods=0x%x\n"
4021                           "dev_capab=0x%x\n"
4022                           "group_capab=0x%x\n"
4023                           "level=%d\n",
4024                           MAC2STR(info->p2p_device_addr),
4025                           wps_dev_type_bin2str(info->pri_dev_type,
4026                                                devtype, sizeof(devtype)),
4027                           info->device_name,
4028                           info->manufacturer,
4029                           info->model_name,
4030                           info->model_number,
4031                           info->serial_number,
4032                           info->config_methods,
4033                           info->dev_capab,
4034                           info->group_capab,
4035                           info->level);
4036         if (res < 0 || res >= end - pos)
4037                 return pos - buf;
4038         pos += res;
4039
4040         for (i = 0; i < info->wps_sec_dev_type_list_len / WPS_DEV_TYPE_LEN; i++)
4041         {
4042                 const u8 *t;
4043                 t = &info->wps_sec_dev_type_list[i * WPS_DEV_TYPE_LEN];
4044                 res = os_snprintf(pos, end - pos, "sec_dev_type=%s\n",
4045                                   wps_dev_type_bin2str(t, devtype,
4046                                                        sizeof(devtype)));
4047                 if (res < 0 || res >= end - pos)
4048                         return pos - buf;
4049                 pos += res;
4050         }
4051
4052         ssid = wpas_p2p_get_persistent(wpa_s, info->p2p_device_addr, NULL, 0);
4053         if (ssid) {
4054                 res = os_snprintf(pos, end - pos, "persistent=%d\n", ssid->id);
4055                 if (res < 0 || res >= end - pos)
4056                         return pos - buf;
4057                 pos += res;
4058         }
4059
4060         res = p2p_get_peer_info_txt(info, pos, end - pos);
4061         if (res < 0)
4062                 return pos - buf;
4063         pos += res;
4064
4065         return pos - buf;
4066 }
4067
4068
4069 static int p2p_ctrl_disallow_freq(struct wpa_supplicant *wpa_s,
4070                                   const char *param)
4071 {
4072         struct wpa_freq_range *freq = NULL, *n;
4073         unsigned int count = 0, i;
4074         const char *pos, *pos2, *pos3;
4075
4076         if (wpa_s->global->p2p == NULL)
4077                 return -1;
4078
4079         /*
4080          * param includes comma separated frequency range.
4081          * For example: 2412-2432,2462,5000-6000
4082          */
4083         pos = param;
4084         while (pos && pos[0]) {
4085                 n = os_realloc_array(freq, count + 1,
4086                                      sizeof(struct wpa_freq_range));
4087                 if (n == NULL) {
4088                         os_free(freq);
4089                         return -1;
4090                 }
4091                 freq = n;
4092                 freq[count].min = atoi(pos);
4093                 pos2 = os_strchr(pos, '-');
4094                 pos3 = os_strchr(pos, ',');
4095                 if (pos2 && (!pos3 || pos2 < pos3)) {
4096                         pos2++;
4097                         freq[count].max = atoi(pos2);
4098                 } else
4099                         freq[count].max = freq[count].min;
4100                 pos = pos3;
4101                 if (pos)
4102                         pos++;
4103                 count++;
4104         }
4105
4106         for (i = 0; i < count; i++) {
4107                 wpa_printf(MSG_DEBUG, "P2P: Disallowed frequency range %u-%u",
4108                            freq[i].min, freq[i].max);
4109         }
4110
4111         os_free(wpa_s->global->p2p_disallow_freq);
4112         wpa_s->global->p2p_disallow_freq = freq;
4113         wpa_s->global->num_p2p_disallow_freq = count;
4114         wpas_p2p_update_channel_list(wpa_s);
4115         return 0;
4116 }
4117
4118
4119 static int p2p_ctrl_set(struct wpa_supplicant *wpa_s, char *cmd)
4120 {
4121         char *param;
4122
4123         if (wpa_s->global->p2p == NULL)
4124                 return -1;
4125
4126         param = os_strchr(cmd, ' ');
4127         if (param == NULL)
4128                 return -1;
4129         *param++ = '\0';
4130
4131         if (os_strcmp(cmd, "discoverability") == 0) {
4132                 p2p_set_client_discoverability(wpa_s->global->p2p,
4133                                                atoi(param));
4134                 return 0;
4135         }
4136
4137         if (os_strcmp(cmd, "managed") == 0) {
4138                 p2p_set_managed_oper(wpa_s->global->p2p, atoi(param));
4139                 return 0;
4140         }
4141
4142         if (os_strcmp(cmd, "listen_channel") == 0) {
4143                 return p2p_set_listen_channel(wpa_s->global->p2p, 81,
4144                                               atoi(param));
4145         }
4146
4147         if (os_strcmp(cmd, "ssid_postfix") == 0) {
4148                 return p2p_set_ssid_postfix(wpa_s->global->p2p, (u8 *) param,
4149                                             os_strlen(param));
4150         }
4151
4152         if (os_strcmp(cmd, "noa") == 0) {
4153                 char *pos;
4154                 int count, start, duration;
4155                 /* GO NoA parameters: count,start_offset(ms),duration(ms) */
4156                 count = atoi(param);
4157                 pos = os_strchr(param, ',');
4158                 if (pos == NULL)
4159                         return -1;
4160                 pos++;
4161                 start = atoi(pos);
4162                 pos = os_strchr(pos, ',');
4163                 if (pos == NULL)
4164                         return -1;
4165                 pos++;
4166                 duration = atoi(pos);
4167                 if (count < 0 || count > 255 || start < 0 || duration < 0)
4168                         return -1;
4169                 if (count == 0 && duration > 0)
4170                         return -1;
4171                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: P2P_SET GO NoA: count=%d "
4172                            "start=%d duration=%d", count, start, duration);
4173                 return wpas_p2p_set_noa(wpa_s, count, start, duration);
4174         }
4175
4176         if (os_strcmp(cmd, "ps") == 0)
4177                 return wpa_drv_set_p2p_powersave(wpa_s, atoi(param), -1, -1);
4178
4179         if (os_strcmp(cmd, "oppps") == 0)
4180                 return wpa_drv_set_p2p_powersave(wpa_s, -1, atoi(param), -1);
4181
4182         if (os_strcmp(cmd, "ctwindow") == 0)
4183                 return wpa_drv_set_p2p_powersave(wpa_s, -1, -1, atoi(param));
4184
4185         if (os_strcmp(cmd, "disabled") == 0) {
4186                 wpa_s->global->p2p_disabled = atoi(param);
4187                 wpa_printf(MSG_DEBUG, "P2P functionality %s",
4188                            wpa_s->global->p2p_disabled ?
4189                            "disabled" : "enabled");
4190                 if (wpa_s->global->p2p_disabled) {
4191                         wpas_p2p_stop_find(wpa_s);
4192                         os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
4193                         p2p_flush(wpa_s->global->p2p);
4194                 }
4195                 return 0;
4196         }
4197
4198         if (os_strcmp(cmd, "conc_pref") == 0) {
4199                 if (os_strcmp(param, "sta") == 0)
4200                         wpa_s->global->conc_pref = WPA_CONC_PREF_STA;
4201                 else if (os_strcmp(param, "p2p") == 0)
4202                         wpa_s->global->conc_pref = WPA_CONC_PREF_P2P;
4203                 else {
4204                         wpa_printf(MSG_INFO, "Invalid conc_pref value");
4205                         return -1;
4206                 }
4207                 wpa_printf(MSG_DEBUG, "Single channel concurrency preference: "
4208                            "%s", param);
4209                 return 0;
4210         }
4211
4212         if (os_strcmp(cmd, "force_long_sd") == 0) {
4213                 wpa_s->force_long_sd = atoi(param);
4214                 return 0;
4215         }
4216
4217         if (os_strcmp(cmd, "peer_filter") == 0) {
4218                 u8 addr[ETH_ALEN];
4219                 if (hwaddr_aton(param, addr))
4220                         return -1;
4221                 p2p_set_peer_filter(wpa_s->global->p2p, addr);
4222                 return 0;
4223         }
4224
4225         if (os_strcmp(cmd, "cross_connect") == 0)
4226                 return wpas_p2p_set_cross_connect(wpa_s, atoi(param));
4227
4228         if (os_strcmp(cmd, "go_apsd") == 0) {
4229                 if (os_strcmp(param, "disable") == 0)
4230                         wpa_s->set_ap_uapsd = 0;
4231                 else {
4232                         wpa_s->set_ap_uapsd = 1;
4233                         wpa_s->ap_uapsd = atoi(param);
4234                 }
4235                 return 0;
4236         }
4237
4238         if (os_strcmp(cmd, "client_apsd") == 0) {
4239                 if (os_strcmp(param, "disable") == 0)
4240                         wpa_s->set_sta_uapsd = 0;
4241                 else {
4242                         int be, bk, vi, vo;
4243                         char *pos;
4244                         /* format: BE,BK,VI,VO;max SP Length */
4245                         be = atoi(param);
4246                         pos = os_strchr(param, ',');
4247                         if (pos == NULL)
4248                                 return -1;
4249                         pos++;
4250                         bk = atoi(pos);
4251                         pos = os_strchr(pos, ',');
4252                         if (pos == NULL)
4253                                 return -1;
4254                         pos++;
4255                         vi = atoi(pos);
4256                         pos = os_strchr(pos, ',');
4257                         if (pos == NULL)
4258                                 return -1;
4259                         pos++;
4260                         vo = atoi(pos);
4261                         /* ignore max SP Length for now */
4262
4263                         wpa_s->set_sta_uapsd = 1;
4264                         wpa_s->sta_uapsd = 0;
4265                         if (be)
4266                                 wpa_s->sta_uapsd |= BIT(0);
4267                         if (bk)
4268                                 wpa_s->sta_uapsd |= BIT(1);
4269                         if (vi)
4270                                 wpa_s->sta_uapsd |= BIT(2);
4271                         if (vo)
4272                                 wpa_s->sta_uapsd |= BIT(3);
4273                 }
4274                 return 0;
4275         }
4276
4277         if (os_strcmp(cmd, "disallow_freq") == 0)
4278                 return p2p_ctrl_disallow_freq(wpa_s, param);
4279
4280         if (os_strcmp(cmd, "disc_int") == 0) {
4281                 int min_disc_int, max_disc_int, max_disc_tu;
4282                 char *pos;
4283
4284                 pos = param;
4285
4286                 min_disc_int = atoi(pos);
4287                 pos = os_strchr(pos, ' ');
4288                 if (pos == NULL)
4289                         return -1;
4290                 *pos++ = '\0';
4291
4292                 max_disc_int = atoi(pos);
4293                 pos = os_strchr(pos, ' ');
4294                 if (pos == NULL)
4295                         return -1;
4296                 *pos++ = '\0';
4297
4298                 max_disc_tu = atoi(pos);
4299
4300                 return p2p_set_disc_int(wpa_s->global->p2p, min_disc_int,
4301                                         max_disc_int, max_disc_tu);
4302         }
4303
4304         wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown P2P_SET field value '%s'",
4305                    cmd);
4306
4307         return -1;
4308 }
4309
4310
4311 static int p2p_ctrl_presence_req(struct wpa_supplicant *wpa_s, char *cmd)
4312 {
4313         char *pos, *pos2;
4314         unsigned int dur1 = 0, int1 = 0, dur2 = 0, int2 = 0;
4315
4316         if (cmd[0]) {
4317                 pos = os_strchr(cmd, ' ');
4318                 if (pos == NULL)
4319                         return -1;
4320                 *pos++ = '\0';
4321                 dur1 = atoi(cmd);
4322
4323                 pos2 = os_strchr(pos, ' ');
4324                 if (pos2)
4325                         *pos2++ = '\0';
4326                 int1 = atoi(pos);
4327         } else
4328                 pos2 = NULL;
4329
4330         if (pos2) {
4331                 pos = os_strchr(pos2, ' ');
4332                 if (pos == NULL)
4333                         return -1;
4334                 *pos++ = '\0';
4335                 dur2 = atoi(pos2);
4336                 int2 = atoi(pos);
4337         }
4338
4339         return wpas_p2p_presence_req(wpa_s, dur1, int1, dur2, int2);
4340 }
4341
4342
4343 static int p2p_ctrl_ext_listen(struct wpa_supplicant *wpa_s, char *cmd)
4344 {
4345         char *pos;
4346         unsigned int period = 0, interval = 0;
4347
4348         if (cmd[0]) {
4349                 pos = os_strchr(cmd, ' ');
4350                 if (pos == NULL)
4351                         return -1;
4352                 *pos++ = '\0';
4353                 period = atoi(cmd);
4354                 interval = atoi(pos);
4355         }
4356
4357         return wpas_p2p_ext_listen(wpa_s, period, interval);
4358 }
4359
4360 #endif /* CONFIG_P2P */
4361
4362
4363 #ifdef CONFIG_INTERWORKING
4364 static int ctrl_interworking_connect(struct wpa_supplicant *wpa_s, char *dst)
4365 {
4366         u8 bssid[ETH_ALEN];
4367         struct wpa_bss *bss;
4368
4369         if (hwaddr_aton(dst, bssid)) {
4370                 wpa_printf(MSG_DEBUG, "Invalid BSSID '%s'", dst);
4371                 return -1;
4372         }
4373
4374         bss = wpa_bss_get_bssid(wpa_s, bssid);
4375         if (bss == NULL) {
4376                 wpa_printf(MSG_DEBUG, "Could not find BSS " MACSTR,
4377                            MAC2STR(bssid));
4378                 return -1;
4379         }
4380
4381         return interworking_connect(wpa_s, bss);
4382 }
4383
4384
4385 static int get_anqp(struct wpa_supplicant *wpa_s, char *dst)
4386 {
4387         u8 dst_addr[ETH_ALEN];
4388         int used;
4389         char *pos;
4390 #define MAX_ANQP_INFO_ID 100
4391         u16 id[MAX_ANQP_INFO_ID];
4392         size_t num_id = 0;
4393
4394         used = hwaddr_aton2(dst, dst_addr);
4395         if (used < 0)
4396                 return -1;
4397         pos = dst + used;
4398         while (num_id < MAX_ANQP_INFO_ID) {
4399                 id[num_id] = atoi(pos);
4400                 if (id[num_id])
4401                         num_id++;
4402                 pos = os_strchr(pos + 1, ',');
4403                 if (pos == NULL)
4404                         break;
4405                 pos++;
4406         }
4407
4408         if (num_id == 0)
4409                 return -1;
4410
4411         return anqp_send_req(wpa_s, dst_addr, id, num_id);
4412 }
4413
4414
4415 static int gas_request(struct wpa_supplicant *wpa_s, char *cmd)
4416 {
4417         u8 dst_addr[ETH_ALEN];
4418         struct wpabuf *advproto, *query = NULL;
4419         int used, ret = -1;
4420         char *pos, *end;
4421         size_t len;
4422
4423         used = hwaddr_aton2(cmd, dst_addr);
4424         if (used < 0)
4425                 return -1;
4426
4427         pos = cmd + used;
4428         while (*pos == ' ')
4429                 pos++;
4430
4431         /* Advertisement Protocol ID */
4432         end = os_strchr(pos, ' ');
4433         if (end)
4434                 len = end - pos;
4435         else
4436                 len = os_strlen(pos);
4437         if (len & 0x01)
4438                 return -1;
4439         len /= 2;
4440         if (len == 0)
4441                 return -1;
4442         advproto = wpabuf_alloc(len);
4443         if (advproto == NULL)
4444                 return -1;
4445         if (hexstr2bin(pos, wpabuf_put(advproto, len), len) < 0)
4446                 goto fail;
4447
4448         if (end) {
4449                 /* Optional Query Request */
4450                 pos = end + 1;
4451                 while (*pos == ' ')
4452                         pos++;
4453
4454                 len = os_strlen(pos);
4455                 if (len) {
4456                         if (len & 0x01)
4457                                 goto fail;
4458                         len /= 2;
4459                         if (len == 0)
4460                                 goto fail;
4461                         query = wpabuf_alloc(len);
4462                         if (query == NULL)
4463                                 goto fail;
4464                         if (hexstr2bin(pos, wpabuf_put(query, len), len) < 0)
4465                                 goto fail;
4466                 }
4467         }
4468
4469         ret = gas_send_request(wpa_s, dst_addr, advproto, query);
4470
4471 fail:
4472         wpabuf_free(advproto);
4473         wpabuf_free(query);
4474
4475         return ret;
4476 }
4477
4478
4479 static int gas_response_get(struct wpa_supplicant *wpa_s, char *cmd, char *buf,
4480                             size_t buflen)
4481 {
4482         u8 addr[ETH_ALEN];
4483         int dialog_token;
4484         int used;
4485         char *pos;
4486         size_t resp_len, start, requested_len;
4487
4488         if (!wpa_s->last_gas_resp)
4489                 return -1;
4490
4491         used = hwaddr_aton2(cmd, addr);
4492         if (used < 0)
4493                 return -1;
4494
4495         pos = cmd + used;
4496         while (*pos == ' ')
4497                 pos++;
4498         dialog_token = atoi(pos);
4499
4500         if (os_memcmp(addr, wpa_s->last_gas_addr, ETH_ALEN) != 0 ||
4501             dialog_token != wpa_s->last_gas_dialog_token)
4502                 return -1;
4503
4504         resp_len = wpabuf_len(wpa_s->last_gas_resp);
4505         start = 0;
4506         requested_len = resp_len;
4507
4508         pos = os_strchr(pos, ' ');
4509         if (pos) {
4510                 start = atoi(pos);
4511                 if (start > resp_len)
4512                         return os_snprintf(buf, buflen, "FAIL-Invalid range");
4513                 pos = os_strchr(pos, ',');
4514                 if (pos == NULL)
4515                         return -1;
4516                 pos++;
4517                 requested_len = atoi(pos);
4518                 if (start + requested_len > resp_len)
4519                         return os_snprintf(buf, buflen, "FAIL-Invalid range");
4520         }
4521
4522         if (requested_len * 2 + 1 > buflen)
4523                 return os_snprintf(buf, buflen, "FAIL-Too long response");
4524
4525         return wpa_snprintf_hex(buf, buflen,
4526                                 wpabuf_head_u8(wpa_s->last_gas_resp) + start,
4527                                 requested_len);
4528 }
4529 #endif /* CONFIG_INTERWORKING */
4530
4531
4532 #ifdef CONFIG_HS20
4533
4534 static int get_hs20_anqp(struct wpa_supplicant *wpa_s, char *dst)
4535 {
4536         u8 dst_addr[ETH_ALEN];
4537         int used;
4538         char *pos;
4539         u32 subtypes = 0;
4540
4541         used = hwaddr_aton2(dst, dst_addr);
4542         if (used < 0)
4543                 return -1;
4544         pos = dst + used;
4545         for (;;) {
4546                 int num = atoi(pos);
4547                 if (num <= 0 || num > 31)
4548                         return -1;
4549                 subtypes |= BIT(num);
4550                 pos = os_strchr(pos + 1, ',');
4551                 if (pos == NULL)
4552                         break;
4553                 pos++;
4554         }
4555
4556         if (subtypes == 0)
4557                 return -1;
4558
4559         return hs20_anqp_send_req(wpa_s, dst_addr, subtypes, NULL, 0);
4560 }
4561
4562
4563 static int hs20_nai_home_realm_list(struct wpa_supplicant *wpa_s,
4564                                     const u8 *addr, const char *realm)
4565 {
4566         u8 *buf;
4567         size_t rlen, len;
4568         int ret;
4569
4570         rlen = os_strlen(realm);
4571         len = 3 + rlen;
4572         buf = os_malloc(len);
4573         if (buf == NULL)
4574                 return -1;
4575         buf[0] = 1; /* NAI Home Realm Count */
4576         buf[1] = 0; /* Formatted in accordance with RFC 4282 */
4577         buf[2] = rlen;
4578         os_memcpy(buf + 3, realm, rlen);
4579
4580         ret = hs20_anqp_send_req(wpa_s, addr,
4581                                  BIT(HS20_STYPE_NAI_HOME_REALM_QUERY),
4582                                  buf, len);
4583
4584         os_free(buf);
4585
4586         return ret;
4587 }
4588
4589
4590 static int hs20_get_nai_home_realm_list(struct wpa_supplicant *wpa_s,
4591                                         char *dst)
4592 {
4593         struct wpa_cred *cred = wpa_s->conf->cred;
4594         u8 dst_addr[ETH_ALEN];
4595         int used;
4596         u8 *buf;
4597         size_t len;
4598         int ret;
4599
4600         used = hwaddr_aton2(dst, dst_addr);
4601         if (used < 0)
4602                 return -1;
4603
4604         while (dst[used] == ' ')
4605                 used++;
4606         if (os_strncmp(dst + used, "realm=", 6) == 0)
4607                 return hs20_nai_home_realm_list(wpa_s, dst_addr,
4608                                                 dst + used + 6);
4609
4610         len = os_strlen(dst + used);
4611
4612         if (len == 0 && cred && cred->realm)
4613                 return hs20_nai_home_realm_list(wpa_s, dst_addr, cred->realm);
4614
4615         if (len % 1)
4616                 return -1;
4617         len /= 2;
4618         buf = os_malloc(len);
4619         if (buf == NULL)
4620                 return -1;
4621         if (hexstr2bin(dst + used, buf, len) < 0) {
4622                 os_free(buf);
4623                 return -1;
4624         }
4625
4626         ret = hs20_anqp_send_req(wpa_s, dst_addr,
4627                                  BIT(HS20_STYPE_NAI_HOME_REALM_QUERY),
4628                                  buf, len);
4629         os_free(buf);
4630
4631         return ret;
4632 }
4633
4634 #endif /* CONFIG_HS20 */
4635
4636
4637 static int wpa_supplicant_ctrl_iface_sta_autoconnect(
4638         struct wpa_supplicant *wpa_s, char *cmd)
4639 {
4640         wpa_s->auto_reconnect_disabled = atoi(cmd) == 0 ? 1 : 0;
4641         return 0;
4642 }
4643
4644
4645 #ifdef CONFIG_AUTOSCAN
4646
4647 static int wpa_supplicant_ctrl_iface_autoscan(struct wpa_supplicant *wpa_s,
4648                                               char *cmd)
4649 {
4650         enum wpa_states state = wpa_s->wpa_state;
4651         char *new_params = NULL;
4652
4653         if (os_strlen(cmd) > 0) {
4654                 new_params = os_strdup(cmd);
4655                 if (new_params == NULL)
4656                         return -1;
4657         }
4658
4659         os_free(wpa_s->conf->autoscan);
4660         wpa_s->conf->autoscan = new_params;
4661
4662         if (wpa_s->conf->autoscan == NULL)
4663                 autoscan_deinit(wpa_s);
4664         else if (state == WPA_DISCONNECTED || state == WPA_INACTIVE)
4665                 autoscan_init(wpa_s, 1);
4666         else if (state == WPA_SCANNING)
4667                 wpa_supplicant_reinit_autoscan(wpa_s);
4668
4669         return 0;
4670 }
4671
4672 #endif /* CONFIG_AUTOSCAN */
4673
4674
4675 static int wpa_supplicant_signal_poll(struct wpa_supplicant *wpa_s, char *buf,
4676                                       size_t buflen)
4677 {
4678         struct wpa_signal_info si;
4679         int ret;
4680
4681         ret = wpa_drv_signal_poll(wpa_s, &si);
4682         if (ret)
4683                 return -1;
4684
4685         ret = os_snprintf(buf, buflen, "RSSI=%d\nLINKSPEED=%d\n"
4686                           "NOISE=%d\nFREQUENCY=%u\n",
4687                           si.current_signal, si.current_txrate / 1000,
4688                           si.current_noise, si.frequency);
4689         if (ret < 0 || (unsigned int) ret > buflen)
4690                 return -1;
4691         return ret;
4692 }
4693
4694
4695 static int wpa_supplicant_pktcnt_poll(struct wpa_supplicant *wpa_s, char *buf,
4696                                       size_t buflen)
4697 {
4698         struct hostap_sta_driver_data sta;
4699         int ret;
4700
4701         ret = wpa_drv_pktcnt_poll(wpa_s, &sta);
4702         if (ret)
4703                 return -1;
4704
4705         ret = os_snprintf(buf, buflen, "TXGOOD=%lu\nTXBAD=%lu\nRXGOOD=%lu\n",
4706                           sta.tx_packets, sta.tx_retry_failed, sta.rx_packets);
4707         if (ret < 0 || (size_t) ret > buflen)
4708                 return -1;
4709         return ret;
4710 }
4711
4712
4713 char * wpa_supplicant_ctrl_iface_process(struct wpa_supplicant *wpa_s,
4714                                          char *buf, size_t *resp_len)
4715 {
4716         char *reply;
4717         const int reply_size = 4096;
4718         int ctrl_rsp = 0;
4719         int reply_len;
4720
4721         if (os_strncmp(buf, WPA_CTRL_RSP, os_strlen(WPA_CTRL_RSP)) == 0 ||
4722             os_strncmp(buf, "SET_NETWORK ", 12) == 0 ||
4723             os_strncmp(buf, "WPS_NFC_TAG_READ", 16) == 0 ||
4724             os_strncmp(buf, "NFC_RX_HANDOVER_SEL", 19) == 0) {
4725                 wpa_hexdump_ascii_key(MSG_DEBUG, "RX ctrl_iface",
4726                                       (const u8 *) buf, os_strlen(buf));
4727         } else {
4728                 int level = MSG_DEBUG;
4729                 if (os_strcmp(buf, "PING") == 0)
4730                         level = MSG_EXCESSIVE;
4731                 wpa_hexdump_ascii(level, "RX ctrl_iface",
4732                                   (const u8 *) buf, os_strlen(buf));
4733                 wpa_dbg(wpa_s, level, "Control interface command '%s'", buf);
4734         }
4735
4736         reply = os_malloc(reply_size);
4737         if (reply == NULL) {
4738                 *resp_len = 1;
4739                 return NULL;
4740         }
4741
4742         os_memcpy(reply, "OK\n", 3);
4743         reply_len = 3;
4744
4745         if (os_strcmp(buf, "PING") == 0) {
4746                 os_memcpy(reply, "PONG\n", 5);
4747                 reply_len = 5;
4748         } else if (os_strcmp(buf, "IFNAME") == 0) {
4749                 reply_len = os_strlen(wpa_s->ifname);
4750                 os_memcpy(reply, wpa_s->ifname, reply_len);
4751         } else if (os_strncmp(buf, "RELOG", 5) == 0) {
4752                 if (wpa_debug_reopen_file() < 0)
4753                         reply_len = -1;
4754         } else if (os_strncmp(buf, "NOTE ", 5) == 0) {
4755                 wpa_printf(MSG_INFO, "NOTE: %s", buf + 5);
4756         } else if (os_strcmp(buf, "MIB") == 0) {
4757                 reply_len = wpa_sm_get_mib(wpa_s->wpa, reply, reply_size);
4758                 if (reply_len >= 0) {
4759                         int res;
4760                         res = eapol_sm_get_mib(wpa_s->eapol, reply + reply_len,
4761                                                reply_size - reply_len);
4762                         if (res < 0)
4763                                 reply_len = -1;
4764                         else
4765                                 reply_len += res;
4766                 }
4767         } else if (os_strncmp(buf, "STATUS", 6) == 0) {
4768                 reply_len = wpa_supplicant_ctrl_iface_status(
4769                         wpa_s, buf + 6, reply, reply_size);
4770         } else if (os_strcmp(buf, "PMKSA") == 0) {
4771                 reply_len = wpa_sm_pmksa_cache_list(wpa_s->wpa, reply,
4772                                                     reply_size);
4773         } else if (os_strncmp(buf, "SET ", 4) == 0) {
4774                 if (wpa_supplicant_ctrl_iface_set(wpa_s, buf + 4))
4775                         reply_len = -1;
4776         } else if (os_strncmp(buf, "GET ", 4) == 0) {
4777                 reply_len = wpa_supplicant_ctrl_iface_get(wpa_s, buf + 4,
4778                                                           reply, reply_size);
4779         } else if (os_strcmp(buf, "LOGON") == 0) {
4780                 eapol_sm_notify_logoff(wpa_s->eapol, FALSE);
4781         } else if (os_strcmp(buf, "LOGOFF") == 0) {
4782                 eapol_sm_notify_logoff(wpa_s->eapol, TRUE);
4783         } else if (os_strcmp(buf, "REASSOCIATE") == 0) {
4784                 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
4785                         reply_len = -1;
4786                 else
4787                         wpas_request_connection(wpa_s);
4788         } else if (os_strcmp(buf, "RECONNECT") == 0) {
4789                 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
4790                         reply_len = -1;
4791                 else if (wpa_s->disconnected)
4792                         wpas_request_connection(wpa_s);
4793 #ifdef IEEE8021X_EAPOL
4794         } else if (os_strncmp(buf, "PREAUTH ", 8) == 0) {
4795                 if (wpa_supplicant_ctrl_iface_preauth(wpa_s, buf + 8))
4796                         reply_len = -1;
4797 #endif /* IEEE8021X_EAPOL */
4798 #ifdef CONFIG_PEERKEY
4799         } else if (os_strncmp(buf, "STKSTART ", 9) == 0) {
4800                 if (wpa_supplicant_ctrl_iface_stkstart(wpa_s, buf + 9))
4801                         reply_len = -1;
4802 #endif /* CONFIG_PEERKEY */
4803 #ifdef CONFIG_IEEE80211R
4804         } else if (os_strncmp(buf, "FT_DS ", 6) == 0) {
4805                 if (wpa_supplicant_ctrl_iface_ft_ds(wpa_s, buf + 6))
4806                         reply_len = -1;
4807 #endif /* CONFIG_IEEE80211R */
4808 #ifdef CONFIG_WPS
4809         } else if (os_strcmp(buf, "WPS_PBC") == 0) {
4810                 int res = wpa_supplicant_ctrl_iface_wps_pbc(wpa_s, NULL);
4811                 if (res == -2) {
4812                         os_memcpy(reply, "FAIL-PBC-OVERLAP\n", 17);
4813                         reply_len = 17;
4814                 } else if (res)
4815                         reply_len = -1;
4816         } else if (os_strncmp(buf, "WPS_PBC ", 8) == 0) {
4817                 int res = wpa_supplicant_ctrl_iface_wps_pbc(wpa_s, buf + 8);
4818                 if (res == -2) {
4819                         os_memcpy(reply, "FAIL-PBC-OVERLAP\n", 17);
4820                         reply_len = 17;
4821                 } else if (res)
4822                         reply_len = -1;
4823         } else if (os_strncmp(buf, "WPS_PIN ", 8) == 0) {
4824                 reply_len = wpa_supplicant_ctrl_iface_wps_pin(wpa_s, buf + 8,
4825                                                               reply,
4826                                                               reply_size);
4827         } else if (os_strncmp(buf, "WPS_CHECK_PIN ", 14) == 0) {
4828                 reply_len = wpa_supplicant_ctrl_iface_wps_check_pin(
4829                         wpa_s, buf + 14, reply, reply_size);
4830         } else if (os_strcmp(buf, "WPS_CANCEL") == 0) {
4831                 if (wpas_wps_cancel(wpa_s))
4832                         reply_len = -1;
4833 #ifdef CONFIG_WPS_NFC
4834         } else if (os_strcmp(buf, "WPS_NFC") == 0) {
4835                 if (wpa_supplicant_ctrl_iface_wps_nfc(wpa_s, NULL))
4836                         reply_len = -1;
4837         } else if (os_strncmp(buf, "WPS_NFC ", 8) == 0) {
4838                 if (wpa_supplicant_ctrl_iface_wps_nfc(wpa_s, buf + 8))
4839                         reply_len = -1;
4840         } else if (os_strncmp(buf, "WPS_NFC_TOKEN ", 14) == 0) {
4841                 reply_len = wpa_supplicant_ctrl_iface_wps_nfc_token(
4842                         wpa_s, buf + 14, reply, reply_size);
4843         } else if (os_strncmp(buf, "WPS_NFC_TAG_READ ", 17) == 0) {
4844                 if (wpa_supplicant_ctrl_iface_wps_nfc_tag_read(wpa_s,
4845                                                                buf + 17))
4846                         reply_len = -1;
4847         } else if (os_strncmp(buf, "NFC_GET_HANDOVER_REQ ", 21) == 0) {
4848                 reply_len = wpas_ctrl_nfc_get_handover_req(
4849                         wpa_s, buf + 21, reply, reply_size);
4850         } else if (os_strncmp(buf, "NFC_GET_HANDOVER_SEL ", 21) == 0) {
4851                 reply_len = wpas_ctrl_nfc_get_handover_sel(
4852                         wpa_s, buf + 21, reply, reply_size);
4853         } else if (os_strncmp(buf, "NFC_RX_HANDOVER_REQ ", 20) == 0) {
4854                 reply_len = wpas_ctrl_nfc_rx_handover_req(
4855                         wpa_s, buf + 20, reply, reply_size);
4856         } else if (os_strncmp(buf, "NFC_RX_HANDOVER_SEL ", 20) == 0) {
4857                 if (wpas_ctrl_nfc_rx_handover_sel(wpa_s, buf + 20))
4858                         reply_len = -1;
4859 #endif /* CONFIG_WPS_NFC */
4860         } else if (os_strncmp(buf, "WPS_REG ", 8) == 0) {
4861                 if (wpa_supplicant_ctrl_iface_wps_reg(wpa_s, buf + 8))
4862                         reply_len = -1;
4863 #ifdef CONFIG_AP
4864         } else if (os_strncmp(buf, "WPS_AP_PIN ", 11) == 0) {
4865                 reply_len = wpa_supplicant_ctrl_iface_wps_ap_pin(
4866                         wpa_s, buf + 11, reply, reply_size);
4867 #endif /* CONFIG_AP */
4868 #ifdef CONFIG_WPS_ER
4869         } else if (os_strcmp(buf, "WPS_ER_START") == 0) {
4870                 if (wpas_wps_er_start(wpa_s, NULL))
4871                         reply_len = -1;
4872         } else if (os_strncmp(buf, "WPS_ER_START ", 13) == 0) {
4873                 if (wpas_wps_er_start(wpa_s, buf + 13))
4874                         reply_len = -1;
4875         } else if (os_strcmp(buf, "WPS_ER_STOP") == 0) {
4876                 if (wpas_wps_er_stop(wpa_s))
4877                         reply_len = -1;
4878         } else if (os_strncmp(buf, "WPS_ER_PIN ", 11) == 0) {
4879                 if (wpa_supplicant_ctrl_iface_wps_er_pin(wpa_s, buf + 11))
4880                         reply_len = -1;
4881         } else if (os_strncmp(buf, "WPS_ER_PBC ", 11) == 0) {
4882                 int ret = wpas_wps_er_pbc(wpa_s, buf + 11);
4883                 if (ret == -2) {
4884                         os_memcpy(reply, "FAIL-PBC-OVERLAP\n", 17);
4885                         reply_len = 17;
4886                 } else if (ret == -3) {
4887                         os_memcpy(reply, "FAIL-UNKNOWN-UUID\n", 18);
4888                         reply_len = 18;
4889                 } else if (ret == -4) {
4890                         os_memcpy(reply, "FAIL-NO-AP-SETTINGS\n", 20);
4891                         reply_len = 20;
4892                 } else if (ret)
4893                         reply_len = -1;
4894         } else if (os_strncmp(buf, "WPS_ER_LEARN ", 13) == 0) {
4895                 if (wpa_supplicant_ctrl_iface_wps_er_learn(wpa_s, buf + 13))
4896                         reply_len = -1;
4897         } else if (os_strncmp(buf, "WPS_ER_SET_CONFIG ", 18) == 0) {
4898                 if (wpa_supplicant_ctrl_iface_wps_er_set_config(wpa_s,
4899                                                                 buf + 18))
4900                         reply_len = -1;
4901         } else if (os_strncmp(buf, "WPS_ER_CONFIG ", 14) == 0) {
4902                 if (wpa_supplicant_ctrl_iface_wps_er_config(wpa_s, buf + 14))
4903                         reply_len = -1;
4904 #ifdef CONFIG_WPS_NFC
4905         } else if (os_strncmp(buf, "WPS_ER_NFC_CONFIG_TOKEN ", 24) == 0) {
4906                 reply_len = wpa_supplicant_ctrl_iface_wps_er_nfc_config_token(
4907                         wpa_s, buf + 24, reply, reply_size);
4908 #endif /* CONFIG_WPS_NFC */
4909 #endif /* CONFIG_WPS_ER */
4910 #endif /* CONFIG_WPS */
4911 #ifdef CONFIG_IBSS_RSN
4912         } else if (os_strncmp(buf, "IBSS_RSN ", 9) == 0) {
4913                 if (wpa_supplicant_ctrl_iface_ibss_rsn(wpa_s, buf + 9))
4914                         reply_len = -1;
4915 #endif /* CONFIG_IBSS_RSN */
4916 #ifdef CONFIG_P2P
4917         } else if (os_strncmp(buf, "P2P_FIND ", 9) == 0) {
4918                 if (p2p_ctrl_find(wpa_s, buf + 9))
4919                         reply_len = -1;
4920         } else if (os_strcmp(buf, "P2P_FIND") == 0) {
4921                 if (p2p_ctrl_find(wpa_s, ""))
4922                         reply_len = -1;
4923         } else if (os_strcmp(buf, "P2P_STOP_FIND") == 0) {
4924                 wpas_p2p_stop_find(wpa_s);
4925         } else if (os_strncmp(buf, "P2P_CONNECT ", 12) == 0) {
4926                 reply_len = p2p_ctrl_connect(wpa_s, buf + 12, reply,
4927                                              reply_size);
4928         } else if (os_strncmp(buf, "P2P_LISTEN ", 11) == 0) {
4929                 if (p2p_ctrl_listen(wpa_s, buf + 11))
4930                         reply_len = -1;
4931         } else if (os_strcmp(buf, "P2P_LISTEN") == 0) {
4932                 if (p2p_ctrl_listen(wpa_s, ""))
4933                         reply_len = -1;
4934         } else if (os_strncmp(buf, "P2P_GROUP_REMOVE ", 17) == 0) {
4935                 if (wpas_p2p_group_remove(wpa_s, buf + 17))
4936                         reply_len = -1;
4937         } else if (os_strcmp(buf, "P2P_GROUP_ADD") == 0) {
4938                 if (wpas_p2p_group_add(wpa_s, 0, 0, 0))
4939                         reply_len = -1;
4940         } else if (os_strncmp(buf, "P2P_GROUP_ADD ", 14) == 0) {
4941                 if (p2p_ctrl_group_add(wpa_s, buf + 14))
4942                         reply_len = -1;
4943         } else if (os_strncmp(buf, "P2P_PROV_DISC ", 14) == 0) {
4944                 if (p2p_ctrl_prov_disc(wpa_s, buf + 14))
4945                         reply_len = -1;
4946         } else if (os_strcmp(buf, "P2P_GET_PASSPHRASE") == 0) {
4947                 reply_len = p2p_get_passphrase(wpa_s, reply, reply_size);
4948         } else if (os_strncmp(buf, "P2P_SERV_DISC_REQ ", 18) == 0) {
4949                 reply_len = p2p_ctrl_serv_disc_req(wpa_s, buf + 18, reply,
4950                                                    reply_size);
4951         } else if (os_strncmp(buf, "P2P_SERV_DISC_CANCEL_REQ ", 25) == 0) {
4952                 if (p2p_ctrl_serv_disc_cancel_req(wpa_s, buf + 25) < 0)
4953                         reply_len = -1;
4954         } else if (os_strncmp(buf, "P2P_SERV_DISC_RESP ", 19) == 0) {
4955                 if (p2p_ctrl_serv_disc_resp(wpa_s, buf + 19) < 0)
4956                         reply_len = -1;
4957         } else if (os_strcmp(buf, "P2P_SERVICE_UPDATE") == 0) {
4958                 wpas_p2p_sd_service_update(wpa_s);
4959         } else if (os_strncmp(buf, "P2P_SERV_DISC_EXTERNAL ", 23) == 0) {
4960                 if (p2p_ctrl_serv_disc_external(wpa_s, buf + 23) < 0)
4961                         reply_len = -1;
4962         } else if (os_strcmp(buf, "P2P_SERVICE_FLUSH") == 0) {
4963                 wpas_p2p_service_flush(wpa_s);
4964         } else if (os_strncmp(buf, "P2P_SERVICE_ADD ", 16) == 0) {
4965                 if (p2p_ctrl_service_add(wpa_s, buf + 16) < 0)
4966                         reply_len = -1;
4967         } else if (os_strncmp(buf, "P2P_SERVICE_DEL ", 16) == 0) {
4968                 if (p2p_ctrl_service_del(wpa_s, buf + 16) < 0)
4969                         reply_len = -1;
4970         } else if (os_strncmp(buf, "P2P_REJECT ", 11) == 0) {
4971                 if (p2p_ctrl_reject(wpa_s, buf + 11) < 0)
4972                         reply_len = -1;
4973         } else if (os_strncmp(buf, "P2P_INVITE ", 11) == 0) {
4974                 if (p2p_ctrl_invite(wpa_s, buf + 11) < 0)
4975                         reply_len = -1;
4976         } else if (os_strncmp(buf, "P2P_PEER ", 9) == 0) {
4977                 reply_len = p2p_ctrl_peer(wpa_s, buf + 9, reply,
4978                                               reply_size);
4979         } else if (os_strncmp(buf, "P2P_SET ", 8) == 0) {
4980                 if (p2p_ctrl_set(wpa_s, buf + 8) < 0)
4981                         reply_len = -1;
4982         } else if (os_strcmp(buf, "P2P_FLUSH") == 0) {
4983                 os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
4984                 wpa_s->force_long_sd = 0;
4985                 if (wpa_s->global->p2p)
4986                         p2p_flush(wpa_s->global->p2p);
4987         } else if (os_strncmp(buf, "P2P_UNAUTHORIZE ", 16) == 0) {
4988                 if (wpas_p2p_unauthorize(wpa_s, buf + 16) < 0)
4989                         reply_len = -1;
4990         } else if (os_strcmp(buf, "P2P_CANCEL") == 0) {
4991                 if (wpas_p2p_cancel(wpa_s))
4992                         reply_len = -1;
4993         } else if (os_strncmp(buf, "P2P_PRESENCE_REQ ", 17) == 0) {
4994                 if (p2p_ctrl_presence_req(wpa_s, buf + 17) < 0)
4995                         reply_len = -1;
4996         } else if (os_strcmp(buf, "P2P_PRESENCE_REQ") == 0) {
4997                 if (p2p_ctrl_presence_req(wpa_s, "") < 0)
4998                         reply_len = -1;
4999         } else if (os_strncmp(buf, "P2P_EXT_LISTEN ", 15) == 0) {
5000                 if (p2p_ctrl_ext_listen(wpa_s, buf + 15) < 0)
5001                         reply_len = -1;
5002         } else if (os_strcmp(buf, "P2P_EXT_LISTEN") == 0) {
5003                 if (p2p_ctrl_ext_listen(wpa_s, "") < 0)
5004                         reply_len = -1;
5005 #endif /* CONFIG_P2P */
5006 #ifdef CONFIG_WIFI_DISPLAY
5007         } else if (os_strncmp(buf, "WFD_SUBELEM_SET ", 16) == 0) {
5008                 if (wifi_display_subelem_set(wpa_s->global, buf + 16) < 0)
5009                         reply_len = -1;
5010         } else if (os_strncmp(buf, "WFD_SUBELEM_GET ", 16) == 0) {
5011                 reply_len = wifi_display_subelem_get(wpa_s->global, buf + 16,
5012                                                      reply, reply_size);
5013 #endif /* CONFIG_WIFI_DISPLAY */
5014 #ifdef CONFIG_INTERWORKING
5015         } else if (os_strcmp(buf, "FETCH_ANQP") == 0) {
5016                 if (interworking_fetch_anqp(wpa_s) < 0)
5017                         reply_len = -1;
5018         } else if (os_strcmp(buf, "STOP_FETCH_ANQP") == 0) {
5019                 interworking_stop_fetch_anqp(wpa_s);
5020         } else if (os_strncmp(buf, "INTERWORKING_SELECT", 19) == 0) {
5021                 if (interworking_select(wpa_s, os_strstr(buf + 19, "auto") !=
5022                                         NULL) < 0)
5023                         reply_len = -1;
5024         } else if (os_strncmp(buf, "INTERWORKING_CONNECT ", 21) == 0) {
5025                 if (ctrl_interworking_connect(wpa_s, buf + 21) < 0)
5026                         reply_len = -1;
5027         } else if (os_strncmp(buf, "ANQP_GET ", 9) == 0) {
5028                 if (get_anqp(wpa_s, buf + 9) < 0)
5029                         reply_len = -1;
5030         } else if (os_strncmp(buf, "GAS_REQUEST ", 12) == 0) {
5031                 if (gas_request(wpa_s, buf + 12) < 0)
5032                         reply_len = -1;
5033         } else if (os_strncmp(buf, "GAS_RESPONSE_GET ", 17) == 0) {
5034                 reply_len = gas_response_get(wpa_s, buf + 17, reply,
5035                                              reply_size);
5036 #endif /* CONFIG_INTERWORKING */
5037 #ifdef CONFIG_HS20
5038         } else if (os_strncmp(buf, "HS20_ANQP_GET ", 14) == 0) {
5039                 if (get_hs20_anqp(wpa_s, buf + 14) < 0)
5040                         reply_len = -1;
5041         } else if (os_strncmp(buf, "HS20_GET_NAI_HOME_REALM_LIST ", 29) == 0) {
5042                 if (hs20_get_nai_home_realm_list(wpa_s, buf + 29) < 0)
5043                         reply_len = -1;
5044 #endif /* CONFIG_HS20 */
5045         } else if (os_strncmp(buf, WPA_CTRL_RSP, os_strlen(WPA_CTRL_RSP)) == 0)
5046         {
5047                 if (wpa_supplicant_ctrl_iface_ctrl_rsp(
5048                             wpa_s, buf + os_strlen(WPA_CTRL_RSP)))
5049                         reply_len = -1;
5050                 else
5051                         ctrl_rsp = 1;
5052         } else if (os_strcmp(buf, "RECONFIGURE") == 0) {
5053                 if (wpa_supplicant_reload_configuration(wpa_s))
5054                         reply_len = -1;
5055         } else if (os_strcmp(buf, "TERMINATE") == 0) {
5056                 wpa_supplicant_terminate_proc(wpa_s->global);
5057         } else if (os_strncmp(buf, "BSSID ", 6) == 0) {
5058                 if (wpa_supplicant_ctrl_iface_bssid(wpa_s, buf + 6))
5059                         reply_len = -1;
5060         } else if (os_strncmp(buf, "BLACKLIST", 9) == 0) {
5061                 reply_len = wpa_supplicant_ctrl_iface_blacklist(
5062                         wpa_s, buf + 9, reply, reply_size);
5063         } else if (os_strncmp(buf, "LOG_LEVEL", 9) == 0) {
5064                 reply_len = wpa_supplicant_ctrl_iface_log_level(
5065                         wpa_s, buf + 9, reply, reply_size);
5066         } else if (os_strcmp(buf, "LIST_NETWORKS") == 0) {
5067                 reply_len = wpa_supplicant_ctrl_iface_list_networks(
5068                         wpa_s, reply, reply_size);
5069         } else if (os_strcmp(buf, "DISCONNECT") == 0) {
5070 #ifdef CONFIG_SME
5071                 wpa_s->sme.prev_bssid_set = 0;
5072 #endif /* CONFIG_SME */
5073                 wpa_s->reassociate = 0;
5074                 wpa_s->disconnected = 1;
5075                 wpa_supplicant_cancel_sched_scan(wpa_s);
5076                 wpa_supplicant_cancel_scan(wpa_s);
5077                 wpa_supplicant_deauthenticate(wpa_s,
5078                                               WLAN_REASON_DEAUTH_LEAVING);
5079         } else if (os_strcmp(buf, "SCAN") == 0) {
5080                 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
5081                         reply_len = -1;
5082                 else {
5083                         if (!wpa_s->scanning &&
5084                             ((wpa_s->wpa_state <= WPA_SCANNING) ||
5085                              (wpa_s->wpa_state == WPA_COMPLETED))) {
5086                                 wpa_s->normal_scans = 0;
5087                                 wpa_s->scan_req = MANUAL_SCAN_REQ;
5088                                 wpa_supplicant_req_scan(wpa_s, 0, 0);
5089                         } else if (wpa_s->sched_scanning) {
5090                                 wpa_printf(MSG_DEBUG, "Stop ongoing "
5091                                            "sched_scan to allow requested "
5092                                            "full scan to proceed");
5093                                 wpa_supplicant_cancel_sched_scan(wpa_s);
5094                                 wpa_s->scan_req = MANUAL_SCAN_REQ;
5095                                 wpa_supplicant_req_scan(wpa_s, 0, 0);
5096                         } else {
5097                                 wpa_printf(MSG_DEBUG, "Ongoing scan action - "
5098                                            "reject new request");
5099                                 reply_len = os_snprintf(reply, reply_size,
5100                                                         "FAIL-BUSY\n");
5101                         }
5102                 }
5103         } else if (os_strcmp(buf, "SCAN_RESULTS") == 0) {
5104                 reply_len = wpa_supplicant_ctrl_iface_scan_results(
5105                         wpa_s, reply, reply_size);
5106         } else if (os_strncmp(buf, "SELECT_NETWORK ", 15) == 0) {
5107                 if (wpa_supplicant_ctrl_iface_select_network(wpa_s, buf + 15))
5108                         reply_len = -1;
5109         } else if (os_strncmp(buf, "ENABLE_NETWORK ", 15) == 0) {
5110                 if (wpa_supplicant_ctrl_iface_enable_network(wpa_s, buf + 15))
5111                         reply_len = -1;
5112         } else if (os_strncmp(buf, "DISABLE_NETWORK ", 16) == 0) {
5113                 if (wpa_supplicant_ctrl_iface_disable_network(wpa_s, buf + 16))
5114                         reply_len = -1;
5115         } else if (os_strcmp(buf, "ADD_NETWORK") == 0) {
5116                 reply_len = wpa_supplicant_ctrl_iface_add_network(
5117                         wpa_s, reply, reply_size);
5118         } else if (os_strncmp(buf, "REMOVE_NETWORK ", 15) == 0) {
5119                 if (wpa_supplicant_ctrl_iface_remove_network(wpa_s, buf + 15))
5120                         reply_len = -1;
5121         } else if (os_strncmp(buf, "SET_NETWORK ", 12) == 0) {
5122                 if (wpa_supplicant_ctrl_iface_set_network(wpa_s, buf + 12))
5123                         reply_len = -1;
5124         } else if (os_strncmp(buf, "GET_NETWORK ", 12) == 0) {
5125                 reply_len = wpa_supplicant_ctrl_iface_get_network(
5126                         wpa_s, buf + 12, reply, reply_size);
5127         } else if (os_strcmp(buf, "LIST_CREDS") == 0) {
5128                 reply_len = wpa_supplicant_ctrl_iface_list_creds(
5129                         wpa_s, reply, reply_size);
5130         } else if (os_strcmp(buf, "ADD_CRED") == 0) {
5131                 reply_len = wpa_supplicant_ctrl_iface_add_cred(
5132                         wpa_s, reply, reply_size);
5133         } else if (os_strncmp(buf, "REMOVE_CRED ", 12) == 0) {
5134                 if (wpa_supplicant_ctrl_iface_remove_cred(wpa_s, buf + 12))
5135                         reply_len = -1;
5136         } else if (os_strncmp(buf, "SET_CRED ", 9) == 0) {
5137                 if (wpa_supplicant_ctrl_iface_set_cred(wpa_s, buf + 9))
5138                         reply_len = -1;
5139 #ifndef CONFIG_NO_CONFIG_WRITE
5140         } else if (os_strcmp(buf, "SAVE_CONFIG") == 0) {
5141                 if (wpa_supplicant_ctrl_iface_save_config(wpa_s))
5142                         reply_len = -1;
5143 #endif /* CONFIG_NO_CONFIG_WRITE */
5144         } else if (os_strncmp(buf, "GET_CAPABILITY ", 15) == 0) {
5145                 reply_len = wpa_supplicant_ctrl_iface_get_capability(
5146                         wpa_s, buf + 15, reply, reply_size);
5147         } else if (os_strncmp(buf, "AP_SCAN ", 8) == 0) {
5148                 if (wpa_supplicant_ctrl_iface_ap_scan(wpa_s, buf + 8))
5149                         reply_len = -1;
5150         } else if (os_strncmp(buf, "SCAN_INTERVAL ", 14) == 0) {
5151                 if (wpa_supplicant_ctrl_iface_scan_interval(wpa_s, buf + 14))
5152                         reply_len = -1;
5153         } else if (os_strcmp(buf, "INTERFACE_LIST") == 0) {
5154                 reply_len = wpa_supplicant_global_iface_list(
5155                         wpa_s->global, reply, reply_size);
5156         } else if (os_strcmp(buf, "INTERFACES") == 0) {
5157                 reply_len = wpa_supplicant_global_iface_interfaces(
5158                         wpa_s->global, reply, reply_size);
5159         } else if (os_strncmp(buf, "BSS ", 4) == 0) {
5160                 reply_len = wpa_supplicant_ctrl_iface_bss(
5161                         wpa_s, buf + 4, reply, reply_size);
5162 #ifdef CONFIG_AP
5163         } else if (os_strcmp(buf, "STA-FIRST") == 0) {
5164                 reply_len = ap_ctrl_iface_sta_first(wpa_s, reply, reply_size);
5165         } else if (os_strncmp(buf, "STA ", 4) == 0) {
5166                 reply_len = ap_ctrl_iface_sta(wpa_s, buf + 4, reply,
5167                                               reply_size);
5168         } else if (os_strncmp(buf, "STA-NEXT ", 9) == 0) {
5169                 reply_len = ap_ctrl_iface_sta_next(wpa_s, buf + 9, reply,
5170                                                    reply_size);
5171         } else if (os_strncmp(buf, "DEAUTHENTICATE ", 15) == 0) {
5172                 if (ap_ctrl_iface_sta_deauthenticate(wpa_s, buf + 15))
5173                         reply_len = -1;
5174         } else if (os_strncmp(buf, "DISASSOCIATE ", 13) == 0) {
5175                 if (ap_ctrl_iface_sta_disassociate(wpa_s, buf + 13))
5176                         reply_len = -1;
5177 #endif /* CONFIG_AP */
5178         } else if (os_strcmp(buf, "SUSPEND") == 0) {
5179                 wpas_notify_suspend(wpa_s->global);
5180         } else if (os_strcmp(buf, "RESUME") == 0) {
5181                 wpas_notify_resume(wpa_s->global);
5182         } else if (os_strcmp(buf, "DROP_SA") == 0) {
5183                 wpa_supplicant_ctrl_iface_drop_sa(wpa_s);
5184         } else if (os_strncmp(buf, "ROAM ", 5) == 0) {
5185                 if (wpa_supplicant_ctrl_iface_roam(wpa_s, buf + 5))
5186                         reply_len = -1;
5187         } else if (os_strncmp(buf, "STA_AUTOCONNECT ", 16) == 0) {
5188                 if (wpa_supplicant_ctrl_iface_sta_autoconnect(wpa_s, buf + 16))
5189                         reply_len = -1;
5190         } else if (os_strncmp(buf, "BSS_EXPIRE_AGE ", 15) == 0) {
5191                 if (wpa_supplicant_ctrl_iface_bss_expire_age(wpa_s, buf + 15))
5192                         reply_len = -1;
5193         } else if (os_strncmp(buf, "BSS_EXPIRE_COUNT ", 17) == 0) {
5194                 if (wpa_supplicant_ctrl_iface_bss_expire_count(wpa_s,
5195                                                                buf + 17))
5196                         reply_len = -1;
5197         } else if (os_strncmp(buf, "BSS_FLUSH ", 10) == 0) {
5198                 if (wpa_supplicant_ctrl_iface_bss_flush(wpa_s, buf + 10))
5199                         reply_len = -1;
5200 #ifdef CONFIG_TDLS
5201         } else if (os_strncmp(buf, "TDLS_DISCOVER ", 14) == 0) {
5202                 if (wpa_supplicant_ctrl_iface_tdls_discover(wpa_s, buf + 14))
5203                         reply_len = -1;
5204         } else if (os_strncmp(buf, "TDLS_SETUP ", 11) == 0) {
5205                 if (wpa_supplicant_ctrl_iface_tdls_setup(wpa_s, buf + 11))
5206                         reply_len = -1;
5207         } else if (os_strncmp(buf, "TDLS_TEARDOWN ", 14) == 0) {
5208                 if (wpa_supplicant_ctrl_iface_tdls_teardown(wpa_s, buf + 14))
5209                         reply_len = -1;
5210 #endif /* CONFIG_TDLS */
5211         } else if (os_strncmp(buf, "SIGNAL_POLL", 11) == 0) {
5212                 reply_len = wpa_supplicant_signal_poll(wpa_s, reply,
5213                                                        reply_size);
5214         } else if (os_strncmp(buf, "PKTCNT_POLL", 11) == 0) {
5215                 reply_len = wpa_supplicant_pktcnt_poll(wpa_s, reply,
5216                                                        reply_size);
5217 #ifdef CONFIG_AUTOSCAN
5218         } else if (os_strncmp(buf, "AUTOSCAN ", 9) == 0) {
5219                 if (wpa_supplicant_ctrl_iface_autoscan(wpa_s, buf + 9))
5220                         reply_len = -1;
5221 #endif /* CONFIG_AUTOSCAN */
5222         } else if (os_strcmp(buf, "REAUTHENTICATE") == 0) {
5223                 eapol_sm_request_reauth(wpa_s->eapol);
5224         } else {
5225                 os_memcpy(reply, "UNKNOWN COMMAND\n", 16);
5226                 reply_len = 16;
5227         }
5228
5229         if (reply_len < 0) {
5230                 os_memcpy(reply, "FAIL\n", 5);
5231                 reply_len = 5;
5232         }
5233
5234         if (ctrl_rsp)
5235                 eapol_sm_notify_ctrl_response(wpa_s->eapol);
5236
5237         *resp_len = reply_len;
5238         return reply;
5239 }
5240
5241
5242 static int wpa_supplicant_global_iface_add(struct wpa_global *global,
5243                                            char *cmd)
5244 {
5245         struct wpa_interface iface;
5246         char *pos;
5247
5248         /*
5249          * <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB<driver_param>
5250          * TAB<bridge_ifname>
5251          */
5252         wpa_printf(MSG_DEBUG, "CTRL_IFACE GLOBAL INTERFACE_ADD '%s'", cmd);
5253
5254         os_memset(&iface, 0, sizeof(iface));
5255
5256         do {
5257                 iface.ifname = pos = cmd;
5258                 pos = os_strchr(pos, '\t');
5259                 if (pos)
5260                         *pos++ = '\0';
5261                 if (iface.ifname[0] == '\0')
5262                         return -1;
5263                 if (pos == NULL)
5264                         break;
5265
5266                 iface.confname = pos;
5267                 pos = os_strchr(pos, '\t');
5268                 if (pos)
5269                         *pos++ = '\0';
5270                 if (iface.confname[0] == '\0')
5271                         iface.confname = NULL;
5272                 if (pos == NULL)
5273                         break;
5274
5275                 iface.driver = pos;
5276                 pos = os_strchr(pos, '\t');
5277                 if (pos)
5278                         *pos++ = '\0';
5279                 if (iface.driver[0] == '\0')
5280                         iface.driver = NULL;
5281                 if (pos == NULL)
5282                         break;
5283
5284                 iface.ctrl_interface = pos;
5285                 pos = os_strchr(pos, '\t');
5286                 if (pos)
5287                         *pos++ = '\0';
5288                 if (iface.ctrl_interface[0] == '\0')
5289                         iface.ctrl_interface = NULL;
5290                 if (pos == NULL)
5291                         break;
5292
5293                 iface.driver_param = pos;
5294                 pos = os_strchr(pos, '\t');
5295                 if (pos)
5296                         *pos++ = '\0';
5297                 if (iface.driver_param[0] == '\0')
5298                         iface.driver_param = NULL;
5299                 if (pos == NULL)
5300                         break;
5301
5302                 iface.bridge_ifname = pos;
5303                 pos = os_strchr(pos, '\t');
5304                 if (pos)
5305                         *pos++ = '\0';
5306                 if (iface.bridge_ifname[0] == '\0')
5307                         iface.bridge_ifname = NULL;
5308                 if (pos == NULL)
5309                         break;
5310         } while (0);
5311
5312         if (wpa_supplicant_get_iface(global, iface.ifname))
5313                 return -1;
5314
5315         return wpa_supplicant_add_iface(global, &iface) ? 0 : -1;
5316 }
5317
5318
5319 static int wpa_supplicant_global_iface_remove(struct wpa_global *global,
5320                                               char *cmd)
5321 {
5322         struct wpa_supplicant *wpa_s;
5323
5324         wpa_printf(MSG_DEBUG, "CTRL_IFACE GLOBAL INTERFACE_REMOVE '%s'", cmd);
5325
5326         wpa_s = wpa_supplicant_get_iface(global, cmd);
5327         if (wpa_s == NULL)
5328                 return -1;
5329         return wpa_supplicant_remove_iface(global, wpa_s, 0);
5330 }
5331
5332
5333 static void wpa_free_iface_info(struct wpa_interface_info *iface)
5334 {
5335         struct wpa_interface_info *prev;
5336
5337         while (iface) {
5338                 prev = iface;
5339                 iface = iface->next;
5340
5341                 os_free(prev->ifname);
5342                 os_free(prev->desc);
5343                 os_free(prev);
5344         }
5345 }
5346
5347
5348 static int wpa_supplicant_global_iface_list(struct wpa_global *global,
5349                                             char *buf, int len)
5350 {
5351         int i, res;
5352         struct wpa_interface_info *iface = NULL, *last = NULL, *tmp;
5353         char *pos, *end;
5354
5355         for (i = 0; wpa_drivers[i]; i++) {
5356                 struct wpa_driver_ops *drv = wpa_drivers[i];
5357                 if (drv->get_interfaces == NULL)
5358                         continue;
5359                 tmp = drv->get_interfaces(global->drv_priv[i]);
5360                 if (tmp == NULL)
5361                         continue;
5362
5363                 if (last == NULL)
5364                         iface = last = tmp;
5365                 else
5366                         last->next = tmp;
5367                 while (last->next)
5368                         last = last->next;
5369         }
5370
5371         pos = buf;
5372         end = buf + len;
5373         for (tmp = iface; tmp; tmp = tmp->next) {
5374                 res = os_snprintf(pos, end - pos, "%s\t%s\t%s\n",
5375                                   tmp->drv_name, tmp->ifname,
5376                                   tmp->desc ? tmp->desc : "");
5377                 if (res < 0 || res >= end - pos) {
5378                         *pos = '\0';
5379                         break;
5380                 }
5381                 pos += res;
5382         }
5383
5384         wpa_free_iface_info(iface);
5385
5386         return pos - buf;
5387 }
5388
5389
5390 static int wpa_supplicant_global_iface_interfaces(struct wpa_global *global,
5391                                                   char *buf, int len)
5392 {
5393         int res;
5394         char *pos, *end;
5395         struct wpa_supplicant *wpa_s;
5396
5397         wpa_s = global->ifaces;
5398         pos = buf;
5399         end = buf + len;
5400
5401         while (wpa_s) {
5402                 res = os_snprintf(pos, end - pos, "%s\n", wpa_s->ifname);
5403                 if (res < 0 || res >= end - pos) {
5404                         *pos = '\0';
5405                         break;
5406                 }
5407                 pos += res;
5408                 wpa_s = wpa_s->next;
5409         }
5410         return pos - buf;
5411 }
5412
5413
5414 char * wpa_supplicant_global_ctrl_iface_process(struct wpa_global *global,
5415                                                 char *buf, size_t *resp_len)
5416 {
5417         char *reply;
5418         const int reply_size = 2048;
5419         int reply_len;
5420         int level = MSG_DEBUG;
5421
5422         if (os_strcmp(buf, "PING") == 0)
5423                 level = MSG_EXCESSIVE;
5424         wpa_hexdump_ascii(level, "RX global ctrl_iface",
5425                           (const u8 *) buf, os_strlen(buf));
5426
5427         reply = os_malloc(reply_size);
5428         if (reply == NULL) {
5429                 *resp_len = 1;
5430                 return NULL;
5431         }
5432
5433         os_memcpy(reply, "OK\n", 3);
5434         reply_len = 3;
5435
5436         if (os_strcmp(buf, "PING") == 0) {
5437                 os_memcpy(reply, "PONG\n", 5);
5438                 reply_len = 5;
5439         } else if (os_strncmp(buf, "INTERFACE_ADD ", 14) == 0) {
5440                 if (wpa_supplicant_global_iface_add(global, buf + 14))
5441                         reply_len = -1;
5442         } else if (os_strncmp(buf, "INTERFACE_REMOVE ", 17) == 0) {
5443                 if (wpa_supplicant_global_iface_remove(global, buf + 17))
5444                         reply_len = -1;
5445         } else if (os_strcmp(buf, "INTERFACE_LIST") == 0) {
5446                 reply_len = wpa_supplicant_global_iface_list(
5447                         global, reply, reply_size);
5448         } else if (os_strcmp(buf, "INTERFACES") == 0) {
5449                 reply_len = wpa_supplicant_global_iface_interfaces(
5450                         global, reply, reply_size);
5451         } else if (os_strcmp(buf, "TERMINATE") == 0) {
5452                 wpa_supplicant_terminate_proc(global);
5453         } else if (os_strcmp(buf, "SUSPEND") == 0) {
5454                 wpas_notify_suspend(global);
5455         } else if (os_strcmp(buf, "RESUME") == 0) {
5456                 wpas_notify_resume(global);
5457         } else {
5458                 os_memcpy(reply, "UNKNOWN COMMAND\n", 16);
5459                 reply_len = 16;
5460         }
5461
5462         if (reply_len < 0) {
5463                 os_memcpy(reply, "FAIL\n", 5);
5464                 reply_len = 5;
5465         }
5466
5467         *resp_len = reply_len;
5468         return reply;
5469 }