[thirdparty/hostap.git] / wpa_supplicant / ap.c

/*
 * WPA Supplicant - Basic AP mode support routines
 * Copyright (c) 2003-2009, Jouni Malinen <j@w1.fi>
 * Copyright (c) 2009, Atheros Communications
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Alternatively, this software may be distributed under the terms of BSD
 * license.
 *
 * See README and COPYING for more details.
 */

#include "includes.h"

#include "common.h"
#include "../hostapd/hostapd.h"
#include "../hostapd/config.h"
#ifdef NEED_MLME
#include "../hostapd/ieee802_11.h"
#endif /* NEED_MLME */
#include "eap_common/eap_defs.h"
#include "eap_server/eap_methods.h"
#include "eap_common/eap_wsc_common.h"
#include "config_ssid.h"
#include "wpa_supplicant_i.h"
#include "driver_i.h"
#include "ap.h"


int hostapd_for_each_interface(int (*cb)(struct hostapd_iface *iface,
					 void *ctx), void *ctx)
{
	/* TODO */
	return 0;
}


int hostapd_ctrl_iface_init(struct hostapd_data *hapd)
{
	return 0;
}


void hostapd_ctrl_iface_deinit(struct hostapd_data *hapd)
{
}


struct ap_driver_data {
	struct hostapd_data *hapd;
};


static void * ap_driver_init(struct hostapd_data *hapd,
			     struct wpa_init_params *params)
{
	struct ap_driver_data *drv;
	struct wpa_supplicant *wpa_s = hapd->iface->owner;

	drv = os_zalloc(sizeof(struct ap_driver_data));
	if (drv == NULL) {
		wpa_printf(MSG_ERROR, "Could not allocate memory for AP "
			   "driver data");
		return NULL;
	}
	drv->hapd = hapd;
	os_memcpy(hapd->own_addr, wpa_s->own_addr, ETH_ALEN);

	return drv;
}


static void ap_driver_deinit(void *priv)
{
	struct ap_driver_data *drv = priv;

	os_free(drv);
}


static int ap_driver_send_ether(void *priv, const u8 *dst, const u8 *src,
				u16 proto, const u8 *data, size_t data_len)
{
	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	return -1;
}


static int ap_driver_set_key(const char *iface, void *priv, wpa_alg alg,
			     const u8 *addr, int key_idx, int set_tx,
			     const u8 *seq, size_t seq_len, const u8 *key,
			     size_t key_len)
{
	struct ap_driver_data *drv = priv;
	struct wpa_supplicant *wpa_s = drv->hapd->iface->owner;
	return wpa_drv_set_key(wpa_s, alg, addr, key_idx, set_tx, seq, seq_len,
			       key, key_len);
}


static int ap_driver_get_seqnum(const char *iface, void *priv, const u8 *addr,
				int idx, u8 *seq)
{
	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	return -1;
}


static int ap_driver_flush(void *priv)
{
	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	return -1;
}


static int ap_driver_read_sta_data(void *priv,
				   struct hostap_sta_driver_data *data,
				   const u8 *addr)
{
	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	return -1;
}


static int ap_driver_sta_set_flags(void *priv, const u8 *addr, int total_flags,
				   int flags_or, int flags_and)
{
	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	return -1;
}


static int ap_driver_sta_deauth(void *priv, const u8 *addr, int reason)
{
	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	return -1;
}


static int ap_driver_sta_disassoc(void *priv, const u8 *addr, int reason)
{
	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	return -1;
}


static int ap_driver_sta_remove(void *priv, const u8 *addr)
{
	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	return -1;
}


static int ap_driver_send_mgmt_frame(void *priv, const void *data, size_t len,
				     int flags)
{
	struct ap_driver_data *drv = priv;
	struct wpa_supplicant *wpa_s = drv->hapd->iface->owner;
	return wpa_drv_send_mlme(wpa_s, data, len);
}


static int ap_driver_sta_add(const char *ifname, void *priv,
			     struct hostapd_sta_add_params *params)
{
	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	return -1;
}


