STATIC Boolean
authEAPOLClientItemIDRemovePasswordItem(EAPOLClientItemIDRef itemID)
{
AuthorizationExternalForm * auth_ext_p;
CFDataRef itemID_data;
kern_return_t kret;
int result = ENXIO;
mach_port_t server;
server = eapolcfg_auth_server_port();
if (server == MACH_PORT_NULL) {
return (FALSE);
}
auth_ext_p = EAPOLClientItemIDGetAuthorizationExternalForm(itemID);
itemID_data = itemID_copy_data(itemID);
kret = eapolclientitemid_remove_password(server,
auth_ext_p->bytes,
sizeof(auth_ext_p->bytes),
(xmlData_t)
CFDataGetBytePtr(itemID_data),
CFDataGetLength(itemID_data),
&result);
if (kret != KERN_SUCCESS) {
EAPLOG(LOG_ERR, "eapolclientitemid_remove_password failed %d",
kret);
}
if (result != 0) {
EAPLOG(LOG_DEBUG, "eapolclientitemid_remove_password() returned %d",
result);
}
my_CFRelease(&itemID_data);
return (result == 0);
}
boolean_t
wireless_bind(const char * if_name, wireless_t * wref_p)
{
Apple80211Err error;
boolean_t found = FALSE;
CFStringRef if_name_cf;
Apple80211Ref wref;
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - wireless_bind");
error = Apple80211Open(&wref);
if (error != kA11NoErr) {
EAPLOG(LOG_ERR, "Apple80211Open failed, %x\n", error);
return (FALSE);
}
if_name_cf = CFStringCreateWithCString(NULL, if_name,
kCFStringEncodingASCII);
error = Apple80211BindToInterface(wref, if_name_cf);
CFRelease(if_name_cf);
if (error == kA11NoErr) {
*wref_p = (wireless_t)wref;
found = TRUE;
}
else {
#ifdef TEST_WIRELESS
EAPLOG(LOG_ERR, "Apple80211BindToInterface %s failed, %x\n",
if_name, error);
#endif /* TEST_WIRELESS */
Apple80211Close(wref);
*wref_p = NULL;
}
return (found);
}
static CFArrayRef
wireless_scan_ssid(wireless_t wref, CFStringRef ssid)
{
CFArrayRef bssid_list = NULL;
Apple80211Err error;
CFDictionaryRef scan_args;
CFArrayRef scan_result = NULL;
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - wireless_scan_ssid");
scan_args = make_scan_args(ssid, 1);
error = Apple80211Scan((Apple80211Ref)wref, &scan_result, scan_args);
CFRelease(scan_args);
if (error != kA11NoErr) {
EAPLOG(LOG_ERR, "Apple80211Scan failed, %d\n", error);
goto failed;
}
bssid_list = copy_bssid_list_from_scan(scan_result, ssid);
if (bssid_list == NULL) {
EAPLOG(LOG_ERR, "No scan results\n");
}
else {
CFShow(bssid_list);
}
fflush(stdout);
fflush(stderr);
failed:
my_CFRelease(&scan_result);
return (bssid_list);
}
/*
* Function: copy_interface
* Purpose:
* Get a reference to an SCNetworkInterfaceRef for the specified
* interface name. First try to get an interface configured in the
* current set. If that fails, copy a service configured over the
* specified interface, and add it to the current set.
*
* Return the interface, service, and set for the caller to release.
*/
STATIC SCNetworkInterfaceRef
copy_interface(SCPreferencesRef prefs, CFStringRef if_name,
SCNetworkSetRef * ret_set_p,
SCNetworkServiceRef * ret_service_p)
{
SCNetworkSetRef current_set = NULL;
SCNetworkServiceRef service = NULL;
SCNetworkInterfaceRef net_if;
SCNetworkInterfaceRef ret = NULL;
/* if the interface is part of a service/set, we're done */
net_if = copy_configured_interface(prefs, if_name);
if (net_if != NULL) {
ret = net_if;
CFRetain(ret);
goto done;
}
/* interface isn't part of a service/set, make it so */
net_if = copy_present_interface(if_name);
if (net_if == NULL) {
goto done;
}
/* find the service in any set */
service = copy_service(prefs, net_if);
if (service == NULL) {
EAPLOG(LOG_ERR,
"EAPOLClientConfiguration: can't get service");
goto done;
}
/* add the service to the current set */
current_set = SCNetworkSetCopyCurrent(prefs);
if (current_set == NULL) {
EAPLOG(LOG_ERR,
"EAPOLClientConfiguration: can't get current set");
goto done;
}
if (SCNetworkSetAddService(current_set, service) == FALSE) {
EAPLOG(LOG_ERR,
"EAPOLClientConfiguration: failed to add dummy service");
goto done;
}
/* return this SCNetworkInterfaceRef since it's bound to the prefs */
ret = SCNetworkServiceGetInterface(service);
CFRetain(ret);
done:
my_CFRelease(&net_if);
if (ret == NULL) {
my_CFRelease(&service);
my_CFRelease(¤t_set);
}
*ret_service_p = service;
*ret_set_p = current_set;
return (ret);
}
/**
** interface to eapolcfg_auth MiG routines
**/
STATIC Boolean
authEAPOLClientItemIDSetIdentity(EAPOLClientItemIDRef itemID,
SecIdentityRef identity)
{
AuthorizationExternalForm * auth_ext_p;
CFDataRef id_data = NULL;
OOBData_t id_handle;
mach_msg_type_number_t id_handle_length;
CFDataRef itemID_data = NULL;
kern_return_t kret;
int result = ENXIO;
mach_port_t server;
server = eapolcfg_auth_server_port();
if (server == MACH_PORT_NULL) {
return (FALSE);
}
auth_ext_p = EAPOLClientItemIDGetAuthorizationExternalForm(itemID);
if (identity != NULL) {
id_data = EAPSecIdentityHandleCreate(identity);
if (id_data == NULL) {
goto done;
}
id_handle = (OOBData_t)CFDataGetBytePtr(id_data);
id_handle_length = CFDataGetLength(id_data);
}
else {
id_handle = NULL;
id_handle_length = 0;
}
itemID_data = itemID_copy_data(itemID);
kret = eapolclientitemid_set_identity(server,
auth_ext_p->bytes,
sizeof(auth_ext_p->bytes),
(xmlData_t)
CFDataGetBytePtr(itemID_data),
CFDataGetLength(itemID_data),
id_handle,
id_handle_length,
&result);
if (kret != KERN_SUCCESS) {
EAPLOG(LOG_ERR, "eapolclientitemid_set_identity failed %d",
kret);
}
if (result != 0) {
EAPLOG(LOG_NOTICE, "eapolclientitemid_set_identity() returned %d",
result);
}
done:
my_CFRelease(&itemID_data);
my_CFRelease(&id_data);
return (result == 0);
}
static void
async_scan_callback(wireless_t wref, CFArrayRef bssid_list, void * arg)
{
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - async_scan_callback");
if (bssid_list == NULL) {
EAPLOG(LOG_ERR, "No scan results\n");
}
else {
CFShow(bssid_list);
}
return;
}
static char *
wireless_first(wireless_t * wref_p)
{
int count;
Apple80211Err error;
int i;
CFArrayRef if_name_list;
char * ret_name = NULL;
Apple80211Ref wref;
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - wireless_first");
error = Apple80211Open(&wref);
if (error != kA11NoErr) {
EAPLOG(LOG_ERR, "Apple80211Open failed, %x\n", error);
return (NULL);
}
error = Apple80211GetIfListCopy(wref, &if_name_list);
if (error != kA11NoErr) {
EAPLOG(LOG_ERR, "Apple80211GetIfListCopy failed, %x\n", error);
goto done;
}
count = CFArrayGetCount(if_name_list);
if (count > 0) {
CFStringRef if_name;
if_name = CFArrayGetValueAtIndex(if_name_list, 0);
error = Apple80211BindToInterface(wref, if_name);
if (error != kA11NoErr) {
EAPLOG(LOG_ERR, "Apple80211BindToInterface failed, %x\n",
error);
}
else {
ret_name = my_CFStringToCString(if_name, kCFStringEncodingASCII);
}
}
CFRelease(if_name_list);
done:
if (ret_name == NULL) {
Apple80211Close(wref);
*wref_p = NULL;
}
else {
*wref_p = (wireless_t)wref;
}
return (ret_name);
}
/*
* Function: set_eapol_configuration
* Purpose:
* Set the EAPOL configuration in the prefs.
*/
STATIC Boolean
set_eapol_configuration(SCPreferencesRef prefs, CFStringRef if_name,
CFDictionaryRef dict)
{
SCNetworkSetRef current_set = NULL;
SCNetworkInterfaceRef net_if_save;
Boolean ret = FALSE;
SCNetworkServiceRef service = NULL;
net_if_save = copy_interface(prefs, if_name, ¤t_set, &service);
if (net_if_save != NULL) {
ret = SCNetworkInterfaceSetExtendedConfiguration(net_if_save, kEAPOL,
dict);
if (ret == FALSE) {
EAPLOG(LOG_ERR,
"EAPOLClientConfiguration: SetExtendedConfiguration failed");
}
}
if (current_set != NULL) {
SCNetworkSetRemoveService(current_set, service);
CFRelease(current_set);
}
my_CFRelease(&service);
my_CFRelease(&net_if_save);
return (ret);
}
static bool
wireless_async_scan_ssid(wireless_t this_wref, CFStringRef ssid)
{
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - wireless_async_scan_ssid");
return (wireless_scan(this_wref, ssid, 1, async_scan_callback, (void *)ssid));
}
void wireless_clear_wpa_pmk_cache (wireless_t wref){
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - wireless_clear_wpa_pmk_cache");
return;
}
boolean_t
wireless_set_wpa_pmk(wireless_t wref,
const struct ether_addr * bssid,
const uint8_t * key, int key_length)
{
struct apple80211_key akey;
EAPLOG(LOG_ERR, "######## DEBUG ####### - wireless_set_wpa_pmk");
/* validate the key_length */
if (key_length > 32 || key_length < 0) {
return (FALSE);
}
bzero(&akey, sizeof(akey));
akey.version = APPLE80211_VERSION;
if (key_length != 0) {
/* copy the session key, zero-padding to 32 bytes */
memcpy(akey.key, key, key_length);
key_length = 32;
}
akey.key_len = (u_int32_t)key_length;
if (bssid != NULL) {
akey.key_cipher_type = APPLE80211_CIPHER_PMKSA;
akey.key_ea = *bssid;
}
else {
akey.key_cipher_type = APPLE80211_CIPHER_PMK;
}
return (Apple80211Set((Apple80211Ref)wref, APPLE80211_IOC_CIPHER_KEY, 0,
&akey, sizeof(akey)) == kA11NoErr);
}
CFDictionaryRef
make_scan_args(CFStringRef ssid, int num_scans)
{
uint32_t n;
CFMutableDictionaryRef scan_args;
CFNumberRef val;
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - make_scan_args");
scan_args = CFDictionaryCreateMutable(NULL, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFDictionarySetValue(scan_args, APPLE80211KEY_SCAN_SSID, ssid);
CFDictionarySetValue(scan_args, APPLE80211KEY_SCAN_MERGE,
kCFBooleanFalse);
n = num_scans;
val = CFNumberCreate(NULL, kCFNumberSInt32Type, &n);
CFDictionarySetValue(scan_args, APPLE80211KEY_SCAN_NUM_SCANS, val);
CFRelease(val);
n = APPLE80211_MODE_AUTO;
val = CFNumberCreate(NULL, kCFNumberSInt32Type, &n);
CFDictionarySetValue(scan_args, APPLE80211KEY_SCAN_PHY_MODE, val);
CFRelease(val);
n = APPLE80211_SCAN_TYPE_ACTIVE;
val = CFNumberCreate(NULL, kCFNumberSInt32Type, &n);
CFDictionarySetValue(scan_args, APPLE80211KEY_SCAN_TYPE, val);
CFRelease(val);
return (scan_args);
}
boolean_t
wireless_ap_mac(wireless_t wref, struct ether_addr * AP_mac)
{
const struct ether_addr no_ap = { {0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } };
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - wireless_ap_mac");
#if TARGET_OS_EMBEDDED
if (get_ap_address((Apple80211Ref)wref, AP_mac) == FALSE) {
return (FALSE);
}
#else
if (Apple80211Get((Apple80211Ref)wref, APPLE80211_IOC_BSSID, 0,
AP_mac, sizeof(*AP_mac)) != kA11NoErr) {
return (FALSE);
}
#endif
/* Work around for Atheros: <rdar://problem/5255595> */
if (memcmp(AP_mac, &no_ap, sizeof(no_ap)) == 0) {
return (FALSE);
}
return (TRUE);
}
static __inline__ boolean_t
get_ap_address(Apple80211Ref wref, struct ether_addr * AP_mac)
{
CFMutableStringRef ea_str_cf;
boolean_t ret = FALSE;
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - get_ap_address");
ea_str_cf = CFStringCreateMutable(NULL, 0);
if (Apple80211Get(wref, APPLE80211_IOC_BSSID, 0, ea_str_cf, 0)
== kA11NoErr) {
char * ea_str;
ea_str = my_CFStringToCString(ea_str_cf, kCFStringEncodingASCII);
if (ea_str != NULL) {
struct ether_addr * ret_ea = ether_aton(ea_str);
if (ret_ea != NULL) {
*AP_mac = *ret_ea;
ret = TRUE;
}
free(ea_str);
}
}
CFRelease(ea_str_cf);
return (ret);
}
STATIC mach_port_t
eapolcfg_auth_server_port(void)
{
kern_return_t kret;
mach_port_t server;
#ifdef BOOTSTRAP_PRIVILEGED_SERVER
kret = bootstrap_look_up2(bootstrap_port,
EAPOLCFG_AUTH_SERVER,
&server,
0,
BOOTSTRAP_PRIVILEGED_SERVER);
#else /* BOOTSTRAP_PRIVILEGED_SERVER */
kret = bootstrap_look_up(bootstrap_port, EAPOLCFG_AUTH_SERVER, server_p);
#endif /* BOOTSTRAP_PRIVILEGED_SERVER */
if (kret != BOOTSTRAP_SUCCESS) {
/* just to make sure */
server = MACH_PORT_NULL;
EAPLOG(LOG_NOTICE, "EAPOLClientItemID: can't lookup eapolcfg_auth");
}
return (server);
}
boolean_t
wireless_set_wpa_key(wireless_t wref,
const struct ether_addr * bssid,
const uint8_t * key, int key_length) {
EAPLOG(LOG_ERR, "######## DEBUG ####### - wireless_set_wpa_key");
return wireless_set_wpa_pmk(wref, bssid, key, key_length);
}
void
wireless_free(wireless_t wref)
{
EAPLOG(LOG_ERR, "######## DEBUG ####### - wireless_free");
wireless_scan_cancel(wref);
Apple80211Close((Apple80211Ref)wref);
return;
}
void wireless_disassociate(wireless_t wref)
{
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - wireless_disassociate");
#if TARGET_OS_EMBEDDED
Apple80211Set((Apple80211Ref)wref, APPLE80211_IOC_DISASSOCIATE, 0, 0, 0);
#else
Apple80211Err error;
error = Apple80211Disassociate( (Apple80211Ref)wref );
if (error != kA11NoErr) {
EAPLOG(LOG_ERR,
"wireless_disassociate: WirelessDisassociate failed, %x\n",
error);
}
#endif
return;
}
static boolean_t
wireless_join(wireless_t wref, CFStringRef ssid)
{
Apple80211Err error;
boolean_t ret = FALSE;
CFMutableDictionaryRef scan_args = NULL;
CFArrayRef scan_result = NULL;
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - wireless_join");
scan_args = CFDictionaryCreateMutable(NULL, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks );
CFDictionarySetValue(scan_args, APPLE80211KEY_SCAN_SSID, ssid);
error = Apple80211Scan((Apple80211Ref)wref, &scan_result, scan_args);
CFRelease(scan_args);
if (error != kA11NoErr) {
EAPLOG(LOG_ERR, "Apple80211Scan failed, %d\n", error);
return (FALSE);
}
if (CFArrayGetCount(scan_result) > 0) {
CFDictionaryRef scan_dict;
scan_dict = CFArrayGetValueAtIndex(scan_result, 0);
error = Apple80211Associate((Apple80211Ref)wref, scan_dict, NULL);
if (error != kA11NoErr) {
error = Apple80211Associate((Apple80211Ref)wref,
scan_dict, CFSTR("1234567890"));
}
if (error == kA11NoErr) {
ret = TRUE;
}
else {
EAPLOG(LOG_ERR, "Apple80211Associate failed, %d\n", error);
CFShow(scan_dict);
}
}
if (scan_result != NULL) {
CFRelease(scan_result);
}
return (ret);
}
STATIC SCPreferencesRef
get_sc_prefs(EAPOLClientConfigurationRef cfg)
{
if (cfg->sc_prefs == NULL) {
cfg->sc_prefs = SCPreferencesCreate(NULL, kPrefsName, NULL);
if (cfg->sc_prefs == NULL) {
EAPLOG(LOG_NOTICE,
"EAPOLClientConfiguration: SCPreferencesCreate failed, %s",
SCErrorString(SCError()));
}
}
return (cfg->sc_prefs);
}
static scanCallbackEntryRef
scanCallbackEntryFind(Apple80211Ref wref)
{
scanCallbackEntryRef scan;
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - scanCallbackEntryFind");
TAILQ_FOREACH(scan, S_scanCallbackHead_p, link) {
if (scan->wref == wref) {
return (scan);
}
}
return (NULL);
}
static CFDataRef
wireless_copy_ssid_data(wireless_t wref)
{
CFMutableDataRef ssid;
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - wireless_copy_ssid_data");
ssid = CFDataCreateMutable(kCFAllocatorDefault, 0);
if (Apple80211Get((Apple80211Ref)wref, APPLE80211_IOC_SSID, 0,
ssid, 0) != kA11NoErr) {
CFRelease(ssid);
return (NULL);
}
return ((CFDataRef)ssid);
}
/**
** scanning
**/
static CFDataRef
bssid_string_to_data(CFStringRef bssid)
{
struct ether_addr * eaddr;
char val[32];
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - bssid_string_to_data");
if (CFStringGetCString(bssid, val, sizeof(val), kCFStringEncodingASCII)
== FALSE) {
return (NULL);
}
eaddr = ether_aton(val);
if (eaddr == NULL) {
return (NULL);
}
return (CFDataCreate(NULL, (const UInt8 *)eaddr, sizeof(*eaddr)));
}
static CFArrayRef
copy_bssid_list_from_scan(CFArrayRef scan_result, CFStringRef ssid)
{
CFMutableArrayRef bssid_list = NULL;
int count;
int i;
CFRange range;
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - copy_bssid_list_from_scan");
count = CFArrayGetCount(scan_result);
if (count == 0) {
goto failed;
}
bssid_list = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
range.location = 0;
range.length = 0;
for (i = 0; i < count; i++) {
CFStringRef bssid;
CFDataRef bssid_data;
CFDictionaryRef dict = CFArrayGetValueAtIndex(scan_result, i);
CFStringRef this_ssid;
this_ssid = CFDictionaryGetValue(dict, APPLE80211KEY_SSID_STR);
if (this_ssid == NULL || !CFEqual(this_ssid, ssid)) {
continue;
}
bssid = CFDictionaryGetValue(dict, APPLE80211KEY_BSSID);
if (isA_CFString(bssid) == NULL) {
continue;
}
bssid_data = bssid_string_to_data(bssid);
if (bssid_data != NULL) {
if (!CFArrayContainsValue(bssid_list, range, bssid_data)) {
CFArrayAppendValue(bssid_list, bssid_data);
range.length++;
}
CFRelease(bssid_data);
}
}
if (CFArrayGetCount(bssid_list) == 0) {
CFRelease(bssid_list);
bssid_list = NULL;
}
failed:
return (bssid_list);
}
CFDictionaryRef
make_scan_args(CFStringRef ssid, int num_scans)
{
uint32_t n;
CFMutableDictionaryRef scan_args;
CFNumberRef val;
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - make_scan_args");
scan_args = CFDictionaryCreateMutable(NULL, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFDictionarySetValue(scan_args, APPLE80211KEY_SCAN_SSID, ssid);
CFDictionarySetValue(scan_args, APPLE80211KEY_SCAN_MERGE,
kCFBooleanFalse);
n = num_scans;
val = CFNumberCreate(NULL, kCFNumberSInt32Type, &n);
CFDictionarySetValue(scan_args, APPLE80211KEY_SCAN_NUM_SCANS, val);
CFRelease(val);
n = APPLE80211_MODE_AUTO;
val = CFNumberCreate(NULL, kCFNumberSInt32Type, &n);
CFDictionarySetValue(scan_args, APPLE80211KEY_SCAN_PHY_MODE, val);
CFRelease(val);
n = APPLE80211_SCAN_TYPE_ACTIVE;
val = CFNumberCreate(NULL, kCFNumberSInt32Type, &n);
CFDictionarySetValue(scan_args, APPLE80211KEY_SCAN_TYPE, val);
CFRelease(val);
return (scan_args);
}
static scanCallbackEntryRef
scanCallbackEntryFind(Apple80211Ref wref)
{
scanCallbackEntryRef scan;
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - scanCallbackEntryFind");
TAILQ_FOREACH(scan, S_scanCallbackHead_p, link) {
if (scan->wref == wref) {
return (scan);
}
}
return (NULL);
}
#ifdef APPLE80211KEY_SCAN_BSSID_LIST
static void
scanCallbackEvent(Apple80211Err err, Apple80211Ref wref,
UInt32 event, void * eventData, UInt32 eventDataLen,
void * context)
#else /* APPLE80211KEY_SCAN_BSSID_LIST */
static void
scanCallbackEvent(Apple80211Err err, Apple80211Ref wref,
UInt8 event, void * eventData, void * context)
#endif /* APPLE80211KEY_SCAN_BSSID_LIST */
{
void * arg;
CFArrayRef bssid_list;
scanCallbackEntryRef callback;
wireless_scan_callback_t func;
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - scanCallbackEvent");
switch (event) {
case APPLE80211_M_SCAN_DONE:
callback = scanCallbackEntryFind(wref);
if (callback == NULL) {
EAPLOG(LOG_ERR, "%s: no callback?\n",
__FUNCTION__);
break;
}
func = callback->func;
arg = callback->arg;
callback->state = kScanCallbackStateComplete;
bssid_list = copy_bssid_list_from_scan(eventData, callback->ssid);
(*func)((wireless_t)wref, bssid_list, arg);
if (bssid_list != NULL) {
CFRelease(bssid_list);
}
break;
default:
EAPLOG(LOG_ERR, "%s: unexpected event %d",
__FUNCTION__, (int)event);
break;
}
return;
}
CFStringRef
wireless_copy_ssid_string(wireless_t wref)
{
CFDataRef ssid;
CFStringRef ssid_str;
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - wireless_copy_ssid_string");
ssid = wireless_copy_ssid_data(wref);
if (ssid == NULL) {
return (NULL);
}
ssid_str = ssid_string_from_data(ssid);
CFRelease(ssid);
return (ssid_str);
}
static CFArrayRef
copy_bssid_list_from_scan(CFArrayRef scan_result, CFStringRef ssid)
{
CFMutableArrayRef bssid_list = NULL;
int count;
int i;
CFRange range;
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - copy_bssid_list_from_scan");
count = CFArrayGetCount(scan_result);
if (count == 0) {
goto failed;
}
bssid_list = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
range.location = 0;
range.length = 0;
for (i = 0; i < count; i++) {
CFStringRef bssid;
CFDataRef bssid_data;
CFDictionaryRef dict = CFArrayGetValueAtIndex(scan_result, i);
CFStringRef this_ssid;
this_ssid = CFDictionaryGetValue(dict, APPLE80211KEY_SSID_STR);
if (this_ssid == NULL || !CFEqual(this_ssid, ssid)) {
continue;
}
bssid = CFDictionaryGetValue(dict, APPLE80211KEY_BSSID);
if (isA_CFString(bssid) == NULL) {
continue;
}
bssid_data = bssid_string_to_data(bssid);
if (bssid_data != NULL) {
if (!CFArrayContainsValue(bssid_list, range, bssid_data)) {
CFArrayAppendValue(bssid_list, bssid_data);
range.length++;
}
CFRelease(bssid_data);
}
}
if (CFArrayGetCount(bssid_list) == 0) {
CFRelease(bssid_list);
bssid_list = NULL;
}
failed:
return (bssid_list);
}
/**
** scanning
**/
static CFDataRef
bssid_string_to_data(CFStringRef bssid)
{
struct ether_addr * eaddr;
char val[32];
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - bssid_string_to_data");
if (CFStringGetCString(bssid, val, sizeof(val), kCFStringEncodingASCII)
== FALSE) {
return (NULL);
}
eaddr = ether_aton(val);
if (eaddr == NULL) {
return (NULL);
}
return (CFDataCreate(NULL, (const UInt8 *)eaddr, sizeof(*eaddr)));
}
void
wireless_scan_cancel(wireless_t this_wref)
{
scanCallbackEntryRef callback;
Apple80211Ref wref = (Apple80211Ref)this_wref;
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - wireless_scan_cancel");
callback = scanCallbackEntryFind(wref);
if (callback == NULL) {
return;
}
TAILQ_REMOVE(S_scanCallbackHead_p, callback, link);
/* (void)Apple80211StopMonitoringEvent(wref, APPLE80211_M_SCAN_DONE); */
(void)Apple80211EventMonitoringHalt(wref);
CFRelease(callback->ssid);
free(callback);
return;
}
static CFStringRef
ssid_string_from_data(CFDataRef data)
{
CFStringRef ssid_str;
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - ssid_string_from_data");
ssid_str = CFStringCreateWithBytes(NULL,
CFDataGetBytePtr(data),
CFDataGetLength(data),
kCFStringEncodingUTF8,
FALSE);
if (ssid_str == NULL) {
ssid_str = CFStringCreateWithBytes(NULL,
CFDataGetBytePtr(data),
CFDataGetLength(data),
kCFStringEncodingMacRoman,
FALSE);
}
return (ssid_str);
}
/* get the ssid without linking against AirPort framework */
static CFStringRef
wireless_ssid_ioc(const char * if_name)
{
struct apple80211req req;
int s;
uint8_t ssid[APPLE80211_MAX_SSID_LEN];
CFStringRef ssid_str = NULL;
EAPLOG(LOG_ERR, "######## DEBUG ####### - FAIL - wireless_ssid_ioc");
s = socket(AF_INET, SOCK_DGRAM, 0);
if (s == -1) {
return (NULL);
}
bzero(&req, sizeof(req));
req.req_len = APPLE80211_MAX_SSID_LEN;
req.req_data = ssid;
req.req_type = APPLE80211_IOC_SSID;
strlcpy(req.req_if_name, if_name, sizeof(req.req_if_name));
if (ioctl(s, SIOCGA80211, (char *)&req) < 0) {
perror("SIOCGA80211");
goto done;
}
ssid_str = CFStringCreateWithBytes(NULL, ssid, req.req_len,
kCFStringEncodingUTF8,
FALSE);
if (ssid_str == NULL) {
ssid_str = CFStringCreateWithBytes(NULL, ssid, req.req_len,
kCFStringEncodingMacRoman,
FALSE);
}
done:
close(s);
return (ssid_str);
}
int
main(int argc, char * argv[])
{
int a_flag = 0;
struct ether_addr AP_mac;
int ch;
boolean_t disassociate = FALSE;
const char * if_name = NULL;
boolean_t has_wireless;
const char * key_str = NULL;
const char * network = NULL;
int scan_current_ssid = FALSE;
struct sockaddr_dl w;
wireless_t wref;
while ((ch = getopt(argc, argv, "adhHi:k:sx:")) != EOF) {
switch ((char)ch) {
case 'a':
a_flag = 1;
break;
case 'h':
case 'H':
EAPLOG(LOG_ERR,
"usage: wireless [ -i <interface> ] ( -d | -k | -x <ssid> | -s [ -a ])\n");
exit(0);
break;
case 'x': /* join network */
network = optarg;
break;
case 'k': /* set the wireless key */
key_str = optarg;
break;
case 'd':
disassociate = TRUE;
break;
case 'i': /* specify the interface */
if_name = optarg;
break;
case 's':
scan_current_ssid = TRUE;
break;
default:
break;
}
}
if (if_name != NULL) {
if (wireless_bind(if_name, &wref) == FALSE) {
printf("interface '%s' is not present or not AirPort\n",
if_name);
exit(1);
}
}
else if ((if_name = wireless_first(&wref)) == NULL) {
printf("no AirPort card\n");
exit(0);
}
get_mac_address(if_name, &w);
printf("AirPort: %s %s\n", if_name,
ether_ntoa((struct ether_addr *)(w.sdl_data + w.sdl_nlen)));
if (wireless_ap_mac(wref, &AP_mac) == FALSE) {
printf("Not associated\n");
}
else {
CFStringRef ssid;
printf("Access Point: %s\n", ether_ntoa(&AP_mac));
ssid = wireless_copy_ssid_string(wref);
if (ssid != NULL) {
printf("SSID: ");
fflush(stdout);
CFShow(ssid);
fflush(stderr);
}
if (wireless_is_wpa_enterprise(wref) == TRUE) {
printf("WPA Enterprise\n");
}
else {
printf("Not WPA Enterprise\n");
}
if (disassociate) {
wireless_disassociate(wref);
goto done;
}
else if (scan_current_ssid) {
if (a_flag) {
if (wireless_async_scan_ssid(wref, ssid)) {
CFRunLoopObserverContext context
= { 0, NULL, NULL, NULL, NULL };
CFRunLoopObserverRef observer;
struct ssid_wref ref;
ref.ssid = ssid;
ref.wref = wref;
context.info = &ref;
observer
= CFRunLoopObserverCreate(NULL,
kCFRunLoopBeforeWaiting,
TRUE, 0, before_blocking,
&context);
if (observer != NULL) {
CFRunLoopAddObserver(CFRunLoopGetCurrent(), observer,
kCFRunLoopDefaultMode);
}
else {
EAPLOG(LOG_ERR, "start_initialization: "
"CFRunLoopObserverCreate failed!");
}
CFRunLoopRun();
}
else {
exit(1);
}
}
else {
wireless_scan_ssid(wref, ssid);
}
}
my_CFRelease(&ssid);
}
if (key_str) {
uint8_t key[13];
int key_len;
int hex_len = strlen(key_str);
if (hex_len & 0x1) {
EAPLOG(LOG_ERR, "invalid key, odd number of hex bytes\n");
exit(1);
}
key_len = hex_len / 2;
switch (key_len) {
case 5:
case 13:
hexstrtobin(key_str, hex_len, key, key_len);
if (wireless_set_key(wref, 0, 0, key, key_len)
== FALSE) {
EAPLOG(LOG_ERR, "wireless_set_key failed\n");
}
break;
default:
EAPLOG(LOG_ERR,
"invalid key length %d,"
" must be 5 or 13 hex bytes\n", key_len);
exit(1);
break;
}
}
else if (network != NULL) {
CFDataRef data;
CFStringRef ssid_str;
data = CFDataCreateWithBytesNoCopy(NULL, (const UInt8 *)network,
strlen(network), kCFAllocatorNull);
ssid_str = ssid_string_from_data(data);
EAPLOG(LOG_ERR, "attempting to join network '%s'\n", network);
if (wireless_join(wref, ssid_str) == FALSE) {
EAPLOG(LOG_ERR, "wireless_join failed\n");
}
}
done:
wireless_free(wref);
exit(0);
return (0);
}
