The Tor Browser: netwerk/protocol/file/nsFileChannel.cpp@6474c204b198 (annotated)

netwerk/protocol/file/nsFileChannel.cpp@6474c204b198 (annotated)

netwerk/protocol/file/nsFileChannel.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:set ts=2 sw=2 sts=2 et cin: */
 /* 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 "nsIOService.h"
 #include "nsFileChannel.h"
 #include "nsBaseContentStream.h"
 #include "nsDirectoryIndexStream.h"
 #include "nsThreadUtils.h"
 #include "nsTransportUtils.h"
 #include "nsStreamUtils.h"
 #include "nsMimeTypes.h"
 #include "nsNetUtil.h"
 #include "nsProxyRelease.h"
 #include "nsAutoPtr.h"
 #include "nsIFileURL.h"
 #include "nsIMIMEService.h"
 #include <algorithm>
 //-----------------------------------------------------------------------------
 class nsFileCopyEvent : public nsRunnable {
 public:
   nsFileCopyEvent(nsIOutputStream *dest, nsIInputStream *source, int64_t len)
     : mDest(dest)
     , mSource(source)
     , mLen(len)
     , mStatus(NS_OK)
     , mInterruptStatus(NS_OK) {
   }
   // Read the current status of the file copy operation.
   nsresult Status() { return mStatus; }
   // Call this method to perform the file copy synchronously.
   void DoCopy();
   // Call this method to perform the file copy on a background thread.  The
   // callback is dispatched when the file copy completes.
   nsresult Dispatch(nsIRunnable *callback,
                     nsITransportEventSink *sink,
                     nsIEventTarget *target);
   // Call this method to interrupt a file copy operation that is occuring on
   // a background thread.  The status parameter passed to this function must
   // be a failure code and is set as the status of this file copy operation.
   void Interrupt(nsresult status) {
     NS_ASSERTION(NS_FAILED(status), "must be a failure code");
     mInterruptStatus = status;
   }
   NS_IMETHOD Run() {
     DoCopy();
     return NS_OK;
   }
 private:
   nsCOMPtr<nsIEventTarget> mCallbackTarget;
   nsCOMPtr<nsIRunnable> mCallback;
   nsCOMPtr<nsITransportEventSink> mSink;
   nsCOMPtr<nsIOutputStream> mDest;
   nsCOMPtr<nsIInputStream> mSource;
   int64_t mLen;
   nsresult mStatus;           // modified on i/o thread only
   nsresult mInterruptStatus;  // modified on main thread only
 };
 void
 nsFileCopyEvent::DoCopy()
 {
   // We'll copy in chunks this large by default.  This size affects how
   // frequently we'll check for interrupts.
   const int32_t chunk = nsIOService::gDefaultSegmentSize * nsIOService::gDefaultSegmentCount;
   nsresult rv = NS_OK;
   int64_t len = mLen, progress = 0;
   while (len) {
     // If we've been interrupted, then stop copying.
     rv = mInterruptStatus;
     if (NS_FAILED(rv))
       break;
     int32_t num = std::min((int32_t) len, chunk);
     uint32_t result;
     rv = mSource->ReadSegments(NS_CopySegmentToStream, mDest, num, &result);
     if (NS_FAILED(rv))
       break;
     if (result != (uint32_t) num) {
       rv = NS_ERROR_FILE_DISK_FULL;  // stopped prematurely (out of disk space)
       break;
     }
     // Dispatch progress notification
     if (mSink) {
       progress += num;
       mSink->OnTransportStatus(nullptr, NS_NET_STATUS_WRITING, progress,
                                mLen);
     }
     len -= num;
   }
   if (NS_FAILED(rv))
     mStatus = rv;
   // Close the output stream before notifying our callback so that others may
   // freely "play" with the file.
   mDest->Close();
   // Notify completion
   if (mCallback) {
     mCallbackTarget->Dispatch(mCallback, NS_DISPATCH_NORMAL);
     // Release the callback on the target thread to avoid destroying stuff on
     // the wrong thread.
     nsIRunnable *doomed = nullptr;
     mCallback.swap(doomed);
     NS_ProxyRelease(mCallbackTarget, doomed);
   }
 }
 nsresult
 nsFileCopyEvent::Dispatch(nsIRunnable *callback,
                           nsITransportEventSink *sink,
                           nsIEventTarget *target)
 {
   // Use the supplied event target for all asynchronous operations.
   mCallback = callback;
   mCallbackTarget = target;
   // Build a coalescing proxy for progress events
   nsresult rv = net_NewTransportEventSinkProxy(getter_AddRefs(mSink), sink,
                                                target, true);
   if (NS_FAILED(rv))
     return rv;
   // Dispatch ourselves to I/O thread pool...
   nsCOMPtr<nsIEventTarget> pool =
       do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID, &rv);
   if (NS_FAILED(rv))
     return rv;
   return pool->Dispatch(this, NS_DISPATCH_NORMAL);
 }
 //-----------------------------------------------------------------------------
 // This is a dummy input stream that when read, performs the file copy.  The
 // copy happens on a background thread via mCopyEvent.
 class nsFileUploadContentStream : public nsBaseContentStream {
 public:
   NS_DECL_ISUPPORTS_INHERITED
   nsFileUploadContentStream(bool nonBlocking,
                             nsIOutputStream *dest,
                             nsIInputStream *source,
                             int64_t len,
                             nsITransportEventSink *sink)
     : nsBaseContentStream(nonBlocking)
     , mCopyEvent(new nsFileCopyEvent(dest, source, len))
     , mSink(sink) {
   }
   bool IsInitialized() {
     return mCopyEvent != nullptr;
   }
   NS_IMETHODIMP ReadSegments(nsWriteSegmentFun fun, void *closure,
                              uint32_t count, uint32_t *result);
   NS_IMETHODIMP AsyncWait(nsIInputStreamCallback *callback, uint32_t flags,
                           uint32_t count, nsIEventTarget *target);
 private:
   void OnCopyComplete();
   nsRefPtr<nsFileCopyEvent> mCopyEvent;
   nsCOMPtr<nsITransportEventSink> mSink;
 };
 NS_IMPL_ISUPPORTS_INHERITED0(nsFileUploadContentStream,
                              nsBaseContentStream)
 NS_IMETHODIMP
 nsFileUploadContentStream::ReadSegments(nsWriteSegmentFun fun, void *closure,
                                         uint32_t count, uint32_t *result)
 {
   *result = 0;  // nothing is ever actually read from this stream
   if (IsClosed())
     return NS_OK;
   if (IsNonBlocking()) {
     // Inform the caller that they will have to wait for the copy operation to
     // complete asynchronously.  We'll kick of the copy operation once they
     // call AsyncWait.
     return NS_BASE_STREAM_WOULD_BLOCK;
   }
   // Perform copy synchronously, and then close out the stream.
   mCopyEvent->DoCopy();
   nsresult status = mCopyEvent->Status();
   CloseWithStatus(NS_FAILED(status) ? status : NS_BASE_STREAM_CLOSED);
   return status;
 }
 NS_IMETHODIMP
 nsFileUploadContentStream::AsyncWait(nsIInputStreamCallback *callback,
                                      uint32_t flags, uint32_t count,
                                      nsIEventTarget *target)
 {
   nsresult rv = nsBaseContentStream::AsyncWait(callback, flags, count, target);
   if (NS_FAILED(rv) || IsClosed())
     return rv;
   if (IsNonBlocking()) {
     nsCOMPtr<nsIRunnable> callback =
       NS_NewRunnableMethod(this, &nsFileUploadContentStream::OnCopyComplete);
     mCopyEvent->Dispatch(callback, mSink, target);
   }
   return NS_OK;
 }
 void
 nsFileUploadContentStream::OnCopyComplete()
 {
   // This method is being called to indicate that we are done copying.
   nsresult status = mCopyEvent->Status();
   CloseWithStatus(NS_FAILED(status) ? status : NS_BASE_STREAM_CLOSED);
 }
 //-----------------------------------------------------------------------------
 nsFileChannel::nsFileChannel(nsIURI *uri)
 {
   // If we have a link file, we should resolve its target right away.
   // This is to protect against a same origin attack where the same link file
   // can point to different resources right after the first resource is loaded.
   nsCOMPtr<nsIFile> file;
   nsCOMPtr <nsIURI> targetURI;
   nsAutoCString fileTarget;
   nsCOMPtr<nsIFile> resolvedFile;
   bool symLink;
   nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(uri);
   if (fileURL &&
       NS_SUCCEEDED(fileURL->GetFile(getter_AddRefs(file))) &&
       NS_SUCCEEDED(file->IsSymlink(&symLink)) &&
       symLink &&
       NS_SUCCEEDED(file->GetNativeTarget(fileTarget)) &&
       NS_SUCCEEDED(NS_NewNativeLocalFile(fileTarget, PR_TRUE,
                                          getter_AddRefs(resolvedFile))) &&
       NS_SUCCEEDED(NS_NewFileURI(getter_AddRefs(targetURI),
                    resolvedFile, nullptr))) {
     SetURI(targetURI);
     SetOriginalURI(uri);
     nsLoadFlags loadFlags = 0;
     GetLoadFlags(&loadFlags);
     SetLoadFlags(loadFlags | nsIChannel::LOAD_REPLACE);
   } else {
     SetURI(uri);
   }
 }
 nsresult
 nsFileChannel::MakeFileInputStream(nsIFile *file,
                                    nsCOMPtr<nsIInputStream> &stream,
                                    nsCString &contentType,
                                    bool async)
 {
   // we accept that this might result in a disk hit to stat the file
   bool isDir;
   nsresult rv = file->IsDirectory(&isDir);
   if (NS_FAILED(rv)) {
     // canonicalize error message
     if (rv == NS_ERROR_FILE_TARGET_DOES_NOT_EXIST)
       rv = NS_ERROR_FILE_NOT_FOUND;
     if (async && (NS_ERROR_FILE_NOT_FOUND == rv)) {
       // We don't return "Not Found" errors here. Since we could not find
       // the file, it's not a directory anyway.
       isDir = false;
     } else {
       return rv;
     }
   }
   if (isDir) {
     rv = nsDirectoryIndexStream::Create(file, getter_AddRefs(stream));
     if (NS_SUCCEEDED(rv) && !HasContentTypeHint())
       contentType.AssignLiteral(APPLICATION_HTTP_INDEX_FORMAT);
   } else {
     rv = NS_NewLocalFileInputStream(getter_AddRefs(stream), file, -1, -1,
                                     async? nsIFileInputStream::DEFER_OPEN : 0);
     if (NS_SUCCEEDED(rv) && !HasContentTypeHint()) {
       // Use file extension to infer content type
       nsCOMPtr<nsIMIMEService> mime = do_GetService("@mozilla.org/mime;1", &rv);
       if (NS_SUCCEEDED(rv)) {
         mime->GetTypeFromFile(file, contentType);
       }
     }
   }
   return rv;
 }
 nsresult
 nsFileChannel::OpenContentStream(bool async, nsIInputStream **result,
                                  nsIChannel** channel)
 {
   // NOTE: the resulting file is a clone, so it is safe to pass it to the
   //       file input stream which will be read on a background thread.
   nsCOMPtr<nsIFile> file;
   nsresult rv = GetFile(getter_AddRefs(file));
   if (NS_FAILED(rv))
     return rv;
   nsCOMPtr<nsIFileProtocolHandler> fileHandler;
   rv = NS_GetFileProtocolHandler(getter_AddRefs(fileHandler));
   if (NS_FAILED(rv))
     return rv;
   nsCOMPtr<nsIURI> newURI;
   rv = fileHandler->ReadURLFile(file, getter_AddRefs(newURI));
   if (NS_SUCCEEDED(rv)) {
     nsCOMPtr<nsIChannel> newChannel;
     rv = NS_NewChannel(getter_AddRefs(newChannel), newURI);
     if (NS_FAILED(rv))
       return rv;
     *result = nullptr;
     newChannel.forget(channel);
     return NS_OK;
   }
   nsCOMPtr<nsIInputStream> stream;
   if (mUploadStream) {
     // Pass back a nsFileUploadContentStream instance that knows how to perform
     // the file copy when "read" (the resulting stream in this case does not
     // actually return any data).
     nsCOMPtr<nsIOutputStream> fileStream;
     rv = NS_NewLocalFileOutputStream(getter_AddRefs(fileStream), file,
                                      PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE,
                                      PR_IRUSR | PR_IWUSR);
     if (NS_FAILED(rv))
       return rv;
     nsFileUploadContentStream *uploadStream =
         new nsFileUploadContentStream(async, fileStream, mUploadStream,
                                       mUploadLength, this);
     if (!uploadStream || !uploadStream->IsInitialized()) {
       delete uploadStream;
       return NS_ERROR_OUT_OF_MEMORY;
     }
     stream = uploadStream;
     mContentLength = 0;
     // Since there isn't any content to speak of we just set the content-type
     // to something other than "unknown" to avoid triggering the content-type
     // sniffer code in nsBaseChannel.
     // However, don't override explicitly set types.
     if (!HasContentTypeHint())
       SetContentType(NS_LITERAL_CSTRING(APPLICATION_OCTET_STREAM));
   } else {
     nsAutoCString contentType;
     rv = MakeFileInputStream(file, stream, contentType, async);
     if (NS_FAILED(rv))
       return rv;
     EnableSynthesizedProgressEvents(true);
     // fixup content length and type
     if (mContentLength < 0) {
       int64_t size;
       rv = file->GetFileSize(&size);
       if (NS_FAILED(rv)) {
         if (async &&
             (NS_ERROR_FILE_NOT_FOUND == rv ||
              NS_ERROR_FILE_TARGET_DOES_NOT_EXIST == rv)) {
           size = 0;
         } else {
           return rv;
         }
       }
       mContentLength = size;
     }
     if (!contentType.IsEmpty())
       SetContentType(contentType);
   }
   *result = nullptr;
   stream.swap(*result);
   return NS_OK;
 }
 //-----------------------------------------------------------------------------
 // nsFileChannel::nsISupports
 NS_IMPL_ISUPPORTS_INHERITED(nsFileChannel,
                             nsBaseChannel,
                             nsIUploadChannel,
                             nsIFileChannel)
 //-----------------------------------------------------------------------------
 // nsFileChannel::nsIFileChannel
 NS_IMETHODIMP
 nsFileChannel::GetFile(nsIFile **file)
 {
     nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(URI());
     NS_ENSURE_STATE(fileURL);
     // This returns a cloned nsIFile
     return fileURL->GetFile(file);
 }
 //-----------------------------------------------------------------------------
 // nsFileChannel::nsIUploadChannel
 NS_IMETHODIMP
 nsFileChannel::SetUploadStream(nsIInputStream *stream,
                                const nsACString &contentType,
                                int64_t contentLength)
 {
   NS_ENSURE_TRUE(!Pending(), NS_ERROR_IN_PROGRESS);
   if ((mUploadStream = stream)) {
     mUploadLength = contentLength;
     if (mUploadLength < 0) {
       // Make sure we know how much data we are uploading.
       uint64_t avail;
       nsresult rv = mUploadStream->Available(&avail);
       if (NS_FAILED(rv))
         return rv;
       if (avail < INT64_MAX)
         mUploadLength = avail;
     }
   } else {
     mUploadLength = -1;
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsFileChannel::GetUploadStream(nsIInputStream **result)
 {
     NS_IF_ADDREF(*result = mUploadStream);
     return NS_OK;
 }

The Tor Browser / annotate

netwerk/protocol/file/nsFileChannel.cpp@6474c204b198 (annotated)

netwerk/protocol/file/nsFileChannel.cpp