static int ap_driver_get_inact_sec(void *priv, const u8 *addr)
{
	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	return -1;
}


static int ap_driver_set_freq(void *priv, struct hostapd_freq_params *freq)
{
	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	return 0;
}


static int ap_driver_set_beacon(const char *iface, void *priv,
				const u8 *head, size_t head_len,
				const u8 *tail, size_t tail_len,
				int dtim_period)
{
	struct ap_driver_data *drv = priv;
	struct wpa_supplicant *wpa_s = drv->hapd->iface->owner;
	return wpa_drv_set_beacon(wpa_s, head, head_len, tail, tail_len,
				  dtim_period);
}


static int ap_driver_set_beacon_int(void *priv, int value)
{
	struct ap_driver_data *drv = priv;
	struct wpa_supplicant *wpa_s = drv->hapd->iface->owner;
	return wpa_drv_set_beacon_int(wpa_s, value);
}


static int ap_driver_set_cts_protect(void *priv, int value)
{
	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	return -1;
}


static int ap_driver_set_preamble(void *priv, int value)
{
	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	return -1;
}


static int ap_driver_set_short_slot_time(void *priv, int value)
{
	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	return -1;
}


static int ap_driver_set_tx_queue_params(void *priv, int queue, int aifs,
					 int cw_min, int cw_max,
					 int burst_time)
{
	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	return -1;
}


static struct hostapd_hw_modes *ap_driver_get_hw_feature_data(void *priv,
							      u16 *num_modes,
							      u16 *flags)
{
	struct ap_driver_data *drv = priv;
	struct wpa_supplicant *wpa_s = drv->hapd->iface->owner;
	return wpa_drv_get_hw_feature_data(wpa_s, num_modes, flags);
}


struct wpa_driver_ops ap_driver_ops =
{
	.name = "wpa_supplicant",
	.hapd_init = ap_driver_init,
	.hapd_deinit = ap_driver_deinit,
	.send_ether = ap_driver_send_ether,
	.hapd_set_key = ap_driver_set_key,
	.get_seqnum = ap_driver_get_seqnum,
	.flush = ap_driver_flush,
	.read_sta_data = ap_driver_read_sta_data,
	.sta_set_flags = ap_driver_sta_set_flags,
	.sta_deauth = ap_driver_sta_deauth,
	.sta_disassoc = ap_driver_sta_disassoc,
	.sta_remove = ap_driver_sta_remove,
	.send_mgmt_frame = ap_driver_send_mgmt_frame,
	.sta_add = ap_driver_sta_add,
	.get_inact_sec = ap_driver_get_inact_sec,
	.set_freq = ap_driver_set_freq,
	.hapd_set_beacon = ap_driver_set_beacon,
	.hapd_set_beacon_int = ap_driver_set_beacon_int,
	.set_cts_protect = ap_driver_set_cts_protect,
	.set_preamble = ap_driver_set_preamble,
	.set_short_slot_time = ap_driver_set_short_slot_time,
	.set_tx_queue_params = ap_driver_set_tx_queue_params,
	.get_hw_feature_data = ap_driver_get_hw_feature_data,
};


extern struct wpa_driver_ops *wpa_drivers[];

static int wpa_supplicant_conf_ap(struct wpa_supplicant *wpa_s,
				  struct wpa_ssid *ssid,
				  struct hostapd_config *conf)
{
	struct hostapd_bss_config *bss = &conf->bss[0];
	int j;

	for (j = 0; wpa_drivers[j]; j++) {
		if (os_strcmp("wpa_supplicant", wpa_drivers[j]->name) == 0) {
			conf->driver = wpa_drivers[j];
			break;
		}
	}
	if (conf->driver == NULL) {
		wpa_printf(MSG_ERROR, "No AP driver ops found");
		return -1;
	}

	os_strlcpy(bss->iface, wpa_s->ifname, sizeof(bss->iface));

