src/drivers/driver_osx.m

   1 /*
   2  * WPA Supplicant - Mac OS X Apple80211 driver interface
   3  * Copyright (c) 2007, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #include "includes.h"
  16 #define Boolean __DummyBoolean
  17 #include <CoreFoundation/CoreFoundation.h>
  18 #undef Boolean
  19
  20 #include "common.h"
  21 #include "driver.h"
  22 #include "eloop.h"
  23 #include "common/ieee802_11_defs.h"
  24
  25 #include "Apple80211.h"
  26
  27 struct wpa_driver_osx_data {
  28         void *ctx;
  29         WirelessRef wireless_ctx;
  30         CFArrayRef scan_results;
  31 };
  32
  33
  34 #ifndef CONFIG_NO_STDOUT_DEBUG
  35 extern int wpa_debug_level;
  36
  37 static void dump_dict_cb(const void *key, const void *value, void *context)
  38 {
  39         if (MSG_DEBUG < wpa_debug_level)
  40                 return;
  41
  42         wpa_printf(MSG_DEBUG, "Key:");
  43         CFShow(key);
  44         wpa_printf(MSG_DEBUG, "Value:");
  45         CFShow(value);
  46 }
  47 #endif /* CONFIG_NO_STDOUT_DEBUG */
  48
  49
  50 static void wpa_driver_osx_dump_dict(CFDictionaryRef dict, const char *title)
  51 {
  52 #ifndef CONFIG_NO_STDOUT_DEBUG
  53         wpa_printf(MSG_DEBUG, "OSX: Dump dictionary %s - %u entries",
  54                    title, (unsigned int) CFDictionaryGetCount(dict));
  55         CFDictionaryApplyFunction(dict, dump_dict_cb, NULL);
  56 #endif /* CONFIG_NO_STDOUT_DEBUG */
  57 }
  58
  59
  60 static int wpa_driver_osx_get_ssid(void *priv, u8 *ssid)
  61 {
  62         struct wpa_driver_osx_data *drv = priv;
  63         WirelessError err;
  64         WirelessInfo info;
  65         int len;
  66
  67         err = WirelessGetInfo(drv->wireless_ctx, &info);
  68         if (err) {
  69                 wpa_printf(MSG_DEBUG, "OSX: WirelessGetInfo failed: %d",
  70                            (int) err);
  71                 return -1;
  72         }
  73         if (!info.power) {
  74                 wpa_printf(MSG_DEBUG, "OSX: Wireless device power off");
  75                 return -1;
  76         }
  77
  78         for (len = 0; len < 32; len++)
  79                 if (info.ssid[len] == 0)
  80                         break;
  81
  82         os_memcpy(ssid, info.ssid, len);
  83         return len;
  84 }
  85
  86
  87 static int wpa_driver_osx_get_bssid(void *priv, u8 *bssid)
  88 {
  89         struct wpa_driver_osx_data *drv = priv;
  90         WirelessError err;
  91         WirelessInfo info;
  92
  93         err = WirelessGetInfo(drv->wireless_ctx, &info);
  94         if (err) {
  95                 wpa_printf(MSG_DEBUG, "OSX: WirelessGetInfo failed: %d",
  96                            (int) err);
  97                 return -1;
  98         }
  99         if (!info.power) {
 100                 wpa_printf(MSG_DEBUG, "OSX: Wireless device power off");
 101                 return -1;
 102         }
 103
 104         os_memcpy(bssid, info.bssID, ETH_ALEN);
 105         return 0;
 106 }
 107
 108
 109 static void wpa_driver_osx_scan_timeout(void *eloop_ctx, void *timeout_ctx)
 110 {
 111         wpa_supplicant_event(timeout_ctx, EVENT_SCAN_RESULTS, NULL);
 112 }
 113
 114
 115 static int wpa_driver_osx_scan(void *priv, struct wpa_driver_scan_params *params)
 116 {
 117         struct wpa_driver_osx_data *drv = priv;
 118         WirelessError err;
 119         const u8 *ssid = params->ssids[0].ssid;
 120         size_t ssid_len = params->ssids[0].ssid_len;
 121
 122         if (drv->scan_results) {
 123                 CFRelease(drv->scan_results);
 124                 drv->scan_results = NULL;
 125         }
 126
 127         if (ssid) {
 128                 CFStringRef data;
 129                 data = CFStringCreateWithBytes(kCFAllocatorDefault,
 130                                                ssid, ssid_len,
 131                                                kCFStringEncodingISOLatin1,
 132                                                FALSE);
 133                 if (data == NULL) {
 134                         wpa_printf(MSG_DEBUG, "CFStringCreateWithBytes "
 135                                    "failed");
 136                         return -1;
 137                 }
 138
 139                 err = WirelessDirectedScan(drv->wireless_ctx,
 140                                            &drv->scan_results, 0, data);
 141                 CFRelease(data);
 142                 if (err) {
 143                         wpa_printf(MSG_DEBUG, "OSX: WirelessDirectedScan "
 144                                    "failed: 0x%08x", (unsigned int) err);
 145                         return -1;
 146                 }
 147         } else {
 148                 err = WirelessScan(drv->wireless_ctx, &drv->scan_results, 0);
 149                 if (err) {
 150                         wpa_printf(MSG_DEBUG, "OSX: WirelessScan failed: "
 151                                    "0x%08x", (unsigned int) err);
 152                         return -1;
 153                 }
 154         }
 155
 156         eloop_register_timeout(0, 0, wpa_driver_osx_scan_timeout, drv,
 157                                drv->ctx);
 158         return 0;
 159 }
 160
 161
 162 static void wpa_driver_osx_add_scan_entry(struct wpa_scan_results *res,
 163                                           WirelessNetworkInfo *info)
 164 {
 165         struct wpa_scan_res *result, **tmp;
 166         size_t extra_len;
 167         u8 *pos;
 168
 169         extra_len = 2 + info->ssid_len;
 170
 171         result = os_zalloc(sizeof(*result) + extra_len);
 172         if (result == NULL)
 173                 return;
 174         os_memcpy(result->bssid, info->bssid, ETH_ALEN);
 175         result->freq = 2407 + info->channel * 5;
 176         //result->beacon_int =;
 177         result->caps = info->capability;
 178         //result->qual = info->signal;
 179         result->noise = info->noise;
 180
 181         pos = (u8 *)(result + 1);
 182
 183         *pos++ = WLAN_EID_SSID;
 184         *pos++ = info->ssid_len;
 185         os_memcpy(pos, info->ssid, info->ssid_len);
 186         pos += info->ssid_len;
 187
 188         result->ie_len = pos - (u8 *)(result + 1);
 189
 190         tmp = os_realloc(res->res,
 191                          (res->num + 1) * sizeof(struct wpa_scan_res *));
 192         if (tmp == NULL) {
 193                 os_free(result);
 194                 return;
 195         }
 196         tmp[res->num++] = result;
 197         res->res = tmp;
 198 }
 199
 200
 201 static struct wpa_scan_results * wpa_driver_osx_get_scan_results(void *priv)
 202 {
 203         struct wpa_driver_osx_data *drv = priv;
 204         struct wpa_scan_results *res;
 205         size_t i, num;
 206
 207         if (drv->scan_results == NULL)
 208                 return 0;
 209
 210         num = CFArrayGetCount(drv->scan_results);
 211
 212         res = os_zalloc(sizeof(*res));
 213         if (res == NULL)
 214                 return NULL;
 215
 216         for (i = 0; i < num; i++)
 217                 wpa_driver_osx_add_scan_entry(res, (WirelessNetworkInfo *)
 218                         CFDataGetBytePtr(CFArrayGetValueAtIndex(
 219                                 drv->scan_results, i)));
 220
 221         return res;
 222 }
 223
 224
 225 static void wpa_driver_osx_assoc_timeout(void *eloop_ctx, void *timeout_ctx)
 226 {
 227         struct wpa_driver_osx_data *drv = eloop_ctx;
 228         u8 bssid[ETH_ALEN];
 229         CFDictionaryRef ai;
 230
 231         if (wpa_driver_osx_get_bssid(drv, bssid) != 0) {
 232                 eloop_register_timeout(1, 0, wpa_driver_osx_assoc_timeout,
 233                                        drv, drv->ctx);
 234                 return;
 235         }
 236
 237         ai = WirelessGetAssociationInfo(drv->wireless_ctx);
 238         if (ai) {
 239                 wpa_driver_osx_dump_dict(ai, "WirelessGetAssociationInfo");
 240                 CFRelease(ai);
 241         } else {
 242                 wpa_printf(MSG_DEBUG, "OSX: Failed to get association info");
 243         }
 244
 245         wpa_supplicant_event(timeout_ctx, EVENT_ASSOC, NULL);
 246 }
 247
 248
 249 static int wpa_driver_osx_associate(void *priv,
 250                                     struct wpa_driver_associate_params *params)
 251 {
 252         struct wpa_driver_osx_data *drv = priv;
 253         WirelessError err;
 254         CFDataRef ssid;
 255         CFStringRef key;
 256         int assoc_type;
 257
 258         ssid = CFDataCreate(kCFAllocatorDefault, params->ssid,
 259                             params->ssid_len);
 260         if (ssid == NULL)
 261                 return -1;
 262
 263         /* TODO: support for WEP */
 264         if (params->key_mgmt_suite == KEY_MGMT_PSK) {
 265                 if (params->passphrase == NULL)
 266                         return -1;
 267                 key = CFStringCreateWithCString(kCFAllocatorDefault,
 268                                                 params->passphrase,
 269                                                 kCFStringEncodingISOLatin1);
 270                 if (key == NULL) {
 271                         CFRelease(ssid);
 272                         return -1;
 273                 }
 274         } else
 275                 key = NULL;
 276
 277         if (params->key_mgmt_suite == KEY_MGMT_NONE)
 278                 assoc_type = 0;
 279         else
 280                 assoc_type = 4;
 281
 282         wpa_printf(MSG_DEBUG, "OSX: WirelessAssociate(type=%d key=%p)",
 283                    assoc_type, key);
 284         err = WirelessAssociate(drv->wireless_ctx, assoc_type, ssid, key);
 285         CFRelease(ssid);
 286         if (key)
 287                 CFRelease(key);
 288         if (err) {
 289                 wpa_printf(MSG_DEBUG, "OSX: WirelessAssociate failed: 0x%08x",
 290                            (unsigned int) err);
 291                 return -1;
 292         }
 293
 294         /*
 295          * Driver is actually already associated; report association from an
 296          * eloop callback.
 297          */
 298         eloop_cancel_timeout(wpa_driver_osx_assoc_timeout, drv, drv->ctx);
 299         eloop_register_timeout(0, 0, wpa_driver_osx_assoc_timeout, drv,
 300                                drv->ctx);
 301
 302         return 0;
 303 }
 304
 305
 306 static int wpa_driver_osx_set_key(const char *ifname, void *priv, wpa_alg alg, const u8 *addr,
 307                                   int key_idx, int set_tx, const u8 *seq,
 308                                   size_t seq_len, const u8 *key,
 309                                   size_t key_len)
 310 {
 311         struct wpa_driver_osx_data *drv = priv;
 312         WirelessError err;
 313
 314         if (alg == WPA_ALG_WEP) {
 315                 err = WirelessSetKey(drv->wireless_ctx, 1, key_idx, key_len,
 316                                      key);
 317                 if (err != 0) {
 318                         wpa_printf(MSG_DEBUG, "OSX: WirelessSetKey failed: "
 319                                    "0x%08x", (unsigned int) err);
 320                         return -1;
 321                 }
 322
 323                 return 0;
 324         }
 325
 326         if (alg == WPA_ALG_PMK) {
 327                 err = WirelessSetWPAKey(drv->wireless_ctx, 1, key_len, key);
 328                 if (err != 0) {
 329                         wpa_printf(MSG_DEBUG, "OSX: WirelessSetWPAKey failed: "
 330                                    "0x%08x", (unsigned int) err);
 331                         return -1;
 332                 }
 333                 return 0;
 334         }
 335
 336         wpa_printf(MSG_DEBUG, "OSX: Unsupported set_key alg %d", alg);
 337         return -1;
 338 }
 339
 340
 341 static int wpa_driver_osx_get_capa(void *priv, struct wpa_driver_capa *capa)
 342 {
 343         os_memset(capa, 0, sizeof(*capa));
 344
 345         capa->key_mgmt = WPA_DRIVER_CAPA_KEY_MGMT_WPA |
 346                 WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
 347                 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK |
 348                 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK;
 349         capa->enc = WPA_DRIVER_CAPA_ENC_WEP40 | WPA_DRIVER_CAPA_ENC_WEP104 |
 350                 WPA_DRIVER_CAPA_ENC_TKIP | WPA_DRIVER_CAPA_ENC_CCMP;
 351         capa->auth = WPA_DRIVER_AUTH_OPEN | WPA_DRIVER_AUTH_SHARED |
 352                 WPA_DRIVER_AUTH_LEAP;
 353         capa->flags = WPA_DRIVER_FLAGS_4WAY_HANDSHAKE;
 354
 355         return 0;
 356 }
 357
 358
 359 static void * wpa_driver_osx_init(void *ctx, const char *ifname)
 360 {
 361         struct wpa_driver_osx_data *drv;
 362         WirelessError err;
 363         u8 enabled, power;
 364
 365         if (!WirelessIsAvailable()) {
 366                 wpa_printf(MSG_ERROR, "OSX: No wireless interface available");
 367                 return NULL;
 368         }
 369
 370         drv = os_zalloc(sizeof(*drv));
 371         if (drv == NULL)
 372                 return NULL;
 373         drv->ctx = ctx;
 374         err = WirelessAttach(&drv->wireless_ctx, 0);
 375         if (err) {
 376                 wpa_printf(MSG_ERROR, "OSX: WirelessAttach failed: %d",
 377                            (int) err);
 378                 os_free(drv);
 379                 return NULL;
 380         }
 381
 382         err = WirelessGetEnabled(drv->wireless_ctx, &enabled);
 383         if (err)
 384                 wpa_printf(MSG_DEBUG, "OSX: WirelessGetEnabled failed: 0x%08x",
 385                            (unsigned int) err);
 386         err = WirelessGetPower(drv->wireless_ctx, &power);
 387         if (err)
 388                 wpa_printf(MSG_DEBUG, "OSX: WirelessGetPower failed: 0x%08x",
 389                            (unsigned int) err);
 390
 391         wpa_printf(MSG_DEBUG, "OSX: Enabled=%d Power=%d", enabled, power);
 392
 393         if (!enabled) {
 394                 err = WirelessSetEnabled(drv->wireless_ctx, 1);
 395                 if (err) {
 396                         wpa_printf(MSG_DEBUG, "OSX: WirelessSetEnabled failed:"
 397                                    " 0x%08x", (unsigned int) err);
 398                         WirelessDetach(drv->wireless_ctx);
 399                         os_free(drv);
 400                         return NULL;
 401                 }
 402         }
 403
 404         if (!power) {
 405                 err = WirelessSetPower(drv->wireless_ctx, 1);
 406                 if (err) {
 407                         wpa_printf(MSG_DEBUG, "OSX: WirelessSetPower failed: "
 408                                    "0x%08x", (unsigned int) err);
 409                         WirelessDetach(drv->wireless_ctx);
 410                         os_free(drv);
 411                         return NULL;
 412                 }
 413         }
 414
 415         return drv;
 416 }
 417
 418
 419 static void wpa_driver_osx_deinit(void *priv)
 420 {
 421         struct wpa_driver_osx_data *drv = priv;
 422         WirelessError err;
 423
 424         eloop_cancel_timeout(wpa_driver_osx_scan_timeout, drv, drv->ctx);
 425         eloop_cancel_timeout(wpa_driver_osx_assoc_timeout, drv, drv->ctx);
 426
 427         err = WirelessSetPower(drv->wireless_ctx, 0);
 428         if (err) {
 429                 wpa_printf(MSG_DEBUG, "OSX: WirelessSetPower(0) failed: "
 430                            "0x%08x", (unsigned int) err);
 431         }
 432
 433         err = WirelessDetach(drv->wireless_ctx);
 434         if (err) {
 435                 wpa_printf(MSG_DEBUG, "OSX: WirelessDetach failed: 0x%08x",
 436                            (unsigned int) err);
 437         }
 438
 439         if (drv->scan_results)
 440                 CFRelease(drv->scan_results);
 441
 442         os_free(drv);
 443 }
 444
 445
 446 const struct wpa_driver_ops wpa_driver_osx_ops = {
 447         .name = "osx",
 448         .desc = "Mac OS X Apple80211 driver",
 449         .get_ssid = wpa_driver_osx_get_ssid,
 450         .get_bssid = wpa_driver_osx_get_bssid,
 451         .init = wpa_driver_osx_init,
 452         .deinit = wpa_driver_osx_deinit,
 453         .scan2 = wpa_driver_osx_scan,
 454         .get_scan_results2 = wpa_driver_osx_get_scan_results,
 455         .associate = wpa_driver_osx_associate,
 456         .set_key = wpa_driver_osx_set_key,
 457         .get_capa = wpa_driver_osx_get_capa,
 458 };