[thirdparty/hostap.git] / src / drivers / driver_nl80211_android.c

/*
 * Driver interaction with Linux nl80211/cfg80211 - Android specific
 * Copyright (c) 2002-2014, Jouni Malinen <j@w1.fi>
 * Copyright (c) 2007, Johannes Berg <johannes@sipsolutions.net>
 * Copyright (c) 2009-2010, Atheros Communications
 *
 * This software may be distributed under the terms of the BSD license.
 * See README for more details.
 */

#include "includes.h"
#include <sys/ioctl.h>
#include <net/if.h>
#include <netlink/genl/genl.h>
#include <netlink/genl/family.h>
#include <netlink/genl/ctrl.h>
#include <fcntl.h>

#include "utils/common.h"
#include "driver_nl80211.h"
#include "android_drv.h"


typedef struct android_wifi_priv_cmd {
	char *buf;
	int used_len;
	int total_len;
} android_wifi_priv_cmd;

static int drv_errors = 0;

static void wpa_driver_send_hang_msg(struct wpa_driver_nl80211_data *drv)
{
	drv_errors++;
	if (drv_errors > DRV_NUMBER_SEQUENTIAL_ERRORS) {
		drv_errors = 0;
		wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "HANGED");
	}
}


static int android_priv_cmd(struct i802_bss *bss, const char *cmd)
{
	struct wpa_driver_nl80211_data *drv = bss->drv;
	struct ifreq ifr;
	android_wifi_priv_cmd priv_cmd;
	char buf[MAX_DRV_CMD_SIZE];
	int ret;

	os_memset(&ifr, 0, sizeof(ifr));
	os_memset(&priv_cmd, 0, sizeof(priv_cmd));
	os_strlcpy(ifr.ifr_name, bss->ifname, IFNAMSIZ);

	os_memset(buf, 0, sizeof(buf));
	os_strlcpy(buf, cmd, sizeof(buf));

	priv_cmd.buf = buf;
	priv_cmd.used_len = sizeof(buf);
	priv_cmd.total_len = sizeof(buf);
	ifr.ifr_data = &priv_cmd;

	ret = ioctl(drv->global->ioctl_sock, SIOCDEVPRIVATE + 1, &ifr);
	if (ret < 0) {
		wpa_printf(MSG_ERROR, "%s: failed to issue private commands",
			   __func__);
		wpa_driver_send_hang_msg(drv);
		return ret;
	}

	drv_errors = 0;
	return 0;
}


int android_pno_start(struct i802_bss *bss,
		      struct wpa_driver_scan_params *params)
{
	struct wpa_driver_nl80211_data *drv = bss->drv;
	struct ifreq ifr;
	android_wifi_priv_cmd priv_cmd;
	int ret = 0, i = 0, bp;
	char buf[WEXT_PNO_MAX_COMMAND_SIZE];

	bp = WEXT_PNOSETUP_HEADER_SIZE;
	os_memcpy(buf, WEXT_PNOSETUP_HEADER, bp);
	buf[bp++] = WEXT_PNO_TLV_PREFIX;
	buf[bp++] = WEXT_PNO_TLV_VERSION;
	buf[bp++] = WEXT_PNO_TLV_SUBVERSION;
	buf[bp++] = WEXT_PNO_TLV_RESERVED;

	while (i < WEXT_PNO_AMOUNT && (size_t) i < params->num_ssids) {
		/* Check that there is enough space needed for 1 more SSID, the
		 * other sections and null termination */
		if ((bp + WEXT_PNO_SSID_HEADER_SIZE + MAX_SSID_LEN +
		     WEXT_PNO_NONSSID_SECTIONS_SIZE + 1) >= (int) sizeof(buf))
			break;
		wpa_hexdump_ascii(MSG_DEBUG, "For PNO Scan",
				  params->ssids[i].ssid,
				  params->ssids[i].ssid_len);
		buf[bp++] = WEXT_PNO_SSID_SECTION;
		buf[bp++] = params->ssids[i].ssid_len;
		os_memcpy(&buf[bp], params->ssids[i].ssid,
			  params->ssids[i].ssid_len);
		bp += params->ssids[i].ssid_len;
		i++;
	}

	buf[bp++] = WEXT_PNO_SCAN_INTERVAL_SECTION;
	os_snprintf(&buf[bp], WEXT_PNO_SCAN_INTERVAL_LENGTH + 1, "%x",
		    WEXT_PNO_SCAN_INTERVAL);
	bp += WEXT_PNO_SCAN_INTERVAL_LENGTH;

	buf[bp++] = WEXT_PNO_REPEAT_SECTION;
	os_snprintf(&buf[bp], WEXT_PNO_REPEAT_LENGTH + 1, "%x",
		    WEXT_PNO_REPEAT);
	bp += WEXT_PNO_REPEAT_LENGTH;

	buf[bp++] = WEXT_PNO_MAX_REPEAT_SECTION;
	os_snprintf(&buf[bp], WEXT_PNO_MAX_REPEAT_LENGTH + 1, "%x",
		    WEXT_PNO_MAX_REPEAT);
	bp += WEXT_PNO_MAX_REPEAT_LENGTH + 1;

