netwerk/dns/DNSRequestChild.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set sw=2 ts=8 et tw=80 : */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "mozilla/net/ChildDNSService.h"
   8 #include "mozilla/net/DNSRequestChild.h"
   9 #include "mozilla/net/NeckoChild.h"
  10 #include "mozilla/unused.h"
  11 #include "nsIDNSRecord.h"
  12 #include "nsHostResolver.h"
  13 #include "nsTArray.h"
  14 #include "nsNetAddr.h"
  15 #include "nsIThread.h"
  16 #include "nsThreadUtils.h"
  17
  18 using namespace mozilla::ipc;
  19
  20 namespace mozilla {
  21 namespace net {
  22
  23 //-----------------------------------------------------------------------------
  24 // ChildDNSRecord:
  25 // A simple class to provide nsIDNSRecord on the child
  26 //-----------------------------------------------------------------------------
  27
  28 class ChildDNSRecord : public nsIDNSRecord
  29 {
  30 public:
  31   NS_DECL_THREADSAFE_ISUPPORTS
  32   NS_DECL_NSIDNSRECORD
  33
  34   ChildDNSRecord(const DNSRecord& reply, uint16_t flags);
  35
  36 private:
  37   virtual ~ChildDNSRecord();
  38
  39   nsCString mCanonicalName;
  40   nsTArray<NetAddr> mAddresses;
  41   uint32_t mCurrent; // addr iterator
  42   uint32_t mLength;  // number of addrs
  43   uint16_t mFlags;
  44 };
  45
  46 NS_IMPL_ISUPPORTS(ChildDNSRecord, nsIDNSRecord)
  47
  48 ChildDNSRecord::ChildDNSRecord(const DNSRecord& reply, uint16_t flags)
  49   : mCurrent(0)
  50   , mFlags(flags)
  51 {
  52   mCanonicalName = reply.canonicalName();
  53
  54   // A shame IPDL gives us no way to grab ownership of array: so copy it.
  55   const nsTArray<NetAddr>& addrs = reply.addrs();
  56   uint32_t i = 0;
  57   mLength = addrs.Length();
  58   for (; i < mLength; i++) {
  59     mAddresses.AppendElement(addrs[i]);
  60   }
  61 }
  62
  63 ChildDNSRecord::~ChildDNSRecord()
  64 {
  65 }
  66
  67 //-----------------------------------------------------------------------------
  68 // ChildDNSRecord::nsIDNSRecord
  69 //-----------------------------------------------------------------------------
  70
  71 NS_IMETHODIMP
  72 ChildDNSRecord::GetCanonicalName(nsACString &result)
  73 {
  74   if (!(mFlags & nsHostResolver::RES_CANON_NAME)) {
  75     return NS_ERROR_NOT_AVAILABLE;
  76   }
  77
  78   result = mCanonicalName;
  79   return NS_OK;
  80 }
  81
  82 NS_IMETHODIMP
  83 ChildDNSRecord::GetNextAddr(uint16_t port, NetAddr *addr)
  84 {
  85   if (mCurrent >= mLength) {
  86     return NS_ERROR_NOT_AVAILABLE;
  87   }
  88
  89   memcpy(addr, &mAddresses[mCurrent++], sizeof(NetAddr));
  90
  91   // both Ipv4/6 use same bits for port, so safe to just use ipv4's field
  92   addr->inet.port = htons(port);
  93
  94   return NS_OK;
  95 }
  96
  97 // shamelessly copied from nsDNSRecord
  98 NS_IMETHODIMP
  99 ChildDNSRecord::GetScriptableNextAddr(uint16_t port, nsINetAddr **result)
 100 {
 101   NetAddr addr;
 102   nsresult rv = GetNextAddr(port, &addr);
 103   if (NS_FAILED(rv)) return rv;
 104
 105   NS_ADDREF(*result = new nsNetAddr(&addr));
 106
 107   return NS_OK;
 108 }
 109
 110 // also copied from nsDNSRecord
 111 NS_IMETHODIMP
 112 ChildDNSRecord::GetNextAddrAsString(nsACString &result)
 113 {
 114   NetAddr addr;
 115   nsresult rv = GetNextAddr(0, &addr);
 116   if (NS_FAILED(rv)) {
 117     return rv;
 118   }
 119
 120   char buf[kIPv6CStrBufSize];
 121   if (NetAddrToString(&addr, buf, sizeof(buf))) {
 122     result.Assign(buf);
 123     return NS_OK;
 124   }
 125   NS_ERROR("NetAddrToString failed unexpectedly");
 126   return NS_ERROR_FAILURE; // conversion failed for some reason
 127 }
 128
 129 NS_IMETHODIMP
 130 ChildDNSRecord::HasMore(bool *result)
 131 {
 132   *result = mCurrent < mLength;
 133   return NS_OK;
 134 }
 135
 136 NS_IMETHODIMP
 137 ChildDNSRecord::Rewind()
 138 {
 139   mCurrent = 0;
 140   return NS_OK;
 141 }
 142
 143 NS_IMETHODIMP
 144 ChildDNSRecord::ReportUnusable(uint16_t aPort)
 145 {
 146   // "We thank you for your feedback" == >/dev/null
 147   // TODO: we could send info back to parent.
 148   return NS_OK;
 149 }
 150
 151 //-----------------------------------------------------------------------------
 152 // CancelDNSRequestEvent
 153 //-----------------------------------------------------------------------------
 154
 155 class CancelDNSRequestEvent : public nsRunnable
 156 {
 157 public:
 158   CancelDNSRequestEvent(DNSRequestChild* aDnsReq, nsresult aReason)
 159     : mDnsRequest(aDnsReq)
 160     , mReasonForCancel(aReason)
 161   {}
 162
 163   NS_IMETHOD Run()
 164   {
 165     if (mDnsRequest->mIPCOpen) {
 166       // Send request to Parent process.
 167       mDnsRequest->SendCancelDNSRequest(mDnsRequest->mHost, mDnsRequest->mFlags,
 168                                         mDnsRequest->mNetworkInterface,
 169                                         mReasonForCancel);
 170     }
 171     return NS_OK;
 172   }
 173 private:
 174   nsRefPtr<DNSRequestChild> mDnsRequest;
 175   nsresult mReasonForCancel;
 176 };
 177
 178 //-----------------------------------------------------------------------------
 179 // DNSRequestChild
 180 //-----------------------------------------------------------------------------
 181
 182 DNSRequestChild::DNSRequestChild(const nsCString& aHost,
 183                                  const uint32_t& aFlags,
 184                                  const nsCString& aNetworkInterface,
 185                                  nsIDNSListener *aListener,
 186                                  nsIEventTarget *target)
 187   : mListener(aListener)
 188   , mTarget(target)
 189   , mResultStatus(NS_OK)
 190   , mHost(aHost)
 191   , mFlags(aFlags)
 192   , mNetworkInterface(aNetworkInterface)
 193   , mIPCOpen(false)
 194 {
 195 }
 196
 197 void
 198 DNSRequestChild::StartRequest()
 199 {
 200   // we can only do IPDL on the main thread
 201   if (!NS_IsMainThread()) {
 202     NS_DispatchToMainThread(
 203       NS_NewRunnableMethod(this, &DNSRequestChild::StartRequest));
 204     return;
 205   }
 206
 207   // Send request to Parent process.
 208   gNeckoChild->SendPDNSRequestConstructor(this, mHost, mFlags,
 209                                           mNetworkInterface);
 210   mIPCOpen = true;
 211
 212   // IPDL holds a reference until IPDL channel gets destroyed
 213   AddIPDLReference();
 214 }
 215
 216 void
 217 DNSRequestChild::CallOnLookupComplete()
 218 {
 219   MOZ_ASSERT(mListener);
 220   mListener->OnLookupComplete(this, mResultRecord, mResultStatus);
 221 }
 222
 223 bool
 224 DNSRequestChild::RecvLookupCompleted(const DNSRequestResponse& reply)
 225 {
 226   mIPCOpen = false;
 227   MOZ_ASSERT(mListener);
 228
 229   switch (reply.type()) {
 230   case DNSRequestResponse::TDNSRecord: {
 231     mResultRecord = new ChildDNSRecord(reply.get_DNSRecord(), mFlags);
 232     break;
 233   }
 234   case DNSRequestResponse::Tnsresult: {
 235     mResultStatus = reply.get_nsresult();
 236     break;
 237   }
 238   default:
 239     NS_NOTREACHED("unknown type");
 240     return false;
 241   }
 242
 243   MOZ_ASSERT(NS_IsMainThread());
 244
 245   bool targetIsMain = false;
 246   if (!mTarget) {
 247     targetIsMain = true;
 248   } else {
 249     mTarget->IsOnCurrentThread(&targetIsMain);
 250   }
 251
 252   if (targetIsMain) {
 253     CallOnLookupComplete();
 254   } else {
 255     nsCOMPtr<nsIRunnable> event =
 256       NS_NewRunnableMethod(this, &DNSRequestChild::CallOnLookupComplete);
 257     mTarget->Dispatch(event, NS_DISPATCH_NORMAL);
 258   }
 259
 260   unused << Send__delete__(this);
 261
 262   return true;
 263 }
 264
 265 void
 266 DNSRequestChild::ReleaseIPDLReference()
 267 {
 268   // Request is done or destroyed. Remove it from the hash table.
 269   nsRefPtr<ChildDNSService> dnsServiceChild =
 270     dont_AddRef(ChildDNSService::GetSingleton());
 271   dnsServiceChild->NotifyRequestDone(this);
 272
 273   Release();
 274 }
 275
 276 void
 277 DNSRequestChild::ActorDestroy(ActorDestroyReason why)
 278 {
 279   mIPCOpen = false;
 280 }
 281
 282 //-----------------------------------------------------------------------------
 283 // DNSRequestChild::nsISupports
 284 //-----------------------------------------------------------------------------
 285
 286 NS_IMPL_ISUPPORTS(DNSRequestChild,
 287                   nsICancelable)
 288
 289 //-----------------------------------------------------------------------------
 290 // DNSRequestChild::nsICancelable
 291 //-----------------------------------------------------------------------------
 292
 293 NS_IMETHODIMP
 294 DNSRequestChild::Cancel(nsresult reason)
 295 {
 296   if(mIPCOpen) {
 297     // We can only do IPDL on the main thread
 298     NS_DispatchToMainThread(
 299       new CancelDNSRequestEvent(this, reason));
 300   }
 301   return NS_OK;
 302 }
 303
 304 //------------------------------------------------------------------------------
 305 }} // mozilla::net