wpa_supplicant/ap.c

   1 /*
   2  * WPA Supplicant - Basic AP mode support routines
   3  * Copyright (c) 2003-2009, Jouni Malinen <j@w1.fi>
   4  * Copyright (c) 2009, Atheros Communications
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * Alternatively, this software may be distributed under the terms of BSD
  11  * license.
  12  *
  13  * See README and COPYING for more details.
  14  */
  15
  16 #include "utils/includes.h"
  17
  18 #include "utils/common.h"
  19 #include "utils/eloop.h"
  20 #include "utils/uuid.h"
  21 #include "common/ieee802_11_defs.h"
  22 #include "common/wpa_ctrl.h"
  23 #include "ap/hostapd.h"
  24 #include "ap/ap_config.h"
  25 #include "ap/ap_drv_ops.h"
  26 #ifdef NEED_AP_MLME
  27 #include "ap/ieee802_11.h"
  28 #endif /* NEED_AP_MLME */
  29 #include "ap/beacon.h"
  30 #include "ap/ieee802_1x.h"
  31 #include "ap/wps_hostapd.h"
  32 #include "ap/ctrl_iface_ap.h"
  33 #include "eap_common/eap_defs.h"
  34 #include "eap_server/eap_methods.h"
  35 #include "eap_common/eap_wsc_common.h"
  36 #include "wps/wps.h"
  37 #include "common/ieee802_11_defs.h"
  38 #include "config_ssid.h"
  39 #include "config.h"
  40 #include "wpa_supplicant_i.h"
  41 #include "driver_i.h"
  42 #include "p2p_supplicant.h"
  43 #include "ap.h"
  44 #include "ap/sta_info.h"
  45 #include "notify.h"
  46
  47
  48 #ifdef CONFIG_WPS
  49 static void wpas_wps_ap_pin_timeout(void *eloop_data, void *user_ctx);
  50 #endif /* CONFIG_WPS */
  51
  52
  53 static int wpa_supplicant_conf_ap(struct wpa_supplicant *wpa_s,
  54                                   struct wpa_ssid *ssid,
  55                                   struct hostapd_config *conf)
  56 {
  57         struct hostapd_bss_config *bss = &conf->bss[0];
  58         int pairwise;
  59
  60         conf->driver = wpa_s->driver;
  61
  62         os_strlcpy(bss->iface, wpa_s->ifname, sizeof(bss->iface));
  63
  64         if (ssid->frequency == 0) {
  65                 /* default channel 11 */
  66                 conf->hw_mode = HOSTAPD_MODE_IEEE80211G;
  67                 conf->channel = 11;
  68         } else if (ssid->frequency >= 2412 && ssid->frequency <= 2472) {
  69                 conf->hw_mode = HOSTAPD_MODE_IEEE80211G;
  70                 conf->channel = (ssid->frequency - 2407) / 5;
  71         } else if ((ssid->frequency >= 5180 && ssid->frequency <= 5240) ||
  72                    (ssid->frequency >= 5745 && ssid->frequency <= 5825)) {
  73                 conf->hw_mode = HOSTAPD_MODE_IEEE80211A;
  74                 conf->channel = (ssid->frequency - 5000) / 5;
  75         } else {
  76                 wpa_printf(MSG_ERROR, "Unsupported AP mode frequency: %d MHz",
  77                            ssid->frequency);
  78                 return -1;
  79         }
  80
  81         /* TODO: enable HT if driver supports it;
  82          * drop to 11b if driver does not support 11g */
  83
  84 #ifdef CONFIG_P2P
  85         if (conf->hw_mode == HOSTAPD_MODE_IEEE80211G) {
  86                 /* Remove 802.11b rates from supported and basic rate sets */
  87                 int *list = os_malloc(4 * sizeof(int));
  88                 if (list) {
  89                         list[0] = 60;
  90                         list[1] = 120;
  91                         list[2] = 240;
  92                         list[3] = -1;
  93                 }
  94                 conf->basic_rates = list;
  95
  96                 list = os_malloc(9 * sizeof(int));
  97                 if (list) {
  98                         list[0] = 60;
  99                         list[1] = 90;
 100                         list[2] = 120;
 101                         list[3] = 180;
 102                         list[4] = 240;
 103                         list[5] = 360;
 104                         list[6] = 480;
 105                         list[7] = 540;
 106                         list[8] = -1;
 107                 }
 108                 conf->supported_rates = list;
 109         }
 110 #endif /* CONFIG_P2P */
 111
 112         if (ssid->ssid_len == 0) {
 113                 wpa_printf(MSG_ERROR, "No SSID configured for AP mode");
 114                 return -1;
 115         }
 116         os_memcpy(bss->ssid.ssid, ssid->ssid, ssid->ssid_len);
 117         bss->ssid.ssid[ssid->ssid_len] = '\0';
 118         bss->ssid.ssid_len = ssid->ssid_len;
 119         bss->ssid.ssid_set = 1;
 120
 121         if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt))
 122                 bss->wpa = ssid->proto;
 123         bss->wpa_key_mgmt = ssid->key_mgmt;
 124         bss->wpa_pairwise = ssid->pairwise_cipher;
 125         if (ssid->passphrase) {
 126                 bss->ssid.wpa_passphrase = os_strdup(ssid->passphrase);
 127         } else if (ssid->psk_set) {
 128                 os_free(bss->ssid.wpa_psk);
 129                 bss->ssid.wpa_psk = os_zalloc(sizeof(struct hostapd_wpa_psk));
 130                 if (bss->ssid.wpa_psk == NULL)
 131                         return -1;
 132                 os_memcpy(bss->ssid.wpa_psk->psk, ssid->psk, PMK_LEN);
 133                 bss->ssid.wpa_psk->group = 1;
 134         }
 135
 136         /* Select group cipher based on the enabled pairwise cipher suites */
 137         pairwise = 0;
 138         if (bss->wpa & 1)
 139                 pairwise |= bss->wpa_pairwise;
 140         if (bss->wpa & 2) {
 141                 if (bss->rsn_pairwise == 0)
 142                         bss->rsn_pairwise = bss->wpa_pairwise;
 143                 pairwise |= bss->rsn_pairwise;
 144         }
 145         if (pairwise & WPA_CIPHER_TKIP)
 146                 bss->wpa_group = WPA_CIPHER_TKIP;
 147         else
 148                 bss->wpa_group = WPA_CIPHER_CCMP;
 149
 150         if (bss->wpa && bss->ieee802_1x)
 151                 bss->ssid.security_policy = SECURITY_WPA;
 152         else if (bss->wpa)
 153                 bss->ssid.security_policy = SECURITY_WPA_PSK;
 154         else if (bss->ieee802_1x) {
 155                 bss->ssid.security_policy = SECURITY_IEEE_802_1X;
 156                 bss->ssid.wep.default_len = bss->default_wep_key_len;
 157         } else if (bss->ssid.wep.keys_set)
 158                 bss->ssid.security_policy = SECURITY_STATIC_WEP;
 159         else
 160                 bss->ssid.security_policy = SECURITY_PLAINTEXT;
 161
 162 #ifdef CONFIG_WPS
 163         /*
 164          * Enable WPS by default, but require user interaction to actually use
 165          * it. Only the internal Registrar is supported.
 166          */
 167         bss->eap_server = 1;
 168         bss->wps_state = 2;
 169         bss->ap_setup_locked = 2;
 170         if (wpa_s->conf->config_methods)
 171                 bss->config_methods = os_strdup(wpa_s->conf->config_methods);
 172         if (wpa_s->conf->device_type)
 173                 bss->device_type = os_strdup(wpa_s->conf->device_type);
 174         if (wpa_s->conf->device_name) {
 175                 bss->device_name = os_strdup(wpa_s->conf->device_name);
 176                 bss->friendly_name = os_strdup(wpa_s->conf->device_name);
 177         }
 178         if (wpa_s->conf->manufacturer)
 179                 bss->manufacturer = os_strdup(wpa_s->conf->manufacturer);
 180         if (wpa_s->conf->model_name)
 181                 bss->model_name = os_strdup(wpa_s->conf->model_name);
 182         if (wpa_s->conf->model_number)
 183                 bss->model_number = os_strdup(wpa_s->conf->model_number);
 184         if (wpa_s->conf->serial_number)
 185                 bss->serial_number = os_strdup(wpa_s->conf->serial_number);
 186         if (is_nil_uuid(wpa_s->conf->uuid))
 187                 os_memcpy(bss->uuid, wpa_s->wps->uuid, WPS_UUID_LEN);
 188         else
 189                 os_memcpy(bss->uuid, wpa_s->conf->uuid, WPS_UUID_LEN);
 190         os_memcpy(bss->os_version, wpa_s->conf->os_version, 4);
 191 #endif /* CONFIG_WPS */
 192
 193         if (wpa_s->max_stations &&
 194             wpa_s->max_stations < wpa_s->conf->max_num_sta)
 195                 bss->max_num_sta = wpa_s->max_stations;
 196         else
 197                 bss->max_num_sta = wpa_s->conf->max_num_sta;
 198
 199         bss->disassoc_low_ack = wpa_s->conf->disassoc_low_ack;
 200
 201         return 0;
 202 }
 203
 204
 205 static void ap_public_action_rx(void *ctx, const u8 *buf, size_t len, int freq)
 206 {
 207 #ifdef CONFIG_P2P
 208         struct wpa_supplicant *wpa_s = ctx;
 209         const struct ieee80211_mgmt *mgmt;
 210         size_t hdr_len;
 211
 212         mgmt = (const struct ieee80211_mgmt *) buf;
 213         hdr_len = (const u8 *) &mgmt->u.action.u.vs_public_action.action - buf;
 214         if (hdr_len > len)
 215                 return;
 216         wpas_p2p_rx_action(wpa_s, mgmt->da, mgmt->sa, mgmt->bssid,
 217                            mgmt->u.action.category,
 218                            &mgmt->u.action.u.vs_public_action.action,
 219                            len - hdr_len, freq);
 220 #endif /* CONFIG_P2P */
 221 }
 222
 223
 224 static void ap_wps_event_cb(void *ctx, enum wps_event event,
 225                             union wps_event_data *data)
 226 {
 227 #ifdef CONFIG_P2P
 228         struct wpa_supplicant *wpa_s = ctx;
 229
 230         if (event == WPS_EV_FAIL && wpa_s->parent && wpa_s->parent != wpa_s &&
 231             wpa_s == wpa_s->global->p2p_group_formation) {
 232                 struct wps_event_fail *fail = &data->fail;
 233
 234                 /*
 235                  * src/ap/wps_hostapd.c has already sent this on the main
 236                  * interface, so only send on the parent interface here if
 237                  * needed.
 238                  */
 239                 wpa_msg(wpa_s->parent, MSG_INFO, WPS_EVENT_FAIL
 240                         "msg=%d config_error=%d",
 241                         fail->msg, fail->config_error);
 242         }
 243 #endif /* CONFIG_P2P */
 244 }
 245
 246
 247 static void ap_sta_authorized_cb(void *ctx, const u8 *mac_addr,
 248                                  int authorized)
 249 {
 250         wpas_notify_sta_authorized(ctx, mac_addr, authorized);
 251 }
 252
 253
 254 static int ap_vendor_action_rx(void *ctx, const u8 *buf, size_t len, int freq)
 255 {
 256 #ifdef CONFIG_P2P
 257         struct wpa_supplicant *wpa_s = ctx;
 258         const struct ieee80211_mgmt *mgmt;
 259         size_t hdr_len;
 260
 261         mgmt = (const struct ieee80211_mgmt *) buf;
 262         hdr_len = (const u8 *) &mgmt->u.action.u.vs_public_action.action - buf;
 263         if (hdr_len > len)
 264                 return -1;
 265         wpas_p2p_rx_action(wpa_s, mgmt->da, mgmt->sa, mgmt->bssid,
 266                            mgmt->u.action.category,
 267                            &mgmt->u.action.u.vs_public_action.action,
 268                            len - hdr_len, freq);
 269 #endif /* CONFIG_P2P */
 270         return 0;
 271 }
 272
 273
 274 static int ap_probe_req_rx(void *ctx, const u8 *addr, const u8 *ie,
 275                            size_t ie_len)
 276 {
 277 #ifdef CONFIG_P2P
 278         struct wpa_supplicant *wpa_s = ctx;
 279         return wpas_p2p_probe_req_rx(wpa_s, addr, ie, ie_len);
 280 #else /* CONFIG_P2P */
 281         return 0;
 282 #endif /* CONFIG_P2P */
 283 }
 284
 285
 286 static void ap_wps_reg_success_cb(void *ctx, const u8 *mac_addr,
 287                                   const u8 *uuid_e)
 288 {
 289 #ifdef CONFIG_P2P
 290         struct wpa_supplicant *wpa_s = ctx;
 291         wpas_p2p_wps_success(wpa_s, mac_addr, 1);
 292 #endif /* CONFIG_P2P */
 293 }
 294
 295
 296 int wpa_supplicant_create_ap(struct wpa_supplicant *wpa_s,
 297                              struct wpa_ssid *ssid)
 298 {
 299         struct wpa_driver_associate_params params;
 300         struct hostapd_iface *hapd_iface;
 301         struct hostapd_config *conf;
 302         size_t i;
 303
 304         if (ssid->ssid == NULL || ssid->ssid_len == 0) {
 305                 wpa_printf(MSG_ERROR, "No SSID configured for AP mode");
 306                 return -1;
 307         }
 308
 309         wpa_supplicant_ap_deinit(wpa_s);
 310
 311         wpa_printf(MSG_DEBUG, "Setting up AP (SSID='%s')",
 312                    wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
 313
 314         os_memset(&params, 0, sizeof(params));
 315         params.ssid = ssid->ssid;
 316         params.ssid_len = ssid->ssid_len;
 317         switch (ssid->mode) {
 318         case WPAS_MODE_INFRA:
 319                 params.mode = IEEE80211_MODE_INFRA;
 320                 break;
 321         case WPAS_MODE_IBSS:
 322                 params.mode = IEEE80211_MODE_IBSS;
 323                 break;
 324         case WPAS_MODE_AP:
 325         case WPAS_MODE_P2P_GO:
 326         case WPAS_MODE_P2P_GROUP_FORMATION:
 327                 params.mode = IEEE80211_MODE_AP;
 328                 break;
 329         }
 330         params.freq = ssid->frequency;
 331
 332         if (ssid->key_mgmt & WPA_KEY_MGMT_PSK)
 333                 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
 334         else
 335                 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
 336         params.key_mgmt_suite = key_mgmt2driver(wpa_s->key_mgmt);
 337
 338         if (ssid->pairwise_cipher & WPA_CIPHER_CCMP)
 339                 wpa_s->pairwise_cipher = WPA_CIPHER_CCMP;
 340         else if (ssid->pairwise_cipher & WPA_CIPHER_TKIP)
 341                 wpa_s->pairwise_cipher = WPA_CIPHER_TKIP;
 342         else if (ssid->pairwise_cipher & WPA_CIPHER_NONE)
 343                 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
 344         else {
 345                 wpa_printf(MSG_WARNING, "WPA: Failed to select pairwise "
 346                            "cipher.");
 347                 return -1;
 348         }
 349         params.pairwise_suite = cipher_suite2driver(wpa_s->pairwise_cipher);
 350         params.group_suite = params.pairwise_suite;
 351
 352 #ifdef CONFIG_P2P
 353         if (ssid->mode == WPAS_MODE_P2P_GO ||
 354             ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION)
 355                 params.p2p = 1;
 356         wpa_drv_set_intra_bss(wpa_s, wpa_s->conf->p2p_intra_bss);
 357 #endif /* CONFIG_P2P */
 358
 359         if (wpa_s->parent->set_ap_uapsd)
 360                 params.uapsd = wpa_s->parent->ap_uapsd;
 361         else
 362                 params.uapsd = -1;
 363
 364         if (wpa_drv_associate(wpa_s, &params) < 0) {
 365                 wpa_msg(wpa_s, MSG_INFO, "Failed to start AP functionality");
 366                 return -1;
 367         }
 368
 369         wpa_s->ap_iface = hapd_iface = os_zalloc(sizeof(*wpa_s->ap_iface));
 370         if (hapd_iface == NULL)
 371                 return -1;
 372         hapd_iface->owner = wpa_s;
 373
 374         wpa_s->ap_iface->conf = conf = hostapd_config_defaults();
 375         if (conf == NULL) {
 376                 wpa_supplicant_ap_deinit(wpa_s);
 377                 return -1;
 378         }
 379
 380         if (wpa_supplicant_conf_ap(wpa_s, ssid, conf)) {
 381                 wpa_printf(MSG_ERROR, "Failed to create AP configuration");
 382                 wpa_supplicant_ap_deinit(wpa_s);
 383                 return -1;
 384         }
 385
 386 #ifdef CONFIG_P2P
 387         if (ssid->mode == WPAS_MODE_P2P_GO)
 388                 conf->bss[0].p2p = P2P_ENABLED | P2P_GROUP_OWNER;
 389         else if (ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION)
 390                 conf->bss[0].p2p = P2P_ENABLED | P2P_GROUP_OWNER |
 391                         P2P_GROUP_FORMATION;
 392 #endif /* CONFIG_P2P */
 393
 394         hapd_iface->num_bss = conf->num_bss;
 395         hapd_iface->bss = os_zalloc(conf->num_bss *
 396                                     sizeof(struct hostapd_data *));
 397         if (hapd_iface->bss == NULL) {
 398                 wpa_supplicant_ap_deinit(wpa_s);
 399                 return -1;
 400         }
 401
 402         for (i = 0; i < conf->num_bss; i++) {
 403                 hapd_iface->bss[i] =
 404                         hostapd_alloc_bss_data(hapd_iface, conf,
 405                                                &conf->bss[i]);
 406                 if (hapd_iface->bss[i] == NULL) {
 407                         wpa_supplicant_ap_deinit(wpa_s);
 408                         return -1;
 409                 }
 410
 411                 hapd_iface->bss[i]->msg_ctx = wpa_s;
 412                 hapd_iface->bss[i]->public_action_cb = ap_public_action_rx;
 413                 hapd_iface->bss[i]->public_action_cb_ctx = wpa_s;
 414                 hapd_iface->bss[i]->vendor_action_cb = ap_vendor_action_rx;
 415                 hapd_iface->bss[i]->vendor_action_cb_ctx = wpa_s;
 416                 hostapd_register_probereq_cb(hapd_iface->bss[i],
 417                                              ap_probe_req_rx, wpa_s);
 418                 hapd_iface->bss[i]->wps_reg_success_cb = ap_wps_reg_success_cb;
 419                 hapd_iface->bss[i]->wps_reg_success_cb_ctx = wpa_s;
 420                 hapd_iface->bss[i]->wps_event_cb = ap_wps_event_cb;
 421                 hapd_iface->bss[i]->wps_event_cb_ctx = wpa_s;
 422                 hapd_iface->bss[i]->sta_authorized_cb = ap_sta_authorized_cb;
 423                 hapd_iface->bss[i]->sta_authorized_cb_ctx = wpa_s;
 424 #ifdef CONFIG_P2P
 425                 hapd_iface->bss[i]->p2p = wpa_s->global->p2p;
 426                 hapd_iface->bss[i]->p2p_group = wpas_p2p_group_init(
 427                         wpa_s, ssid->p2p_persistent_group,
 428                         ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION);
 429 #endif /* CONFIG_P2P */
 430         }
 431
 432         os_memcpy(hapd_iface->bss[0]->own_addr, wpa_s->own_addr, ETH_ALEN);
 433         hapd_iface->bss[0]->driver = wpa_s->driver;
 434         hapd_iface->bss[0]->drv_priv = wpa_s->drv_priv;
 435
 436         if (hostapd_setup_interface(wpa_s->ap_iface)) {
 437                 wpa_printf(MSG_ERROR, "Failed to initialize AP interface");
 438                 wpa_supplicant_ap_deinit(wpa_s);
 439                 return -1;
 440         }
 441
 442         wpa_s->current_ssid = ssid;
 443         os_memcpy(wpa_s->bssid, wpa_s->own_addr, ETH_ALEN);
 444         wpa_s->assoc_freq = ssid->frequency;
 445         wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
 446
 447         if (wpa_s->ap_configured_cb)
 448                 wpa_s->ap_configured_cb(wpa_s->ap_configured_cb_ctx,
 449                                         wpa_s->ap_configured_cb_data);
 450
 451         return 0;
 452 }
 453
 454
 455 void wpa_supplicant_ap_deinit(struct wpa_supplicant *wpa_s)
 456 {
 457 #ifdef CONFIG_WPS
 458         eloop_cancel_timeout(wpas_wps_ap_pin_timeout, wpa_s, NULL);
 459 #endif /* CONFIG_WPS */
 460
 461         if (wpa_s->ap_iface == NULL)
 462                 return;
 463
 464         wpa_s->current_ssid = NULL;
 465         wpa_s->assoc_freq = 0;
 466 #ifdef CONFIG_P2P
 467         if (wpa_s->ap_iface->bss)
 468                 wpa_s->ap_iface->bss[0]->p2p_group = NULL;
 469         wpas_p2p_group_deinit(wpa_s);
 470 #endif /* CONFIG_P2P */
 471         hostapd_interface_deinit(wpa_s->ap_iface);
 472         hostapd_interface_free(wpa_s->ap_iface);
 473         wpa_s->ap_iface = NULL;
 474         wpa_drv_deinit_ap(wpa_s);
 475 }
 476
 477
 478 void ap_tx_status(void *ctx, const u8 *addr,
 479                   const u8 *buf, size_t len, int ack)
 480 {
 481 #ifdef NEED_AP_MLME
 482         struct wpa_supplicant *wpa_s = ctx;
 483         hostapd_tx_status(wpa_s->ap_iface->bss[0], addr, buf, len, ack);
 484 #endif /* NEED_AP_MLME */
 485 }
 486
 487
 488 void ap_rx_from_unknown_sta(void *ctx, const u8 *frame, size_t len)
 489 {
 490 #ifdef NEED_AP_MLME
 491         struct wpa_supplicant *wpa_s = ctx;
 492         const struct ieee80211_hdr *hdr =
 493                 (const struct ieee80211_hdr *) frame;
 494         u16 fc = le_to_host16(hdr->frame_control);
 495         ieee802_11_rx_from_unknown(wpa_s->ap_iface->bss[0], hdr->addr2,
 496                                    (fc & (WLAN_FC_TODS | WLAN_FC_FROMDS)) ==
 497                                    (WLAN_FC_TODS | WLAN_FC_FROMDS));
 498 #endif /* NEED_AP_MLME */
 499 }
 500
 501
 502 void ap_mgmt_rx(void *ctx, struct rx_mgmt *rx_mgmt)
 503 {
 504 #ifdef NEED_AP_MLME
 505         struct wpa_supplicant *wpa_s = ctx;
 506         struct hostapd_frame_info fi;
 507         os_memset(&fi, 0, sizeof(fi));
 508         fi.datarate = rx_mgmt->datarate;
 509         fi.ssi_signal = rx_mgmt->ssi_signal;
 510         ieee802_11_mgmt(wpa_s->ap_iface->bss[0], rx_mgmt->frame,
 511                         rx_mgmt->frame_len, &fi);
 512 #endif /* NEED_AP_MLME */
 513 }
 514
 515
 516 void ap_mgmt_tx_cb(void *ctx, const u8 *buf, size_t len, u16 stype, int ok)
 517 {
 518 #ifdef NEED_AP_MLME
 519         struct wpa_supplicant *wpa_s = ctx;
 520         ieee802_11_mgmt_cb(wpa_s->ap_iface->bss[0], buf, len, stype, ok);
 521 #endif /* NEED_AP_MLME */
 522 }
 523
 524
 525 void wpa_supplicant_ap_rx_eapol(struct wpa_supplicant *wpa_s,
 526                                 const u8 *src_addr, const u8 *buf, size_t len)
 527 {
 528         ieee802_1x_receive(wpa_s->ap_iface->bss[0], src_addr, buf, len);
 529 }
 530
 531
 532 #ifdef CONFIG_WPS
 533
 534 int wpa_supplicant_ap_wps_pbc(struct wpa_supplicant *wpa_s, const u8 *bssid,
 535                               const u8 *p2p_dev_addr)
 536 {
 537         if (!wpa_s->ap_iface)
 538                 return -1;
 539         return hostapd_wps_button_pushed(wpa_s->ap_iface->bss[0],
 540                                          p2p_dev_addr);
 541 }
 542
 543
 544 static int wpa_supplicant_ap_wps_sta_cancel(struct hostapd_data *hapd,
 545                                             struct sta_info *sta, void *ctx)
 546 {
 547         if (sta && (sta->flags & WLAN_STA_WPS)) {
 548                 ap_sta_deauthenticate(hapd, sta,
 549                                       WLAN_REASON_PREV_AUTH_NOT_VALID);
 550                 wpa_printf(MSG_DEBUG, "WPS: %s: Deauth sta=" MACSTR,
 551                            __func__, MAC2STR(sta->addr));
 552                 return 1;
 553         }
 554
 555         return 0;
 556 }
 557
 558
 559 int wpa_supplicant_ap_wps_cancel(struct wpa_supplicant *wpa_s)
 560 {
 561         struct wps_registrar *reg;
 562         int reg_sel = 0, wps_sta = 0;
 563
 564         if (!wpa_s->ap_iface || !wpa_s->ap_iface->bss[0]->wps)
 565                 return -1;
 566
 567         reg = wpa_s->ap_iface->bss[0]->wps->registrar;
 568         reg_sel = wps_registrar_wps_cancel(reg);
 569         wps_sta = ap_for_each_sta(wpa_s->ap_iface->bss[0],
 570                                   wpa_supplicant_ap_wps_sta_cancel, NULL);
 571
 572         if (!reg_sel && !wps_sta) {
 573                 wpa_printf(MSG_DEBUG, "No WPS operation in progress at this "
 574                            "time");
 575                 return -1;
 576         }
 577
 578         /*
 579          * There are 2 cases to return wps cancel as success:
 580          * 1. When wps cancel was initiated but no connection has been
 581          *    established with client yet.
 582          * 2. Client is in the middle of exchanging WPS messages.
 583          */
 584
 585         return 0;
 586 }
 587
 588
 589 int wpa_supplicant_ap_wps_pin(struct wpa_supplicant *wpa_s, const u8 *bssid,
 590                               const char *pin, char *buf, size_t buflen)
 591 {
 592         int ret, ret_len = 0;
 593
 594         if (!wpa_s->ap_iface)
 595                 return -1;
 596
 597         if (pin == NULL) {
 598                 unsigned int rpin = wps_generate_pin();
 599                 ret_len = os_snprintf(buf, buflen, "%d", rpin);
 600                 pin = buf;
 601         } else
 602                 ret_len = os_snprintf(buf, buflen, "%s", pin);
 603
 604         ret = hostapd_wps_add_pin(wpa_s->ap_iface->bss[0], bssid, "any", pin,
 605                                   0);
 606         if (ret)
 607                 return -1;
 608         return ret_len;
 609 }
 610
 611
 612 static void wpas_wps_ap_pin_timeout(void *eloop_data, void *user_ctx)
 613 {
 614         struct wpa_supplicant *wpa_s = eloop_data;
 615         wpa_printf(MSG_DEBUG, "WPS: AP PIN timed out");
 616         wpas_wps_ap_pin_disable(wpa_s);
 617 }
 618
 619
 620 static void wpas_wps_ap_pin_enable(struct wpa_supplicant *wpa_s, int timeout)
 621 {
 622         struct hostapd_data *hapd;
 623
 624         if (wpa_s->ap_iface == NULL)
 625                 return;
 626         hapd = wpa_s->ap_iface->bss[0];
 627         wpa_printf(MSG_DEBUG, "WPS: Enabling AP PIN (timeout=%d)", timeout);
 628         hapd->ap_pin_failures = 0;
 629         eloop_cancel_timeout(wpas_wps_ap_pin_timeout, wpa_s, NULL);
 630         if (timeout > 0)
 631                 eloop_register_timeout(timeout, 0,
 632                                        wpas_wps_ap_pin_timeout, wpa_s, NULL);
 633 }
 634
 635
 636 void wpas_wps_ap_pin_disable(struct wpa_supplicant *wpa_s)
 637 {
 638         struct hostapd_data *hapd;
 639
 640         if (wpa_s->ap_iface == NULL)
 641                 return;
 642         wpa_printf(MSG_DEBUG, "WPS: Disabling AP PIN");
 643         hapd = wpa_s->ap_iface->bss[0];
 644         os_free(hapd->conf->ap_pin);
 645         hapd->conf->ap_pin = NULL;
 646         eloop_cancel_timeout(wpas_wps_ap_pin_timeout, wpa_s, NULL);
 647 }
 648
 649
 650 const char * wpas_wps_ap_pin_random(struct wpa_supplicant *wpa_s, int timeout)
 651 {
 652         struct hostapd_data *hapd;
 653         unsigned int pin;
 654         char pin_txt[9];
 655
 656         if (wpa_s->ap_iface == NULL)
 657                 return NULL;
 658         hapd = wpa_s->ap_iface->bss[0];
 659         pin = wps_generate_pin();
 660         os_snprintf(pin_txt, sizeof(pin_txt), "%u", pin);
 661         os_free(hapd->conf->ap_pin);
 662         hapd->conf->ap_pin = os_strdup(pin_txt);
 663         if (hapd->conf->ap_pin == NULL)
 664                 return NULL;
 665         wpas_wps_ap_pin_enable(wpa_s, timeout);
 666
 667         return hapd->conf->ap_pin;
 668 }
 669
 670
 671 const char * wpas_wps_ap_pin_get(struct wpa_supplicant *wpa_s)
 672 {
 673         struct hostapd_data *hapd;
 674         if (wpa_s->ap_iface == NULL)
 675                 return NULL;
 676         hapd = wpa_s->ap_iface->bss[0];
 677         return hapd->conf->ap_pin;
 678 }
 679
 680
 681 int wpas_wps_ap_pin_set(struct wpa_supplicant *wpa_s, const char *pin,
 682                         int timeout)
 683 {
 684         struct hostapd_data *hapd;
 685         char pin_txt[9];
 686         int ret;
 687
 688         if (wpa_s->ap_iface == NULL)
 689                 return -1;
 690         hapd = wpa_s->ap_iface->bss[0];
 691         ret = os_snprintf(pin_txt, sizeof(pin_txt), "%s", pin);
 692         if (ret < 0 || ret >= (int) sizeof(pin_txt))
 693                 return -1;
 694         os_free(hapd->conf->ap_pin);
 695         hapd->conf->ap_pin = os_strdup(pin_txt);
 696         if (hapd->conf->ap_pin == NULL)
 697                 return -1;
 698         wpas_wps_ap_pin_enable(wpa_s, timeout);
 699
 700         return 0;
 701 }
 702
 703
 704 void wpa_supplicant_ap_pwd_auth_fail(struct wpa_supplicant *wpa_s)
 705 {
 706         struct hostapd_data *hapd;
 707
 708         if (wpa_s->ap_iface == NULL)
 709                 return;
 710         hapd = wpa_s->ap_iface->bss[0];
 711
 712         /*
 713          * Registrar failed to prove its knowledge of the AP PIN. Disable AP
 714          * PIN if this happens multiple times to slow down brute force attacks.
 715          */
 716         hapd->ap_pin_failures++;
 717         wpa_printf(MSG_DEBUG, "WPS: AP PIN authentication failure number %u",
 718                    hapd->ap_pin_failures);
 719         if (hapd->ap_pin_failures < 3)
 720                 return;
 721
 722         wpa_printf(MSG_DEBUG, "WPS: Disable AP PIN");
 723         hapd->ap_pin_failures = 0;
 724         os_free(hapd->conf->ap_pin);
 725         hapd->conf->ap_pin = NULL;
 726 }
 727
 728 #endif /* CONFIG_WPS */
 729
 730
 731 #ifdef CONFIG_CTRL_IFACE
 732
 733 int ap_ctrl_iface_sta_first(struct wpa_supplicant *wpa_s,
 734                             char *buf, size_t buflen)
 735 {
 736         if (wpa_s->ap_iface == NULL)
 737                 return -1;
 738         return hostapd_ctrl_iface_sta_first(wpa_s->ap_iface->bss[0],
 739                                             buf, buflen);
 740 }
 741
 742
 743 int ap_ctrl_iface_sta(struct wpa_supplicant *wpa_s, const char *txtaddr,
 744                       char *buf, size_t buflen)
 745 {
 746         if (wpa_s->ap_iface == NULL)
 747                 return -1;
 748         return hostapd_ctrl_iface_sta(wpa_s->ap_iface->bss[0], txtaddr,
 749                                       buf, buflen);
 750 }
 751
 752
 753 int ap_ctrl_iface_sta_next(struct wpa_supplicant *wpa_s, const char *txtaddr,
 754                            char *buf, size_t buflen)
 755 {
 756         if (wpa_s->ap_iface == NULL)
 757                 return -1;
 758         return hostapd_ctrl_iface_sta_next(wpa_s->ap_iface->bss[0], txtaddr,
 759                                            buf, buflen);
 760 }
 761
 762
 763 int ap_ctrl_iface_wpa_get_status(struct wpa_supplicant *wpa_s, char *buf,
 764                                  size_t buflen, int verbose)
 765 {
 766         char *pos = buf, *end = buf + buflen;
 767         int ret;
 768         struct hostapd_bss_config *conf;
 769
 770         if (wpa_s->ap_iface == NULL)
 771                 return -1;
 772
 773         conf = wpa_s->ap_iface->bss[0]->conf;
 774         if (conf->wpa == 0)
 775                 return 0;
 776
 777         ret = os_snprintf(pos, end - pos,
 778                           "pairwise_cipher=%s\n"
 779                           "group_cipher=%s\n"
 780                           "key_mgmt=%s\n",
 781                           wpa_cipher_txt(conf->rsn_pairwise),
 782                           wpa_cipher_txt(conf->wpa_group),
 783                           wpa_key_mgmt_txt(conf->wpa_key_mgmt,
 784                                            conf->wpa));
 785         if (ret < 0 || ret >= end - pos)
 786                 return pos - buf;
 787         pos += ret;
 788         return pos - buf;
 789 }
 790
 791 #endif /* CONFIG_CTRL_IFACE */
 792
 793
 794 int wpa_supplicant_ap_update_beacon(struct wpa_supplicant *wpa_s)
 795 {
 796         struct hostapd_iface *iface = wpa_s->ap_iface;
 797         struct wpa_ssid *ssid = wpa_s->current_ssid;
 798         struct hostapd_data *hapd;
 799
 800         if (ssid == NULL || wpa_s->ap_iface == NULL)
 801                 return -1;
 802
 803 #ifdef CONFIG_P2P
 804         if (ssid->mode == WPAS_MODE_P2P_GO)
 805                 iface->conf->bss[0].p2p = P2P_ENABLED | P2P_GROUP_OWNER;
 806         else if (ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION)
 807                 iface->conf->bss[0].p2p = P2P_ENABLED | P2P_GROUP_OWNER |
 808                         P2P_GROUP_FORMATION;
 809 #endif /* CONFIG_P2P */
 810
 811         ieee802_11_set_beacons(iface);
 812         hapd = iface->bss[0];
 813         hostapd_set_ap_wps_ie(hapd);
 814
 815         return 0;
 816 }
 817
 818
 819 int wpa_supplicant_ap_mac_addr_filter(struct wpa_supplicant *wpa_s,
 820                                       const u8 *addr)
 821 {
 822         struct hostapd_data *hapd;
 823         struct hostapd_bss_config *conf;
 824
 825         if (!wpa_s->ap_iface)
 826                 return -1;
 827
 828         if (addr)
 829                 wpa_printf(MSG_DEBUG, "AP: Set MAC address filter: " MACSTR,
 830                            MAC2STR(addr));
 831         else
 832                 wpa_printf(MSG_DEBUG, "AP: Clear MAC address filter");
 833
 834         hapd = wpa_s->ap_iface->bss[0];
 835         conf = hapd->conf;
 836
 837         os_free(conf->accept_mac);
 838         conf->accept_mac = NULL;
 839         conf->num_accept_mac = 0;
 840         os_free(conf->deny_mac);
 841         conf->deny_mac = NULL;
 842         conf->num_deny_mac = 0;
 843
 844         if (addr == NULL) {
 845                 conf->macaddr_acl = ACCEPT_UNLESS_DENIED;
 846                 return 0;
 847         }
 848
 849         conf->macaddr_acl = DENY_UNLESS_ACCEPTED;
 850         conf->accept_mac = os_zalloc(sizeof(struct mac_acl_entry));
 851         if (conf->accept_mac == NULL)
 852                 return -1;
 853         os_memcpy(conf->accept_mac[0].addr, addr, ETH_ALEN);
 854         conf->num_accept_mac = 1;
 855
 856         return 0;
 857 }