1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 // Implements a WLAN API binding for CoreWLAN, as available on OSX 10.6 6 7 #include "content/browser/geolocation/wifi_data_provider_mac.h" 8 9 #include <dlfcn.h> 10 #import <Foundation/Foundation.h> 11 12 #include "base/mac/scoped_nsautorelease_pool.h" 13 #include "base/mac/scoped_nsobject.h" 14 #include "base/metrics/histogram.h" 15 #include "base/strings/sys_string_conversions.h" 16 17 // Define a subset of the CoreWLAN interfaces we require. We can't depend on 18 // CoreWLAN.h existing as we need to build on 10.5 SDKs. We can't just send 19 // messages to an untyped id due to the build treating warnings as errors, 20 // hence the reason we need class definitions. 21 // TODO(joth): When we build all 10.6 code exclusively 10.6 SDK (or later) 22 // tidy this up to use the framework directly. See http://crbug.com/37703 23 24 @interface CWInterface : NSObject 25 + (CWInterface*)interface; 26 + (CWInterface*)interfaceWithName:(NSString*)name; 27 + (NSArray*)supportedInterfaces; 28 - (NSArray*)scanForNetworksWithParameters:(NSDictionary*)parameters 29 error:(NSError**)error; 30 @end 31 32 @interface CWNetwork : NSObject <NSCopying, NSCoding> 33 @property (nonatomic, readonly) NSString* ssid; 34 @property (nonatomic, readonly) NSString* bssid; 35 @property (nonatomic, readonly) NSData* bssidData; 36 @property (nonatomic, readonly) NSNumber* securityMode; 37 @property (nonatomic, readonly) NSNumber* phyMode; 38 @property (nonatomic, readonly) NSNumber* channel; 39 @property (nonatomic, readonly) NSNumber* rssi; 40 @property (nonatomic, readonly) NSNumber* noise; 41 @property (nonatomic, readonly) NSData* ieData; 42 @property (nonatomic, readonly) BOOL isIBSS; 43 - (BOOL)isEqualToNetwork:(CWNetwork*)network; 44 @end 45 46 namespace content { 47 48 class CoreWlanApi : public WifiDataProviderCommon::WlanApiInterface { 49 public: 50 CoreWlanApi() {} 51 52 // Must be called before any other interface method. Will return false if the 53 // CoreWLAN framework cannot be initialized (e.g. running on pre-10.6 OSX), 54 // in which case no other method may be called. 55 bool Init(); 56 57 // WlanApiInterface 58 virtual bool GetAccessPointData(WifiData::AccessPointDataSet* data) OVERRIDE; 59 60 private: 61 base::scoped_nsobject<NSBundle> bundle_; 62 base::scoped_nsobject<NSString> merge_key_; 63 64 DISALLOW_COPY_AND_ASSIGN(CoreWlanApi); 65 }; 66 67 bool CoreWlanApi::Init() { 68 // As the WLAN api binding runs on its own thread, we need to provide our own 69 // auto release pool. It's simplest to do this as an automatic variable in 70 // each method that needs it, to ensure the scoping is correct and does not 71 // interfere with any other code using autorelease pools on the thread. 72 base::mac::ScopedNSAutoreleasePool auto_pool; 73 bundle_.reset([[NSBundle alloc] 74 initWithPath:@"/System/Library/Frameworks/CoreWLAN.framework"]); 75 if (!bundle_) { 76 DVLOG(1) << "Failed to load the CoreWLAN framework bundle"; 77 return false; 78 } 79 80 // Dynamically look up the value of the kCWScanKeyMerge (i.e. without build 81 // time dependency on the 10.6 specific library). 82 void* dl_handle = dlopen([[bundle_ executablePath] fileSystemRepresentation], 83 RTLD_LAZY | RTLD_LOCAL); 84 if (dl_handle) { 85 NSString* key = *reinterpret_cast<NSString**>(dlsym(dl_handle, 86 "kCWScanKeyMerge")); 87 if (key) 88 merge_key_.reset([key copy]); 89 } 90 // "Leak" dl_handle rather than dlclose it, to ensure |merge_key_| 91 // remains valid. 92 if (!merge_key_) { 93 // Fall back to a known-working value should the lookup fail (if 94 // this value is itself wrong it's not the end of the world, we might just 95 // get very slightly lower quality location fixes due to SSID merges). 96 DLOG(WARNING) << "Could not dynamically load the CoreWLAN merge key"; 97 merge_key_.reset([@"SCAN_MERGE" retain]); 98 } 99 100 return true; 101 } 102 103 bool CoreWlanApi::GetAccessPointData(WifiData::AccessPointDataSet* data) { 104 base::mac::ScopedNSAutoreleasePool auto_pool; 105 // Initialize the scan parameters with scan key merging disabled, so we get 106 // every AP listed in the scan without any SSID de-duping logic. 107 NSDictionary* params = 108 [NSDictionary dictionaryWithObject:[NSNumber numberWithBool:NO] 109 forKey:merge_key_.get()]; 110 111 Class cw_interface_class = [bundle_ classNamed:@"CWInterface"]; 112 NSArray* supported_interfaces = [cw_interface_class supportedInterfaces]; 113 uint interface_error_count = 0; 114 for (NSString* interface_name in supported_interfaces) { 115 CWInterface* corewlan_interface = 116 [cw_interface_class interfaceWithName:interface_name]; 117 if (!corewlan_interface) { 118 DLOG(WARNING) << interface_name << ": initWithName failed"; 119 ++interface_error_count; 120 continue; 121 } 122 123 const base::TimeTicks start_time = base::TimeTicks::Now(); 124 125 NSError* err = nil; 126 NSArray* scan = [corewlan_interface scanForNetworksWithParameters:params 127 error:&err]; 128 const int error_code = [err code]; 129 const int count = [scan count]; 130 // We could get an error code but count != 0 if the scan was interrupted, 131 // for example. For our purposes this is not fatal, so process as normal. 132 if (error_code && count == 0) { 133 DLOG(WARNING) << interface_name << ": CoreWLAN scan failed with error " 134 << error_code; 135 ++interface_error_count; 136 continue; 137 } 138 139 const base::TimeDelta duration = base::TimeTicks::Now() - start_time; 140 141 UMA_HISTOGRAM_CUSTOM_TIMES( 142 "Net.Wifi.ScanLatency", 143 duration, 144 base::TimeDelta::FromMilliseconds(1), 145 base::TimeDelta::FromMinutes(1), 146 100); 147 148 DVLOG(1) << interface_name << ": found " << count << " wifi APs"; 149 150 for (CWNetwork* network in scan) { 151 DCHECK(network); 152 AccessPointData access_point_data; 153 NSData* mac = [network bssidData]; 154 DCHECK([mac length] == 6); 155 access_point_data.mac_address = MacAddressAsString16( 156 static_cast<const uint8*>([mac bytes])); 157 access_point_data.radio_signal_strength = [[network rssi] intValue]; 158 access_point_data.channel = [[network channel] intValue]; 159 access_point_data.signal_to_noise = 160 access_point_data.radio_signal_strength - [[network noise] intValue]; 161 access_point_data.ssid = base::SysNSStringToUTF16([network ssid]); 162 data->insert(access_point_data); 163 } 164 } 165 166 UMA_HISTOGRAM_CUSTOM_COUNTS( 167 "Net.Wifi.InterfaceCount", 168 [supported_interfaces count] - interface_error_count, 169 1, 170 5, 171 5); 172 173 // Return true even if some interfaces failed to scan, so long as at least 174 // one interface did not fail. 175 return interface_error_count == 0 || 176 [supported_interfaces count] > interface_error_count; 177 } 178 179 WifiDataProviderCommon::WlanApiInterface* NewCoreWlanApi() { 180 scoped_ptr<CoreWlanApi> self(new CoreWlanApi); 181 if (self->Init()) 182 return self.release(); 183 184 return NULL; 185 } 186 187 } // namespace content 188