The Tor Browser: netwerk/wifi/nsWifiScannerDBus.cpp@b8a032363ba2 (annotated)

netwerk/wifi/nsWifiScannerDBus.cpp@b8a032363ba2 (annotated)

netwerk/wifi/nsWifiScannerDBus.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "nsWifiScannerDBus.h"
 #include "nsWifiAccessPoint.h"
 namespace mozilla {
 nsWifiScannerDBus::nsWifiScannerDBus(nsCOMArray<nsWifiAccessPoint> *aAccessPoints)
 : mAccessPoints(aAccessPoints)
 {
   MOZ_ASSERT(mAccessPoints);
   mConnection = dbus_bus_get(DBUS_BUS_SYSTEM, nullptr);
   MOZ_ASSERT(mConnection);
   dbus_connection_set_exit_on_disconnect(mConnection, false);
   MOZ_COUNT_CTOR(nsWifiScannerDBus);
 }
 nsWifiScannerDBus::~nsWifiScannerDBus()
 {
   if (!mConnection) {
     dbus_connection_unref(mConnection);
   }
   MOZ_COUNT_DTOR(nsWifiScannerDBus);
 }
 nsresult
 nsWifiScannerDBus::Scan()
 {
   return SendMessage("org.freedesktop.NetworkManager",
                      "/org/freedesktop/NetworkManager",
                      "GetDevices");
 }
 nsresult
 nsWifiScannerDBus::SendMessage(const char* aInterface,
                                const char* aPath,
                                const char* aFuncCall)
 {
   DBusMessage* msg =
     dbus_message_new_method_call("org.freedesktop.NetworkManager",
                                  aPath, aInterface, aFuncCall);
   if (!msg) {
     return NS_ERROR_FAILURE;
   }
   DBusMessageIter argsIter;
   dbus_message_iter_init_append(msg, &argsIter);
   if (!strcmp(aFuncCall, "Get")) {
     const char* paramInterface = "org.freedesktop.NetworkManager.Device";
     if (!dbus_message_iter_append_basic(&argsIter, DBUS_TYPE_STRING,
                                         &paramInterface)) {
       return NS_ERROR_FAILURE;
     }
     const char* paramDeviceType = "DeviceType";
     if (!dbus_message_iter_append_basic(&argsIter, DBUS_TYPE_STRING,
                                         &paramDeviceType)) {
       return NS_ERROR_FAILURE;
     }
   } else if (!strcmp(aFuncCall, "GetAll")) {
     const char* param = "";
     if (!dbus_message_iter_append_basic(&argsIter, DBUS_TYPE_STRING, &param)) {
       return NS_ERROR_FAILURE;
     }
   }
   DBusError err;
   dbus_error_init(&err);
   // http://dbus.freedesktop.org/doc/api/html/group__DBusConnection.html
   // Refer to function dbus_connection_send_with_reply_and_block.
   const uint32_t DBUS_DEFAULT_TIMEOUT = -1;
   DBusMessage* reply = nullptr;
   reply = dbus_connection_send_with_reply_and_block(mConnection, msg,
                                                     DBUS_DEFAULT_TIMEOUT, &err);
   if (dbus_error_is_set(&err)) {
     dbus_error_free(&err);
     // In the GetAccessPoints case, if there are no access points, error is set.
     // We don't want to error out here.
     if (!strcmp(aFuncCall, "GetAccessPoints")) {
       return NS_OK;
     }
     return NS_ERROR_FAILURE;
   }
   nsresult rv;
   if (!strcmp(aFuncCall, "GetDevices")) {
     rv = IdentifyDevices(reply);
   } else if (!strcmp(aFuncCall, "Get")) {
     rv = IdentifyDeviceType(reply, aPath);
   } else if (!strcmp(aFuncCall, "GetAccessPoints")) {
     rv = IdentifyAccessPoints(reply);
   } else if (!strcmp(aFuncCall, "GetAll")) {
     rv = IdentifyAPProperties(reply);
   } else {
     rv = NS_ERROR_FAILURE;
   }
   dbus_message_unref(reply);
   return rv;
 }
 nsresult
 nsWifiScannerDBus::IdentifyDevices(DBusMessage* aMsg)
 {
   DBusMessageIter iter;
   nsresult rv = GetDBusIterator(aMsg, &iter);
   NS_ENSURE_SUCCESS(rv, rv);
   const char* devicePath;
   do {
     if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_OBJECT_PATH) {
       return NS_ERROR_FAILURE;
     }
     dbus_message_iter_get_basic(&iter, &devicePath);
     if (!devicePath) {
       return NS_ERROR_FAILURE;
     }
     rv = SendMessage("org.freedesktop.DBus.Properties", devicePath, "Get");
     NS_ENSURE_SUCCESS(rv, rv);
   } while (dbus_message_iter_next(&iter));
   return NS_OK;
 }
 nsresult
 nsWifiScannerDBus::IdentifyDeviceType(DBusMessage* aMsg, const char* aDevicePath)
 {
   DBusMessageIter args;
   if (!dbus_message_iter_init(aMsg, &args)) {
     return NS_ERROR_FAILURE;
   }
   if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_VARIANT) {
     return NS_ERROR_FAILURE;
   }
   DBusMessageIter variantIter;
   dbus_message_iter_recurse(&args, &variantIter);
   if (dbus_message_iter_get_arg_type(&variantIter) != DBUS_TYPE_UINT32) {
     return NS_ERROR_FAILURE;
   }
   uint32_t deviceType;
   dbus_message_iter_get_basic(&variantIter, &deviceType);
   // http://projects.gnome.org/NetworkManager/developers/api/07/spec-07.html
   // Refer to NM_DEVICE_TYPE_WIFI under NM_DEVICE_TYPE.
   const uint32_t NM_DEVICE_TYPE_WIFI = 2;
   nsresult rv = NS_OK;
   if (deviceType == NM_DEVICE_TYPE_WIFI) {
     rv = SendMessage("org.freedesktop.NetworkManager.Device.Wireless",
                      aDevicePath, "GetAccessPoints");
   }
   return rv;
 }
 nsresult
 nsWifiScannerDBus::IdentifyAccessPoints(DBusMessage* aMsg)
 {
   DBusMessageIter iter;
   nsresult rv = GetDBusIterator(aMsg, &iter);
   NS_ENSURE_SUCCESS(rv, rv);
   const char* path;
   do {
     if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_OBJECT_PATH) {
       return NS_ERROR_FAILURE;
     }
     dbus_message_iter_get_basic(&iter, &path);
     if (!path) {
       return NS_ERROR_FAILURE;
     }
     rv = SendMessage("org.freedesktop.DBus.Properties", path, "GetAll");
     NS_ENSURE_SUCCESS(rv, rv);
   } while (dbus_message_iter_next(&iter));
   return NS_OK;
 }
 nsresult
 nsWifiScannerDBus::IdentifyAPProperties(DBusMessage* aMsg)
 {
   DBusMessageIter arr;
   nsresult rv = GetDBusIterator(aMsg, &arr);
   NS_ENSURE_SUCCESS(rv, rv);
   nsRefPtr<nsWifiAccessPoint> ap = new nsWifiAccessPoint();
   do {
     DBusMessageIter dict;
     dbus_message_iter_recurse(&arr, &dict);
     do {
       const char* key;
       dbus_message_iter_get_basic(&dict, &key);
       if (!key) {
         return NS_ERROR_FAILURE;
       }
       dbus_message_iter_next(&dict);
       DBusMessageIter variant;
       dbus_message_iter_recurse(&dict, &variant);
       if (!strncmp(key, "Ssid", strlen("Ssid"))) {
         nsresult rv = StoreSsid(&variant, ap);
         NS_ENSURE_SUCCESS(rv, rv);
         break;
       }
       if (!strncmp(key, "HwAddress", strlen("HwAddress"))) {
         nsresult rv = SetMac(&variant, ap);
         NS_ENSURE_SUCCESS(rv, rv);
         break;
       }
       if (!strncmp(key, "Strength", strlen("Strength"))) {
         if (dbus_message_iter_get_arg_type(&variant) != DBUS_TYPE_BYTE) {
           return NS_ERROR_FAILURE;
         }
         uint8_t strength;
         dbus_message_iter_get_basic(&variant, &strength);
         ap->setSignal(strength);
       }
     } while (dbus_message_iter_next(&dict));
   } while (dbus_message_iter_next(&arr));
   mAccessPoints->AppendObject(ap);
   return NS_OK;
 }
 nsresult
 nsWifiScannerDBus::StoreSsid(DBusMessageIter* aVariant, nsWifiAccessPoint* aAp)
 {
   if (dbus_message_iter_get_arg_type(aVariant) != DBUS_TYPE_ARRAY) {
     return NS_ERROR_FAILURE;
   }
   DBusMessageIter variantMember;
   dbus_message_iter_recurse(aVariant, &variantMember);
   const uint32_t MAX_SSID_LEN = 32;
   char ssid[MAX_SSID_LEN];
   memset(ssid, '\0', ArrayLength(ssid));
   uint32_t i = 0;
   do {
     if (dbus_message_iter_get_arg_type(&variantMember) != DBUS_TYPE_BYTE) {
       return NS_ERROR_FAILURE;
     }
     dbus_message_iter_get_basic(&variantMember, &ssid[i]);
     i++;
   } while (dbus_message_iter_next(&variantMember) && i < MAX_SSID_LEN);
   aAp->setSSID(ssid, i);
   return NS_OK;
 }
 nsresult
 nsWifiScannerDBus::SetMac(DBusMessageIter* aVariant, nsWifiAccessPoint* aAp)
 {
   if (dbus_message_iter_get_arg_type(aVariant) != DBUS_TYPE_STRING) {
     return NS_ERROR_FAILURE;
   }
   // hwAddress format is XX:XX:XX:XX:XX:XX. Need to convert to XXXXXX format.
   char* hwAddress;
   dbus_message_iter_get_basic(aVariant, &hwAddress);
   if (!hwAddress) {
     return NS_ERROR_FAILURE;
   }
   const uint32_t MAC_LEN = 6;
   uint8_t macAddress[MAC_LEN];
   char* token = strtok(hwAddress, ":");
   for (uint32_t i = 0; i < ArrayLength(macAddress); i++) {
     if (!token) {
       return NS_ERROR_FAILURE;
     }
     macAddress[i] = strtoul(token, nullptr, 16);
     token = strtok(nullptr, ":");
   }
   aAp->setMac(macAddress);
   return NS_OK;
 }
 nsresult
 nsWifiScannerDBus::GetDBusIterator(DBusMessage* aMsg,
                                    DBusMessageIter* aIterArray)
 {
   DBusMessageIter iter;
   if (!dbus_message_iter_init(aMsg, &iter)) {
     return NS_ERROR_FAILURE;
   }
   if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) {
     return NS_ERROR_FAILURE;
   }
   dbus_message_iter_recurse(&iter, aIterArray);
   return NS_OK;
 }
 } // mozilla
 nsresult
 nsWifiMonitor::DoScan()
 {
   nsCOMArray<nsWifiAccessPoint> accessPoints;
   mozilla::nsWifiScannerDBus wifiScanner(&accessPoints);
   nsCOMArray<nsWifiAccessPoint> lastAccessPoints;
   while (mKeepGoing) {
     accessPoints.Clear();
     nsresult rv = wifiScanner.Scan();
     NS_ENSURE_SUCCESS(rv, rv);
     bool accessPointsChanged = !AccessPointsEqual(accessPoints,
                                                   lastAccessPoints);
     ReplaceArray(lastAccessPoints, accessPoints);
     rv = CallWifiListeners(lastAccessPoints, accessPointsChanged);
     NS_ENSURE_SUCCESS(rv, rv);
     LOG(("waiting on monitor\n"));
     mozilla::ReentrantMonitorAutoEnter mon(mReentrantMonitor);
     mon.Wait(PR_SecondsToInterval(60));
   }
   return NS_OK;
 }

The Tor Browser / annotate

netwerk/wifi/nsWifiScannerDBus.cpp@b8a032363ba2 (annotated)

netwerk/wifi/nsWifiScannerDBus.cpp