	if (ssid->frequency == 0) {
		/* default channel 11 */
		conf->hw_mode = HOSTAPD_MODE_IEEE80211G;
		conf->channel = 11;
	} else if (ssid->frequency >= 2412 && ssid->frequency <= 2472) {
		conf->hw_mode = HOSTAPD_MODE_IEEE80211G;
		conf->channel = (ssid->frequency - 2407) / 5;
	} else if ((ssid->frequency >= 5180 && ssid->frequency <= 5240) ||
		   (ssid->frequency >= 5745 && ssid->frequency <= 5825)) {
		conf->hw_mode = HOSTAPD_MODE_IEEE80211G;
		conf->channel = (ssid->frequency - 5000) / 5;
	} else {
		wpa_printf(MSG_ERROR, "Unsupported AP mode frequency: %d MHz",
			   ssid->frequency);
		return -1;
	}

	/* TODO: enable HT if driver supports it;
	 * drop to 11b if driver does not support 11g */

	if (ssid->ssid_len == 0) {
		wpa_printf(MSG_ERROR, "No SSID configured for AP mode");
		return -1;
	}
	os_memcpy(bss->ssid.ssid, ssid->ssid, ssid->ssid_len);
	bss->ssid.ssid[ssid->ssid_len] = '\0';
	bss->ssid.ssid_len = ssid->ssid_len;
	bss->ssid.ssid_set = 1;

	if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt))
		bss->wpa = ssid->proto;
	bss->wpa_key_mgmt = ssid->key_mgmt;
	bss->wpa_pairwise = ssid->pairwise_cipher;
	if (ssid->passphrase) {
		bss->ssid.wpa_passphrase = os_strdup(ssid->passphrase);
		if (hostapd_setup_wpa_psk(bss))
			return -1;
	} else if (ssid->psk_set) {
		os_free(bss->ssid.wpa_psk);
		bss->ssid.wpa_psk = os_zalloc(sizeof(struct hostapd_wpa_psk));
		if (bss->ssid.wpa_psk == NULL)
			return -1;
		os_memcpy(bss->ssid.wpa_psk->psk, ssid->psk, PMK_LEN);
		bss->ssid.wpa_psk->group = 1;
	}

	return 0;
}


int wpa_supplicant_create_ap(struct wpa_supplicant *wpa_s,
			     struct wpa_ssid *ssid)
{
	struct wpa_driver_associate_params params;
	struct hostapd_iface *hapd_iface;
	struct hostapd_config *conf;
	size_t i;

	if (ssid->ssid == NULL || ssid->ssid_len == 0) {
		wpa_printf(MSG_ERROR, "No SSID configured for AP mode");
		return -1;
	}

	wpa_supplicant_ap_deinit(wpa_s);

	wpa_printf(MSG_DEBUG, "Setting up AP (SSID='%s')",
		   wpa_ssid_txt(ssid->ssid, ssid->ssid_len));

	os_memset(&params, 0, sizeof(params));
	params.ssid = ssid->ssid;
	params.ssid_len = ssid->ssid_len;
	params.mode = ssid->mode;
	params.freq = ssid->frequency;

	if (wpa_drv_associate(wpa_s, &params) < 0) {
		wpa_msg(wpa_s, MSG_INFO, "Failed to start AP functionality");
		return -1;
	}

	wpa_s->ap_iface = hapd_iface = os_zalloc(sizeof(*wpa_s->ap_iface));
	if (hapd_iface == NULL)
		return -1;
	hapd_iface->owner = wpa_s;

	wpa_s->ap_iface->conf = conf = hostapd_config_defaults();
	if (conf == NULL) {
		wpa_supplicant_ap_deinit(wpa_s);
		return -1;
	}

	if (wpa_supplicant_conf_ap(wpa_s, ssid, conf)) {
		wpa_printf(MSG_ERROR, "Failed to create AP configuration");
		wpa_supplicant_ap_deinit(wpa_s);
		return -1;
	}

