The Tor Browser / file revision

 /* -*- 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);

 }