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