	hapd_iface->num_bss = conf->num_bss;
	hapd_iface->bss = os_zalloc(conf->num_bss *
				    sizeof(struct hostapd_data *));
	if (hapd_iface->bss == NULL) {
		wpa_supplicant_ap_deinit(wpa_s);
		return -1;
	}

	for (i = 0; i < conf->num_bss; i++) {
		hapd_iface->bss[i] =
			hostapd_alloc_bss_data(hapd_iface, conf,
					       &conf->bss[i]);
		if (hapd_iface->bss[i] == NULL) {
			wpa_supplicant_ap_deinit(wpa_s);
			return -1;
		}
	}

	if (hostapd_setup_interface(wpa_s->ap_iface)) {
		wpa_printf(MSG_ERROR, "Failed to initialize AP interface");
		wpa_supplicant_ap_deinit(wpa_s);
		return -1;
	}

	return 0;
}


void wpa_supplicant_ap_deinit(struct wpa_supplicant *wpa_s)
{
	if (wpa_s->ap_iface == NULL)
		return;

	hostapd_interface_deinit(wpa_s->ap_iface);
	wpa_s->ap_iface = NULL;
}


void ap_tx_status(void *ctx, const u8 *addr,
		  const u8 *buf, size_t len, int ack)
{
	struct wpa_supplicant *wpa_s = ctx;
	hostapd_tx_status(wpa_s->ap_iface->bss[0], addr, buf, len, ack);
}


void ap_rx_from_unknown_sta(void *ctx, const u8 *addr)
{
	struct wpa_supplicant *wpa_s = ctx;
	ap_rx_from_unknown_sta(wpa_s->ap_iface->bss[0], addr);
}


#ifdef NEED_MLME
void ap_mgmt_rx(void *ctx, u8 *buf, size_t len, u16 stype,
		struct hostapd_frame_info *fi)
{
	struct wpa_supplicant *wpa_s = ctx;
	ieee802_11_mgmt(wpa_s->ap_iface->bss[0], buf, len, stype, fi);
}


void ap_mgmt_tx_cb(void *ctx, u8 *buf, size_t len, u16 stype, int ok)
{
	struct wpa_supplicant *wpa_s = ctx;
	ieee802_11_mgmt_cb(wpa_s->ap_iface->bss[0], buf, len, stype, ok);
}
#endif /* NEED_MLME */
Commit	Line	Data
f1a48710 JM	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 "includes.h"
	17
	18	#include "common.h"
	19	#include "../hostapd/hostapd.h"
089757c6	20	#include "../hostapd/config.h"
0915d02c JM	21	#ifdef NEED_MLME
	22	#include "../hostapd/ieee802_11.h"
	23	#endif /* NEED_MLME */
f1a48710 JM	24	#include "eap_common/eap_defs.h"
	25	#include "eap_server/eap_methods.h"
	26	#include "eap_common/eap_wsc_common.h"
1f1b62a0 JM	27	#include "config_ssid.h"
1f1b62a0 JM	28	#include "wpa_supplicant_i.h"
2d5b792d JM	29	#include "driver_i.h"
2d5b792d JM	30	#include "ap.h"
f1a48710 JM	31
f1a48710 JM	32
2d5b792d JM	33	int hostapd_for_each_interface(int (cb)(struct hostapd_iface iface,
2d5b792d JM	34	void ctx), void ctx)
f1a48710 JM	35	{
f1a48710 JM	36	/* TODO */
2d5b792d	37	return 0;
f1a48710 JM	38	}
	39
	40
2d5b792d	41	int hostapd_ctrl_iface_init(struct hostapd_data *hapd)
f1a48710	42	{
f1a48710 JM	43	return 0;
	44	}
	45
	46
2d5b792d	47	void hostapd_ctrl_iface_deinit(struct hostapd_data *hapd)
f1a48710	48	{
2d5b792d	49	}
f1a48710	50
f1a48710	51
2d5b792d JM	52	struct ap_driver_data {
	53	struct hostapd_data *hapd;
	54	};
