Issue #1829 - Revert "Issue #1751"

netwerk/system/mac/moz.build

@@ -0,0 +1,13 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# 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/.
+
+SOURCES += [
+    'nsNetworkLinkService.mm',
+]
+
+FINAL_LIBRARY = 'xul'
+
+if CONFIG['CLANG_CXX']:
+    CXXFLAGS += ['-Wno-error=shadow']

netwerk/system/mac/nsNetworkLinkService.h

@@ -0,0 +1,54 @@
+/* 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/. */
+
+#ifndef NSNETWORKLINKSERVICEMAC_H_
+#define NSNETWORKLINKSERVICEMAC_H_
+
+#include "nsINetworkLinkService.h"
+#include "nsIObserver.h"
+
+#include <SystemConfiguration/SCNetworkReachability.h>
+#include <SystemConfiguration/SystemConfiguration.h>
+
+class nsNetworkLinkService : public nsINetworkLinkService,
+                             public nsIObserver
+{
+public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSINETWORKLINKSERVICE
+    NS_DECL_NSIOBSERVER
+
+    nsNetworkLinkService();
+
+    nsresult Init();
+    nsresult Shutdown();
+
+protected:
+    virtual ~nsNetworkLinkService();
+
+private:
+    bool mLinkUp;
+    bool mStatusKnown;
+
+    // Toggles allowing the sending of network-changed event.
+    bool mAllowChangedEvent;
+
+    SCNetworkReachabilityRef mReachability;
+    CFRunLoopRef mCFRunLoop;
+    CFRunLoopSourceRef mRunLoopSource;
+    SCDynamicStoreRef mStoreRef;
+
+    void UpdateReachability();
+    void SendEvent(bool aNetworkChanged);
+    static void ReachabilityChanged(SCNetworkReachabilityRef target,
+                                    SCNetworkConnectionFlags flags,
+                                    void *info);
+    static void IPConfigChanged(SCDynamicStoreRef store,
+                                CFArrayRef changedKeys,
+                                void *info);
+    void calculateNetworkId(void);
+    nsCString mNetworkId;
+};
+
+#endif /* NSNETWORKLINKSERVICEMAC_H_ */

netwerk/system/mac/nsNetworkLinkService.mm

