netwerk/base/nsMIMEInputStream.cpp

   1 /* -*- Mode: C++; tab-width: 4; 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 /**
   7  * The MIME stream separates headers and a datastream. It also allows
   8  * automatic creation of the content-length header.
   9  */
  10
  11 #include "nsMIMEInputStream.h"
  12
  13 #include <utility>
  14
  15 #include "ipc/IPCMessageUtils.h"
  16 #include "mozilla/Mutex.h"
  17 #include "mozilla/ipc/InputStreamUtils.h"
  18 #include "nsCOMPtr.h"
  19 #include "nsComponentManagerUtils.h"
  20 #include "nsIAsyncInputStream.h"
  21 #include "nsIClassInfoImpl.h"
  22 #include "nsIHttpHeaderVisitor.h"
  23 #include "nsIIPCSerializableInputStream.h"
  24 #include "nsIInputStreamLength.h"
  25 #include "nsIMIMEInputStream.h"
  26 #include "nsISeekableStream.h"
  27 #include "nsString.h"
  28
  29 using namespace mozilla::ipc;
  30 using mozilla::Maybe;
  31
  32 class nsMIMEInputStream : public nsIMIMEInputStream,
  33                           public nsISeekableStream,
  34                           public nsIIPCSerializableInputStream,
  35                           public nsIAsyncInputStream,
  36                           public nsIInputStreamCallback,
  37                           public nsIInputStreamLength,
  38                           public nsIAsyncInputStreamLength,
  39                           public nsIInputStreamLengthCallback,
  40                           public nsICloneableInputStream {
  41   virtual ~nsMIMEInputStream() = default;
  42
  43  public:
  44   nsMIMEInputStream() = default;
  45
  46   NS_DECL_THREADSAFE_ISUPPORTS
  47   NS_DECL_NSIINPUTSTREAM
  48   NS_DECL_NSIMIMEINPUTSTREAM
  49   NS_DECL_NSISEEKABLESTREAM
  50   NS_DECL_NSITELLABLESTREAM
  51   NS_DECL_NSIIPCSERIALIZABLEINPUTSTREAM
  52   NS_DECL_NSIASYNCINPUTSTREAM
  53   NS_DECL_NSIINPUTSTREAMCALLBACK
  54   NS_DECL_NSIINPUTSTREAMLENGTH
  55   NS_DECL_NSIASYNCINPUTSTREAMLENGTH
  56   NS_DECL_NSIINPUTSTREAMLENGTHCALLBACK
  57   NS_DECL_NSICLONEABLEINPUTSTREAM
  58
  59  private:
  60   struct MOZ_STACK_CLASS ReadSegmentsState {
  61     nsCOMPtr<nsIInputStream> mThisStream;
  62     nsWriteSegmentFun mWriter{nullptr};
  63     void* mClosure{nullptr};
  64   };
  65   static nsresult ReadSegCb(nsIInputStream* aIn, void* aClosure,
  66                             const char* aFromRawSegment, uint32_t aToOffset,
  67                             uint32_t aCount, uint32_t* aWriteCount);
  68
  69   bool IsSeekableInputStream() const;
  70   bool IsAsyncInputStream() const;
  71   bool IsInputStreamLength() const;
  72   bool IsAsyncInputStreamLength() const;
  73   bool IsCloneableInputStream() const;
  74
  75   nsTArray<HeaderEntry> mHeaders;
  76
  77   nsCOMPtr<nsIInputStream> mStream;
  78   mozilla::Atomic<bool, mozilla::Relaxed> mStartedReading{false};
  79
  80   mozilla::Mutex mMutex{"nsMIMEInputStream::mMutex"};
  81   nsCOMPtr<nsIInputStreamCallback> mAsyncWaitCallback MOZ_GUARDED_BY(mMutex);
  82
  83   // This is protected by mutex.
  84   nsCOMPtr<nsIInputStreamLengthCallback> mAsyncInputStreamLengthCallback;
  85 };
  86
  87 NS_IMPL_ADDREF(nsMIMEInputStream)
  88 NS_IMPL_RELEASE(nsMIMEInputStream)
  89
  90 NS_IMPL_CLASSINFO(nsMIMEInputStream, nullptr, nsIClassInfo::THREADSAFE,
  91                   NS_MIMEINPUTSTREAM_CID)
  92
  93 NS_INTERFACE_MAP_BEGIN(nsMIMEInputStream)
  94   NS_INTERFACE_MAP_ENTRY(nsIMIMEInputStream)
  95   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsIInputStream, nsIMIMEInputStream)
  96   NS_INTERFACE_MAP_ENTRY(nsITellableStream)
  97   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsISeekableStream, IsSeekableInputStream())
  98   NS_INTERFACE_MAP_ENTRY(nsIIPCSerializableInputStream)
  99   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAsyncInputStream, IsAsyncInputStream())
 100   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIInputStreamCallback,
 101                                      IsAsyncInputStream())
 102   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIMIMEInputStream)
 103   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIInputStreamLength,
 104                                      IsInputStreamLength())
 105   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAsyncInputStreamLength,
 106                                      IsAsyncInputStreamLength())
 107   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIInputStreamLengthCallback,
 108                                      IsAsyncInputStreamLength())
 109   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsICloneableInputStream,
 110                                      IsCloneableInputStream())
 111   NS_IMPL_QUERY_CLASSINFO(nsMIMEInputStream)
 112 NS_INTERFACE_MAP_END
 113
 114 NS_IMPL_CI_INTERFACE_GETTER(nsMIMEInputStream, nsIMIMEInputStream,
 115                             nsIAsyncInputStream, nsIInputStream,
 116                             nsISeekableStream, nsITellableStream)
 117
 118 NS_IMETHODIMP
 119 nsMIMEInputStream::AddHeader(const char* aName, const char* aValue) {
 120   NS_ENSURE_FALSE(mStartedReading, NS_ERROR_FAILURE);
 121
 122   HeaderEntry* entry = mHeaders.AppendElement();
 123   entry->name().Append(aName);
 124   entry->value().Append(aValue);
 125
 126   return NS_OK;
 127 }
 128
 129 NS_IMETHODIMP
 130 nsMIMEInputStream::VisitHeaders(nsIHttpHeaderVisitor* visitor) {
 131   nsresult rv;
 132
 133   for (auto& header : mHeaders) {
 134     rv = visitor->VisitHeader(header.name(), header.value());
 135     if (NS_FAILED(rv)) {
 136       return rv;
 137     }
 138   }
 139   return NS_OK;
 140 }
 141
 142 NS_IMETHODIMP
 143 nsMIMEInputStream::SetData(nsIInputStream* aStream) {
 144   NS_ENSURE_FALSE(mStartedReading, NS_ERROR_FAILURE);
 145
 146   mStream = aStream;
 147   return NS_OK;
 148 }
 149
 150 NS_IMETHODIMP
 151 nsMIMEInputStream::GetData(nsIInputStream** aStream) {
 152   NS_ENSURE_ARG_POINTER(aStream);
 153   *aStream = do_AddRef(mStream).take();
 154   return NS_OK;
 155 }
 156
 157 #define INITSTREAMS                               \
 158   if (!mStartedReading) {                         \
 159     NS_ENSURE_TRUE(mStream, NS_ERROR_UNEXPECTED); \
 160     mStartedReading = true;                       \
 161   }
 162
 163 // Reset mStartedReading when Seek-ing to start
 164 NS_IMETHODIMP
 165 nsMIMEInputStream::Seek(int32_t whence, int64_t offset) {
 166   NS_ENSURE_TRUE(mStream, NS_ERROR_UNEXPECTED);
 167
 168   nsresult rv;
 169   nsCOMPtr<nsISeekableStream> stream = do_QueryInterface(mStream);
 170
 171   if (whence == NS_SEEK_SET && offset == 0) {
 172     rv = stream->Seek(whence, offset);
 173     if (NS_SUCCEEDED(rv)) mStartedReading = false;
 174   } else {
 175     INITSTREAMS;
 176     rv = stream->Seek(whence, offset);
 177   }
 178
 179   return rv;
 180 }
 181
 182 // Proxy ReadSegments since we need to be a good little nsIInputStream
 183 NS_IMETHODIMP nsMIMEInputStream::ReadSegments(nsWriteSegmentFun aWriter,
 184                                               void* aClosure, uint32_t aCount,
 185                                               uint32_t* _retval) {
 186   INITSTREAMS;
 187   ReadSegmentsState state;
 188   // Disambiguate ambiguous nsIInputStream.
 189   state.mThisStream =
 190       static_cast<nsIInputStream*>(static_cast<nsIMIMEInputStream*>(this));
 191   state.mWriter = aWriter;
 192   state.mClosure = aClosure;
 193   return mStream->ReadSegments(ReadSegCb, &state, aCount, _retval);
 194 }
 195
 196 nsresult nsMIMEInputStream::ReadSegCb(nsIInputStream* aIn, void* aClosure,
 197                                       const char* aFromRawSegment,
 198                                       uint32_t aToOffset, uint32_t aCount,
 199                                       uint32_t* aWriteCount) {
 200   ReadSegmentsState* state = (ReadSegmentsState*)aClosure;
 201   return (state->mWriter)(state->mThisStream, state->mClosure, aFromRawSegment,
 202                           aToOffset, aCount, aWriteCount);
 203 }
 204
 205 /**
 206  * Forward everything else to the mStream after calling INITSTREAMS
 207  */
 208
 209 // nsIInputStream
 210 NS_IMETHODIMP nsMIMEInputStream::Close(void) {
 211   INITSTREAMS;
 212   return mStream->Close();
 213 }
 214 NS_IMETHODIMP nsMIMEInputStream::Available(uint64_t* _retval) {
 215   INITSTREAMS;
 216   return mStream->Available(_retval);
 217 }
 218 NS_IMETHODIMP nsMIMEInputStream::StreamStatus() {
 219   INITSTREAMS;
 220   return mStream->StreamStatus();
 221 }
 222 NS_IMETHODIMP nsMIMEInputStream::Read(char* buf, uint32_t count,
 223                                       uint32_t* _retval) {
 224   INITSTREAMS;
 225   return mStream->Read(buf, count, _retval);
 226 }
 227 NS_IMETHODIMP nsMIMEInputStream::IsNonBlocking(bool* aNonBlocking) {
 228   INITSTREAMS;
 229   return mStream->IsNonBlocking(aNonBlocking);
 230 }
 231
 232 // nsIAsyncInputStream
 233 NS_IMETHODIMP
 234 nsMIMEInputStream::CloseWithStatus(nsresult aStatus) {
 235   INITSTREAMS;
 236   nsCOMPtr<nsIAsyncInputStream> asyncStream = do_QueryInterface(mStream);
 237   return asyncStream->CloseWithStatus(aStatus);
 238 }
 239
 240 NS_IMETHODIMP
 241 nsMIMEInputStream::AsyncWait(nsIInputStreamCallback* aCallback, uint32_t aFlags,
 242                              uint32_t aRequestedCount,
 243                              nsIEventTarget* aEventTarget) {
 244   INITSTREAMS;
 245   nsCOMPtr<nsIAsyncInputStream> asyncStream = do_QueryInterface(mStream);
 246   if (NS_WARN_IF(!asyncStream)) {
 247     return NS_ERROR_FAILURE;
 248   }
 249
 250   nsCOMPtr<nsIInputStreamCallback> callback = aCallback ? this : nullptr;
 251   {
 252     mozilla::MutexAutoLock lock(mMutex);
 253     if (NS_WARN_IF(mAsyncWaitCallback && aCallback &&
 254                    mAsyncWaitCallback != aCallback)) {
 255       return NS_ERROR_FAILURE;
 256     }
 257
 258     mAsyncWaitCallback = aCallback;
 259   }
 260
 261   return asyncStream->AsyncWait(callback, aFlags, aRequestedCount,
 262                                 aEventTarget);
 263 }
 264
 265 // nsIInputStreamCallback
 266
 267 NS_IMETHODIMP
 268 nsMIMEInputStream::OnInputStreamReady(nsIAsyncInputStream* aStream) {
 269   nsCOMPtr<nsIInputStreamCallback> callback;
 270
 271   {
 272     mozilla::MutexAutoLock lock(mMutex);
 273
 274     // We have been canceled in the meanwhile.
 275     if (!mAsyncWaitCallback) {
 276       return NS_OK;
 277     }
 278
 279     callback.swap(mAsyncWaitCallback);
 280   }
 281
 282   MOZ_ASSERT(callback);
 283   return callback->OnInputStreamReady(this);
 284 }
 285
 286 // nsITellableStream
 287 NS_IMETHODIMP nsMIMEInputStream::Tell(int64_t* _retval) {
 288   INITSTREAMS;
 289   nsCOMPtr<nsITellableStream> stream = do_QueryInterface(mStream);
 290   return stream->Tell(_retval);
 291 }
 292
 293 // nsISeekableStream
 294 NS_IMETHODIMP nsMIMEInputStream::SetEOF(void) {
 295   INITSTREAMS;
 296   nsCOMPtr<nsISeekableStream> stream = do_QueryInterface(mStream);
 297   return stream->SetEOF();
 298 }
 299
 300 /**
 301  * Factory method used by do_CreateInstance
 302  */
 303
 304 nsresult nsMIMEInputStreamConstructor(REFNSIID iid, void** result) {
 305   *result = nullptr;
 306
 307   RefPtr<nsMIMEInputStream> inst = new nsMIMEInputStream();
 308   if (!inst) return NS_ERROR_OUT_OF_MEMORY;
 309
 310   return inst->QueryInterface(iid, result);
 311 }
 312
 313 void nsMIMEInputStream::SerializedComplexity(uint32_t aMaxSize,
 314                                              uint32_t* aSizeUsed,
 315                                              uint32_t* aPipes,
 316                                              uint32_t* aTransferables) {
 317   if (nsCOMPtr<nsIIPCSerializableInputStream> serializable =
 318           do_QueryInterface(mStream)) {
 319     InputStreamHelper::SerializedComplexity(mStream, aMaxSize, aSizeUsed,
 320                                             aPipes, aTransferables);
 321   } else {
 322     *aPipes = 1;
 323   }
 324 }
 325
 326 void nsMIMEInputStream::Serialize(InputStreamParams& aParams, uint32_t aMaxSize,
 327                                   uint32_t* aSizeUsed) {
 328   MOZ_ASSERT(aSizeUsed);
 329   *aSizeUsed = 0;
 330
 331   MIMEInputStreamParams params;
 332   params.headers() = mHeaders.Clone();
 333   params.startedReading() = mStartedReading;
 334
 335   if (!mStream) {
 336     aParams = params;
 337     return;
 338   }
 339
 340   InputStreamParams wrappedParams;
 341
 342   if (nsCOMPtr<nsIIPCSerializableInputStream> serializable =
 343           do_QueryInterface(mStream)) {
 344     InputStreamHelper::SerializeInputStream(mStream, wrappedParams, aMaxSize,
 345                                             aSizeUsed);
 346   } else {
 347     // Falling back to sending the underlying stream over a pipe when
 348     // sending an nsMIMEInputStream over IPC is potentially wasteful
 349     // if it is sent several times. This can possibly happen with
 350     // fission. There are two ways to improve this, see bug 1648369
 351     // and bug 1648370.
 352     InputStreamHelper::SerializeInputStreamAsPipe(mStream, wrappedParams);
 353   }
 354
 355   NS_ASSERTION(wrappedParams.type() != InputStreamParams::T__None,
 356                "Wrapped stream failed to serialize!");
 357
 358   params.optionalStream().emplace(wrappedParams);
 359   aParams = params;
 360 }
 361
 362 bool nsMIMEInputStream::Deserialize(const InputStreamParams& aParams) {
 363   if (aParams.type() != InputStreamParams::TMIMEInputStreamParams) {
 364     NS_ERROR("Received unknown parameters from the other process!");
 365     return false;
 366   }
 367
 368   const MIMEInputStreamParams& params = aParams.get_MIMEInputStreamParams();
 369   const Maybe<InputStreamParams>& wrappedParams = params.optionalStream();
 370
 371   if (wrappedParams.isSome()) {
 372     nsCOMPtr<nsIInputStream> stream;
 373     stream = InputStreamHelper::DeserializeInputStream(wrappedParams.ref());
 374     if (!stream) {
 375       NS_WARNING("Failed to deserialize wrapped stream!");
 376       return false;
 377     }
 378
 379     MOZ_ALWAYS_SUCCEEDS(SetData(stream));
 380   }
 381
 382   mHeaders = params.headers().Clone();
 383   mStartedReading = params.startedReading();
 384
 385   return true;
 386 }
 387
 388 NS_IMETHODIMP
 389 nsMIMEInputStream::Length(int64_t* aLength) {
 390   nsCOMPtr<nsIInputStreamLength> stream = do_QueryInterface(mStream);
 391   if (NS_WARN_IF(!stream)) {
 392     return NS_ERROR_FAILURE;
 393   }
 394
 395   return stream->Length(aLength);
 396 }
 397
 398 NS_IMETHODIMP
 399 nsMIMEInputStream::AsyncLengthWait(nsIInputStreamLengthCallback* aCallback,
 400                                    nsIEventTarget* aEventTarget) {
 401   nsCOMPtr<nsIAsyncInputStreamLength> stream = do_QueryInterface(mStream);
 402   if (NS_WARN_IF(!stream)) {
 403     return NS_ERROR_FAILURE;
 404   }
 405
 406   nsCOMPtr<nsIInputStreamLengthCallback> callback = aCallback ? this : nullptr;
 407   {
 408     mozilla::MutexAutoLock lock(mMutex);
 409     mAsyncInputStreamLengthCallback = aCallback;
 410   }
 411
 412   return stream->AsyncLengthWait(callback, aEventTarget);
 413 }
 414
 415 NS_IMETHODIMP
 416 nsMIMEInputStream::OnInputStreamLengthReady(nsIAsyncInputStreamLength* aStream,
 417                                             int64_t aLength) {
 418   nsCOMPtr<nsIInputStreamLengthCallback> callback;
 419   {
 420     mozilla::MutexAutoLock lock(mMutex);
 421     // We have been canceled in the meanwhile.
 422     if (!mAsyncInputStreamLengthCallback) {
 423       return NS_OK;
 424     }
 425
 426     callback.swap(mAsyncInputStreamLengthCallback);
 427   }
 428
 429   MOZ_ASSERT(callback);
 430   return callback->OnInputStreamLengthReady(this, aLength);
 431 }
 432
 433 bool nsMIMEInputStream::IsSeekableInputStream() const {
 434   nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(mStream);
 435   return !!seekable;
 436 }
 437
 438 bool nsMIMEInputStream::IsAsyncInputStream() const {
 439   nsCOMPtr<nsIAsyncInputStream> asyncStream = do_QueryInterface(mStream);
 440   return !!asyncStream;
 441 }
 442
 443 bool nsMIMEInputStream::IsInputStreamLength() const {
 444   nsCOMPtr<nsIInputStreamLength> stream = do_QueryInterface(mStream);
 445   return !!stream;
 446 }
 447
 448 bool nsMIMEInputStream::IsAsyncInputStreamLength() const {
 449   nsCOMPtr<nsIAsyncInputStreamLength> stream = do_QueryInterface(mStream);
 450   return !!stream;
 451 }
 452
 453 bool nsMIMEInputStream::IsCloneableInputStream() const {
 454   nsCOMPtr<nsICloneableInputStream> stream = do_QueryInterface(mStream);
 455   return !!stream;
 456 }
 457
 458 // nsICloneableInputStream interface
 459
 460 NS_IMETHODIMP
 461 nsMIMEInputStream::GetCloneable(bool* aCloneable) {
 462   nsCOMPtr<nsICloneableInputStream> stream = do_QueryInterface(mStream);
 463   if (!mStream) {
 464     return NS_ERROR_FAILURE;
 465   }
 466
 467   return stream->GetCloneable(aCloneable);
 468 }
 469
 470 NS_IMETHODIMP
 471 nsMIMEInputStream::Clone(nsIInputStream** aResult) {
 472   nsCOMPtr<nsICloneableInputStream> stream = do_QueryInterface(mStream);
 473   if (!mStream) {
 474     return NS_ERROR_FAILURE;
 475   }
 476
 477   nsCOMPtr<nsIInputStream> clonedStream;
 478   nsresult rv = stream->Clone(getter_AddRefs(clonedStream));
 479   if (NS_WARN_IF(NS_FAILED(rv))) {
 480     return rv;
 481   }
 482
 483   nsCOMPtr<nsIMIMEInputStream> mimeStream = new nsMIMEInputStream();
 484
 485   rv = mimeStream->SetData(clonedStream);
 486   if (NS_WARN_IF(NS_FAILED(rv))) {
 487     return rv;
 488   }
 489
 490   for (const HeaderEntry& entry : mHeaders) {
 491     rv = mimeStream->AddHeader(entry.name().get(), entry.value().get());
 492     MOZ_ASSERT(NS_SUCCEEDED(rv));
 493   }
 494
 495   static_cast<nsMIMEInputStream*>(mimeStream.get())->mStartedReading =
 496       static_cast<bool>(mStartedReading);
 497
 498   mimeStream.forget(aResult);
 499   return NS_OK;
 500 }