f1a48710	55
2d5b792d	56
92f475b4 JM	57	static void * ap_driver_init(struct hostapd_data *hapd,
92f475b4 JM	58	struct wpa_init_params *params)
2d5b792d JM	59	{
2d5b792d JM	60	struct ap_driver_data *drv;
0892aaaf	61	struct wpa_supplicant *wpa_s = hapd->iface->owner;
2d5b792d JM	62
	63	drv = os_zalloc(sizeof(struct ap_driver_data));
	64	if (drv == NULL) {
	65	wpa_printf(MSG_ERROR, "Could not allocate memory for AP "
	66	"driver data");
	67	return NULL;
	68	}
	69	drv->hapd = hapd;
0892aaaf	70	os_memcpy(hapd->own_addr, wpa_s->own_addr, ETH_ALEN);
2d5b792d JM	71
2d5b792d JM	72	return drv;
f1a48710 JM	73	}
	74
	75
2d5b792d	76	static void ap_driver_deinit(void *priv)
f1a48710	77	{
2d5b792d JM	78	struct ap_driver_data *drv = priv;
	79
	80	os_free(drv);
f1a48710 JM	81	}
	82
	83
2d5b792d JM	84	static int ap_driver_send_ether(void priv, const u8 dst, const u8 *src,
2d5b792d JM	85	u16 proto, const u8 *data, size_t data_len)
f1a48710	86	{
0f2b2c19 JM	87	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	88	return -1;
	89	}
	90
	91
	92	static int ap_driver_set_key(const char iface, void priv, wpa_alg alg,
	93	const u8 *addr, int key_idx, int set_tx,
	94	const u8 seq, size_t seq_len, const u8 key,
	95	size_t key_len)
	96	{
	97	struct ap_driver_data *drv = priv;
	98	struct wpa_supplicant *wpa_s = drv->hapd->iface->owner;
	99	return wpa_drv_set_key(wpa_s, alg, addr, key_idx, set_tx, seq, seq_len,
	100	key, key_len);
	101	}
	102
	103
	104	static int ap_driver_get_seqnum(const char iface, void priv, const u8 *addr,
	105	int idx, u8 *seq)
	106	{
	107	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	108	return -1;
	109	}
	110
	111
	112	static int ap_driver_flush(void *priv)
	113	{
	114	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	115	return -1;
	116	}
	117
	118
	119	static int ap_driver_read_sta_data(void *priv,
	120	struct hostap_sta_driver_data *data,
	121	const u8 *addr)
	122	{
	123	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	124	return -1;
	125	}
	126
	127
	128	static int ap_driver_sta_set_flags(void priv, const u8 addr, int total_flags,
	129	int flags_or, int flags_and)
	130	{
	131	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	132	return -1;
	133	}
	134
	135
	136	static int ap_driver_sta_deauth(void priv, const u8 addr, int reason)
	137	{
	138	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	139	return -1;
	140	}
	141
	142
	143	static int ap_driver_sta_disassoc(void priv, const u8 addr, int reason)
	144	{
	145	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	146	return -1;
	147	}
	148
	149
	150	static int ap_driver_sta_remove(void priv, const u8 addr)
151	{
152	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
153	return -1;
154	}
155
156
157	static int ap_driver_send_mgmt_frame(void priv, const void data, size_t len,
158	int flags)
159	{
2c2010ac JM	160	struct ap_driver_data *drv = priv;
	161	struct wpa_supplicant *wpa_s = drv->hapd->iface->owner;
	162	return wpa_drv_send_mlme(wpa_s, data, len);
0f2b2c19 JM	163	}
	164
	165
	166	static int ap_driver_sta_add(const char ifname, void priv,
	167	struct hostapd_sta_add_params *params)
	168	{
	169	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	170	return -1;
	171	}
	172
	173
	174	static int ap_driver_get_inact_sec(void priv, const u8 addr)
	175	{
	176	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	177	return -1;
	178	}
	179
	180
	181	static int ap_driver_set_freq(void priv, struct hostapd_freq_params freq)
	182	{
	183	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
f1a48710 JM	184	return 0;
	185	}
	186
	187
