The Tor Browser: intl/uconv/src/nsConverterInputStream.cpp@97036ab72558 (annotated)

intl/uconv/src/nsConverterInputStream.cpp@97036ab72558 (annotated)

intl/uconv/src/nsConverterInputStream.cpp

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "nsConverterInputStream.h"
 #include "nsIInputStream.h"
 #include "nsICharsetConverterManager.h"
 #include "nsReadLine.h"
 #include "nsStreamUtils.h"
 #include "nsServiceManagerUtils.h"
 #include <algorithm>
 #define CONVERTER_BUFFER_SIZE 8192
 NS_IMPL_ISUPPORTS(nsConverterInputStream, nsIConverterInputStream,
                   nsIUnicharInputStream, nsIUnicharLineInputStream)
 NS_IMETHODIMP
 nsConverterInputStream::Init(nsIInputStream* aStream,
                              const char *aCharset,
                              int32_t aBufferSize,
                              char16_t aReplacementChar)
 {
     static NS_DEFINE_CID(kCharsetConverterManagerCID, NS_ICHARSETCONVERTERMANAGER_CID);
     if (!aCharset)
         aCharset = "UTF-8";
     nsresult rv;
     if (aBufferSize <=0) aBufferSize=CONVERTER_BUFFER_SIZE;
     // get the decoder
     nsCOMPtr<nsICharsetConverterManager> ccm =
         do_GetService(kCharsetConverterManagerCID, &rv);
     if (NS_FAILED(rv)) return rv;
     rv = ccm->GetUnicodeDecoder(aCharset ? aCharset : "ISO-8859-1", getter_AddRefs(mConverter));
     if (NS_FAILED(rv)) return rv;
     // set up our buffers
     if (!mByteData.SetCapacity(aBufferSize) ||
         !mUnicharData.SetCapacity(aBufferSize)) {
       return NS_ERROR_OUT_OF_MEMORY;
     }
     mInput = aStream;
     mReplacementChar = aReplacementChar;
     if (!aReplacementChar ||
         aReplacementChar != mConverter->GetCharacterForUnMapped()) {
         mConverter->SetInputErrorBehavior(nsIUnicodeDecoder::kOnError_Signal);
     }
     return NS_OK;
 }
 NS_IMETHODIMP
 nsConverterInputStream::Close()
 {
     nsresult rv = mInput ? mInput->Close() : NS_OK;
     mLineBuffer = nullptr;
     mInput = nullptr;
     mConverter = nullptr;
     mByteData.Clear();
     mUnicharData.Clear();
     return rv;
 }
 NS_IMETHODIMP
 nsConverterInputStream::Read(char16_t* aBuf,
                              uint32_t aCount,
                              uint32_t *aReadCount)
 {
   NS_ASSERTION(mUnicharDataLength >= mUnicharDataOffset, "unsigned madness");
   uint32_t readCount = mUnicharDataLength - mUnicharDataOffset;
   if (0 == readCount) {
     // Fill the unichar buffer
     readCount = Fill(&mLastErrorCode);
     if (readCount == 0) {
       *aReadCount = 0;
       return mLastErrorCode;
     }
   }
   if (readCount > aCount) {
     readCount = aCount;
   }
   memcpy(aBuf, mUnicharData.Elements() + mUnicharDataOffset,
          readCount * sizeof(char16_t));
   mUnicharDataOffset += readCount;
   *aReadCount = readCount;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsConverterInputStream::ReadSegments(nsWriteUnicharSegmentFun aWriter,
                                      void* aClosure,
                                      uint32_t aCount, uint32_t *aReadCount)
 {
   NS_ASSERTION(mUnicharDataLength >= mUnicharDataOffset, "unsigned madness");
   uint32_t bytesToWrite = mUnicharDataLength - mUnicharDataOffset;
   nsresult rv;
   if (0 == bytesToWrite) {
     // Fill the unichar buffer
     bytesToWrite = Fill(&rv);
     if (bytesToWrite <= 0) {
       *aReadCount = 0;
       return rv;
     }
   }
   if (bytesToWrite > aCount)
     bytesToWrite = aCount;
   uint32_t bytesWritten;
   uint32_t totalBytesWritten = 0;
   while (bytesToWrite) {
     rv = aWriter(this, aClosure,
                  mUnicharData.Elements() + mUnicharDataOffset,
                  totalBytesWritten, bytesToWrite, &bytesWritten);
     if (NS_FAILED(rv)) {
       // don't propagate errors to the caller
       break;
     }
     bytesToWrite -= bytesWritten;
     totalBytesWritten += bytesWritten;
     mUnicharDataOffset += bytesWritten;
   }
   *aReadCount = totalBytesWritten;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsConverterInputStream::ReadString(uint32_t aCount, nsAString& aString,
                                    uint32_t* aReadCount)
 {
   NS_ASSERTION(mUnicharDataLength >= mUnicharDataOffset, "unsigned madness");
   uint32_t readCount = mUnicharDataLength - mUnicharDataOffset;
   if (0 == readCount) {
     // Fill the unichar buffer
     readCount = Fill(&mLastErrorCode);
     if (readCount == 0) {
       *aReadCount = 0;
       return mLastErrorCode;
     }
   }
   if (readCount > aCount) {
     readCount = aCount;
   }
   const char16_t* buf = mUnicharData.Elements() + mUnicharDataOffset;
   aString.Assign(buf, readCount);
   mUnicharDataOffset += readCount;
   *aReadCount = readCount;
   return NS_OK;
 }
 uint32_t
 nsConverterInputStream::Fill(nsresult * aErrorCode)
 {
   if (nullptr == mInput) {
     // We already closed the stream!
     *aErrorCode = NS_BASE_STREAM_CLOSED;
     return 0;
   }
   if (NS_FAILED(mLastErrorCode)) {
     // We failed to completely convert last time, and error-recovery
     // is disabled.  We will fare no better this time, so...
     *aErrorCode = mLastErrorCode;
     return 0;
   }
   // We assume a many to one conversion and are using equal sizes for
   // the two buffers.  However if an error happens at the very start
   // of a byte buffer we may end up in a situation where n bytes lead
   // to n+1 unicode chars.  Thus we need to keep track of the leftover
   // bytes as we convert.
   uint32_t nb;
   *aErrorCode = NS_FillArray(mByteData, mInput, mLeftOverBytes, &nb);
   if (nb == 0 && mLeftOverBytes == 0) {
     // No more data
     *aErrorCode = NS_OK;
     return 0;
   }
   NS_ASSERTION(uint32_t(nb) + mLeftOverBytes == mByteData.Length(),
                "mByteData is lying to us somewhere");
   // Now convert as much of the byte buffer to unicode as possible
   mUnicharDataOffset = 0;
   mUnicharDataLength = 0;
   uint32_t srcConsumed = 0;
   do {
     int32_t srcLen = mByteData.Length() - srcConsumed;
     int32_t dstLen = mUnicharData.Capacity() - mUnicharDataLength;
     *aErrorCode = mConverter->Convert(mByteData.Elements()+srcConsumed,
                                       &srcLen,
                                       mUnicharData.Elements()+mUnicharDataLength,
                                       &dstLen);
     mUnicharDataLength += dstLen;
     // XXX if srcLen is negative, we want to drop the _first_ byte in
     // the erroneous byte sequence and try again.  This is not quite
     // possible right now -- see bug 160784
     srcConsumed += srcLen;
     if (NS_FAILED(*aErrorCode) && mReplacementChar) {
       NS_ASSERTION(0 < mUnicharData.Capacity() - mUnicharDataLength,
                    "Decoder returned an error but filled the output buffer! "
                    "Should not happen.");
       mUnicharData.Elements()[mUnicharDataLength++] = mReplacementChar;
       ++srcConsumed;
       // XXX this is needed to make sure we don't underrun our buffer;
       // bug 160784 again
       srcConsumed = std::max<uint32_t>(srcConsumed, 0);
       mConverter->Reset();
     }
     NS_ASSERTION(srcConsumed <= mByteData.Length(),
                  "Whoa.  The converter should have returned NS_OK_UDEC_MOREINPUT before this point!");
   } while (mReplacementChar &&
            NS_FAILED(*aErrorCode) &&
            mUnicharData.Capacity() > mUnicharDataLength);
   mLeftOverBytes = mByteData.Length() - srcConsumed;
   return mUnicharDataLength;
 }
 NS_IMETHODIMP
 nsConverterInputStream::ReadLine(nsAString& aLine, bool* aResult)
 {
   if (!mLineBuffer) {
     mLineBuffer = new nsLineBuffer<char16_t>;
   }
   return NS_ReadLine(this, mLineBuffer.get(), aLine, aResult);
 }

The Tor Browser / annotate

intl/uconv/src/nsConverterInputStream.cpp@97036ab72558 (annotated)

intl/uconv/src/nsConverterInputStream.cpp