tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

nsNamedPipeService.cpp (8128B)

      1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* This Source Code Form is subject to the terms of the Mozilla Public
      3 * License, v. 2.0. If a copy of the MPL was not distributed with this
      4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      5 
      6 #include "mozilla/Services.h"
      7 #include "nsCOMPtr.h"
      8 #include "nsIObserverService.h"
      9 #include "nsNamedPipeService.h"
     10 #include "nsNetCID.h"
     11 #include "nsThreadUtils.h"
     12 #include "mozilla/ClearOnShutdown.h"
     13 #include "mozilla/Logging.h"
     14 
     15 namespace mozilla {
     16 namespace net {
     17 
     18 static mozilla::LazyLogModule gNamedPipeServiceLog("NamedPipeWin");
     19 #define LOG_NPS_DEBUG(...) \
     20  MOZ_LOG(gNamedPipeServiceLog, mozilla::LogLevel::Debug, (__VA_ARGS__))
     21 #define LOG_NPS_ERROR(...) \
     22  MOZ_LOG(gNamedPipeServiceLog, mozilla::LogLevel::Error, (__VA_ARGS__))
     23 
     24 StaticRefPtr<NamedPipeService> NamedPipeService::gSingleton;
     25 
     26 NS_IMPL_ISUPPORTS(NamedPipeService, nsINamedPipeService, nsIObserver,
     27                  nsIRunnable)
     28 
     29 NamedPipeService::NamedPipeService()
     30    : mIocp(nullptr), mIsShutdown(false), mLock("NamedPipeServiceLock") {}
     31 
     32 nsresult NamedPipeService::Init() {
     33  MOZ_ASSERT(!mIsShutdown);
     34 
     35  nsresult rv;
     36 
     37  // nsIObserverService must be accessed in main thread.
     38  // register shutdown event to stop NamedPipeSrv thread.
     39  nsCOMPtr<nsIObserver> self(this);
     40  nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction(
     41      "NamedPipeService::Init", [self = std::move(self)]() -> void {
     42        MOZ_ASSERT(NS_IsMainThread());
     43 
     44        nsCOMPtr<nsIObserverService> svc =
     45            mozilla::services::GetObserverService();
     46 
     47        if (NS_WARN_IF(!svc)) {
     48          return;
     49        }
     50 
     51        if (NS_WARN_IF(NS_FAILED(svc->AddObserver(
     52                self, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false)))) {
     53          return;
     54        }
     55      });
     56 
     57  if (NS_IsMainThread()) {
     58    rv = r->Run();
     59  } else {
     60    rv = NS_DispatchToMainThread(r);
     61  }
     62  if (NS_WARN_IF(NS_FAILED(rv))) {
     63    return rv;
     64  }
     65 
     66  mIocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, nullptr, 0, 1);
     67  if (NS_WARN_IF(!mIocp || mIocp == INVALID_HANDLE_VALUE)) {
     68    Shutdown();
     69    return NS_ERROR_FAILURE;
     70  }
     71 
     72  rv = NS_NewNamedThread("NamedPipeSrv", getter_AddRefs(mThread));
     73  if (NS_WARN_IF(NS_FAILED(rv))) {
     74    Shutdown();
     75    return rv;
     76  }
     77 
     78  return NS_OK;
     79 }
     80 
     81 // static
     82 already_AddRefed<nsINamedPipeService> NamedPipeService::GetOrCreate() {
     83  MOZ_ASSERT(NS_IsMainThread());
     84 
     85  RefPtr<NamedPipeService> inst;
     86  if (gSingleton) {
     87    inst = gSingleton;
     88  } else {
     89    inst = new NamedPipeService();
     90    nsresult rv = inst->Init();
     91    NS_ENSURE_SUCCESS(rv, nullptr);
     92    gSingleton = inst;
     93    ClearOnShutdown(&gSingleton);
     94  }
     95 
     96  return inst.forget();
     97 }
     98 
     99 void NamedPipeService::Shutdown() {
    100  MOZ_ASSERT(NS_IsMainThread());
    101 
    102  // remove observer
    103  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
    104  if (obs) {
    105    obs->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
    106  }
    107 
    108  // stop thread
    109  if (mThread && !mIsShutdown) {
    110    mIsShutdown = true;
    111 
    112    // invoke ERROR_ABANDONED_WAIT_0 to |GetQueuedCompletionStatus|
    113    CloseHandle(mIocp);
    114    mIocp = nullptr;
    115 
    116    mThread->Shutdown();
    117  }
    118 
    119  // close I/O Completion Port
    120  if (mIocp && mIocp != INVALID_HANDLE_VALUE) {
    121    CloseHandle(mIocp);
    122    mIocp = nullptr;
    123  }
    124 }
    125 
    126 void NamedPipeService::RemoveRetiredObjects() {
    127  MOZ_ASSERT(NS_GetCurrentThread() == mThread);
    128  mLock.AssertCurrentThreadOwns();
    129 
    130  if (!mRetiredHandles.IsEmpty()) {
    131    for (auto& handle : mRetiredHandles) {
    132      CloseHandle(handle);
    133    }
    134    mRetiredHandles.Clear();
    135  }
    136 
    137  mRetiredObservers.Clear();
    138 }
    139 
    140 /**
    141 * Implement nsINamedPipeService
    142 */
    143 
    144 NS_IMETHODIMP
    145 NamedPipeService::AddDataObserver(void* aHandle,
    146                                  nsINamedPipeDataObserver* aObserver) {
    147  if (!aHandle || aHandle == INVALID_HANDLE_VALUE || !aObserver) {
    148    return NS_ERROR_ILLEGAL_VALUE;
    149  }
    150 
    151  nsresult rv;
    152 
    153  HANDLE h = CreateIoCompletionPort(aHandle, mIocp,
    154                                    reinterpret_cast<ULONG_PTR>(aObserver), 1);
    155  if (NS_WARN_IF(!h)) {
    156    LOG_NPS_ERROR("CreateIoCompletionPort error (%lu)", GetLastError());
    157    return NS_ERROR_FAILURE;
    158  }
    159  if (NS_WARN_IF(h != mIocp)) {
    160    LOG_NPS_ERROR(
    161        "CreateIoCompletionPort got unexpected value %p (should be %p)", h,
    162        mIocp);
    163    CloseHandle(h);
    164    return NS_ERROR_FAILURE;
    165  }
    166 
    167  {
    168    MutexAutoLock lock(mLock);
    169    MOZ_ASSERT(!mObservers.Contains(aObserver));
    170 
    171    mObservers.AppendElement(aObserver);
    172 
    173    // start event loop
    174    if (mObservers.Length() == 1) {
    175      rv = mThread->Dispatch(this, NS_DISPATCH_NORMAL);
    176      if (NS_WARN_IF(NS_FAILED(rv))) {
    177        LOG_NPS_ERROR("Dispatch to thread failed (%08x)", uint32_t(rv));
    178        mObservers.Clear();
    179        return rv;
    180      }
    181    }
    182  }
    183 
    184  return NS_OK;
    185 }
    186 
    187 NS_IMETHODIMP
    188 NamedPipeService::RemoveDataObserver(void* aHandle,
    189                                     nsINamedPipeDataObserver* aObserver) {
    190  MutexAutoLock lock(mLock);
    191  mObservers.RemoveElement(aObserver);
    192 
    193  mRetiredHandles.AppendElement(aHandle);
    194  mRetiredObservers.AppendElement(aObserver);
    195 
    196  return NS_OK;
    197 }
    198 
    199 NS_IMETHODIMP
    200 NamedPipeService::IsOnCurrentThread(bool* aRetVal) {
    201  MOZ_ASSERT(mThread);
    202  MOZ_ASSERT(aRetVal);
    203 
    204  if (!mThread) {
    205    *aRetVal = false;
    206    return NS_OK;
    207  }
    208 
    209  return mThread->IsOnCurrentThread(aRetVal);
    210 }
    211 
    212 /**
    213 * Implement nsIObserver
    214 */
    215 
    216 NS_IMETHODIMP
    217 NamedPipeService::Observe(nsISupports* aSubject, const char* aTopic,
    218                          const char16_t* aData) {
    219  MOZ_ASSERT(NS_IsMainThread());
    220 
    221  if (!strcmp(NS_XPCOM_SHUTDOWN_OBSERVER_ID, aTopic)) {
    222    Shutdown();
    223  }
    224 
    225  return NS_OK;
    226 }
    227 
    228 /**
    229 * Implement nsIRunnable
    230 */
    231 
    232 NS_IMETHODIMP
    233 NamedPipeService::Run() {
    234  MOZ_ASSERT(NS_GetCurrentThread() == mThread);
    235  MOZ_ASSERT(mIocp && mIocp != INVALID_HANDLE_VALUE);
    236 
    237  while (!mIsShutdown) {
    238    {
    239      MutexAutoLock lock(mLock);
    240      if (mObservers.IsEmpty()) {
    241        LOG_NPS_DEBUG("no observer, stop loop");
    242        break;
    243      }
    244 
    245      RemoveRetiredObjects();
    246    }
    247 
    248    DWORD bytesTransferred = 0;
    249    ULONG_PTR key = 0;
    250    LPOVERLAPPED overlapped = nullptr;
    251    BOOL success =
    252        GetQueuedCompletionStatus(mIocp, &bytesTransferred, &key, &overlapped,
    253                                  1000);  // timeout, 1s
    254    auto err = GetLastError();
    255    if (!success) {
    256      if (err == WAIT_TIMEOUT) {
    257        continue;
    258      } else if (err == ERROR_ABANDONED_WAIT_0) {  // mIocp was closed
    259        break;
    260      } else if (!overlapped) {
    261        /**
    262         * Did not dequeue a completion packet from the completion port, and
    263         * bytesTransferred/key are meaningless.
    264         * See remarks of |GetQueuedCompletionStatus| API.
    265         */
    266 
    267        LOG_NPS_ERROR("invalid overlapped (%lu)", err);
    268        continue;
    269      }
    270 
    271      MOZ_ASSERT(key);
    272    }
    273 
    274    /**
    275     * Windows doesn't provide a method to remove created I/O Completion Port,
    276     * all we can do is just close the handle we monitored before.
    277     * In some cases, there's race condition that the monitored handle has an
    278     * I/O status after the observer is being removed and destroyed.
    279     * To avoid changing the ref-count of a dangling pointer, don't use nsCOMPtr
    280     * here.
    281     */
    282    nsINamedPipeDataObserver* target =
    283        reinterpret_cast<nsINamedPipeDataObserver*>(key);
    284 
    285    nsCOMPtr<nsINamedPipeDataObserver> obs;
    286    {
    287      MutexAutoLock lock(mLock);
    288 
    289      auto idx = mObservers.IndexOf(target);
    290      if (idx == decltype(mObservers)::NoIndex) {
    291        LOG_NPS_ERROR("observer %p not found", target);
    292        continue;
    293      }
    294      obs = target;
    295    }
    296 
    297    MOZ_ASSERT(obs.get());
    298 
    299    if (success) {
    300      LOG_NPS_DEBUG("OnDataAvailable: obs=%p, bytes=%lu", obs.get(),
    301                    bytesTransferred);
    302      obs->OnDataAvailable(bytesTransferred, overlapped);
    303    } else {
    304      LOG_NPS_ERROR("GetQueuedCompletionStatus %p failed, error=%lu", obs.get(),
    305                    err);
    306      obs->OnError(err, overlapped);
    307    }
    308  }
    309 
    310  {
    311    MutexAutoLock lock(mLock);
    312    RemoveRetiredObjects();
    313  }
    314 
    315  return NS_OK;
    316 }
    317 
    318 }  // namespace net
    319 }  // namespace mozilla