0f2b2c19	188	static int ap_driver_set_beacon(const char iface, void priv,
d2440ba0 JM	189	const u8 *head, size_t head_len,
	190	const u8 *tail, size_t tail_len,
	191	int dtim_period)
0f2b2c19	192	{
d2440ba0 JM	193	struct ap_driver_data *drv = priv;
	194	struct wpa_supplicant *wpa_s = drv->hapd->iface->owner;
	195	return wpa_drv_set_beacon(wpa_s, head, head_len, tail, tail_len,
	196	dtim_period);
0f2b2c19 JM	197	}
	198
	199
	200	static int ap_driver_set_beacon_int(void *priv, int value)
	201	{
d2440ba0 JM	202	struct ap_driver_data *drv = priv;
	203	struct wpa_supplicant *wpa_s = drv->hapd->iface->owner;
	204	return wpa_drv_set_beacon_int(wpa_s, value);
0f2b2c19 JM	205	}
	206
	207
	208	static int ap_driver_set_cts_protect(void *priv, int value)
	209	{
	210	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	211	return -1;
	212	}
	213
	214
	215	static int ap_driver_set_preamble(void *priv, int value)
	216	{
	217	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	218	return -1;
	219	}
	220
	221
	222	static int ap_driver_set_short_slot_time(void *priv, int value)
	223	{
	224	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	225	return -1;
	226	}
	227
	228
	229	static int ap_driver_set_tx_queue_params(void *priv, int queue, int aifs,
	230	int cw_min, int cw_max,
	231	int burst_time)
	232	{
	233	wpa_printf(MSG_DEBUG, "AP TODO: %s", __func__);
	234	return -1;
	235	}
	236
	237
	238	static struct hostapd_hw_modes ap_driver_get_hw_feature_data(void priv,
	239	u16 *num_modes,
	240	u16 *flags)
	241	{
282d5590 JM	242	struct ap_driver_data *drv = priv;
	243	struct wpa_supplicant *wpa_s = drv->hapd->iface->owner;
	244	return wpa_drv_get_hw_feature_data(wpa_s, num_modes, flags);
0f2b2c19 JM	245	}
	246
	247
