The Tor Browser: netwerk/system/win32/nsNotifyAddrListener.cpp@6474c204b198 (annotated)

netwerk/system/win32/nsNotifyAddrListener.cpp@6474c204b198 (annotated)

netwerk/system/win32/nsNotifyAddrListener.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* vim:set et sw=4 ts=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 <stdarg.h>
 #include <windef.h>
 #include <winbase.h>
 #include <wingdi.h>
 #include <winuser.h>
 #include <ole2.h>
 #include <netcon.h>
 #include <objbase.h>
 #include <iprtrmib.h>
 #include "plstr.h"
 #include "nsThreadUtils.h"
 #include "nsIObserverService.h"
 #include "nsServiceManagerUtils.h"
 #include "nsNotifyAddrListener.h"
 #include "nsString.h"
 #include "nsAutoPtr.h"
 #include "mozilla/Services.h"
 #include "nsCRT.h"
 #include <iptypes.h>
 #include <iphlpapi.h>
 static HMODULE sNetshell;
 static decltype(NcFreeNetconProperties)* sNcFreeNetconProperties;
 static void InitNetshellLibrary(void)
 {
     if (!sNetshell) {
         sNetshell = LoadLibraryW(L"Netshell.dll");
         if (sNetshell) {
             sNcFreeNetconProperties = (decltype(NcFreeNetconProperties)*)
                 GetProcAddress(sNetshell, "NcFreeNetconProperties");
         }
     }
 }
 static void FreeDynamicLibraries(void)
 {
     if (sNetshell) {
         sNcFreeNetconProperties = nullptr;
         FreeLibrary(sNetshell);
         sNetshell = nullptr;
     }
 }
 NS_IMPL_ISUPPORTS(nsNotifyAddrListener,
                   nsINetworkLinkService,
                   nsIRunnable,
                   nsIObserver)
 nsNotifyAddrListener::nsNotifyAddrListener()
     : mLinkUp(true)  // assume true by default
     , mStatusKnown(false)
     , mCheckAttempted(false)
     , mShutdownEvent(nullptr)
 {
 }
 nsNotifyAddrListener::~nsNotifyAddrListener()
 {
     NS_ASSERTION(!mThread, "nsNotifyAddrListener thread shutdown failed");
     FreeDynamicLibraries();
 }
 NS_IMETHODIMP
 nsNotifyAddrListener::GetIsLinkUp(bool *aIsUp)
 {
     if (!mCheckAttempted && !mStatusKnown) {
         mCheckAttempted = true;
         CheckLinkStatus();
     }
     *aIsUp = mLinkUp;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsNotifyAddrListener::GetLinkStatusKnown(bool *aIsUp)
 {
     *aIsUp = mStatusKnown;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsNotifyAddrListener::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;
 }
 NS_IMETHODIMP
 nsNotifyAddrListener::Run()
 {
     PR_SetCurrentThreadName("Link Monitor");
     HANDLE ev = CreateEvent(nullptr, FALSE, FALSE, nullptr);
     NS_ENSURE_TRUE(ev, NS_ERROR_OUT_OF_MEMORY);
     HANDLE handles[2] = { ev, mShutdownEvent };
     OVERLAPPED overlapped = { 0 };
     bool shuttingDown = false;
     overlapped.hEvent = ev;
     while (!shuttingDown) {
         HANDLE h;
         DWORD ret = NotifyAddrChange(&h, &overlapped);
         if (ret == ERROR_IO_PENDING) {
             ret = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
             if (ret == WAIT_OBJECT_0) {
                 CheckLinkStatus();
             } else {
                 shuttingDown = true;
             }
         } else {
             shuttingDown = true;
         }
     }
     CloseHandle(ev);
     return NS_OK;
 }
 NS_IMETHODIMP
 nsNotifyAddrListener::Observe(nsISupports *subject,
                               const char *topic,
                               const char16_t *data)
 {
     if (!strcmp("xpcom-shutdown-threads", topic))
         Shutdown();
     return NS_OK;
 }
 nsresult
 nsNotifyAddrListener::Init(void)
 {
     nsCOMPtr<nsIObserverService> observerService =
         mozilla::services::GetObserverService();
     if (!observerService)
         return NS_ERROR_FAILURE;
     nsresult rv = observerService->AddObserver(this, "xpcom-shutdown-threads",
                                                false);
     NS_ENSURE_SUCCESS(rv, rv);
     mShutdownEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
     NS_ENSURE_TRUE(mShutdownEvent, NS_ERROR_OUT_OF_MEMORY);
     rv = NS_NewThread(getter_AddRefs(mThread), this);
     NS_ENSURE_SUCCESS(rv, rv);
     return NS_OK;
 }
 nsresult
 nsNotifyAddrListener::Shutdown(void)
 {
     // remove xpcom shutdown observer
     nsCOMPtr<nsIObserverService> observerService =
         mozilla::services::GetObserverService();
     if (observerService)
         observerService->RemoveObserver(this, "xpcom-shutdown-threads");
     if (!mShutdownEvent)
         return NS_OK;
     SetEvent(mShutdownEvent);
     nsresult rv = mThread->Shutdown();
     // Have to break the cycle here, otherwise nsNotifyAddrListener holds
     // onto the thread and the thread holds onto the nsNotifyAddrListener
     // via its mRunnable
     mThread = nullptr;
     CloseHandle(mShutdownEvent);
     mShutdownEvent = nullptr;
     return rv;
 }
 /* Sends the given event to the UI thread.  Assumes aEventID never goes out
  * of scope (static strings are ideal).
  */
 nsresult
 nsNotifyAddrListener::SendEventToUI(const char *aEventID)
 {
     if (!aEventID)
         return NS_ERROR_NULL_POINTER;
     nsresult rv;
     nsCOMPtr<nsIRunnable> event = new ChangeEvent(this, aEventID);
     if (NS_FAILED(rv = NS_DispatchToMainThread(event)))
         NS_WARNING("Failed to dispatch ChangeEvent");
     return rv;
 }
 NS_IMETHODIMP
 nsNotifyAddrListener::ChangeEvent::Run()
 {
     nsCOMPtr<nsIObserverService> observerService =
         mozilla::services::GetObserverService();
     if (observerService)
         observerService->NotifyObservers(
                 mService, NS_NETWORK_LINK_TOPIC,
                 NS_ConvertASCIItoUTF16(mEventID).get());
     return NS_OK;
 }
 bool
 nsNotifyAddrListener::CheckIsGateway(PIP_ADAPTER_ADDRESSES aAdapter)
 {
     if (!aAdapter->FirstUnicastAddress)
         return false;
     LPSOCKADDR aAddress = aAdapter->FirstUnicastAddress->Address.lpSockaddr;
     if (!aAddress)
         return false;
     PSOCKADDR_IN in_addr = (PSOCKADDR_IN)aAddress;
     bool isGateway = (aAddress->sa_family == AF_INET &&
         in_addr->sin_addr.S_un.S_un_b.s_b1 == 192 &&
         in_addr->sin_addr.S_un.S_un_b.s_b2 == 168 &&
         in_addr->sin_addr.S_un.S_un_b.s_b3 == 0 &&
         in_addr->sin_addr.S_un.S_un_b.s_b4 == 1);
     if (isGateway)
       isGateway = CheckICSStatus(aAdapter->FriendlyName);
     return isGateway;
 }
 bool
 nsNotifyAddrListener::CheckICSStatus(PWCHAR aAdapterName)
 {
     InitNetshellLibrary();
     // This method enumerates all privately shared connections and checks if some
     // of them has the same name as the one provided in aAdapterName. If such
     // connection is found in the collection the adapter is used as ICS gateway
     bool isICSGatewayAdapter = false;
     HRESULT hr;
     nsRefPtr<INetSharingManager> netSharingManager;
     hr = CoCreateInstance(
                 CLSID_NetSharingManager,
                 nullptr,
                 CLSCTX_INPROC_SERVER,
                 IID_INetSharingManager,
                 getter_AddRefs(netSharingManager));
     nsRefPtr<INetSharingPrivateConnectionCollection> privateCollection;
     if (SUCCEEDED(hr)) {
         hr = netSharingManager->get_EnumPrivateConnections(
                     ICSSC_DEFAULT,
                     getter_AddRefs(privateCollection));
     }
     nsRefPtr<IEnumNetSharingPrivateConnection> privateEnum;
     if (SUCCEEDED(hr)) {
         nsRefPtr<IUnknown> privateEnumUnknown;
         hr = privateCollection->get__NewEnum(getter_AddRefs(privateEnumUnknown));
         if (SUCCEEDED(hr)) {
             hr = privateEnumUnknown->QueryInterface(
                         IID_IEnumNetSharingPrivateConnection,
                         getter_AddRefs(privateEnum));
         }
     }
     if (SUCCEEDED(hr)) {
         ULONG fetched;
         VARIANT connectionVariant;
         while (!isICSGatewayAdapter &&
                SUCCEEDED(hr = privateEnum->Next(1, &connectionVariant,
                &fetched)) &&
                fetched) {
             if (connectionVariant.vt != VT_UNKNOWN) {
                 // We should call VariantClear here but it needs to link
                 // with oleaut32.lib that produces a Ts incrase about 10ms
                 // that is undesired. As it is quit unlikely the result would
                 // be of a different type anyway, let's pass the variant
                 // unfreed here.
                 NS_ERROR("Variant of unexpected type, expecting VT_UNKNOWN, we probably leak it!");
                 continue;
             }
             nsRefPtr<INetConnection> connection;
             if (SUCCEEDED(connectionVariant.punkVal->QueryInterface(
                               IID_INetConnection,
                               getter_AddRefs(connection)))) {
                 connectionVariant.punkVal->Release();
                 NETCON_PROPERTIES *properties;
                 if (SUCCEEDED(connection->GetProperties(&properties))) {
                     if (!wcscmp(properties->pszwName, aAdapterName))
                         isICSGatewayAdapter = true;
                     if (sNcFreeNetconProperties)
                         sNcFreeNetconProperties(properties);
                 }
             }
         }
     }
     return isICSGatewayAdapter;
 }
 DWORD
 nsNotifyAddrListener::CheckAdaptersAddresses(void)
 {
     ULONG len = 16384;
     PIP_ADAPTER_ADDRESSES addresses = (PIP_ADAPTER_ADDRESSES) malloc(len);
     if (!addresses)
         return ERROR_OUTOFMEMORY;
     DWORD ret = GetAdaptersAddresses(AF_UNSPEC, 0, nullptr, addresses, &len);
     if (ret == ERROR_BUFFER_OVERFLOW) {
         free(addresses);
         addresses = (PIP_ADAPTER_ADDRESSES) malloc(len);
         if (!addresses)
             return ERROR_BUFFER_OVERFLOW;
         ret = GetAdaptersAddresses(AF_UNSPEC, 0, nullptr, addresses, &len);
     }
     if (FAILED(CoInitializeEx(nullptr, COINIT_MULTITHREADED))) {
         free(addresses);
         return ERROR_NOT_SUPPORTED;
     }
     if (ret == ERROR_SUCCESS) {
         PIP_ADAPTER_ADDRESSES ptr;
         bool linkUp = false;
         for (ptr = addresses; !linkUp && ptr; ptr = ptr->Next) {
             if (ptr->OperStatus == IfOperStatusUp &&
                     ptr->IfType != IF_TYPE_SOFTWARE_LOOPBACK &&
                     !CheckIsGateway(ptr))
                 linkUp = true;
         }
         mLinkUp = linkUp;
         mStatusKnown = true;
     }
     free(addresses);
     CoUninitialize();
     return ret;
 }
 /**
  * Checks the status of all network adapters.  If one is up and has a valid IP
  * address, sets mLinkUp to true.  Sets mStatusKnown to true if the link status
  * is definitive.
  */
 void
 nsNotifyAddrListener::CheckLinkStatus(void)
 {
     DWORD ret;
     const char *event;
     // This call is very expensive (~650 milliseconds), so we don't want to
     // call it synchronously. Instead, we just start up assuming we have a
     // network link, but we'll report that the status is unknown.
     if (NS_IsMainThread()) {
         NS_WARNING("CheckLinkStatus called on main thread! No check "
                    "performed. Assuming link is up, status is unknown.");
         mLinkUp = true;
     } else {
         ret = CheckAdaptersAddresses();
         if (ret != ERROR_SUCCESS) {
             mLinkUp = true;
         }
     }
     if (mStatusKnown)
         event = mLinkUp ? NS_NETWORK_LINK_DATA_UP : NS_NETWORK_LINK_DATA_DOWN;
     else
         event = NS_NETWORK_LINK_DATA_UNKNOWN;
     SendEventToUI(event);
 }

The Tor Browser / annotate

netwerk/system/win32/nsNotifyAddrListener.cpp@6474c204b198 (annotated)

netwerk/system/win32/nsNotifyAddrListener.cpp