dom/cache/AutoUtils.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 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/dom/cache/AutoUtils.h"
   8
   9 #include "mozilla/Unused.h"
  10 #include "mozilla/dom/InternalHeaders.h"
  11 #include "mozilla/dom/InternalRequest.h"
  12 #include "mozilla/dom/cache/CacheParent.h"
  13 #include "mozilla/dom/cache/CacheStreamControlParent.h"
  14 #include "mozilla/dom/cache/ReadStream.h"
  15 #include "mozilla/dom/cache/SavedTypes.h"
  16 #include "mozilla/dom/cache/StreamList.h"
  17 #include "mozilla/dom/cache/TypeUtils.h"
  18 #include "mozilla/ipc/IPCStreamUtils.h"
  19 #include "mozilla/ipc/PBackgroundParent.h"
  20 #include "nsCharSeparatedTokenizer.h"
  21 #include "nsHttp.h"
  22
  23 using mozilla::Maybe;
  24 using mozilla::Unused;
  25 using mozilla::dom::cache::CacheReadStream;
  26 using mozilla::ipc::PBackgroundParent;
  27
  28 namespace {
  29
  30 enum CleanupAction { Forget, Delete };
  31
  32 void CleanupChild(CacheReadStream& aReadStream, CleanupAction aAction) {
  33   // fds cleaned up by mStreamCleanupList
  34 }
  35
  36 void CleanupChild(Maybe<CacheReadStream>& aMaybeReadStream,
  37                   CleanupAction aAction) {
  38   if (aMaybeReadStream.isNothing()) {
  39     return;
  40   }
  41
  42   CleanupChild(aMaybeReadStream.ref(), aAction);
  43 }
  44
  45 }  // namespace
  46
  47 namespace mozilla::dom::cache {
  48
  49 // --------------------------------------------
  50
  51 AutoChildOpArgs::AutoChildOpArgs(TypeUtils* aTypeUtils,
  52                                  const CacheOpArgs& aOpArgs,
  53                                  uint32_t aEntryCount)
  54     : mTypeUtils(aTypeUtils), mOpArgs(aOpArgs), mSent(false) {
  55   MOZ_DIAGNOSTIC_ASSERT(mTypeUtils);
  56   MOZ_RELEASE_ASSERT(aEntryCount != 0);
  57   if (mOpArgs.type() == CacheOpArgs::TCachePutAllArgs) {
  58     CachePutAllArgs& args = mOpArgs.get_CachePutAllArgs();
  59     args.requestResponseList().SetCapacity(aEntryCount);
  60   } else {
  61     MOZ_DIAGNOSTIC_ASSERT(aEntryCount == 1);
  62   }
  63 }
  64
  65 AutoChildOpArgs::~AutoChildOpArgs() {
  66   CleanupAction action = mSent ? Forget : Delete;
  67
  68   switch (mOpArgs.type()) {
  69     case CacheOpArgs::TCacheMatchArgs: {
  70       CacheMatchArgs& args = mOpArgs.get_CacheMatchArgs();
  71       CleanupChild(args.request().body(), action);
  72       break;
  73     }
  74     case CacheOpArgs::TCacheMatchAllArgs: {
  75       CacheMatchAllArgs& args = mOpArgs.get_CacheMatchAllArgs();
  76       if (args.maybeRequest().isNothing()) {
  77         break;
  78       }
  79       CleanupChild(args.maybeRequest().ref().body(), action);
  80       break;
  81     }
  82     case CacheOpArgs::TCachePutAllArgs: {
  83       CachePutAllArgs& args = mOpArgs.get_CachePutAllArgs();
  84       auto& list = args.requestResponseList();
  85       for (uint32_t i = 0; i < list.Length(); ++i) {
  86         CleanupChild(list[i].request().body(), action);
  87         CleanupChild(list[i].response().body(), action);
  88       }
  89       break;
  90     }
  91     case CacheOpArgs::TCacheDeleteArgs: {
  92       CacheDeleteArgs& args = mOpArgs.get_CacheDeleteArgs();
  93       CleanupChild(args.request().body(), action);
  94       break;
  95     }
  96     case CacheOpArgs::TCacheKeysArgs: {
  97       CacheKeysArgs& args = mOpArgs.get_CacheKeysArgs();
  98       if (args.maybeRequest().isNothing()) {
  99         break;
 100       }
 101       CleanupChild(args.maybeRequest().ref().body(), action);
 102       break;
 103     }
 104     case CacheOpArgs::TStorageMatchArgs: {
 105       StorageMatchArgs& args = mOpArgs.get_StorageMatchArgs();
 106       CleanupChild(args.request().body(), action);
 107       break;
 108     }
 109     default:
 110       // Other types do not need cleanup
 111       break;
 112   }
 113 }
 114
 115 void AutoChildOpArgs::Add(const InternalRequest& aRequest,
 116                           BodyAction aBodyAction, SchemeAction aSchemeAction,
 117                           ErrorResult& aRv) {
 118   MOZ_DIAGNOSTIC_ASSERT(!mSent);
 119
 120   switch (mOpArgs.type()) {
 121     case CacheOpArgs::TCacheMatchArgs: {
 122       CacheMatchArgs& args = mOpArgs.get_CacheMatchArgs();
 123       mTypeUtils->ToCacheRequest(args.request(), aRequest, aBodyAction,
 124                                  aSchemeAction, aRv);
 125       break;
 126     }
 127     case CacheOpArgs::TCacheMatchAllArgs: {
 128       CacheMatchAllArgs& args = mOpArgs.get_CacheMatchAllArgs();
 129       MOZ_DIAGNOSTIC_ASSERT(args.maybeRequest().isNothing());
 130       args.maybeRequest().emplace(CacheRequest());
 131       mTypeUtils->ToCacheRequest(args.maybeRequest().ref(), aRequest,
 132                                  aBodyAction, aSchemeAction, aRv);
 133       break;
 134     }
 135     case CacheOpArgs::TCacheDeleteArgs: {
 136       CacheDeleteArgs& args = mOpArgs.get_CacheDeleteArgs();
 137       mTypeUtils->ToCacheRequest(args.request(), aRequest, aBodyAction,
 138                                  aSchemeAction, aRv);
 139       break;
 140     }
 141     case CacheOpArgs::TCacheKeysArgs: {
 142       CacheKeysArgs& args = mOpArgs.get_CacheKeysArgs();
 143       MOZ_DIAGNOSTIC_ASSERT(args.maybeRequest().isNothing());
 144       args.maybeRequest().emplace(CacheRequest());
 145       mTypeUtils->ToCacheRequest(args.maybeRequest().ref(), aRequest,
 146                                  aBodyAction, aSchemeAction, aRv);
 147       break;
 148     }
 149     case CacheOpArgs::TStorageMatchArgs: {
 150       StorageMatchArgs& args = mOpArgs.get_StorageMatchArgs();
 151       mTypeUtils->ToCacheRequest(args.request(), aRequest, aBodyAction,
 152                                  aSchemeAction, aRv);
 153       break;
 154     }
 155     default:
 156       MOZ_CRASH("Cache args type cannot send a Request!");
 157   }
 158 }
 159
 160 namespace {
 161
 162 bool MatchInPutList(const InternalRequest& aRequest,
 163                     const nsTArray<CacheRequestResponse>& aPutList) {
 164   // This method implements the SW spec QueryCache algorithm against an
 165   // in memory array of Request/Response objects.  This essentially the
 166   // same algorithm that is implemented in DBSchema.cpp.  Unfortunately
 167   // we cannot unify them because when operating against the real database
 168   // we don't want to load all request/response objects into memory.
 169
 170   // Note, we can skip the check for a invalid request method because
 171   // Cache should only call into here with a GET or HEAD.
 172 #ifdef DEBUG
 173   nsAutoCString method;
 174   aRequest.GetMethod(method);
 175   MOZ_ASSERT(method.LowerCaseEqualsLiteral("get") ||
 176              method.LowerCaseEqualsLiteral("head"));
 177 #endif
 178
 179   RefPtr<InternalHeaders> requestHeaders = aRequest.Headers();
 180
 181   for (uint32_t i = 0; i < aPutList.Length(); ++i) {
 182     const CacheRequest& cachedRequest = aPutList[i].request();
 183     const CacheResponse& cachedResponse = aPutList[i].response();
 184
 185     nsAutoCString url;
 186     aRequest.GetURL(url);
 187
 188     nsAutoCString requestUrl(cachedRequest.urlWithoutQuery());
 189     requestUrl.Append(cachedRequest.urlQuery());
 190
 191     // If the URLs don't match, then just skip to the next entry.
 192     if (url != requestUrl) {
 193       continue;
 194     }
 195
 196     RefPtr<InternalHeaders> cachedRequestHeaders =
 197         TypeUtils::ToInternalHeaders(cachedRequest.headers());
 198
 199     RefPtr<InternalHeaders> cachedResponseHeaders =
 200         TypeUtils::ToInternalHeaders(cachedResponse.headers());
 201
 202     nsCString varyHeaders;
 203     ErrorResult rv;
 204     cachedResponseHeaders->Get("vary"_ns, varyHeaders, rv);
 205     MOZ_ALWAYS_TRUE(!rv.Failed());
 206
 207     // Assume the vary headers match until we find a conflict
 208     bool varyHeadersMatch = true;
 209
 210     for (const nsACString& header :
 211          nsCCharSeparatedTokenizer(varyHeaders, NS_HTTP_HEADER_SEP).ToRange()) {
 212       MOZ_DIAGNOSTIC_ASSERT(!header.EqualsLiteral("*"),
 213                             "We should have already caught this in "
 214                             "TypeUtils::ToPCacheResponseWithoutBody()");
 215
 216       ErrorResult headerRv;
 217       nsAutoCString value;
 218       requestHeaders->Get(header, value, headerRv);
 219       if (NS_WARN_IF(headerRv.Failed())) {
 220         headerRv.SuppressException();
 221         MOZ_DIAGNOSTIC_ASSERT(value.IsEmpty());
 222       }
 223
 224       nsAutoCString cachedValue;
 225       cachedRequestHeaders->Get(header, cachedValue, headerRv);
 226       if (NS_WARN_IF(headerRv.Failed())) {
 227         headerRv.SuppressException();
 228         MOZ_DIAGNOSTIC_ASSERT(cachedValue.IsEmpty());
 229       }
 230
 231       if (value != cachedValue) {
 232         varyHeadersMatch = false;
 233         break;
 234       }
 235     }
 236
 237     // URL was equal and all vary headers match!
 238     if (varyHeadersMatch) {
 239       return true;
 240     }
 241   }
 242
 243   return false;
 244 }
 245
 246 }  // namespace
 247
 248 void AutoChildOpArgs::Add(JSContext* aCx, const InternalRequest& aRequest,
 249                           BodyAction aBodyAction, SchemeAction aSchemeAction,
 250                           Response& aResponse, ErrorResult& aRv) {
 251   MOZ_DIAGNOSTIC_ASSERT(!mSent);
 252
 253   switch (mOpArgs.type()) {
 254     case CacheOpArgs::TCachePutAllArgs: {
 255       CachePutAllArgs& args = mOpArgs.get_CachePutAllArgs();
 256
 257       // Throw an error if a request/response pair would mask another
 258       // request/response pair in the same PutAll operation.  This is
 259       // step 2.3.2.3 from the "Batch Cache Operations" spec algorithm.
 260       if (MatchInPutList(aRequest, args.requestResponseList())) {
 261         aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
 262         return;
 263       }
 264
 265       MOZ_RELEASE_ASSERT(args.requestResponseList().Length() <
 266                          args.requestResponseList().Capacity());
 267
 268       // The FileDescriptorSetChild asserts in its destructor that all fds have
 269       // been removed.  The copy constructor, however, simply duplicates the
 270       // fds without removing any.  This means each temporary and copy must be
 271       // explicitly cleaned up.
 272       //
 273       // Avoid a lot of this hassle by making sure we only create one here.  On
 274       // error we remove it.
 275       CacheRequestResponse& pair = *args.requestResponseList().AppendElement();
 276       pair.request().body() = Nothing();
 277       pair.response().body() = Nothing();
 278
 279       mTypeUtils->ToCacheRequest(pair.request(), aRequest, aBodyAction,
 280                                  aSchemeAction, aRv);
 281       if (!aRv.Failed()) {
 282         mTypeUtils->ToCacheResponse(aCx, pair.response(), aResponse, aRv);
 283       }
 284
 285       if (aRv.Failed()) {
 286         CleanupChild(pair.request().body(), Delete);
 287         args.requestResponseList().RemoveLastElement();
 288       }
 289
 290       break;
 291     }
 292     default:
 293       MOZ_CRASH("Cache args type cannot send a Request/Response pair!");
 294   }
 295 }
 296
 297 const CacheOpArgs& AutoChildOpArgs::SendAsOpArgs() {
 298   MOZ_DIAGNOSTIC_ASSERT(!mSent);
 299   mSent = true;
 300   return mOpArgs;
 301 }
 302
 303 // --------------------------------------------
 304
 305 AutoParentOpResult::AutoParentOpResult(
 306     mozilla::ipc::PBackgroundParent* aManager, const CacheOpResult& aOpResult,
 307     uint32_t aEntryCount)
 308     : mManager(aManager),
 309       mOpResult(aOpResult),
 310       mStreamControl(nullptr),
 311       mSent(false) {
 312   MOZ_DIAGNOSTIC_ASSERT(mManager);
 313   MOZ_RELEASE_ASSERT(aEntryCount != 0);
 314   if (mOpResult.type() == CacheOpResult::TCacheMatchAllResult) {
 315     CacheMatchAllResult& result = mOpResult.get_CacheMatchAllResult();
 316     result.responseList().SetCapacity(aEntryCount);
 317   } else if (mOpResult.type() == CacheOpResult::TCacheKeysResult) {
 318     CacheKeysResult& result = mOpResult.get_CacheKeysResult();
 319     result.requestList().SetCapacity(aEntryCount);
 320   } else {
 321     MOZ_DIAGNOSTIC_ASSERT(aEntryCount == 1);
 322   }
 323 }
 324
 325 AutoParentOpResult::~AutoParentOpResult() {
 326   CleanupAction action = mSent ? Forget : Delete;
 327
 328   switch (mOpResult.type()) {
 329     case CacheOpResult::TStorageOpenResult: {
 330       StorageOpenResult& result = mOpResult.get_StorageOpenResult();
 331       if (action == Forget || !result.actor()) {
 332         break;
 333       }
 334
 335       QM_WARNONLY_TRY(
 336           OkIf(PCacheParent::Send__delete__(result.actor().AsParent())));
 337       break;
 338     }
 339     default:
 340       // other types do not need additional clean up
 341       break;
 342   }
 343
 344   if (action == Delete && mStreamControl) {
 345     mStreamControl->AssertWillDelete();
 346     QM_WARNONLY_TRY(
 347         OkIf(PCacheStreamControlParent::Send__delete__(mStreamControl)));
 348   }
 349 }
 350
 351 void AutoParentOpResult::Add(CacheId aOpenedCacheId,
 352                              SafeRefPtr<Manager> aManager) {
 353   MOZ_DIAGNOSTIC_ASSERT(mOpResult.type() == CacheOpResult::TStorageOpenResult);
 354   MOZ_DIAGNOSTIC_ASSERT(!mOpResult.get_StorageOpenResult().actor());
 355   mOpResult.get_StorageOpenResult().actor() = mManager->SendPCacheConstructor(
 356       new CacheParent(std::move(aManager), aOpenedCacheId));
 357 }
 358
 359 void AutoParentOpResult::Add(const SavedResponse& aSavedResponse,
 360                              StreamList& aStreamList) {
 361   MOZ_DIAGNOSTIC_ASSERT(!mSent);
 362
 363   switch (mOpResult.type()) {
 364     case CacheOpResult::TCacheMatchResult: {
 365       CacheMatchResult& result = mOpResult.get_CacheMatchResult();
 366       MOZ_DIAGNOSTIC_ASSERT(result.maybeResponse().isNothing());
 367       result.maybeResponse().emplace(aSavedResponse.mValue);
 368       SerializeResponseBody(aSavedResponse, aStreamList,
 369                             &result.maybeResponse().ref());
 370       break;
 371     }
 372     case CacheOpResult::TCacheMatchAllResult: {
 373       CacheMatchAllResult& result = mOpResult.get_CacheMatchAllResult();
 374       MOZ_RELEASE_ASSERT(result.responseList().Length() <
 375                          result.responseList().Capacity());
 376       result.responseList().AppendElement(aSavedResponse.mValue);
 377       SerializeResponseBody(aSavedResponse, aStreamList,
 378                             &result.responseList().LastElement());
 379       break;
 380     }
 381     case CacheOpResult::TStorageMatchResult: {
 382       StorageMatchResult& result = mOpResult.get_StorageMatchResult();
 383       MOZ_DIAGNOSTIC_ASSERT(result.maybeResponse().isNothing());
 384       result.maybeResponse().emplace(aSavedResponse.mValue);
 385       SerializeResponseBody(aSavedResponse, aStreamList,
 386                             &result.maybeResponse().ref());
 387       break;
 388     }
 389     default:
 390       MOZ_CRASH("Cache result type cannot handle returning a Response!");
 391   }
 392 }
 393
 394 void AutoParentOpResult::Add(const SavedRequest& aSavedRequest,
 395                              StreamList& aStreamList) {
 396   MOZ_DIAGNOSTIC_ASSERT(!mSent);
 397
 398   switch (mOpResult.type()) {
 399     case CacheOpResult::TCacheKeysResult: {
 400       CacheKeysResult& result = mOpResult.get_CacheKeysResult();
 401       MOZ_RELEASE_ASSERT(result.requestList().Length() <
 402                          result.requestList().Capacity());
 403       result.requestList().AppendElement(aSavedRequest.mValue);
 404       CacheRequest& request = result.requestList().LastElement();
 405
 406       if (!aSavedRequest.mHasBodyId) {
 407         request.body() = Nothing();
 408         break;
 409       }
 410
 411       request.body().emplace(CacheReadStream());
 412       SerializeReadStream(aSavedRequest.mBodyId, aStreamList,
 413                           &request.body().ref());
 414       break;
 415     }
 416     default:
 417       MOZ_CRASH("Cache result type cannot handle returning a Request!");
 418   }
 419 }
 420
 421 const CacheOpResult& AutoParentOpResult::SendAsOpResult() {
 422   MOZ_DIAGNOSTIC_ASSERT(!mSent);
 423   mSent = true;
 424   return mOpResult;
 425 }
 426
 427 void AutoParentOpResult::SerializeResponseBody(
 428     const SavedResponse& aSavedResponse, StreamList& aStreamList,
 429     CacheResponse* aResponseOut) {
 430   MOZ_DIAGNOSTIC_ASSERT(aResponseOut);
 431
 432   if (!aSavedResponse.mHasBodyId) {
 433     aResponseOut->body() = Nothing();
 434     return;
 435   }
 436
 437   aResponseOut->body().emplace(CacheReadStream());
 438   SerializeReadStream(aSavedResponse.mBodyId, aStreamList,
 439                       &aResponseOut->body().ref());
 440 }
 441
 442 void AutoParentOpResult::SerializeReadStream(const nsID& aId,
 443                                              StreamList& aStreamList,
 444                                              CacheReadStream* aReadStreamOut) {
 445   MOZ_DIAGNOSTIC_ASSERT(aReadStreamOut);
 446   MOZ_DIAGNOSTIC_ASSERT(!mSent);
 447
 448   nsCOMPtr<nsIInputStream> stream = aStreamList.Extract(aId);
 449
 450   if (!mStreamControl) {
 451     mStreamControl = static_cast<CacheStreamControlParent*>(
 452         mManager->SendPCacheStreamControlConstructor(
 453             new CacheStreamControlParent()));
 454
 455     // If this failed, then the child process is gone.  Warn and allow actor
 456     // cleanup to proceed as normal.
 457     if (!mStreamControl) {
 458       NS_WARNING("Cache failed to create stream control actor.");
 459       return;
 460     }
 461   }
 462
 463   aStreamList.SetStreamControl(mStreamControl);
 464
 465   RefPtr<ReadStream> readStream =
 466       ReadStream::Create(mStreamControl, aId, stream);
 467   ErrorResult rv;
 468   readStream->Serialize(aReadStreamOut, rv);
 469   MOZ_DIAGNOSTIC_ASSERT(!rv.Failed());
 470 }
 471
 472 }  // namespace mozilla::dom::cache