c5121837	248	struct wpa_driver_ops ap_driver_ops =
f1a48710	249	{
2d5b792d	250	.name = "wpa_supplicant",
c5121837 JM	251	.hapd_init = ap_driver_init,
c5121837 JM	252	.hapd_deinit = ap_driver_deinit,
2d5b792d	253	.send_ether = ap_driver_send_ether,
c5121837	254	.hapd_set_key = ap_driver_set_key,
0f2b2c19 JM	255	.get_seqnum = ap_driver_get_seqnum,
	256	.flush = ap_driver_flush,
	257	.read_sta_data = ap_driver_read_sta_data,
	258	.sta_set_flags = ap_driver_sta_set_flags,
	259	.sta_deauth = ap_driver_sta_deauth,
	260	.sta_disassoc = ap_driver_sta_disassoc,
	261	.sta_remove = ap_driver_sta_remove,
	262	.send_mgmt_frame = ap_driver_send_mgmt_frame,
	263	.sta_add = ap_driver_sta_add,
	264	.get_inact_sec = ap_driver_get_inact_sec,
	265	.set_freq = ap_driver_set_freq,
c5121837 JM	266	.hapd_set_beacon = ap_driver_set_beacon,
c5121837 JM	267	.hapd_set_beacon_int = ap_driver_set_beacon_int,
0f2b2c19 JM	268	.set_cts_protect = ap_driver_set_cts_protect,
	269	.set_preamble = ap_driver_set_preamble,
	270	.set_short_slot_time = ap_driver_set_short_slot_time,
	271	.set_tx_queue_params = ap_driver_set_tx_queue_params,
c3965310	272	.get_hw_feature_data = ap_driver_get_hw_feature_data,
2d5b792d	273	};
f1a48710	274
f1a48710	275
c5121837	276	extern struct wpa_driver_ops *wpa_drivers[];
07f117ed JM	277
	278	static int wpa_supplicant_conf_ap(struct wpa_supplicant *wpa_s,
	279	struct wpa_ssid *ssid,
	280	struct hostapd_config *conf)
	281	{
	282	struct hostapd_bss_config *bss = &conf->bss[0];
c5121837 JM	283	int j;
	284
	285	for (j = 0; wpa_drivers[j]; j++) {
	286	if (os_strcmp("wpa_supplicant", wpa_drivers[j]->name) == 0) {
	287	conf->driver = wpa_drivers[j];
	288	break;
	289	}
	290	}
	291	if (conf->driver == NULL) {
	292	wpa_printf(MSG_ERROR, "No AP driver ops found");
	293	return -1;
	294	}
07f117ed JM	295
	296	os_strlcpy(bss->iface, wpa_s->ifname, sizeof(bss->iface));
	297
	298	if (ssid->frequency == 0) {
	299	/* default channel 11 */
	300	conf->hw_mode = HOSTAPD_MODE_IEEE80211G;
	301	conf->channel = 11;
	302	} else if (ssid->frequency >= 2412 && ssid->frequency <= 2472) {
	303	conf->hw_mode = HOSTAPD_MODE_IEEE80211G;
	304	conf->channel = (ssid->frequency - 2407) / 5;
	305	} else if ((ssid->frequency >= 5180 && ssid->frequency <= 5240) \|\|
	306	(ssid->frequency >= 5745 && ssid->frequency <= 5825)) {
	307	conf->hw_mode = HOSTAPD_MODE_IEEE80211G;
	308	conf->channel = (ssid->frequency - 5000) / 5;
	309	} else {
	310	wpa_printf(MSG_ERROR, "Unsupported AP mode frequency: %d MHz",
	311	ssid->frequency);
	312	return -1;
	313	}
	314
	315	/* TODO: enable HT if driver supports it;
	316	* drop to 11b if driver does not support 11g */
	317
	318	if (ssid->ssid_len == 0) {
	319	wpa_printf(MSG_ERROR, "No SSID configured for AP mode");
	320	return -1;
	321	}
	322	os_memcpy(bss->ssid.ssid, ssid->ssid, ssid->ssid_len);
	323	bss->ssid.ssid[ssid->ssid_len] = '\0';
	324	bss->ssid.ssid_len = ssid->ssid_len;
	325	bss->ssid.ssid_set = 1;
	326
	327	if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt))
	328	bss->wpa = ssid->proto;
	329	bss->wpa_key_mgmt = ssid->key_mgmt;
	330	bss->wpa_pairwise = ssid->pairwise_cipher;
	331	if (ssid->passphrase) {
	332	bss->ssid.wpa_passphrase = os_strdup(ssid->passphrase);
	333	if (hostapd_setup_wpa_psk(bss))
	334	return -1;
	335	} else if (ssid->psk_set) {
	336	os_free(bss->ssid.wpa_psk);
	337	bss->ssid.wpa_psk = os_zalloc(sizeof(struct hostapd_wpa_psk));
	338	if (bss->ssid.wpa_psk == NULL)
	339	return -1;
	340	os_memcpy(bss->ssid.wpa_psk->psk, ssid->psk, PMK_LEN);
	341	bss->ssid.wpa_psk->group = 1;
	342	}
	343
	344	return 0;
	345	}
	346
	347
