1 /* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
4
5 #include "nsWifiScannerDBus.h"
6 #include "mozilla/DBusHelpers.h"
7 #include "nsWifiAccessPoint.h"
8
9 namespace mozilla {
10
nsWifiScannerDBus(nsCOMArray<nsWifiAccessPoint> * aAccessPoints)11 nsWifiScannerDBus::nsWifiScannerDBus(
12 nsCOMArray<nsWifiAccessPoint>* aAccessPoints)
13 : mAccessPoints(aAccessPoints) {
14 MOZ_ASSERT(mAccessPoints);
15
16 mConnection =
17 already_AddRefed<DBusConnection>(dbus_bus_get(DBUS_BUS_SYSTEM, nullptr));
18
19 if (mConnection) {
20 dbus_connection_setup_with_g_main(mConnection, nullptr);
21 dbus_connection_set_exit_on_disconnect(mConnection, false);
22 }
23
24 MOZ_COUNT_CTOR(nsWifiScannerDBus);
25 }
26
~nsWifiScannerDBus()27 nsWifiScannerDBus::~nsWifiScannerDBus() { MOZ_COUNT_DTOR(nsWifiScannerDBus); }
28
Scan()29 nsresult nsWifiScannerDBus::Scan() {
30 if (!mConnection) {
31 return NS_ERROR_NOT_AVAILABLE;
32 }
33 return SendGetDevices();
34 }
35
36 // http://dbus.freedesktop.org/doc/api/html/group__DBusConnection.html
37 // Refer to function dbus_connection_send_with_reply_and_block.
38 static const uint32_t DBUS_DEFAULT_TIMEOUT = -1;
39
SendGetDevices()40 nsresult nsWifiScannerDBus::SendGetDevices() {
41 RefPtr<DBusMessage> msg =
42 already_AddRefed<DBusMessage>(dbus_message_new_method_call(
43 "org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager",
44 "org.freedesktop.NetworkManager", "GetDevices"));
45 if (!msg) {
46 return NS_ERROR_FAILURE;
47 }
48
49 DBusError err;
50 dbus_error_init(&err);
51
52 RefPtr<DBusMessage> reply =
53 already_AddRefed<DBusMessage>(dbus_connection_send_with_reply_and_block(
54 mConnection, msg, DBUS_DEFAULT_TIMEOUT, &err));
55 if (dbus_error_is_set(&err)) {
56 dbus_error_free(&err);
57 return NS_ERROR_FAILURE;
58 }
59
60 return IdentifyDevices(reply);
61 }
62
SendGetDeviceType(const char * aPath)63 nsresult nsWifiScannerDBus::SendGetDeviceType(const char* aPath) {
64 RefPtr<DBusMessage> msg = already_AddRefed<DBusMessage>(
65 dbus_message_new_method_call("org.freedesktop.NetworkManager", aPath,
66 "org.freedesktop.DBus.Properties", "Get"));
67 if (!msg) {
68 return NS_ERROR_FAILURE;
69 }
70
71 DBusMessageIter argsIter;
72 dbus_message_iter_init_append(msg, &argsIter);
73
74 const char* paramInterface = "org.freedesktop.NetworkManager.Device";
75 if (!dbus_message_iter_append_basic(&argsIter, DBUS_TYPE_STRING,
76 ¶mInterface)) {
77 return NS_ERROR_FAILURE;
78 }
79
80 const char* paramDeviceType = "DeviceType";
81 if (!dbus_message_iter_append_basic(&argsIter, DBUS_TYPE_STRING,
82 ¶mDeviceType)) {
83 return NS_ERROR_FAILURE;
84 }
85
86 DBusError err;
87 dbus_error_init(&err);
88
89 RefPtr<DBusMessage> reply =
90 already_AddRefed<DBusMessage>(dbus_connection_send_with_reply_and_block(
91 mConnection, msg, DBUS_DEFAULT_TIMEOUT, &err));
92 if (dbus_error_is_set(&err)) {
93 dbus_error_free(&err);
94 return NS_ERROR_FAILURE;
95 }
96
97 return IdentifyDeviceType(reply, aPath);
98 }
99
SendGetAccessPoints(const char * aPath)100 nsresult nsWifiScannerDBus::SendGetAccessPoints(const char* aPath) {
101 RefPtr<DBusMessage> msg =
102 already_AddRefed<DBusMessage>(dbus_message_new_method_call(
103 "org.freedesktop.NetworkManager", aPath,
104 "org.freedesktop.NetworkManager.Device.Wireless", "GetAccessPoints"));
105 if (!msg) {
106 return NS_ERROR_FAILURE;
107 }
108
109 DBusError err;
110 dbus_error_init(&err);
111
112 RefPtr<DBusMessage> reply =
113 already_AddRefed<DBusMessage>(dbus_connection_send_with_reply_and_block(
114 mConnection, msg, DBUS_DEFAULT_TIMEOUT, &err));
115 if (dbus_error_is_set(&err)) {
116 dbus_error_free(&err);
117 // In the GetAccessPoints case, if there are no access points, error is set.
118 // We don't want to error out here.
119 return NS_OK;
120 }
121
122 return IdentifyAccessPoints(reply);
123 }
124
SendGetAPProperties(const char * aPath)125 nsresult nsWifiScannerDBus::SendGetAPProperties(const char* aPath) {
126 RefPtr<DBusMessage> msg =
127 already_AddRefed<DBusMessage>(dbus_message_new_method_call(
128 "org.freedesktop.NetworkManager", aPath,
129 "org.freedesktop.DBus.Properties", "GetAll"));
130 if (!msg) {
131 return NS_ERROR_FAILURE;
132 }
133
134 DBusMessageIter argsIter;
135 dbus_message_iter_init_append(msg, &argsIter);
136
137 const char* param = "org.freedesktop.NetworkManager.AccessPoint";
138 if (!dbus_message_iter_append_basic(&argsIter, DBUS_TYPE_STRING, ¶m)) {
139 return NS_ERROR_FAILURE;
140 }
141
142 DBusError err;
143 dbus_error_init(&err);
144
145 RefPtr<DBusMessage> reply =
146 already_AddRefed<DBusMessage>(dbus_connection_send_with_reply_and_block(
147 mConnection, msg, DBUS_DEFAULT_TIMEOUT, &err));
148 if (dbus_error_is_set(&err)) {
149 dbus_error_free(&err);
150 return NS_ERROR_FAILURE;
151 }
152
153 return IdentifyAPProperties(reply);
154 }
155
IdentifyDevices(DBusMessage * aMsg)156 nsresult nsWifiScannerDBus::IdentifyDevices(DBusMessage* aMsg) {
157 DBusMessageIter iter;
158 nsresult rv = GetDBusIterator(aMsg, &iter);
159 NS_ENSURE_SUCCESS(rv, rv);
160
161 const char* devicePath;
162 do {
163 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_OBJECT_PATH) {
164 return NS_ERROR_FAILURE;
165 }
166
167 dbus_message_iter_get_basic(&iter, &devicePath);
168 if (!devicePath) {
169 return NS_ERROR_FAILURE;
170 }
171
172 rv = SendGetDeviceType(devicePath);
173 NS_ENSURE_SUCCESS(rv, rv);
174 } while (dbus_message_iter_next(&iter));
175
176 return NS_OK;
177 }
178
IdentifyDeviceType(DBusMessage * aMsg,const char * aDevicePath)179 nsresult nsWifiScannerDBus::IdentifyDeviceType(DBusMessage* aMsg,
180 const char* aDevicePath) {
181 DBusMessageIter args;
182 if (!dbus_message_iter_init(aMsg, &args)) {
183 return NS_ERROR_FAILURE;
184 }
185
186 if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_VARIANT) {
187 return NS_ERROR_FAILURE;
188 }
189
190 DBusMessageIter variantIter;
191 dbus_message_iter_recurse(&args, &variantIter);
192 if (dbus_message_iter_get_arg_type(&variantIter) != DBUS_TYPE_UINT32) {
193 return NS_ERROR_FAILURE;
194 }
195
196 uint32_t deviceType;
197 dbus_message_iter_get_basic(&variantIter, &deviceType);
198
199 // http://projects.gnome.org/NetworkManager/developers/api/07/spec-07.html
200 // Refer to NM_DEVICE_TYPE_WIFI under NM_DEVICE_TYPE.
201 const uint32_t NM_DEVICE_TYPE_WIFI = 2;
202 nsresult rv = NS_OK;
203 if (deviceType == NM_DEVICE_TYPE_WIFI) {
204 rv = SendGetAccessPoints(aDevicePath);
205 }
206
207 return rv;
208 }
209
IdentifyAccessPoints(DBusMessage * aMsg)210 nsresult nsWifiScannerDBus::IdentifyAccessPoints(DBusMessage* aMsg) {
211 DBusMessageIter iter;
212 nsresult rv = GetDBusIterator(aMsg, &iter);
213 NS_ENSURE_SUCCESS(rv, rv);
214
215 const char* path;
216 do {
217 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_OBJECT_PATH) {
218 return NS_ERROR_FAILURE;
219 }
220 dbus_message_iter_get_basic(&iter, &path);
221 if (!path) {
222 return NS_ERROR_FAILURE;
223 }
224
225 rv = SendGetAPProperties(path);
226 NS_ENSURE_SUCCESS(rv, rv);
227 } while (dbus_message_iter_next(&iter));
228
229 return NS_OK;
230 }
231
IdentifyAPProperties(DBusMessage * aMsg)232 nsresult nsWifiScannerDBus::IdentifyAPProperties(DBusMessage* aMsg) {
233 DBusMessageIter arr;
234 nsresult rv = GetDBusIterator(aMsg, &arr);
235 NS_ENSURE_SUCCESS(rv, rv);
236
237 RefPtr<nsWifiAccessPoint> ap = new nsWifiAccessPoint();
238 do {
239 DBusMessageIter dict;
240 dbus_message_iter_recurse(&arr, &dict);
241
242 do {
243 const char* key;
244 dbus_message_iter_get_basic(&dict, &key);
245 if (!key) {
246 return NS_ERROR_FAILURE;
247 }
248 dbus_message_iter_next(&dict);
249
250 DBusMessageIter variant;
251 dbus_message_iter_recurse(&dict, &variant);
252
253 if (!strncmp(key, "Ssid", strlen("Ssid"))) {
254 nsresult rv = StoreSsid(&variant, ap);
255 NS_ENSURE_SUCCESS(rv, rv);
256 break;
257 }
258
259 if (!strncmp(key, "HwAddress", strlen("HwAddress"))) {
260 nsresult rv = SetMac(&variant, ap);
261 NS_ENSURE_SUCCESS(rv, rv);
262 break;
263 }
264
265 if (!strncmp(key, "Strength", strlen("Strength"))) {
266 if (dbus_message_iter_get_arg_type(&variant) != DBUS_TYPE_BYTE) {
267 return NS_ERROR_FAILURE;
268 }
269
270 uint8_t strength;
271 dbus_message_iter_get_basic(&variant, &strength);
272 ap->setSignal(strength);
273 }
274 } while (dbus_message_iter_next(&dict));
275 } while (dbus_message_iter_next(&arr));
276
277 mAccessPoints->AppendObject(ap);
278 return NS_OK;
279 }
280
StoreSsid(DBusMessageIter * aVariant,nsWifiAccessPoint * aAp)281 nsresult nsWifiScannerDBus::StoreSsid(DBusMessageIter* aVariant,
282 nsWifiAccessPoint* aAp) {
283 if (dbus_message_iter_get_arg_type(aVariant) != DBUS_TYPE_ARRAY) {
284 return NS_ERROR_FAILURE;
285 }
286
287 DBusMessageIter variantMember;
288 dbus_message_iter_recurse(aVariant, &variantMember);
289
290 const uint32_t MAX_SSID_LEN = 32;
291 char ssid[MAX_SSID_LEN];
292 memset(ssid, '\0', ArrayLength(ssid));
293 uint32_t i = 0;
294 do {
295 if (dbus_message_iter_get_arg_type(&variantMember) != DBUS_TYPE_BYTE) {
296 return NS_ERROR_FAILURE;
297 }
298
299 dbus_message_iter_get_basic(&variantMember, &ssid[i]);
300 i++;
301 } while (dbus_message_iter_next(&variantMember) && i < MAX_SSID_LEN);
302
303 aAp->setSSID(ssid, i);
304 return NS_OK;
305 }
306
SetMac(DBusMessageIter * aVariant,nsWifiAccessPoint * aAp)307 nsresult nsWifiScannerDBus::SetMac(DBusMessageIter* aVariant,
308 nsWifiAccessPoint* aAp) {
309 if (dbus_message_iter_get_arg_type(aVariant) != DBUS_TYPE_STRING) {
310 return NS_ERROR_FAILURE;
311 }
312
313 // hwAddress format is XX:XX:XX:XX:XX:XX. Need to convert to XXXXXX format.
314 char* hwAddress;
315 dbus_message_iter_get_basic(aVariant, &hwAddress);
316 if (!hwAddress) {
317 return NS_ERROR_FAILURE;
318 }
319
320 const uint32_t MAC_LEN = 6;
321 uint8_t macAddress[MAC_LEN];
322 char* token = strtok(hwAddress, ":");
323 for (uint32_t i = 0; i < ArrayLength(macAddress); i++) {
324 if (!token) {
325 return NS_ERROR_FAILURE;
326 }
327 macAddress[i] = strtoul(token, nullptr, 16);
328 token = strtok(nullptr, ":");
329 }
330 aAp->setMac(macAddress);
331 return NS_OK;
332 }
333
GetDBusIterator(DBusMessage * aMsg,DBusMessageIter * aIterArray)334 nsresult nsWifiScannerDBus::GetDBusIterator(DBusMessage* aMsg,
335 DBusMessageIter* aIterArray) {
336 DBusMessageIter iter;
337 if (!dbus_message_iter_init(aMsg, &iter)) {
338 return NS_ERROR_FAILURE;
339 }
340
341 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) {
342 return NS_ERROR_FAILURE;
343 }
344
345 dbus_message_iter_recurse(&iter, aIterArray);
346 return NS_OK;
347 }
348
349 } // namespace mozilla
350
DoScan()351 nsresult nsWifiMonitor::DoScan() {
352 nsCOMArray<nsWifiAccessPoint> accessPoints;
353 mozilla::nsWifiScannerDBus wifiScanner(&accessPoints);
354 nsCOMArray<nsWifiAccessPoint> lastAccessPoints;
355
356 while (mKeepGoing) {
357 accessPoints.Clear();
358 nsresult rv = wifiScanner.Scan();
359 NS_ENSURE_SUCCESS(rv, rv);
360 bool accessPointsChanged =
361 !AccessPointsEqual(accessPoints, lastAccessPoints);
362 ReplaceArray(lastAccessPoints, accessPoints);
363
364 rv = CallWifiListeners(lastAccessPoints, accessPointsChanged);
365 NS_ENSURE_SUCCESS(rv, rv);
366
367 LOG(("waiting on monitor\n"));
368 mozilla::ReentrantMonitorAutoEnter mon(mReentrantMonitor);
369 mon.Wait(PR_SecondsToInterval(kDefaultWifiScanInterval));
370 }
371
372 return NS_OK;
373 }
374