@@ -0,0 +1,526 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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 <sys/socket.h>
+#include <sys/sysctl.h>
+
+#include <net/if.h>
+#include <net/if_dl.h>
+#include <net/if_types.h>
+#include <net/route.h>
+
+#include <netinet/in.h>
+#include <netinet/if_ether.h>
+
+#include <arpa/inet.h>
+#include "nsCOMPtr.h"
+#include "nsIObserverService.h"
+#include "nsServiceManagerUtils.h"
+#include "nsString.h"
+#include "nsCRT.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/SHA1.h"
+#include "mozilla/Base64.h"
+#include "nsNetworkLinkService.h"
+
+#import <Cocoa/Cocoa.h>
+#import <netinet/in.h>
+
+#define NETWORK_NOTIFY_CHANGED_PREF "network.notify.changed"
+
+using namespace mozilla;
+
+static LazyLogModule gNotifyAddrLog("nsNotifyAddr");
+#define LOG(args) MOZ_LOG(gNotifyAddrLog, mozilla::LogLevel::Debug, args)
+
+// If non-successful, extract the error code and return it.  This
+// error code dance is inspired by
+// http://developer.apple.com/technotes/tn/tn1145.html
+static OSStatus getErrorCodeBool(Boolean success)
+{
+    OSStatus err = noErr;
+    if (!success) {
+        int scErr = ::SCError();
+        if (scErr == kSCStatusOK) {
+            scErr = kSCStatusFailed;
+        }
+        err = scErr;
+    }
+    return err;
+}
+
+// If given a NULL pointer, return the error code.
+static OSStatus getErrorCodePtr(const void *value)
+{
+    return getErrorCodeBool(value != NULL);
+}
+
+// Convenience function to allow NULL input.
+static void CFReleaseSafe(CFTypeRef cf)
+{
+    if (cf) {
+        // "If cf is NULL, this will cause a runtime error and your
+        // application will crash." / Apple docs
+        ::CFRelease(cf);
+    }
+}
+
+NS_IMPL_ISUPPORTS(nsNetworkLinkService,
+                  nsINetworkLinkService,
+                  nsIObserver)
+
+nsNetworkLinkService::nsNetworkLinkService()
+    : mLinkUp(true)
+    , mStatusKnown(false)
+    , mAllowChangedEvent(true)
+    , mReachability(nullptr)
+    , mCFRunLoop(nullptr)
+    , mRunLoopSource(nullptr)
+    , mStoreRef(nullptr)
+{
+}
+
+nsNetworkLinkService::~nsNetworkLinkService() = default;
+
+NS_IMETHODIMP
+nsNetworkLinkService::GetIsLinkUp(bool *aIsUp)
+{
+    *aIsUp = mLinkUp;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNetworkLinkService::GetLinkStatusKnown(bool *aIsUp)
+{
+    *aIsUp = mStatusKnown;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNetworkLinkService::GetLinkType(uint32_t *aLinkType)
+{
+    NS_ENSURE_ARG_POINTER(aLinkType);
+
+    // XXX This function has not yet been implemented for this platform
+    *aLinkType = nsINetworkLinkService::LINK_TYPE_UNKNOWN;
+    return NS_OK;
+}
+
+#ifndef SA_SIZE
+#define SA_SIZE(sa)                                                     \
+  (  (!(sa) || ((struct sockaddr *)(sa))->sa_len == 0) ?                \
+     sizeof(uint32_t)            :                                      \
+     1 + ( (((struct sockaddr *)(sa))->sa_len - 1) | (sizeof(uint32_t) - 1) ) )
+#endif
+
+static char *getMac(struct sockaddr_dl *sdl, char *buf, size_t bufsize)
+{
+    char *cp;
+    int n, p = 0;
+
+    buf[0] = 0;
+    cp = (char *)LLADDR(sdl);
+    n = sdl->sdl_alen;
+    if (n > 0) {
+        while (--n >= 0) {
+            p += snprintf(&buf[p], bufsize - p, "%02x%s",
+                          *cp++ & 0xff, n > 0 ? ":" : "");
+        }
+    }
+    return buf;
+}
+
+/* If the IP matches, get the MAC and return true */
+static bool matchIp(struct sockaddr_dl *sdl, struct sockaddr_inarp *addr,
+                    char *ip, char *buf, size_t bufsize)
+{
+    if (sdl->sdl_alen) {
+        if (!strcmp(inet_ntoa(addr->sin_addr), ip)) {
+            getMac(sdl, buf, bufsize);
+            return true; /* done! */
+        }
+    }
+    return false; /* continue */
+}
+
+/*
+ * Scan for the 'IP' address in the ARP table and store the corresponding MAC
+ * address in 'mac'. The output buffer is 'maclen' bytes big.
+ *
+ * Returns 'true' if it found the IP and returns a MAC.
+ */
+static bool scanArp(char *ip, char *mac, size_t maclen)
+{
+    int mib[6];
+    char *lim, *next;
+    int st;
+
+    mib[0] = CTL_NET;
+    mib[1] = PF_ROUTE;
+    mib[2] = 0;
+    mib[3] = AF_INET;
+    mib[4] = NET_RT_FLAGS;
+    mib[5] = RTF_LLINFO;
+
+    size_t needed;
+    if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) {
+        return false;
+    }
+    if (needed == 0) {
+        // empty table
+        return false;
+    }
+
+    UniquePtr <char[]>buf(new char[needed]);
+
+    for (;;) {
+        st = sysctl(mib, 6, &buf[0], &needed, NULL, 0);
+        if (st == 0 || errno != ENOMEM) {
+            break;
+        }
+        needed += needed / 8;
+
+        auto tmp = MakeUnique<char[]>(needed);
+        memcpy(&tmp[0], &buf[0], needed);
+        buf = Move(tmp);
+    }
+    if (st == -1) {
+        return false;
+    }
+    lim = &buf[needed];
+
+    struct rt_msghdr *rtm;
+    for (next = &buf[0]; next < lim; next += rtm->rtm_msglen) {
+        rtm = reinterpret_cast<struct rt_msghdr *>(next);
+        struct sockaddr_inarp *sin2 =
+            reinterpret_cast<struct sockaddr_inarp *>(rtm + 1);
+        struct sockaddr_dl *sdl =
+            reinterpret_cast<struct sockaddr_dl *>
+            ((char *)sin2 + SA_SIZE(sin2));
+        if (matchIp(sdl, sin2, ip, mac, maclen)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+static int routingTable(char *gw, size_t aGwLen)
+{
+    size_t needed;
+    int mib[6];
+    struct rt_msghdr *rtm;
+    struct sockaddr *sa;
+    struct sockaddr_in *sockin;
+
+    mib[0] = CTL_NET;
+    mib[1] = PF_ROUTE;
+    mib[2] = 0;
+    mib[3] = 0;
+    mib[4] = NET_RT_DUMP;
+    mib[5] = 0;
+    if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) {
+        return 1;
+    }
+
+    UniquePtr <char[]>buf(new char[needed]);
+
+    if (sysctl(mib, 6, &buf[0], &needed, NULL, 0) < 0) {
+        return 3;
+    }
+
+    rtm = reinterpret_cast<struct rt_msghdr *>(&buf[0]);
+    sa = reinterpret_cast<struct sockaddr *>(rtm + 1);
+    sa = reinterpret_cast<struct sockaddr *>(SA_SIZE(sa) + (char *)sa);
+    sockin = reinterpret_cast<struct sockaddr_in *>(sa);
+    inet_ntop(AF_INET, &sockin->sin_addr.s_addr, gw, aGwLen-1);
+
+    return 0;
+}
+
+//
+// Figure out the current "network identification" string.
+//
+// It detects the IP of the default gateway in the routing table, then the MAC
+// address of that IP in the ARP table before it hashes that string (to avoid
+// information leakage).
+//
+void nsNetworkLinkService::calculateNetworkId(void)
+{
+    bool found = false;
+    char hw[MAXHOSTNAMELEN];
+    if (!routingTable(hw, sizeof(hw))) {
+        char mac[256]; // big enough for a printable MAC address
+        if (scanArp(hw, mac, sizeof(mac))) {
+            LOG(("networkid: MAC %s\n", hw));
+            nsAutoCString mac(hw);
+            // This 'addition' could potentially be a
+            // fixed number from the profile or something.
+            nsAutoCString addition("local-rubbish");
+            nsAutoCString output;
+            SHA1Sum sha1;
+            nsCString combined(mac + addition);
+            sha1.update(combined.get(), combined.Length());
+            uint8_t digest[SHA1Sum::kHashSize];
+            sha1.finish(digest);
+            nsCString newString(reinterpret_cast<char*>(digest),
+                                SHA1Sum::kHashSize);
+            nsresult rv = Base64Encode(newString, output);
+            MOZ_RELEASE_ASSERT(NS_SUCCEEDED(rv));
+            LOG(("networkid: id %s\n", output.get()));
+            if (mNetworkId != output) {
+                // new id
+                mNetworkId = output;
+            }
+            else {
+                // same id
+            }
+            found = true;
+        }
+    }
+    if (!found) {
+        // no id
+    }
+}
+
+
+NS_IMETHODIMP
+nsNetworkLinkService::Observe(nsISupports *subject,
+                              const char *topic,
+                              const char16_t *data)
+{
+    if (!strcmp(topic, "xpcom-shutdown")) {
+        Shutdown();
+    }
+
+    return NS_OK;
+}
+
+/* static */
+void
+nsNetworkLinkService::IPConfigChanged(SCDynamicStoreRef aStoreREf,
+                                      CFArrayRef aChangedKeys,
+                                      void *aInfo)
+{
+    nsNetworkLinkService *service =
+        static_cast<nsNetworkLinkService*>(aInfo);
+    service->SendEvent(true);
+}
+
+nsresult
+nsNetworkLinkService::Init(void)
+{
+    nsresult rv;
+
+    nsCOMPtr<nsIObserverService> observerService =
+        do_GetService("@mozilla.org/observer-service;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = observerService->AddObserver(this, "xpcom-shutdown", false);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    Preferences::AddBoolVarCache(&mAllowChangedEvent,
+                                 NETWORK_NOTIFY_CHANGED_PREF, true);
+
+    // If the network reachability API can reach 0.0.0.0 without
+    // requiring a connection, there is a network interface available.
+    struct sockaddr_in addr;
+    bzero(&addr, sizeof(addr));
+    addr.sin_len = sizeof(addr);
+    addr.sin_family = AF_INET;
+    mReachability =
+        ::SCNetworkReachabilityCreateWithAddress(NULL,
+                                                 (struct sockaddr *)&addr);
+    if (!mReachability) {
+        return NS_ERROR_NOT_AVAILABLE;
+    }
+
+    SCNetworkReachabilityContext context = {0, this, NULL, NULL, NULL};
+    if (!::SCNetworkReachabilitySetCallback(mReachability,
+                                            ReachabilityChanged,
+                                            &context)) {
+        NS_WARNING("SCNetworkReachabilitySetCallback failed.");
+        ::CFRelease(mReachability);
+        mReachability = NULL;
+        return NS_ERROR_NOT_AVAILABLE;
+    }
+
+    SCDynamicStoreContext storeContext = {0, this, NULL, NULL, NULL};
+    mStoreRef =
+        ::SCDynamicStoreCreate(NULL,
+                               CFSTR("AddIPAddressListChangeCallbackSCF"),
+                               IPConfigChanged, &storeContext);
+
+    CFStringRef patterns[2] = {NULL, NULL};
+    OSStatus err = getErrorCodePtr(mStoreRef);
+    if (err == noErr) {
+        // This pattern is "State:/Network/Service/[^/]+/IPv4".
+        patterns[0] =
+            ::SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
+                                                          kSCDynamicStoreDomainState,
+                                                          kSCCompAnyRegex,
+                                                          kSCEntNetIPv4);
+        err = getErrorCodePtr(patterns[0]);
+        if (err == noErr) {
+            // This pattern is "State:/Network/Service/[^/]+/IPv6".
+            patterns[1] =
+                ::SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
+                                                              kSCDynamicStoreDomainState,
+                                                              kSCCompAnyRegex,
+                                                              kSCEntNetIPv6);
+            err = getErrorCodePtr(patterns[1]);
+        }
+    }
+
+    CFArrayRef patternList = NULL;
+    // Create a pattern list containing just one pattern,
+    // then tell SCF that we want to watch changes in keys
+    // that match that pattern list, then create our run loop
+    // source.
+    if (err == noErr) {
+        patternList = ::CFArrayCreate(NULL, (const void **) patterns,
+                                      2, &kCFTypeArrayCallBacks);
+        if (!patternList) {
+            err = -1;
+        }
+    }
+    if (err == noErr) {
+        err =
+            getErrorCodeBool(::SCDynamicStoreSetNotificationKeys(mStoreRef,
+                                                                 NULL,
+                                                                 patternList));
+    }
+
+    if (err == noErr) {
+        mRunLoopSource =
+            ::SCDynamicStoreCreateRunLoopSource(NULL, mStoreRef, 0);
+        err = getErrorCodePtr(mRunLoopSource);
+    }
+
+    CFReleaseSafe(patterns[0]);
+    CFReleaseSafe(patterns[1]);
+    CFReleaseSafe(patternList);
+
+    if (err != noErr) {
+        CFReleaseSafe(mStoreRef);
+        return NS_ERROR_NOT_AVAILABLE;
+    }
+
+    // Get the current run loop.  This service is initialized at startup,
+    // so we shouldn't run in to any problems with modal dialog run loops.
+    mCFRunLoop = [[NSRunLoop currentRunLoop] getCFRunLoop];
+    if (!mCFRunLoop) {
+        NS_WARNING("Could not get current run loop.");
+        ::CFRelease(mReachability);
+        mReachability = NULL;
+        return NS_ERROR_NOT_AVAILABLE;
+    }
+    ::CFRetain(mCFRunLoop);
+
+    ::CFRunLoopAddSource(mCFRunLoop, mRunLoopSource, kCFRunLoopDefaultMode);
+
+    if (!::SCNetworkReachabilityScheduleWithRunLoop(mReachability, mCFRunLoop,
+                                                    kCFRunLoopDefaultMode)) {
+        NS_WARNING("SCNetworkReachabilityScheduleWIthRunLoop failed.");
+        ::CFRelease(mReachability);
+        mReachability = NULL;
+        ::CFRelease(mCFRunLoop);
+        mCFRunLoop = NULL;
+        return NS_ERROR_NOT_AVAILABLE;
+    }
+
+    UpdateReachability();
+
+    return NS_OK;
+}
+
+nsresult
+nsNetworkLinkService::Shutdown()
+{
+    if (!::SCNetworkReachabilityUnscheduleFromRunLoop(mReachability,
+                                                      mCFRunLoop,
+                                                      kCFRunLoopDefaultMode)) {
+        NS_WARNING("SCNetworkReachabilityUnscheduleFromRunLoop failed.");
+    }
+
+    CFRunLoopRemoveSource(mCFRunLoop, mRunLoopSource, kCFRunLoopDefaultMode);
+
+    ::CFRelease(mReachability);
+    mReachability = nullptr;
+
+    ::CFRelease(mCFRunLoop);
+    mCFRunLoop = nullptr;
+
+    ::CFRelease(mStoreRef);
+    mStoreRef = nullptr;
+
+    ::CFRelease(mRunLoopSource);
+    mRunLoopSource = nullptr;
+
+    return NS_OK;
+}
+
+void
+nsNetworkLinkService::UpdateReachability()
+{
+    if (!mReachability) {
+        return;
+    }
+
+    SCNetworkConnectionFlags flags;
+    if (!::SCNetworkReachabilityGetFlags(mReachability, &flags)) {
+        mStatusKnown = false;
+        return;
+    }
+
+    bool reachable = (flags & kSCNetworkFlagsReachable) != 0;
+    bool needsConnection = (flags & kSCNetworkFlagsConnectionRequired) != 0;
+
+    mLinkUp = (reachable && !needsConnection);
+    mStatusKnown = true;
+}
+
+void
+nsNetworkLinkService::SendEvent(bool aNetworkChanged)
+{
+    nsCOMPtr<nsIObserverService> observerService =
+        do_GetService("@mozilla.org/observer-service;1");
+    if (!observerService) {
+        return;
+    }
+
+    const char *event;
+    if (aNetworkChanged) {
+        if (!mAllowChangedEvent) {
+            return;
+        }
+        event = NS_NETWORK_LINK_DATA_CHANGED;
+    } else if (!mStatusKnown) {
+        event = NS_NETWORK_LINK_DATA_UNKNOWN;
+    } else {
+        event = mLinkUp ? NS_NETWORK_LINK_DATA_UP
+            : NS_NETWORK_LINK_DATA_DOWN;
+    }
+    LOG(("SendEvent: network is '%s'\n", event));
+
+    observerService->NotifyObservers(static_cast<nsINetworkLinkService*>(this),
+                                     NS_NETWORK_LINK_TOPIC,
+                                     NS_ConvertASCIItoUTF16(event).get());
+}
+
+/* static */
+void
+nsNetworkLinkService::ReachabilityChanged(SCNetworkReachabilityRef target,
+                                          SCNetworkConnectionFlags flags,
+                                          void *info)
+{
+    nsNetworkLinkService *service =
+        static_cast<nsNetworkLinkService*>(info);
+
+    service->UpdateReachability();
+    service->SendEvent(false);
+    service->calculateNetworkId();
+}