blob: 6349a9da5b0a8db40c7133f1ca39ab26ec016e31 [file] [log] [blame]
// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Implements a WLAN API binding for CoreWLAN, as available on OSX 10.6
#include "device/geolocation/wifi_data_provider_mac.h"
#include <dlfcn.h>
#import <Foundation/Foundation.h>
#include <stdint.h>
#include "base/mac/scoped_nsautorelease_pool.h"
#include "base/mac/scoped_nsobject.h"
#include "base/macros.h"
#include "base/metrics/histogram_macros.h"
#include "base/strings/sys_string_conversions.h"
// Define a subset of the CoreWLAN interfaces we require. We can't depend on
// CoreWLAN.h existing as we need to build on 10.5 SDKs. We can't just send
// messages to an untyped id due to the build treating warnings as errors,
// hence the reason we need class definitions.
// TODO(joth): When we build all 10.6 code exclusively 10.6 SDK (or later)
// tidy this up to use the framework directly. See
@interface CWInterface : NSObject
+ (CWInterface*)interface;
+ (CWInterface*)interfaceWithName:(NSString*)name;
+ (NSArray*)supportedInterfaces;
- (NSArray*)scanForNetworksWithParameters:(NSDictionary*)parameters
@interface CWNetwork : NSObject <NSCopying, NSCoding>
@property (nonatomic, readonly) NSString* ssid;
@property (nonatomic, readonly) NSString* bssid;
@property (nonatomic, readonly) NSData* bssidData;
@property (nonatomic, readonly) NSNumber* securityMode;
@property (nonatomic, readonly) NSNumber* phyMode;
@property (nonatomic, readonly) NSNumber* channel;
@property (nonatomic, readonly) NSNumber* rssi;
@property (nonatomic, readonly) NSInteger rssiValue;
@property (nonatomic, readonly) NSNumber* noise;
@property (nonatomic, readonly) NSData* ieData;
@property (nonatomic, readonly) BOOL isIBSS;
- (BOOL)isEqualToNetwork:(CWNetwork*)network;
namespace device {
class CoreWlanApi : public WifiDataProviderCommon::WlanApiInterface {
CoreWlanApi() {}
// Must be called before any other interface method. Will return false if the
// CoreWLAN framework cannot be initialized (e.g. running on pre-10.6 OSX),
// in which case no other method may be called.
bool Init();
// WlanApiInterface
bool GetAccessPointData(WifiData::AccessPointDataSet* data) override;
base::scoped_nsobject<NSBundle> bundle_;
base::scoped_nsobject<NSString> merge_key_;
bool CoreWlanApi::Init() {
// As the WLAN api binding runs on its own thread, we need to provide our own
// auto release pool. It's simplest to do this as an automatic variable in
// each method that needs it, to ensure the scoping is correct and does not
// interfere with any other code using autorelease pools on the thread.
base::mac::ScopedNSAutoreleasePool auto_pool;
bundle_.reset([[NSBundle alloc]
if (!bundle_) {
DVLOG(1) << "Failed to load the CoreWLAN framework bundle";
return false;
// Dynamically look up the value of the kCWScanKeyMerge (i.e. without build
// time dependency on the 10.6 specific library).
void* dl_handle = dlopen([[bundle_ executablePath] fileSystemRepresentation],
if (dl_handle) {
NSString* key = *reinterpret_cast<NSString**>(dlsym(dl_handle,
if (key)
merge_key_.reset([key copy]);
// "Leak" dl_handle rather than dlclose it, to ensure |merge_key_|
// remains valid.
if (!merge_key_) {
// Fall back to a known-working value should the lookup fail (if
// this value is itself wrong it's not the end of the world, we might just
// get very slightly lower quality location fixes due to SSID merges).
DLOG(WARNING) << "Could not dynamically load the CoreWLAN merge key";
merge_key_.reset([@"SCAN_MERGE" retain]);
return true;
bool CoreWlanApi::GetAccessPointData(WifiData::AccessPointDataSet* data) {
base::mac::ScopedNSAutoreleasePool auto_pool;
// Initialize the scan parameters with scan key merging disabled, so we get
// every AP listed in the scan without any SSID de-duping logic.
NSDictionary* params =
[NSDictionary dictionaryWithObject:[NSNumber numberWithBool:NO]
Class cw_interface_class = [bundle_ classNamed:@"CWInterface"];
NSArray* supported_interfaces = [cw_interface_class supportedInterfaces];
uint interface_error_count = 0;
for (NSString* interface_name in supported_interfaces) {
CWInterface* corewlan_interface =
[cw_interface_class interfaceWithName:interface_name];
if (!corewlan_interface) {
DLOG(WARNING) << interface_name << ": initWithName failed";
const base::TimeTicks start_time = base::TimeTicks::Now();
NSError* err = nil;
NSArray* scan = [corewlan_interface scanForNetworksWithParameters:params
const int error_code = [err code];
const int count = [scan count];
// We could get an error code but count != 0 if the scan was interrupted,
// for example. For our purposes this is not fatal, so process as normal.
if (error_code && count == 0) {
DLOG(WARNING) << interface_name << ": CoreWLAN scan failed with error "
<< error_code;
const base::TimeDelta duration = base::TimeTicks::Now() - start_time;
DVLOG(1) << interface_name << ": found " << count << " wifi APs";
for (CWNetwork* network in scan) {
AccessPointData access_point_data;
NSData* mac = [network bssidData];
DCHECK([mac length] == 6);
if (![mac bytes])
continue; //
access_point_data.mac_address =
MacAddressAsString16(static_cast<const uint8_t*>([mac bytes]));
access_point_data.radio_signal_strength = [network rssiValue]; = [[network channel] intValue];
access_point_data.signal_to_noise =
access_point_data.radio_signal_strength - [[network noise] intValue];
access_point_data.ssid = base::SysNSStringToUTF16([network ssid]);
[supported_interfaces count] - interface_error_count,
// Return true even if some interfaces failed to scan, so long as at least
// one interface did not fail.
return interface_error_count == 0 ||
[supported_interfaces count] > interface_error_count;
WifiDataProviderCommon::WlanApiInterface* NewCoreWlanApi() {
std::unique_ptr<CoreWlanApi> self(new CoreWlanApi);
if (self->Init())
return self.release();
return NULL;
} // namespace device