intl/uconv/nsConverterInputStream.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 #include "nsConverterInputStream.h"
   7 #include "nsIInputStream.h"
   8 #include "nsReadLine.h"
   9 #include "nsStreamUtils.h"
  10 #include <algorithm>
  11 #include "mozilla/dom/EncodingUtils.h"
  12
  13 using mozilla::dom::EncodingUtils;
  14
  15 #define CONVERTER_BUFFER_SIZE 8192
  16
  17 NS_IMPL_ISUPPORTS(nsConverterInputStream, nsIConverterInputStream,
  18                   nsIUnicharInputStream, nsIUnicharLineInputStream)
  19
  20
  21 NS_IMETHODIMP
  22 nsConverterInputStream::Init(nsIInputStream* aStream,
  23                              const char *aCharset,
  24                              int32_t aBufferSize,
  25                              char16_t aReplacementChar)
  26 {
  27     nsAutoCString label;
  28     if (!aCharset) {
  29         label.AssignLiteral("UTF-8");
  30     } else {
  31         label = aCharset;
  32     }
  33
  34     if (aBufferSize <=0) aBufferSize=CONVERTER_BUFFER_SIZE;
  35
  36     // get the decoder
  37     nsAutoCString encoding;
  38     if (label.EqualsLiteral("UTF-16")) {
  39         // Compat with old test cases. Unclear if any extensions really care.
  40         encoding.Assign(label);
  41     } else if (!EncodingUtils::FindEncodingForLabelNoReplacement(label,
  42                                                                  encoding)) {
  43       return NS_ERROR_UCONV_NOCONV;
  44     }
  45     mConverter = EncodingUtils::DecoderForEncoding(encoding);
  46
  47     // set up our buffers
  48     if (!mByteData.SetCapacity(aBufferSize) ||
  49         !mUnicharData.SetCapacity(aBufferSize)) {
  50       return NS_ERROR_OUT_OF_MEMORY;
  51     }
  52
  53     mInput = aStream;
  54     mReplacementChar = aReplacementChar;
  55     if (!aReplacementChar ||
  56         aReplacementChar != mConverter->GetCharacterForUnMapped()) {
  57         mConverter->SetInputErrorBehavior(nsIUnicodeDecoder::kOnError_Signal);
  58     }
  59
  60     return NS_OK;
  61 }
  62
  63 NS_IMETHODIMP
  64 nsConverterInputStream::Close()
  65 {
  66     nsresult rv = mInput ? mInput->Close() : NS_OK;
  67     mLineBuffer = nullptr;
  68     mInput = nullptr;
  69     mConverter = nullptr;
  70     mByteData.Clear();
  71     mUnicharData.Clear();
  72     return rv;
  73 }
  74
  75 NS_IMETHODIMP
  76 nsConverterInputStream::Read(char16_t* aBuf,
  77                              uint32_t aCount,
  78                              uint32_t *aReadCount)
  79 {
  80   NS_ASSERTION(mUnicharDataLength >= mUnicharDataOffset, "unsigned madness");
  81   uint32_t readCount = mUnicharDataLength - mUnicharDataOffset;
  82   if (0 == readCount) {
  83     // Fill the unichar buffer
  84     readCount = Fill(&mLastErrorCode);
  85     if (readCount == 0) {
  86       *aReadCount = 0;
  87       return mLastErrorCode;
  88     }
  89   }
  90   if (readCount > aCount) {
  91     readCount = aCount;
  92   }
  93   memcpy(aBuf, mUnicharData.Elements() + mUnicharDataOffset,
  94          readCount * sizeof(char16_t));
  95   mUnicharDataOffset += readCount;
  96   *aReadCount = readCount;
  97   return NS_OK;
  98 }
  99
 100 NS_IMETHODIMP
 101 nsConverterInputStream::ReadSegments(nsWriteUnicharSegmentFun aWriter,
 102                                      void* aClosure,
 103                                      uint32_t aCount, uint32_t *aReadCount)
 104 {
 105   NS_ASSERTION(mUnicharDataLength >= mUnicharDataOffset, "unsigned madness");
 106   uint32_t bytesToWrite = mUnicharDataLength - mUnicharDataOffset;
 107   nsresult rv;
 108   if (0 == bytesToWrite) {
 109     // Fill the unichar buffer
 110     bytesToWrite = Fill(&rv);
 111     if (bytesToWrite <= 0) {
 112       *aReadCount = 0;
 113       return rv;
 114     }
 115   }
 116
 117   if (bytesToWrite > aCount)
 118     bytesToWrite = aCount;
 119
 120   uint32_t bytesWritten;
 121   uint32_t totalBytesWritten = 0;
 122
 123   while (bytesToWrite) {
 124     rv = aWriter(this, aClosure,
 125                  mUnicharData.Elements() + mUnicharDataOffset,
 126                  totalBytesWritten, bytesToWrite, &bytesWritten);
 127     if (NS_FAILED(rv)) {
 128       // don't propagate errors to the caller
 129       break;
 130     }
 131
 132     bytesToWrite -= bytesWritten;
 133     totalBytesWritten += bytesWritten;
 134     mUnicharDataOffset += bytesWritten;
 135
 136   }
 137
 138   *aReadCount = totalBytesWritten;
 139
 140   return NS_OK;
 141 }
 142
 143 NS_IMETHODIMP
 144 nsConverterInputStream::ReadString(uint32_t aCount, nsAString& aString,
 145                                    uint32_t* aReadCount)
 146 {
 147   NS_ASSERTION(mUnicharDataLength >= mUnicharDataOffset, "unsigned madness");
 148   uint32_t readCount = mUnicharDataLength - mUnicharDataOffset;
 149   if (0 == readCount) {
 150     // Fill the unichar buffer
 151     readCount = Fill(&mLastErrorCode);
 152     if (readCount == 0) {
 153       *aReadCount = 0;
 154       return mLastErrorCode;
 155     }
 156   }
 157   if (readCount > aCount) {
 158     readCount = aCount;
 159   }
 160   const char16_t* buf = mUnicharData.Elements() + mUnicharDataOffset;
 161   aString.Assign(buf, readCount);
 162   mUnicharDataOffset += readCount;
 163   *aReadCount = readCount;
 164   return NS_OK;
 165 }
 166
 167 uint32_t
 168 nsConverterInputStream::Fill(nsresult * aErrorCode)
 169 {
 170   if (nullptr == mInput) {
 171     // We already closed the stream!
 172     *aErrorCode = NS_BASE_STREAM_CLOSED;
 173     return 0;
 174   }
 175
 176   if (NS_FAILED(mLastErrorCode)) {
 177     // We failed to completely convert last time, and error-recovery
 178     // is disabled.  We will fare no better this time, so...
 179     *aErrorCode = mLastErrorCode;
 180     return 0;
 181   }
 182
 183   // We assume a many to one conversion and are using equal sizes for
 184   // the two buffers.  However if an error happens at the very start
 185   // of a byte buffer we may end up in a situation where n bytes lead
 186   // to n+1 unicode chars.  Thus we need to keep track of the leftover
 187   // bytes as we convert.
 188
 189   uint32_t nb;
 190   *aErrorCode = NS_FillArray(mByteData, mInput, mLeftOverBytes, &nb);
 191   if (nb == 0 && mLeftOverBytes == 0) {
 192     // No more data
 193     *aErrorCode = NS_OK;
 194     return 0;
 195   }
 196
 197   NS_ASSERTION(uint32_t(nb) + mLeftOverBytes == mByteData.Length(),
 198                "mByteData is lying to us somewhere");
 199
 200   // Now convert as much of the byte buffer to unicode as possible
 201   mUnicharDataOffset = 0;
 202   mUnicharDataLength = 0;
 203   uint32_t srcConsumed = 0;
 204   do {
 205     int32_t srcLen = mByteData.Length() - srcConsumed;
 206     int32_t dstLen = mUnicharData.Capacity() - mUnicharDataLength;
 207     *aErrorCode = mConverter->Convert(mByteData.Elements()+srcConsumed,
 208                                       &srcLen,
 209                                       mUnicharData.Elements()+mUnicharDataLength,
 210                                       &dstLen);
 211     mUnicharDataLength += dstLen;
 212     // XXX if srcLen is negative, we want to drop the _first_ byte in
 213     // the erroneous byte sequence and try again.  This is not quite
 214     // possible right now -- see bug 160784
 215     srcConsumed += srcLen;
 216     if (NS_FAILED(*aErrorCode) && mReplacementChar) {
 217       NS_ASSERTION(0 < mUnicharData.Capacity() - mUnicharDataLength,
 218                    "Decoder returned an error but filled the output buffer! "
 219                    "Should not happen.");
 220       mUnicharData.Elements()[mUnicharDataLength++] = mReplacementChar;
 221       ++srcConsumed;
 222       // XXX this is needed to make sure we don't underrun our buffer;
 223       // bug 160784 again
 224       srcConsumed = std::max<uint32_t>(srcConsumed, 0);
 225       mConverter->Reset();
 226     }
 227     NS_ASSERTION(srcConsumed <= mByteData.Length(),
 228                  "Whoa.  The converter should have returned NS_OK_UDEC_MOREINPUT before this point!");
 229   } while (mReplacementChar &&
 230            NS_FAILED(*aErrorCode) &&
 231            mUnicharData.Capacity() > mUnicharDataLength);
 232
 233   mLeftOverBytes = mByteData.Length() - srcConsumed;
 234
 235   return mUnicharDataLength;
 236 }
 237
 238 NS_IMETHODIMP
 239 nsConverterInputStream::ReadLine(nsAString& aLine, bool* aResult)
 240 {
 241   if (!mLineBuffer) {
 242     mLineBuffer = new nsLineBuffer<char16_t>;
 243   }
 244   return NS_ReadLine(this, mLineBuffer.get(), aLine, aResult);
 245 }