dom/fetch/BodyExtractor.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 "BodyExtractor.h"
   8 #include "mozilla/dom/File.h"
   9 #include "mozilla/dom/FormData.h"
  10 #include "mozilla/dom/TypedArray.h"
  11 #include "mozilla/dom/URLSearchParams.h"
  12 #include "mozilla/dom/XMLHttpRequest.h"
  13 #include "mozilla/UniquePtr.h"
  14 #include "nsContentUtils.h"
  15 #include "nsDOMSerializer.h"
  16 #include "nsIGlobalObject.h"
  17 #include "nsIInputStream.h"
  18 #include "nsIOutputStream.h"
  19 #include "nsIStorageStream.h"
  20 #include "nsStringStream.h"
  21
  22 namespace mozilla::dom {
  23
  24 static nsresult GetBufferDataAsStream(Vector<uint8_t>&& aData,
  25                                       nsIInputStream** aResult,
  26                                       uint64_t* aContentLength,
  27                                       nsACString& aContentType,
  28                                       nsACString& aCharset) {
  29   aContentType.SetIsVoid(true);
  30   aCharset.Truncate();
  31
  32   *aContentLength = aData.length();
  33
  34   nsCOMPtr<nsIInputStream> stream;
  35   nsresult rv = NS_NewByteInputStream(
  36       getter_AddRefs(stream),
  37       AsChars(Span(aData.extractOrCopyRawBuffer(), *aContentLength)),
  38       NS_ASSIGNMENT_ADOPT);
  39   NS_ENSURE_SUCCESS(rv, rv);
  40
  41   stream.forget(aResult);
  42
  43   return NS_OK;
  44 }
  45
  46 template <>
  47 nsresult BodyExtractor<const ArrayBuffer>::GetAsStream(
  48     nsIInputStream** aResult, uint64_t* aContentLength,
  49     nsACString& aContentTypeWithCharset, nsACString& aCharset) const {
  50   Maybe<Vector<uint8_t>> body = mBody->CreateFromData<Vector<uint8_t>>();
  51   if (body.isNothing()) {
  52     return NS_ERROR_OUT_OF_MEMORY;
  53   }
  54   return GetBufferDataAsStream(body.extract(), aResult, aContentLength,
  55                                aContentTypeWithCharset, aCharset);
  56 }
  57
  58 template <>
  59 nsresult BodyExtractor<const ArrayBufferView>::GetAsStream(
  60     nsIInputStream** aResult, uint64_t* aContentLength,
  61     nsACString& aContentTypeWithCharset, nsACString& aCharset) const {
  62   Maybe<Vector<uint8_t>> body = mBody->CreateFromData<Vector<uint8_t>>();
  63   if (body.isNothing()) {
  64     return NS_ERROR_OUT_OF_MEMORY;
  65   }
  66   return GetBufferDataAsStream(body.extract(), aResult, aContentLength,
  67                                aContentTypeWithCharset, aCharset);
  68 }
  69
  70 template <>
  71 nsresult BodyExtractor<Document>::GetAsStream(
  72     nsIInputStream** aResult, uint64_t* aContentLength,
  73     nsACString& aContentTypeWithCharset, nsACString& aCharset) const {
  74   NS_ENSURE_STATE(mBody);
  75   aCharset.AssignLiteral("UTF-8");
  76
  77   nsresult rv;
  78   nsCOMPtr<nsIStorageStream> storStream;
  79   rv = NS_NewStorageStream(4096, UINT32_MAX, getter_AddRefs(storStream));
  80   NS_ENSURE_SUCCESS(rv, rv);
  81
  82   nsCOMPtr<nsIOutputStream> output;
  83   rv = storStream->GetOutputStream(0, getter_AddRefs(output));
  84   NS_ENSURE_SUCCESS(rv, rv);
  85
  86   if (mBody->IsHTMLDocument()) {
  87     aContentTypeWithCharset.AssignLiteral("text/html;charset=UTF-8");
  88
  89     nsString serialized;
  90     if (!nsContentUtils::SerializeNodeToMarkup(mBody, true, serialized)) {
  91       return NS_ERROR_OUT_OF_MEMORY;
  92     }
  93
  94     nsAutoCString utf8Serialized;
  95     if (!AppendUTF16toUTF8(serialized, utf8Serialized, fallible)) {
  96       return NS_ERROR_OUT_OF_MEMORY;
  97     }
  98
  99     uint32_t written;
 100     rv = output->Write(utf8Serialized.get(), utf8Serialized.Length(), &written);
 101     NS_ENSURE_SUCCESS(rv, rv);
 102
 103     MOZ_ASSERT(written == utf8Serialized.Length());
 104   } else {
 105     aContentTypeWithCharset.AssignLiteral("application/xml;charset=UTF-8");
 106
 107     auto serializer = MakeUnique<nsDOMSerializer>();
 108
 109     // Make sure to use the encoding we'll send
 110     ErrorResult res;
 111     serializer->SerializeToStream(*mBody, output, u"UTF-8"_ns, res);
 112     if (NS_WARN_IF(res.Failed())) {
 113       return res.StealNSResult();
 114     }
 115   }
 116
 117   output->Close();
 118
 119   uint32_t length;
 120   rv = storStream->GetLength(&length);
 121   NS_ENSURE_SUCCESS(rv, rv);
 122   *aContentLength = length;
 123
 124   rv = storStream->NewInputStream(0, aResult);
 125   NS_ENSURE_SUCCESS(rv, rv);
 126   return NS_OK;
 127 }
 128
 129 template <>
 130 nsresult BodyExtractor<const nsAString>::GetAsStream(
 131     nsIInputStream** aResult, uint64_t* aContentLength,
 132     nsACString& aContentTypeWithCharset, nsACString& aCharset) const {
 133   nsCString encoded;
 134   if (!CopyUTF16toUTF8(*mBody, encoded, fallible)) {
 135     return NS_ERROR_OUT_OF_MEMORY;
 136   }
 137
 138   uint32_t encodedLength = encoded.Length();
 139   nsresult rv = NS_NewCStringInputStream(aResult, std::move(encoded));
 140   if (NS_WARN_IF(NS_FAILED(rv))) {
 141     return rv;
 142   }
 143
 144   *aContentLength = encodedLength;
 145   aContentTypeWithCharset.AssignLiteral("text/plain;charset=UTF-8");
 146   aCharset.AssignLiteral("UTF-8");
 147   return NS_OK;
 148 }
 149
 150 template <>
 151 nsresult BodyExtractor<nsIInputStream>::GetAsStream(
 152     nsIInputStream** aResult, uint64_t* aContentLength,
 153     nsACString& aContentTypeWithCharset, nsACString& aCharset) const {
 154   aContentTypeWithCharset.AssignLiteral("text/plain");
 155   aCharset.Truncate();
 156
 157   nsresult rv = mBody->Available(aContentLength);
 158   NS_ENSURE_SUCCESS(rv, rv);
 159
 160   nsCOMPtr<nsIInputStream> stream(mBody);
 161   stream.forget(aResult);
 162   return NS_OK;
 163 }
 164
 165 template <>
 166 nsresult BodyExtractor<const Blob>::GetAsStream(
 167     nsIInputStream** aResult, uint64_t* aContentLength,
 168     nsACString& aContentTypeWithCharset, nsACString& aCharset) const {
 169   return mBody->GetSendInfo(aResult, aContentLength, aContentTypeWithCharset,
 170                             aCharset);
 171 }
 172
 173 template <>
 174 nsresult BodyExtractor<const FormData>::GetAsStream(
 175     nsIInputStream** aResult, uint64_t* aContentLength,
 176     nsACString& aContentTypeWithCharset, nsACString& aCharset) const {
 177   return mBody->GetSendInfo(aResult, aContentLength, aContentTypeWithCharset,
 178                             aCharset);
 179 }
 180
 181 template <>
 182 nsresult BodyExtractor<const URLSearchParams>::GetAsStream(
 183     nsIInputStream** aResult, uint64_t* aContentLength,
 184     nsACString& aContentTypeWithCharset, nsACString& aCharset) const {
 185   return mBody->GetSendInfo(aResult, aContentLength, aContentTypeWithCharset,
 186                             aCharset);
 187 }
 188
 189 }  // namespace mozilla::dom