	memset(&ifr, 0, sizeof(ifr));
	memset(&priv_cmd, 0, sizeof(priv_cmd));
	os_strlcpy(ifr.ifr_name, bss->ifname, IFNAMSIZ);

	priv_cmd.buf = buf;
	priv_cmd.used_len = bp;
	priv_cmd.total_len = bp;
	ifr.ifr_data = &priv_cmd;

	ret = ioctl(drv->global->ioctl_sock, SIOCDEVPRIVATE + 1, &ifr);

	if (ret < 0) {
		wpa_printf(MSG_ERROR, "ioctl[SIOCSIWPRIV] (pnosetup): %d",
			   ret);
		wpa_driver_send_hang_msg(drv);
		return ret;
	}

	drv_errors = 0;

	return android_priv_cmd(bss, "PNOFORCE 1");
}


int android_pno_stop(struct i802_bss *bss)
{
	return android_priv_cmd(bss, "PNOFORCE 0");
}


#ifdef ANDROID_P2P
#ifdef ANDROID_LIB_STUB

int wpa_driver_set_p2p_noa(void *priv, u8 count, int start, int duration)
{
	return 0;
}


int wpa_driver_get_p2p_noa(void *priv, u8 *buf, size_t len)
{
	return 0;
}


int wpa_driver_set_p2p_ps(void *priv, int legacy_ps, int opp_ps, int ctwindow)
{
	return -1;
}


int wpa_driver_set_ap_wps_p2p_ie(void *priv, const struct wpabuf *beacon,
				 const struct wpabuf *proberesp,
				 const struct wpabuf *assocresp)
{
	return 0;
}

#endif /* ANDROID_LIB_STUB */
#endif /* ANDROID_P2P */


int android_nl_socket_set_nonblocking(struct nl_handle *handle)
{
	return fcntl(nl_socket_get_fd(handle), F_SETFL, O_NONBLOCK);
}
Commit	Line	Data
70a96c81 JM	1	/*
	2	* Driver interaction with Linux nl80211/cfg80211 - Android specific
	3	* Copyright (c) 2002-2014, Jouni Malinen <j@w1.fi>
	4	* Copyright (c) 2007, Johannes Berg <johannes@sipsolutions.net>
	5	* Copyright (c) 2009-2010, Atheros Communications
	6	*
	7	* This software may be distributed under the terms of the BSD license.
	8	* See README for more details.
	9	*/
	10
	11	#include "includes.h"
	12	#include <sys/ioctl.h>
	13	#include <net/if.h>
	14	#include <netlink/genl/genl.h>
	15	#include <netlink/genl/family.h>
	16	#include <netlink/genl/ctrl.h>