2d5b792d JM	348	int wpa_supplicant_create_ap(struct wpa_supplicant *wpa_s,
	349	struct wpa_ssid *ssid)
	350	{
	351	struct wpa_driver_associate_params params;
	352	struct hostapd_iface *hapd_iface;
	353	struct hostapd_config *conf;
	354	size_t i;
f1a48710	355
2d5b792d JM	356	if (ssid->ssid == NULL \|\| ssid->ssid_len == 0) {
	357	wpa_printf(MSG_ERROR, "No SSID configured for AP mode");
	358	return -1;
f1a48710 JM	359	}
f1a48710 JM	360
2d5b792d	361	wpa_supplicant_ap_deinit(wpa_s);
d2440ba0 JM	362
	363	wpa_printf(MSG_DEBUG, "Setting up AP (SSID='%s')",
	364	wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
	365
	366	os_memset(&params, 0, sizeof(params));
	367	params.ssid = ssid->ssid;
	368	params.ssid_len = ssid->ssid_len;
	369	params.mode = ssid->mode;
	370	params.freq = ssid->frequency;
	371
	372	if (wpa_drv_associate(wpa_s, &params) < 0) {
	373	wpa_msg(wpa_s, MSG_INFO, "Failed to start AP functionality");
	374	return -1;
	375	}
	376
2d5b792d JM	377	wpa_s->ap_iface = hapd_iface = os_zalloc(sizeof(*wpa_s->ap_iface));
	378	if (hapd_iface == NULL)
	379	return -1;
0f2b2c19	380	hapd_iface->owner = wpa_s;
1f1b62a0	381
2d5b792d JM	382	wpa_s->ap_iface->conf = conf = hostapd_config_defaults();
	383	if (conf == NULL) {
	384	wpa_supplicant_ap_deinit(wpa_s);
	385	return -1;
	386	}
1f1b62a0	387
07f117ed JM	388	if (wpa_supplicant_conf_ap(wpa_s, ssid, conf)) {
	389	wpa_printf(MSG_ERROR, "Failed to create AP configuration");
	390	wpa_supplicant_ap_deinit(wpa_s);
	391	return -1;
	392	}
	393
2d5b792d JM	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	}
1f1b62a0	401
2d5b792d JM	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
	412	if (hostapd_setup_interface(wpa_s->ap_iface)) {
	413	wpa_printf(MSG_ERROR, "Failed to initialize AP interface");
	414	wpa_supplicant_ap_deinit(wpa_s);
	415	return -1;
1f1b62a0 JM	416	}
1f1b62a0 JM	417
2d5b792d JM	418	return 0;
	419	}
	420
	421
	422	void wpa_supplicant_ap_deinit(struct wpa_supplicant *wpa_s)
	423	{
	424	if (wpa_s->ap_iface == NULL)
	425	return;
	426
	427	hostapd_interface_deinit(wpa_s->ap_iface);
	428	wpa_s->ap_iface = NULL;
1f1b62a0	429	}
0915d02c JM	430
	431
	432	void ap_tx_status(void ctx, const u8 addr,
	433	const u8 *buf, size_t len, int ack)
	434	{
	435	struct wpa_supplicant *wpa_s = ctx;
	436	hostapd_tx_status(wpa_s->ap_iface->bss[0], addr, buf, len, ack);
	437	}
	438
	439
	440	void ap_rx_from_unknown_sta(void ctx, const u8 addr)
	441	{
	442	struct wpa_supplicant *wpa_s = ctx;
	443	ap_rx_from_unknown_sta(wpa_s->ap_iface->bss[0], addr);
	444	}
	445
	446
	447	#ifdef NEED_MLME
	448	void ap_mgmt_rx(void ctx, u8 buf, size_t len, u16 stype,
	449	struct hostapd_frame_info *fi)
	450	{
	451	struct wpa_supplicant *wpa_s = ctx;
	452	ieee802_11_mgmt(wpa_s->ap_iface->bss[0], buf, len, stype, fi);
	453	}
	454
	455
	456	void ap_mgmt_tx_cb(void ctx, u8 buf, size_t len, u16 stype, int ok)
	457	{
	458	struct wpa_supplicant *wpa_s = ctx;
	459	ieee802_11_mgmt_cb(wpa_s->ap_iface->bss[0], buf, len, stype, ok);
	460	}
	461	#endif /* NEED_MLME */