src/drivers/driver_iphone.m - LeafOS-Project/android_external_wpa_supplicant_8 - Gitiles

 /*
  * WPA Supplicant - iPhone/iPod touch Apple80211 driver interface
  * Copyright (c) 2007, Jouni Malinen <j@w1.fi>
  *
  * 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"
 #define Boolean __DummyBoolean
 #include <CoreFoundation/CoreFoundation.h>
 #undef Boolean

 #include "common.h"
 #include "driver.h"
 #include "eloop.h"
 #include "common/ieee802_11_defs.h"

 #include "MobileApple80211.h"

 struct wpa_driver_iphone_data {
 	void *ctx;
 	Apple80211Ref wireless_ctx;
 	CFArrayRef scan_results;
 	int ctrl_power;
 };


 static const void * cfdict_get_key_str(CFDictionaryRef dict, const char *key)
 {
 	const void *res;
 	CFStringRef str = CFStringCreateWithCString(kCFAllocatorDefault, key,
 						    kCFStringEncodingMacRoman);
 	if (str == NULL)
 		return NULL;

 	res = CFDictionaryGetValue(dict, str);
 	CFRelease(str);
 	return res;
 }


 static int wpa_driver_iphone_get_ssid(void *priv, u8 *ssid)
 {
 	struct wpa_driver_iphone_data *drv = priv;
 	CFDataRef data;
 	int err, len;

 	err = Apple80211CopyValue(drv->wireless_ctx, APPLE80211_VALUE_SSID, 0,
 				  &data);
 	if (err != 0) {
 		wpa_printf(MSG_DEBUG, "iPhone: Apple80211CopyValue(SSID) "
 			   "failed: %d", err);
 		return -1;
 	}

 	len = CFDataGetLength(data);
 	if (len > 32) {
 		CFRelease(data);
 		return -1;
 	}
 	os_memcpy(ssid, CFDataGetBytePtr(data), len);
 	CFRelease(data);

 	return len;
 }


 static int wpa_driver_iphone_get_bssid(void *priv, u8 *bssid)
 {
 	struct wpa_driver_iphone_data *drv = priv;
 	CFStringRef data;
 	int err;
 	int a1, a2, a3, a4, a5, a6;

 	err = Apple80211CopyValue(drv->wireless_ctx, APPLE80211_VALUE_BSSID, 0,
 				  &data);
 	if (err != 0) {
 		wpa_printf(MSG_DEBUG, "iPhone: Apple80211CopyValue(BSSID) "
 			   "failed: %d", err);
 		return -1;
 	}

 	sscanf(CFStringGetCStringPtr(data, kCFStringEncodingMacRoman),
 	       "%x:%x:%x:%x:%x:%x", &a1, &a2, &a3, &a4, &a5, &a6);
 	bssid[0] = a1;
 	bssid[1] = a2;
 	bssid[2] = a3;
 	bssid[3] = a4;
 	bssid[4] = a5;
 	bssid[5] = a6;

 	CFRelease(data);

 	return 0;
 }


 static void wpa_driver_iphone_scan_timeout(void *eloop_ctx, void *timeout_ctx)
 {
 	wpa_supplicant_event(timeout_ctx, EVENT_SCAN_RESULTS, NULL);
 }


 static int wpa_driver_iphone_scan(void *priv, const u8 *ssid, size_t ssid_len)
 {
 	struct wpa_driver_iphone_data *drv = priv;
 	int err;

 	if (drv->scan_results) {
 		CFRelease(drv->scan_results);
 		drv->scan_results = NULL;
 	}

 	err = Apple80211Scan(drv->wireless_ctx, &drv->scan_results, NULL);
 	if (err) {
 		wpa_printf(MSG_DEBUG, "iPhone: Apple80211Scan failed: %d",
 			   err);
 		return -1;
 	}

 	eloop_register_timeout(0, 0, wpa_driver_iphone_scan_timeout, drv,
 			       drv->ctx);
 	return 0;
 }


 static int wpa_driver_iphone_get_scan_results(void *priv,
 					      struct wpa_scan_result *results,
 					      size_t max_size)
 {
 	struct wpa_driver_iphone_data *drv = priv;
 	size_t i, num;

 	if (drv->scan_results == NULL)
 		return 0;

 	num = CFArrayGetCount(drv->scan_results);
 	if (num > max_size)
 		num = max_size;
 	os_memset(results, 0, num * sizeof(struct wpa_scan_result));

 	for (i = 0; i < num; i++) {
 		struct wpa_scan_result *res = &results[i];
 		CFDictionaryRef dict =
 			CFArrayGetValueAtIndex(drv->scan_results, i);
 		CFDataRef data;
 		CFStringRef str;
 		CFNumberRef num;
 		int val;

 		data = cfdict_get_key_str(dict, "SSID");
 		if (data) {
 			res->ssid_len = CFDataGetLength(data);
 			if (res->ssid_len > 32)
 				res->ssid_len = 32;
 			os_memcpy(res->ssid, CFDataGetBytePtr(data),
 				  res->ssid_len);
 		}

 		str = cfdict_get_key_str(dict, "BSSID");
 		if (str) {
 			int a1, a2, a3, a4, a5, a6;
 			sscanf(CFStringGetCStringPtr(
 				       str, kCFStringEncodingMacRoman),
 			       "%x:%x:%x:%x:%x:%x",
 			       &a1, &a2, &a3, &a4, &a5, &a6);
 			res->bssid[0] = a1;
 			res->bssid[1] = a2;
 			res->bssid[2] = a3;
 			res->bssid[3] = a4;
 			res->bssid[4] = a5;
 			res->bssid[5] = a6;
 		}

 		num = cfdict_get_key_str(dict, "CAPABILITIES");
 		if (num) {
 			if (CFNumberGetValue(num, kCFNumberSInt32Type, &val))
 				res->caps = val;
 		}

 		num = cfdict_get_key_str(dict, "CHANNEL");
 		if (num) {
 			if (CFNumberGetValue(num, kCFNumberSInt32Type, &val))
 				res->freq = 2407 + val * 5;
 		}

 		num = cfdict_get_key_str(dict, "RSSI");
 		if (num) {
 			if (CFNumberGetValue(num, kCFNumberSInt32Type, &val))
 				res->level = val;
 		}

 		num = cfdict_get_key_str(dict, "NOISE");
 		if (num) {
 			if (CFNumberGetValue(num, kCFNumberSInt32Type, &val))
 				res->noise = val;
 		}

 		data = cfdict_get_key_str(dict, "IE");
 		if (data) {
 			u8 *ptr = (u8 *) CFDataGetBytePtr(data);
 			int len = CFDataGetLength(data);
 			u8 *pos = ptr, *end = ptr + len;

 			while (pos + 2 < end) {
 				if (pos + 2 + pos[1] > end)
 					break;
 				if (pos[0] == WLAN_EID_RSN &&
 				    pos[1] <= SSID_MAX_WPA_IE_LEN) {
 					os_memcpy(res->rsn_ie, pos,
 						  2 + pos[1]);
 					res->rsn_ie_len = 2 + pos[1];
 				}
 				if (pos[0] == WLAN_EID_VENDOR_SPECIFIC &&
 				    pos[1] > 4 && pos[2] == 0x00 &&
 				    pos[3] == 0x50 && pos[4] == 0xf2 &&
 				    pos[5] == 0x01) {
 					os_memcpy(res->wpa_ie, pos,
 						  2 + pos[1]);
 					res->wpa_ie_len = 2 + pos[1];
 				}

 				pos = pos + 2 + pos[1];
 			}
 		}
 	}

 	return num;
 }


 static void wpa_driver_iphone_assoc_timeout(void *eloop_ctx, void *timeout_ctx)
 {
 	struct wpa_driver_iphone_data *drv = eloop_ctx;
 	u8 bssid[ETH_ALEN];

 	if (wpa_driver_iphone_get_bssid(drv, bssid) != 0) {
 		eloop_register_timeout(1, 0, wpa_driver_iphone_assoc_timeout,
 				       drv, drv->ctx);
 		return;
 	}

 	wpa_supplicant_event(timeout_ctx, EVENT_ASSOC, NULL);
 }


 static int wpa_driver_iphone_associate(
 	void *priv, struct wpa_driver_associate_params *params)
 {
 	struct wpa_driver_iphone_data *drv = priv;
 	int i, num, err;
 	size_t ssid_len;
 	CFDictionaryRef bss = NULL;

 	/*
 	 * TODO: Consider generating parameters instead of just using an entry
 	 * from scan results in order to support ap_scan=2.
 	 */

 	if (drv->scan_results == NULL) {
 		wpa_printf(MSG_DEBUG, "iPhone: No scan results - cannot "
 			   "associate");
 		return -1;
 	}

 	num = CFArrayGetCount(drv->scan_results);

 	for (i = 0; i < num; i++) {
 		CFDictionaryRef dict =
 			CFArrayGetValueAtIndex(drv->scan_results, i);
 		CFDataRef data;

 		data = cfdict_get_key_str(dict, "SSID");
 		if (data == NULL)
 			continue;

 		ssid_len = CFDataGetLength(data);
 		if (ssid_len != params->ssid_len ||
 		    os_memcmp(CFDataGetBytePtr(data), params->ssid, ssid_len)
 		    != 0)
 			continue;

 		bss = dict;
 		break;
 	}

 	if (bss == NULL) {
 		wpa_printf(MSG_DEBUG, "iPhone: Could not find SSID from scan "
 			   "results - cannot associate");
 		return -1;
 	}

 	wpa_printf(MSG_DEBUG, "iPhone: Trying to associate with a BSS found "
 		   "from scan results");

 	err = Apple80211Associate(drv->wireless_ctx, bss, NULL);
 	if (err) {
 		wpa_printf(MSG_DEBUG, "iPhone: Apple80211Associate() failed: "
 			   "%d", err);
 		return -1;
 	}

 	/*
 	 * Driver is actually already associated; report association from an
 	 * eloop callback.
 	 */
 	eloop_cancel_timeout(wpa_driver_iphone_assoc_timeout, drv, drv->ctx);
 	eloop_register_timeout(0, 0, wpa_driver_iphone_assoc_timeout, drv,
 			       drv->ctx);

 	return 0;
 }


 static int wpa_driver_iphone_set_key(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)
 {
 	/*
 	 * TODO: Need to either support configuring PMK for 4-way handshake or
 	 * PTK for TKIP/CCMP.
 	 */
 	return -1;
 }


 static int wpa_driver_iphone_get_capa(void *priv, struct wpa_driver_capa *capa)
 {
 	os_memset(capa, 0, sizeof(*capa));

 	capa->key_mgmt = WPA_DRIVER_CAPA_KEY_MGMT_WPA |
 		WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
 		WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK |
 		WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK;
 	capa->enc = WPA_DRIVER_CAPA_ENC_WEP40 | WPA_DRIVER_CAPA_ENC_WEP104 |
 		WPA_DRIVER_CAPA_ENC_TKIP | WPA_DRIVER_CAPA_ENC_CCMP;
 	capa->auth = WPA_DRIVER_AUTH_OPEN | WPA_DRIVER_AUTH_SHARED |
 		WPA_DRIVER_AUTH_LEAP;
 	capa->flags = WPA_DRIVER_FLAGS_4WAY_HANDSHAKE;

 	return 0;
 }


 static void * wpa_driver_iphone_init(void *ctx, const char *ifname)
 {
 	struct wpa_driver_iphone_data *drv;
 	int err;
 	char power;
 	CFStringRef name;
 	CFDictionaryRef dict;

 	drv = os_zalloc(sizeof(*drv));
 	if (drv == NULL)
 		return NULL;
 	drv->ctx = ctx;
 	err = Apple80211Open(&drv->wireless_ctx);
 	if (err) {
 		wpa_printf(MSG_ERROR, "iPhone: Apple80211Open failed: %d",
 			   err);
 		os_free(drv);
 		return NULL;
 	}

 	name = CFStringCreateWithCString(kCFAllocatorDefault, ifname,
 					 kCFStringEncodingISOLatin1);
 	if (name == NULL) {
 		wpa_printf(MSG_ERROR, "iPhone: ifname -> CFString failed");
 		Apple80211Close(drv->wireless_ctx);
 		os_free(drv);
 		return NULL;
 	}

 	err = Apple80211BindToInterface(drv->wireless_ctx, name);
 	CFRelease(name);

 	if (err) {
 		wpa_printf(MSG_ERROR, "iPhone: Apple80211BindToInterface "
 			   "failed: %d", err);
 		Apple80211Close(drv->wireless_ctx);
 		os_free(drv);
 		return NULL;
 	}

 	err = Apple80211GetPower(drv->wireless_ctx, &power);
 	if (err)
 		wpa_printf(MSG_DEBUG, "iPhone: Apple80211GetPower failed: %d",
 			   err);

 	wpa_printf(MSG_DEBUG, "iPhone: Power=%d", power);

 	if (!power) {
 		drv->ctrl_power = 1;
 		err = Apple80211SetPower(drv->wireless_ctx, 1);
 		if (err) {
 			wpa_printf(MSG_DEBUG, "iPhone: Apple80211SetPower "
 				   "failed: %d", err);
 			Apple80211Close(drv->wireless_ctx);
 			os_free(drv);
 			return NULL;
 		}
 	}

 	err = Apple80211GetInfoCopy(drv->wireless_ctx, &dict);
 	if (err == 0) {
 		CFShow(dict);
 		CFRelease(dict);
 	} else {
 		printf("Apple80211GetInfoCopy: %d\n", err);
 	}

 	return drv;
 }


 static void wpa_driver_iphone_deinit(void *priv)
 {
 	struct wpa_driver_iphone_data *drv = priv;
 	int err;

 	eloop_cancel_timeout(wpa_driver_iphone_scan_timeout, drv, drv->ctx);
 	eloop_cancel_timeout(wpa_driver_iphone_assoc_timeout, drv, drv->ctx);

 	if (drv->ctrl_power) {
 		wpa_printf(MSG_DEBUG, "iPhone: Power down the interface");
 		err = Apple80211SetPower(drv->wireless_ctx, 0);
 		if (err) {
 			wpa_printf(MSG_DEBUG, "iPhone: Apple80211SetPower(0) "
 				   "failed: %d", err);
 		}
 	}

 	err = Apple80211Close(drv->wireless_ctx);
 	if (err) {
 		wpa_printf(MSG_DEBUG, "iPhone: Apple80211Close failed: %d",
 			   err);
 	}

 	if (drv->scan_results)
 		CFRelease(drv->scan_results);

 	os_free(drv);
 }


 const struct wpa_driver_ops wpa_driver_iphone_ops = {
 	.name = "iphone",
 	.desc = "iPhone/iPod touch Apple80211 driver",
 	.get_ssid = wpa_driver_iphone_get_ssid,
 	.get_bssid = wpa_driver_iphone_get_bssid,
 	.init = wpa_driver_iphone_init,
 	.deinit = wpa_driver_iphone_deinit,
 	.scan = wpa_driver_iphone_scan,
 	.get_scan_results = wpa_driver_iphone_get_scan_results,
 	.associate = wpa_driver_iphone_associate,
 	.set_key = wpa_driver_iphone_set_key,
 	.get_capa = wpa_driver_iphone_get_capa,
 };
	/*
	* WPA Supplicant - iPhone/iPod touch Apple80211 driver interface
	* Copyright (c) 2007, Jouni Malinen <j@w1.fi>
	*
	* 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"
	#define Boolean __DummyBoolean
	#include <CoreFoundation/CoreFoundation.h>
	#undef Boolean

	#include "common.h"
	#include "driver.h"
	#include "eloop.h"
	#include "common/ieee802_11_defs.h"

	#include "MobileApple80211.h"

	struct wpa_driver_iphone_data {
	void *ctx;
	Apple80211Ref wireless_ctx;
	CFArrayRef scan_results;
	int ctrl_power;
	};


	static const void * cfdict_get_key_str(CFDictionaryRef dict, const char *key)
	{
	const void *res;
	CFStringRef str = CFStringCreateWithCString(kCFAllocatorDefault, key,
	kCFStringEncodingMacRoman);
	if (str == NULL)
	return NULL;

	res = CFDictionaryGetValue(dict, str);
	CFRelease(str);
	return res;
	}


	static int wpa_driver_iphone_get_ssid(void priv, u8 ssid)
	{
	struct wpa_driver_iphone_data *drv = priv;
	CFDataRef data;
	int err, len;

	err = Apple80211CopyValue(drv->wireless_ctx, APPLE80211_VALUE_SSID, 0,
	&data);
	if (err != 0) {
	wpa_printf(MSG_DEBUG, "iPhone: Apple80211CopyValue(SSID) "
	"failed: %d", err);
	return -1;
	}

	len = CFDataGetLength(data);
	if (len > 32) {
	CFRelease(data);
	return -1;
	}
	os_memcpy(ssid, CFDataGetBytePtr(data), len);
	CFRelease(data);

	return len;
	}


	static int wpa_driver_iphone_get_bssid(void priv, u8 bssid)
	{
	struct wpa_driver_iphone_data *drv = priv;
	CFStringRef data;
	int err;
	int a1, a2, a3, a4, a5, a6;

	err = Apple80211CopyValue(drv->wireless_ctx, APPLE80211_VALUE_BSSID, 0,
	&data);
	if (err != 0) {
	wpa_printf(MSG_DEBUG, "iPhone: Apple80211CopyValue(BSSID) "
	"failed: %d", err);
	return -1;
	}

	sscanf(CFStringGetCStringPtr(data, kCFStringEncodingMacRoman),
	"%x:%x:%x:%x:%x:%x", &a1, &a2, &a3, &a4, &a5, &a6);
	bssid[0] = a1;
	bssid[1] = a2;
	bssid[2] = a3;
	bssid[3] = a4;
	bssid[4] = a5;
	bssid[5] = a6;

	CFRelease(data);

	return 0;
	}


	static void wpa_driver_iphone_scan_timeout(void eloop_ctx, void timeout_ctx)
	{
	wpa_supplicant_event(timeout_ctx, EVENT_SCAN_RESULTS, NULL);
	}


	static int wpa_driver_iphone_scan(void priv, const u8 ssid, size_t ssid_len)
	{
	struct wpa_driver_iphone_data *drv = priv;
	int err;

	if (drv->scan_results) {
	CFRelease(drv->scan_results);
	drv->scan_results = NULL;
	}

	err = Apple80211Scan(drv->wireless_ctx, &drv->scan_results, NULL);
	if (err) {
	wpa_printf(MSG_DEBUG, "iPhone: Apple80211Scan failed: %d",
	err);
	return -1;
	}

	eloop_register_timeout(0, 0, wpa_driver_iphone_scan_timeout, drv,
	drv->ctx);
	return 0;
	}


	static int wpa_driver_iphone_get_scan_results(void *priv,
	struct wpa_scan_result *results,
	size_t max_size)
	{
	struct wpa_driver_iphone_data *drv = priv;
	size_t i, num;

	if (drv->scan_results == NULL)
	return 0;

	num = CFArrayGetCount(drv->scan_results);
	if (num > max_size)
	num = max_size;
	os_memset(results, 0, num * sizeof(struct wpa_scan_result));

	for (i = 0; i < num; i++) {
	struct wpa_scan_result *res = &results[i];
	CFDictionaryRef dict =
	CFArrayGetValueAtIndex(drv->scan_results, i);
	CFDataRef data;
	CFStringRef str;
	CFNumberRef num;
	int val;

	data = cfdict_get_key_str(dict, "SSID");
	if (data) {
	res->ssid_len = CFDataGetLength(data);
	if (res->ssid_len > 32)
	res->ssid_len = 32;
	os_memcpy(res->ssid, CFDataGetBytePtr(data),
	res->ssid_len);
	}

	str = cfdict_get_key_str(dict, "BSSID");
	if (str) {
	int a1, a2, a3, a4, a5, a6;
	sscanf(CFStringGetCStringPtr(
	str, kCFStringEncodingMacRoman),
	"%x:%x:%x:%x:%x:%x",
	&a1, &a2, &a3, &a4, &a5, &a6);
	res->bssid[0] = a1;
	res->bssid[1] = a2;
	res->bssid[2] = a3;
	res->bssid[3] = a4;
	res->bssid[4] = a5;
	res->bssid[5] = a6;
	}

	num = cfdict_get_key_str(dict, "CAPABILITIES");
	if (num) {
	if (CFNumberGetValue(num, kCFNumberSInt32Type, &val))
	res->caps = val;
	}

	num = cfdict_get_key_str(dict, "CHANNEL");
	if (num) {
	if (CFNumberGetValue(num, kCFNumberSInt32Type, &val))
	res->freq = 2407 + val * 5;
	}

	num = cfdict_get_key_str(dict, "RSSI");
	if (num) {
	if (CFNumberGetValue(num, kCFNumberSInt32Type, &val))
	res->level = val;
	}

	num = cfdict_get_key_str(dict, "NOISE");
	if (num) {
	if (CFNumberGetValue(num, kCFNumberSInt32Type, &val))
	res->noise = val;
	}

	data = cfdict_get_key_str(dict, "IE");
	if (data) {
	u8 ptr = (u8 ) CFDataGetBytePtr(data);
	int len = CFDataGetLength(data);
	u8 pos = ptr, end = ptr + len;

	while (pos + 2 < end) {
	if (pos + 2 + pos[1] > end)
	break;
	if (pos[0] == WLAN_EID_RSN &&
	pos[1] <= SSID_MAX_WPA_IE_LEN) {
	os_memcpy(res->rsn_ie, pos,
	2 + pos[1]);
	res->rsn_ie_len = 2 + pos[1];
	}
	if (pos[0] == WLAN_EID_VENDOR_SPECIFIC &&
	pos[1] > 4 && pos[2] == 0x00 &&
	pos[3] == 0x50 && pos[4] == 0xf2 &&
	pos[5] == 0x01) {
	os_memcpy(res->wpa_ie, pos,
	2 + pos[1]);
	res->wpa_ie_len = 2 + pos[1];
	}

	pos = pos + 2 + pos[1];
	}
	}
	}

	return num;
	}


	static void wpa_driver_iphone_assoc_timeout(void eloop_ctx, void timeout_ctx)
	{
	struct wpa_driver_iphone_data *drv = eloop_ctx;
	u8 bssid[ETH_ALEN];

	if (wpa_driver_iphone_get_bssid(drv, bssid) != 0) {
	eloop_register_timeout(1, 0, wpa_driver_iphone_assoc_timeout,
	drv, drv->ctx);
	return;
	}

	wpa_supplicant_event(timeout_ctx, EVENT_ASSOC, NULL);
	}


	static int wpa_driver_iphone_associate(
	void priv, struct wpa_driver_associate_params params)
	{
	struct wpa_driver_iphone_data *drv = priv;
	int i, num, err;
	size_t ssid_len;
	CFDictionaryRef bss = NULL;

	/*
	* TODO: Consider generating parameters instead of just using an entry
	* from scan results in order to support ap_scan=2.
	*/

	if (drv->scan_results == NULL) {
	wpa_printf(MSG_DEBUG, "iPhone: No scan results - cannot "
	"associate");
	return -1;
	}

	num = CFArrayGetCount(drv->scan_results);

	for (i = 0; i < num; i++) {
	CFDictionaryRef dict =
	CFArrayGetValueAtIndex(drv->scan_results, i);
	CFDataRef data;

	data = cfdict_get_key_str(dict, "SSID");
	if (data == NULL)
	continue;

	ssid_len = CFDataGetLength(data);
	if (ssid_len != params->ssid_len \|\|
	os_memcmp(CFDataGetBytePtr(data), params->ssid, ssid_len)
	!= 0)
	continue;

	bss = dict;
	break;
	}

	if (bss == NULL) {
	wpa_printf(MSG_DEBUG, "iPhone: Could not find SSID from scan "
	"results - cannot associate");
	return -1;
	}

	wpa_printf(MSG_DEBUG, "iPhone: Trying to associate with a BSS found "
	"from scan results");

	err = Apple80211Associate(drv->wireless_ctx, bss, NULL);
	if (err) {
	wpa_printf(MSG_DEBUG, "iPhone: Apple80211Associate() failed: "
	"%d", err);
	return -1;
	}

	/*
	* Driver is actually already associated; report association from an
	* eloop callback.
	*/
	eloop_cancel_timeout(wpa_driver_iphone_assoc_timeout, drv, drv->ctx);
	eloop_register_timeout(0, 0, wpa_driver_iphone_assoc_timeout, drv,
	drv->ctx);

	return 0;
	}


	static int wpa_driver_iphone_set_key(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)
	{
	/*
	* TODO: Need to either support configuring PMK for 4-way handshake or
	* PTK for TKIP/CCMP.
	*/
	return -1;
	}


	static int wpa_driver_iphone_get_capa(void priv, struct wpa_driver_capa capa)
	{
	os_memset(capa, 0, sizeof(*capa));

	capa->key_mgmt = WPA_DRIVER_CAPA_KEY_MGMT_WPA \|
	WPA_DRIVER_CAPA_KEY_MGMT_WPA2 \|
	WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK \|
	WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK;
	capa->enc = WPA_DRIVER_CAPA_ENC_WEP40 \| WPA_DRIVER_CAPA_ENC_WEP104 \|
	WPA_DRIVER_CAPA_ENC_TKIP \| WPA_DRIVER_CAPA_ENC_CCMP;
	capa->auth = WPA_DRIVER_AUTH_OPEN \| WPA_DRIVER_AUTH_SHARED \|
	WPA_DRIVER_AUTH_LEAP;
	capa->flags = WPA_DRIVER_FLAGS_4WAY_HANDSHAKE;

	return 0;
	}


	static void * wpa_driver_iphone_init(void ctx, const char ifname)
	{
	struct wpa_driver_iphone_data *drv;
	int err;
	char power;
	CFStringRef name;
	CFDictionaryRef dict;

	drv = os_zalloc(sizeof(*drv));
	if (drv == NULL)
	return NULL;
	drv->ctx = ctx;
	err = Apple80211Open(&drv->wireless_ctx);
	if (err) {
	wpa_printf(MSG_ERROR, "iPhone: Apple80211Open failed: %d",
	err);
	os_free(drv);
	return NULL;
	}

	name = CFStringCreateWithCString(kCFAllocatorDefault, ifname,
	kCFStringEncodingISOLatin1);
	if (name == NULL) {
	wpa_printf(MSG_ERROR, "iPhone: ifname -> CFString failed");
	Apple80211Close(drv->wireless_ctx);
	os_free(drv);
	return NULL;
	}

	err = Apple80211BindToInterface(drv->wireless_ctx, name);
	CFRelease(name);

	if (err) {
	wpa_printf(MSG_ERROR, "iPhone: Apple80211BindToInterface "
	"failed: %d", err);
	Apple80211Close(drv->wireless_ctx);
	os_free(drv);
	return NULL;
	}

	err = Apple80211GetPower(drv->wireless_ctx, &power);
	if (err)
	wpa_printf(MSG_DEBUG, "iPhone: Apple80211GetPower failed: %d",
	err);

	wpa_printf(MSG_DEBUG, "iPhone: Power=%d", power);

	if (!power) {
	drv->ctrl_power = 1;
	err = Apple80211SetPower(drv->wireless_ctx, 1);
	if (err) {
	wpa_printf(MSG_DEBUG, "iPhone: Apple80211SetPower "
	"failed: %d", err);
	Apple80211Close(drv->wireless_ctx);
	os_free(drv);
	return NULL;
	}
	}

	err = Apple80211GetInfoCopy(drv->wireless_ctx, &dict);
	if (err == 0) {
	CFShow(dict);
	CFRelease(dict);
	} else {
	printf("Apple80211GetInfoCopy: %d\n", err);
	}

	return drv;
	}


	static void wpa_driver_iphone_deinit(void *priv)
	{
	struct wpa_driver_iphone_data *drv = priv;
	int err;

	eloop_cancel_timeout(wpa_driver_iphone_scan_timeout, drv, drv->ctx);
	eloop_cancel_timeout(wpa_driver_iphone_assoc_timeout, drv, drv->ctx);

	if (drv->ctrl_power) {
	wpa_printf(MSG_DEBUG, "iPhone: Power down the interface");
	err = Apple80211SetPower(drv->wireless_ctx, 0);
	if (err) {
	wpa_printf(MSG_DEBUG, "iPhone: Apple80211SetPower(0) "
	"failed: %d", err);
	}
	}

	err = Apple80211Close(drv->wireless_ctx);
	if (err) {
	wpa_printf(MSG_DEBUG, "iPhone: Apple80211Close failed: %d",
	err);
	}

	if (drv->scan_results)
	CFRelease(drv->scan_results);

	os_free(drv);
	}


	const struct wpa_driver_ops wpa_driver_iphone_ops = {
	.name = "iphone",
	.desc = "iPhone/iPod touch Apple80211 driver",
	.get_ssid = wpa_driver_iphone_get_ssid,
	.get_bssid = wpa_driver_iphone_get_bssid,
	.init = wpa_driver_iphone_init,
	.deinit = wpa_driver_iphone_deinit,
	.scan = wpa_driver_iphone_scan,
	.get_scan_results = wpa_driver_iphone_get_scan_results,
	.associate = wpa_driver_iphone_associate,
	.set_key = wpa_driver_iphone_set_key,
	.get_capa = wpa_driver_iphone_get_capa,
	};