f0399656	17	#include <fcntl.h>
70a96c81 JM	18
	19	#include "utils/common.h"
	20	#include "driver_nl80211.h"
	21	#include "android_drv.h"
	22
	23
	24	typedef struct android_wifi_priv_cmd {
	25	char *buf;
	26	int used_len;
	27	int total_len;
	28	} android_wifi_priv_cmd;
	29
	30	static int drv_errors = 0;
	31
	32	static void wpa_driver_send_hang_msg(struct wpa_driver_nl80211_data *drv)
	33	{
	34	drv_errors++;
	35	if (drv_errors > DRV_NUMBER_SEQUENTIAL_ERRORS) {
	36	drv_errors = 0;
	37	wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "HANGED");
	38	}
	39	}
	40
	41
	42	static int android_priv_cmd(struct i802_bss bss, const char cmd)
	43	{
	44	struct wpa_driver_nl80211_data *drv = bss->drv;
	45	struct ifreq ifr;
	46	android_wifi_priv_cmd priv_cmd;
	47	char buf[MAX_DRV_CMD_SIZE];
	48	int ret;
	49
	50	os_memset(&ifr, 0, sizeof(ifr));
	51	os_memset(&priv_cmd, 0, sizeof(priv_cmd));
	52	os_strlcpy(ifr.ifr_name, bss->ifname, IFNAMSIZ);
	53
	54	os_memset(buf, 0, sizeof(buf));
	55	os_strlcpy(buf, cmd, sizeof(buf));
	56
	57	priv_cmd.buf = buf;
	58	priv_cmd.used_len = sizeof(buf);
	59	priv_cmd.total_len = sizeof(buf);
	60	ifr.ifr_data = &priv_cmd;
	61
	62	ret = ioctl(drv->global->ioctl_sock, SIOCDEVPRIVATE + 1, &ifr);
	63	if (ret < 0) {
	64	wpa_printf(MSG_ERROR, "%s: failed to issue private commands",
	65	__func__);
	66	wpa_driver_send_hang_msg(drv);
	67	return ret;
	68	}
	69
	70	drv_errors = 0;
	71	return 0;
	72	}
	73
	74
	75	int android_pno_start(struct i802_bss *bss,
	76	struct wpa_driver_scan_params *params)
	77	{
	78	struct wpa_driver_nl80211_data *drv = bss->drv;
	79	struct ifreq ifr;
	80	android_wifi_priv_cmd priv_cmd;
	81	int ret = 0, i = 0, bp;
82	char buf[WEXT_PNO_MAX_COMMAND_SIZE];
83
84	bp = WEXT_PNOSETUP_HEADER_SIZE;
85	os_memcpy(buf, WEXT_PNOSETUP_HEADER, bp);
86	buf[bp++] = WEXT_PNO_TLV_PREFIX;
87	buf[bp++] = WEXT_PNO_TLV_VERSION;
88	buf[bp++] = WEXT_PNO_TLV_SUBVERSION;
89	buf[bp++] = WEXT_PNO_TLV_RESERVED;
90
91	while (i < WEXT_PNO_AMOUNT && (size_t) i < params->num_ssids) {
92	/* Check that there is enough space needed for 1 more SSID, the
93	* other sections and null termination */
94	if ((bp + WEXT_PNO_SSID_HEADER_SIZE + MAX_SSID_LEN +
95	WEXT_PNO_NONSSID_SECTIONS_SIZE + 1) >= (int) sizeof(buf))
96	break;
97	wpa_hexdump_ascii(MSG_DEBUG, "For PNO Scan",
98	params->ssids[i].ssid,
99	params->ssids[i].ssid_len);
100	buf[bp++] = WEXT_PNO_SSID_SECTION;
101	buf[bp++] = params->ssids[i].ssid_len;
102	os_memcpy(&buf[bp], params->ssids[i].ssid,
103	params->ssids[i].ssid_len);
104	bp += params->ssids[i].ssid_len;
105	i++;
106	}
107
108	buf[bp++] = WEXT_PNO_SCAN_INTERVAL_SECTION;
109	os_snprintf(&buf[bp], WEXT_PNO_SCAN_INTERVAL_LENGTH + 1, "%x",
110	WEXT_PNO_SCAN_INTERVAL);
111	bp += WEXT_PNO_SCAN_INTERVAL_LENGTH;
112
113	buf[bp++] = WEXT_PNO_REPEAT_SECTION;
114	os_snprintf(&buf[bp], WEXT_PNO_REPEAT_LENGTH + 1, "%x",
115	WEXT_PNO_REPEAT);
116	bp += WEXT_PNO_REPEAT_LENGTH;
117
118	buf[bp++] = WEXT_PNO_MAX_REPEAT_SECTION;
119	os_snprintf(&buf[bp], WEXT_PNO_MAX_REPEAT_LENGTH + 1, "%x",
120	WEXT_PNO_MAX_REPEAT);
121	bp += WEXT_PNO_MAX_REPEAT_LENGTH + 1;
122
123	memset(&ifr, 0, sizeof(ifr));
124	memset(&priv_cmd, 0, sizeof(priv_cmd));
125	os_strlcpy(ifr.ifr_name, bss->ifname, IFNAMSIZ);
126
127	priv_cmd.buf = buf;
128	priv_cmd.used_len = bp;
129	priv_cmd.total_len = bp;
130	ifr.ifr_data = &priv_cmd;
131
132	ret = ioctl(drv->global->ioctl_sock, SIOCDEVPRIVATE + 1, &ifr);
133
134	if (ret < 0) {
135	wpa_printf(MSG_ERROR, "ioctl[SIOCSIWPRIV] (pnosetup): %d",
136	ret);
137	wpa_driver_send_hang_msg(drv);
138	return ret;
139	}
140
141	drv_errors = 0;
142
143	return android_priv_cmd(bss, "PNOFORCE 1");
144	}
145
146
147	int android_pno_stop(struct i802_bss *bss)
148	{
149	return android_priv_cmd(bss, "PNOFORCE 0");
150	}
151
152
153	#ifdef ANDROID_P2P
a1407217	154	#ifdef ANDROID_LIB_STUB
70a96c81 JM	155
	156	int wpa_driver_set_p2p_noa(void *priv, u8 count, int start, int duration)
	157	{
	158	return 0;
	159	}
	160
	161
	162	int wpa_driver_get_p2p_noa(void priv, u8 buf, size_t len)
	163	{
	164	return 0;
	165	}
	166
	167
	168	int wpa_driver_set_p2p_ps(void *priv, int legacy_ps, int opp_ps, int ctwindow)
	169	{
	170	return -1;
	171	}
	172
	173
	174	int wpa_driver_set_ap_wps_p2p_ie(void priv, const struct wpabuf beacon,
	175	const struct wpabuf *proberesp,
	176	const struct wpabuf *assocresp)
	177	{
	178	return 0;
	179	}
	180
a1407217	181	#endif /* ANDROID_LIB_STUB */
70a96c81 JM	182	#endif /* ANDROID_P2P */
	183
	184
	185	int android_nl_socket_set_nonblocking(struct nl_handle *handle)
	186	{
	187	return fcntl(nl_socket_get_fd(handle), F_SETFL, O_NONBLOCK);
	188	}
	189
	190