Quelle nsIncrementalDownload.cpp Sprache: C

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et cindent: */
/* 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 "mozilla/Attributes.h"
#include "mozilla/TaskQueue.h"
#include "mozilla/UniquePtrExtensions.h"
#include "mozilla/UniquePtr.h"

#include "nsIIncrementalDownload.h"
#include "nsIRequestObserver.h"
#include "nsIProgressEventSink.h"
#include "nsIChannelEventSink.h"
#include "nsIAsyncVerifyRedirectCallback.h"
#include "nsIInterfaceRequestor.h"
#include "nsIObserverService.h"
#include "nsIObserver.h"
#include "nsIStreamListener.h"
#include "nsIThreadRetargetableRequest.h"
#include "nsIThreadRetargetableStreamListener.h"
#include "nsIFile.h"
#include "nsIHttpChannel.h"
#include "nsIOService.h"
#include "nsITimer.h"
#include "nsIURI.h"
#include "nsIInputStream.h"
#include "nsNetUtil.h"
#include "nsWeakReference.h"
#include "prio.h"
#include "prprf.h"
#include <algorithm>
#include "nsIContentPolicy.h"
#include "nsContentUtils.h"
#include "mozilla/Logging.h"
#include "mozilla/UniquePtr.h"

// Default values used to initialize a nsIncrementalDownload object.
#define DEFAULT_CHUNK_SIZE (4096 * 16)  // bytes
#define DEFAULT_INTERVAL 60             // seconds

#define UPDATE_PROGRESS_INTERVAL PRTime(100 * PR_USEC_PER_MSEC)  // 100ms

// Number of times to retry a failed byte-range request.
#define MAX_RETRY_COUNT 20

using namespace mozilla;
using namespace mozilla::net;

static LazyLogModule gIDLog("IncrementalDownload");
#undef LOG
#define LOG(args) MOZ_LOG(gIDLog, mozilla::LogLevel::Debug, args)

//-----------------------------------------------------------------------------

static nsresult WriteToFile(nsIFile* lf, const char* data, uint32_t len,
                            int32_t flags) {
  PRFileDesc* fd;
  int32_t mode = 0600;
  nsresult rv;
  rv = lf->OpenNSPRFileDesc(flags, mode, &fd);
  if (NS_FAILED(rv)) return rv;

  if (len) {
    rv = PR_Write(fd, data, len) == int32_t(len) ? NS_OK : NS_ERROR_FAILURE;
  }

  PR_Close(fd);
  return rv;
}

static nsresult AppendToFile(nsIFile* lf, const char* data, uint32_t len) {
  int32_t flags = PR_WRONLY | PR_CREATE_FILE | PR_APPEND;
  return WriteToFile(lf, data, len, flags);
}

// maxSize may be -1 if unknown
static void MakeRangeSpec(const int64_t& size, const int64_t& maxSize,
                          int32_t chunkSize, bool fetchRemaining,
                          nsCString& rangeSpec) {
  rangeSpec.AssignLiteral("bytes=");
  rangeSpec.AppendInt(int64_t(size));
  rangeSpec.Append('-');

  if (fetchRemaining) return;

  int64_t end = size + int64_t(chunkSize);
  if (maxSize != int64_t(-1) && end > maxSize) end = maxSize;
  end -= 1;

  rangeSpec.AppendInt(int64_t(end));
}

//-----------------------------------------------------------------------------

class nsIncrementalDownload final : public nsIIncrementalDownload,
                                    public nsIThreadRetargetableStreamListener,
                                    public nsIObserver,
                                    public nsIInterfaceRequestor,
                                    public nsIChannelEventSink,
                                    public nsSupportsWeakReference,
                                    public nsIAsyncVerifyRedirectCallback {
public:
  NS_DECL_THREADSAFE_ISUPPORTS
  NS_DECL_NSISTREAMLISTENER
  NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER
  NS_DECL_NSIREQUEST
  NS_DECL_NSIINCREMENTALDOWNLOAD
  NS_DECL_NSIREQUESTOBSERVER
  NS_DECL_NSIOBSERVER
  NS_DECL_NSIINTERFACEREQUESTOR
  NS_DECL_NSICHANNELEVENTSINK
  NS_DECL_NSIASYNCVERIFYREDIRECTCALLBACK

  nsIncrementalDownload() = default;

private:
  ~nsIncrementalDownload() = default;
  nsresult FlushChunk();
  void UpdateProgress();
  nsresult CallOnStartRequest();
  void CallOnStopRequest();
  nsresult StartTimer(int32_t interval);
  nsresult ProcessTimeout();
  nsresult ReadCurrentSize();
  nsresult ClearRequestHeader(nsIHttpChannel* channel);

  nsCOMPtr<nsIRequestObserver> mObserver;
  nsCOMPtr<nsIProgressEventSink> mProgressSink;
  nsCOMPtr<nsIURI> mURI;
  nsCOMPtr<nsIURI> mFinalURI;
  nsCOMPtr<nsIFile> mDest;
  nsCOMPtr<nsIChannel> mChannel;
  nsCOMPtr<nsITimer> mTimer;
  mozilla::UniquePtr<char[]> mChunk;
  int32_t mChunkLen{0};
  int32_t mChunkSize{DEFAULT_CHUNK_SIZE};
  int32_t mInterval{DEFAULT_INTERVAL};
  int64_t mTotalSize{-1};
  int64_t mCurrentSize{-1};
  uint32_t mLoadFlags{LOAD_NORMAL};
  int32_t mNonPartialCount{0};
  nsresult mStatus{NS_OK};
  bool mIsPending{false};
  bool mDidOnStartRequest{false};
  PRTime mLastProgressUpdate{0};
  nsCOMPtr<nsIAsyncVerifyRedirectCallback> mRedirectCallback;
  nsCOMPtr<nsIChannel> mNewRedirectChannel;
  nsCString mPartialValidator;
  bool mCacheBust{false};
  nsCString mExtraHeaders;

  // nsITimerCallback is implemented on a subclass so that the name attribute
  // doesn't conflict with the name attribute of the nsIRequest interface.
  class TimerCallback final : public nsITimerCallback, public nsINamed {
   public:
    NS_DECL_ISUPPORTS
    NS_DECL_NSITIMERCALLBACK
    NS_DECL_NSINAMED

    explicit TimerCallback(nsIncrementalDownload* aIncrementalDownload);

   private:
    ~TimerCallback() = default;

    RefPtr<nsIncrementalDownload> mIncrementalDownload;
  };
};

nsresult nsIncrementalDownload::FlushChunk() {
  NS_ASSERTION(mTotalSize != int64_t(-1), "total size should be known");

  if (mChunkLen == 0) return NS_OK;

  nsresult rv = AppendToFile(mDest, mChunk.get(), mChunkLen);
  if (NS_FAILED(rv)) return rv;

  mCurrentSize += int64_t(mChunkLen);
  mChunkLen = 0;

  return NS_OK;
}

void nsIncrementalDownload::UpdateProgress() {
  mLastProgressUpdate = PR_Now();

  if (mProgressSink) {
    mProgressSink->OnProgress(this, mCurrentSize + mChunkLen, mTotalSize);
  }
}

nsresult nsIncrementalDownload::CallOnStartRequest() {
  if (!mObserver || mDidOnStartRequest) return NS_OK;

  mDidOnStartRequest = true;
  return mObserver->OnStartRequest(this);
}

void nsIncrementalDownload::CallOnStopRequest() {
  if (!mObserver) return;

  // Ensure that OnStartRequest is always called once before OnStopRequest.
  nsresult rv = CallOnStartRequest();
  if (NS_SUCCEEDED(mStatus)) mStatus = rv;

  mIsPending = false;

  mObserver->OnStopRequest(this, mStatus);
  mObserver = nullptr;
}

nsresult nsIncrementalDownload::StartTimer(int32_t interval) {
  auto callback = MakeRefPtr<TimerCallback>(this);
  return NS_NewTimerWithCallback(getter_AddRefs(mTimer), callback,
                                 interval * 1000, nsITimer::TYPE_ONE_SHOT);
}

nsresult nsIncrementalDownload::ProcessTimeout() {
  NS_ASSERTION(!mChannel, "how can we have a channel?");

  // Handle existing error conditions
  if (NS_FAILED(mStatus)) {
    CallOnStopRequest();
    return NS_OK;
  }

  // Fetch next chunk

  nsCOMPtr<nsIChannel> channel;
  nsresult rv = NS_NewChannel(
      getter_AddRefs(channel), mFinalURI, nsContentUtils::GetSystemPrincipal(),
      nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
      nsIContentPolicy::TYPE_OTHER,
      nullptr,  // nsICookieJarSettings
      nullptr,  // PerformanceStorage
      nullptr,  // loadGroup
      this,     // aCallbacks
      mLoadFlags);

  if (NS_FAILED(rv)) return rv;

  nsCOMPtr<nsIHttpChannel> http = do_QueryInterface(channel, &rv);
  if (NS_FAILED(rv)) return rv;

  NS_ASSERTION(mCurrentSize != int64_t(-1),
               "we should know the current file size by now");

  rv = ClearRequestHeader(http);
  if (NS_FAILED(rv)) return rv;

  if (!mExtraHeaders.IsEmpty()) {
    rv = AddExtraHeaders(http, mExtraHeaders);
    if (NS_FAILED(rv)) return rv;
  }

  // Don't bother making a range request if we are just going to fetch the
  // entire document.
  if (mInterval || mCurrentSize != int64_t(0)) {
    nsAutoCString range;
    MakeRangeSpec(mCurrentSize, mTotalSize, mChunkSize, mInterval == 0, range);

    rv = http->SetRequestHeader("Range"_ns, range, false);
    if (NS_FAILED(rv)) return rv;

    if (!mPartialValidator.IsEmpty()) {
      rv = http->SetRequestHeader("If-Range"_ns, mPartialValidator, false);
      if (NS_FAILED(rv)) {
        LOG(
            ("nsIncrementalDownload::ProcessTimeout\n"
             " failed to set request header: If-Range\n"));
      }
    }

    if (mCacheBust) {
      rv = http->SetRequestHeader("Cache-Control"_ns, "no-cache"_ns, false);
      if (NS_FAILED(rv)) {
        LOG(
            ("nsIncrementalDownload::ProcessTimeout\n"
             " failed to set request header: If-Range\n"));
      }
      rv = http->SetRequestHeader("Pragma"_ns, "no-cache"_ns, false);
      if (NS_FAILED(rv)) {
        LOG(
            ("nsIncrementalDownload::ProcessTimeout\n"
             " failed to set request header: If-Range\n"));
      }
    }
  }

  rv = channel->AsyncOpen(this);
  if (NS_FAILED(rv)) return rv;

  // Wait to assign mChannel when we know we are going to succeed.  This is
  // important because we don't want to introduce a reference cycle between
  // mChannel and this until we know for a fact that AsyncOpen has succeeded,
  // thus ensuring that our stream listener methods will be invoked.
  mChannel = channel;
  return NS_OK;
}

// Reads the current file size and validates it.
nsresult nsIncrementalDownload::ReadCurrentSize() {
  int64_t size;
  nsresult rv = mDest->GetFileSize((int64_t*)&size);
  if (rv == NS_ERROR_FILE_NOT_FOUND) {
    mCurrentSize = 0;
    return NS_OK;
  }
  if (NS_FAILED(rv)) return rv;

  mCurrentSize = size;
  return NS_OK;
}

// nsISupports
NS_IMPL_ISUPPORTS(nsIncrementalDownload, nsIIncrementalDownload, nsIRequest,
                  nsIStreamListener, nsIThreadRetargetableStreamListener,
                  nsIRequestObserver, nsIObserver, nsIInterfaceRequestor,
                  nsIChannelEventSink, nsISupportsWeakReference,
                  nsIAsyncVerifyRedirectCallback)

// nsIRequest

NS_IMETHODIMP
nsIncrementalDownload::GetName(nsACString& name) {
  NS_ENSURE_TRUE(mURI, NS_ERROR_NOT_INITIALIZED);

  return mURI->GetSpec(name);
}

NS_IMETHODIMP
nsIncrementalDownload::IsPending(bool* isPending) {
  *isPending = mIsPending;
  return NS_OK;
}

NS_IMETHODIMP
nsIncrementalDownload::GetStatus(nsresult* status) {
  *status = mStatus;
  return NS_OK;
}

NS_IMETHODIMP nsIncrementalDownload::SetCanceledReason(
    const nsACString& aReason) {
  return SetCanceledReasonImpl(aReason);
}

NS_IMETHODIMP nsIncrementalDownload::GetCanceledReason(nsACString& aReason) {
  return GetCanceledReasonImpl(aReason);
}

NS_IMETHODIMP nsIncrementalDownload::CancelWithReason(
    nsresult aStatus, const nsACString& aReason) {
  return CancelWithReasonImpl(aStatus, aReason);
}

NS_IMETHODIMP
nsIncrementalDownload::Cancel(nsresult status) {
  NS_ENSURE_ARG(NS_FAILED(status));

  // Ignore this cancelation if we're already canceled.
  if (NS_FAILED(mStatus)) return NS_OK;

  mStatus = status;

  // Nothing more to do if callbacks aren't pending.
  if (!mIsPending) return NS_OK;

  if (mChannel) {
    mChannel->Cancel(mStatus);
    NS_ASSERTION(!mTimer, "what is this timer object doing here?");
  } else {
    // dispatch a timer callback event to drive invoking our listener's
    // OnStopRequest.
    if (mTimer) mTimer->Cancel();
    StartTimer(0);
  }

  return NS_OK;
}

NS_IMETHODIMP
nsIncrementalDownload::Suspend() { return NS_ERROR_NOT_IMPLEMENTED; }

NS_IMETHODIMP
nsIncrementalDownload::Resume() { return NS_ERROR_NOT_IMPLEMENTED; }

NS_IMETHODIMP
nsIncrementalDownload::GetLoadFlags(nsLoadFlags* loadFlags) {
  *loadFlags = mLoadFlags;
  return NS_OK;
}

NS_IMETHODIMP
nsIncrementalDownload::SetLoadFlags(nsLoadFlags loadFlags) {
  mLoadFlags = loadFlags;
  return NS_OK;
}

NS_IMETHODIMP
nsIncrementalDownload::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
  return GetTRRModeImpl(aTRRMode);
}

NS_IMETHODIMP
nsIncrementalDownload::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
  return SetTRRModeImpl(aTRRMode);
}

NS_IMETHODIMP
nsIncrementalDownload::GetLoadGroup(nsILoadGroup** loadGroup) {
  return NS_ERROR_NOT_IMPLEMENTED;
}

NS_IMETHODIMP
nsIncrementalDownload::SetLoadGroup(nsILoadGroup* loadGroup) {
  return NS_ERROR_NOT_IMPLEMENTED;
}

// nsIIncrementalDownload

NS_IMETHODIMP
nsIncrementalDownload::Init(nsIURI* uri, nsIFile* dest, int32_t chunkSize,
                            int32_t interval, const nsACString& extraHeaders) {
  // Keep it simple: only allow initialization once
  NS_ENSURE_FALSE(mURI, NS_ERROR_ALREADY_INITIALIZED);

  mDest = dest;
  NS_ENSURE_ARG(mDest);

  mURI = uri;
  mFinalURI = uri;

  if (chunkSize > 0) mChunkSize = chunkSize;
  if (interval >= 0) mInterval = interval;

  mExtraHeaders = extraHeaders;

  return NS_OK;
}

NS_IMETHODIMP
nsIncrementalDownload::GetURI(nsIURI** result) {
  nsCOMPtr<nsIURI> uri = mURI;
  uri.forget(result);
  return NS_OK;
}

NS_IMETHODIMP
nsIncrementalDownload::GetFinalURI(nsIURI** result) {
  nsCOMPtr<nsIURI> uri = mFinalURI;
  uri.forget(result);
  return NS_OK;
}

NS_IMETHODIMP
nsIncrementalDownload::GetDestination(nsIFile** result) {
  if (!mDest) {
    *result = nullptr;
    return NS_OK;
  }
  // Return a clone of mDest so that callers may modify the resulting nsIFile
  // without corrupting our internal object.  This also works around the fact
  // that some nsIFile impls may cache the result of stat'ing the filesystem.
  return mDest->Clone(result);
}

NS_IMETHODIMP
nsIncrementalDownload::GetTotalSize(int64_t* result) {
  *result = mTotalSize;
  return NS_OK;
}

NS_IMETHODIMP
nsIncrementalDownload::GetCurrentSize(int64_t* result) {
  *result = mCurrentSize;
  return NS_OK;
}

NS_IMETHODIMP
nsIncrementalDownload::Start(nsIRequestObserver* observer,
                             nsISupports* context) {
  NS_ENSURE_ARG(observer);
  NS_ENSURE_FALSE(mIsPending, NS_ERROR_IN_PROGRESS);

  // Observe system shutdown so we can be sure to release any reference held
  // between ourselves and the timer.  We have the observer service hold a weak
  // reference to us, so that we don't have to worry about calling
  // RemoveObserver.  XXX(darin): The timer code should do this for us.
  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
  if (obs) obs->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, true);

  nsresult rv = ReadCurrentSize();
  if (NS_FAILED(rv)) return rv;

  rv = StartTimer(0);
  if (NS_FAILED(rv)) return rv;

  mObserver = observer;
  mProgressSink = do_QueryInterface(observer);  // ok if null

  mIsPending = true;
  return NS_OK;
}

// nsIRequestObserver

NS_IMETHODIMP
nsIncrementalDownload::OnStartRequest(nsIRequest* aRequest) {
  nsresult rv;

  nsCOMPtr<nsIHttpChannel> http = do_QueryInterface(aRequest, &rv);
  if (NS_FAILED(rv)) return rv;

  // Ensure that we are receiving a 206 response.
  uint32_t code;
  rv = http->GetResponseStatus(&code);
  if (NS_FAILED(rv)) return rv;
  if (code != 206) {
    // We may already have the entire file downloaded, in which case
    // our request for a range beyond the end of the file would have
    // been met with an error response code.
    if (code == 416 && mTotalSize == int64_t(-1)) {
      mTotalSize = mCurrentSize;
      // Return an error code here to suppress OnDataAvailable.
      return NS_ERROR_DOWNLOAD_COMPLETE;
    }
    // The server may have decided to give us all of the data in one chunk.  If
    // we requested a partial range, then we don't want to download all of the
    // data at once.  So, we'll just try again, but if this keeps happening then
    // we'll eventually give up.
    if (code == 200) {
      if (mInterval) {
        mChannel = nullptr;
        if (++mNonPartialCount > MAX_RETRY_COUNT) {
          NS_WARNING("unable to fetch a byte range; giving up");
          return NS_ERROR_FAILURE;
        }
        // Increase delay with each failure.
        StartTimer(mInterval * mNonPartialCount);
        return NS_ERROR_DOWNLOAD_NOT_PARTIAL;
      }
      // Since we have been asked to download the rest of the file, we can deal
      // with a 200 response.  This may result in downloading the beginning of
      // the file again, but that can't really be helped.
    } else {
      NS_WARNING("server response was unexpected");
      return NS_ERROR_UNEXPECTED;
    }
  } else {
    // We got a partial response, so clear this counter in case the next chunk
    // results in a 200 response.
    mNonPartialCount = 0;

    // confirm that the content-range response header is consistent with
    // expectations on each 206. If it is not then drop this response and
    // retry with no-cache set.
    if (!mCacheBust) {
      nsAutoCString buf;
      int64_t startByte = 0;
      bool confirmedOK = false;

      rv = http->GetResponseHeader("Content-Range"_ns, buf);
      if (NS_FAILED(rv)) {
        return rv;  // it isn't a useful 206 without a CONTENT-RANGE of some
      }
      // sort

      // Content-Range: bytes 0-299999/25604694
      int32_t p = buf.Find("bytes ");

      // first look for the starting point of the content-range
      // to make sure it is what we expect
      if (p != -1) {
        char* endptr = nullptr;
        const char* s = buf.get() + p + 6;
        while (*s && *s == ' ') s++;
        startByte = strtol(s, &endptr, 10);

        if (*s && endptr && (endptr != s) && (mCurrentSize == startByte)) {
          // ok the starting point is confirmed. We still need to check the
          // total size of the range for consistency if this isn't
          // the first chunk
          if (mTotalSize == int64_t(-1)) {
            // first chunk
            confirmedOK = true;
          } else {
            int32_t slash = buf.FindChar('/');
            int64_t rangeSize = 0;
            if (slash != kNotFound &&
                (PR_sscanf(buf.get() + slash + 1, "%lld",
                           (int64_t*)&rangeSize) == 1) &&
                rangeSize == mTotalSize) {
              confirmedOK = true;
            }
          }
        }
      }

      if (!confirmedOK) {
        NS_WARNING("unexpected content-range");
        mCacheBust = true;
        mChannel = nullptr;
        if (++mNonPartialCount > MAX_RETRY_COUNT) {
          NS_WARNING("unable to fetch a byte range; giving up");
          return NS_ERROR_FAILURE;
        }
        // Increase delay with each failure.
        StartTimer(mInterval * mNonPartialCount);
        return NS_ERROR_DOWNLOAD_NOT_PARTIAL;
      }
    }
  }

  // Do special processing after the first response.
  if (mTotalSize == int64_t(-1)) {
    // Update knowledge of mFinalURI
    rv = http->GetURI(getter_AddRefs(mFinalURI));
    if (NS_FAILED(rv)) return rv;
    Unused << http->GetResponseHeader("Etag"_ns, mPartialValidator);
    if (StringBeginsWith(mPartialValidator, "W/"_ns)) {
      mPartialValidator.Truncate();  // don't use weak validators
    }
    if (mPartialValidator.IsEmpty()) {
      rv = http->GetResponseHeader("Last-Modified"_ns, mPartialValidator);
      if (NS_FAILED(rv)) {
        LOG(
            ("nsIncrementalDownload::OnStartRequest\n"
             " empty validator\n"));
      }
    }

    if (code == 206) {
      // OK, read the Content-Range header to determine the total size of this
      // download file.
      nsAutoCString buf;
      rv = http->GetResponseHeader("Content-Range"_ns, buf);
      if (NS_FAILED(rv)) return rv;
      int32_t slash = buf.FindChar('/');
      if (slash == kNotFound) {
        NS_WARNING("server returned invalid Content-Range header!");
        return NS_ERROR_UNEXPECTED;
      }
      if (PR_sscanf(buf.get() + slash + 1, "%lld", (int64_t*)&mTotalSize) !=
          1) {
        return NS_ERROR_UNEXPECTED;
      }
    } else {
      rv = http->GetContentLength(&mTotalSize);
      if (NS_FAILED(rv)) return rv;
      // We need to know the total size of the thing we're trying to download.
      if (mTotalSize == int64_t(-1)) {
        NS_WARNING("server returned no content-length header!");
        return NS_ERROR_UNEXPECTED;
      }
      // Need to truncate (or create, if it doesn't exist) the file since we
      // are downloading the whole thing.
      WriteToFile(mDest, nullptr, 0, PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE);
      mCurrentSize = 0;
    }

    // Notify observer that we are starting...
    rv = CallOnStartRequest();
    if (NS_FAILED(rv)) return rv;
  }

  // Adjust mChunkSize accordingly if mCurrentSize is close to mTotalSize.
  int64_t diff = mTotalSize - mCurrentSize;
  if (diff <= int64_t(0)) {
    NS_WARNING("about to set a bogus chunk size; giving up");
    return NS_ERROR_UNEXPECTED;
  }

  if (diff < int64_t(mChunkSize)) mChunkSize = uint32_t(diff);

  mChunk = mozilla::MakeUniqueFallible<char[]>(mChunkSize);
  if (!mChunk) rv = NS_ERROR_OUT_OF_MEMORY;

  if (nsIOService::UseSocketProcess() || NS_FAILED(rv)) {
    return rv;
  }

  if (nsCOMPtr<nsIThreadRetargetableRequest> rr = do_QueryInterface(aRequest)) {
    nsCOMPtr<nsIEventTarget> sts =
        do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
    RefPtr queue =
        TaskQueue::Create(sts.forget(), "nsIncrementalDownload Delivery Queue");
    LOG(
        ("nsIncrementalDownload::OnStartRequest\n"
         " Retarget to stream transport service\n"));
    rr->RetargetDeliveryTo(queue);
  }

  return rv;
}

NS_IMETHODIMP
nsIncrementalDownload::CheckListenerChain() { return NS_OK; }

NS_IMETHODIMP
nsIncrementalDownload::OnStopRequest(nsIRequest* request, nsresult status) {
  // Not a real error; just a trick to kill off the channel without our
  // listener having to care.
  if (status == NS_ERROR_DOWNLOAD_NOT_PARTIAL) return NS_OK;

  // Not a real error; just a trick used to suppress OnDataAvailable calls.
  if (status == NS_ERROR_DOWNLOAD_COMPLETE) status = NS_OK;

  if (NS_SUCCEEDED(mStatus)) mStatus = status;

  if (mChunk) {
    if (NS_SUCCEEDED(mStatus)) mStatus = FlushChunk();

    mChunk = nullptr;  // deletes memory
    mChunkLen = 0;
    UpdateProgress();
  }

  mChannel = nullptr;

  // Notify listener if we hit an error or finished
  if (NS_FAILED(mStatus) || mCurrentSize == mTotalSize) {
    CallOnStopRequest();
    return NS_OK;
  }

  return StartTimer(mInterval);  // Do next chunk
}

// nsIStreamListener
NS_IMETHODIMP
nsIncrementalDownload::OnDataAvailable(nsIRequest* request,
                                       nsIInputStream* input, uint64_t offset,
                                       uint32_t count) {
  while (count) {
    uint32_t space = mChunkSize - mChunkLen;
    uint32_t n, len = std::min(space, count);

    nsresult rv = input->Read(&mChunk[mChunkLen], len, &n);
    if (NS_FAILED(rv)) return rv;
    if (n != len) return NS_ERROR_UNEXPECTED;

    count -= n;
    mChunkLen += n;

    if (mChunkLen == mChunkSize) {
      rv = FlushChunk();
      if (NS_FAILED(rv)) return rv;
    }
  }

  if (PR_Now() > mLastProgressUpdate + UPDATE_PROGRESS_INTERVAL) {
    if (NS_IsMainThread()) {
      UpdateProgress();
    } else {
      NS_DispatchToMainThread(
          NewRunnableMethod("nsIncrementalDownload::UpdateProgress", this,
                            &nsIncrementalDownload::UpdateProgress));
    }
  }
  return NS_OK;
}

NS_IMETHODIMP
nsIncrementalDownload::OnDataFinished(nsresult aStatus) { return NS_OK; }

// nsIObserver

NS_IMETHODIMP
nsIncrementalDownload::Observe(nsISupports* subject, const char* topic,
                               const char16_t* data) {
  if (strcmp(topic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0) {
    Cancel(NS_ERROR_ABORT);

    // Since the app is shutting down, we need to go ahead and notify our
    // observer here.  Otherwise, we would notify them after XPCOM has been
    // shutdown or not at all.
    CallOnStopRequest();
  }
  return NS_OK;
}

// nsITimerCallback

nsIncrementalDownload::TimerCallback::TimerCallback(
    nsIncrementalDownload* aIncrementalDownload)
    : mIncrementalDownload(aIncrementalDownload) {}

NS_IMPL_ISUPPORTS(nsIncrementalDownload::TimerCallback, nsITimerCallback,
                  nsINamed)

NS_IMETHODIMP
nsIncrementalDownload::TimerCallback::Notify(nsITimer* aTimer) {
  mIncrementalDownload->mTimer = nullptr;

  nsresult rv = mIncrementalDownload->ProcessTimeout();
  if (NS_FAILED(rv)) mIncrementalDownload->Cancel(rv);

  return NS_OK;
}

// nsINamed

NS_IMETHODIMP
nsIncrementalDownload::TimerCallback::GetName(nsACString& aName) {
  aName.AssignLiteral("nsIncrementalDownload");
  return NS_OK;
}

// nsIInterfaceRequestor

NS_IMETHODIMP
nsIncrementalDownload::GetInterface(const nsIID& iid, void** result) {
  if (iid.Equals(NS_GET_IID(nsIChannelEventSink))) {
    NS_ADDREF_THIS();
    *result = static_cast<nsIChannelEventSink*>(this);
    return NS_OK;
  }

  nsCOMPtr<nsIInterfaceRequestor> ir = do_QueryInterface(mObserver);
  if (ir) return ir->GetInterface(iid, result);

  return NS_ERROR_NO_INTERFACE;
}

nsresult nsIncrementalDownload::ClearRequestHeader(nsIHttpChannel* channel) {
  NS_ENSURE_ARG(channel);

  // We don't support encodings -- they make the Content-Length not equal
  // to the actual size of the data.
  return channel->SetRequestHeader("Accept-Encoding"_ns, ""_ns, false);
}

// nsIChannelEventSink

NS_IMETHODIMP
nsIncrementalDownload::AsyncOnChannelRedirect(
    nsIChannel* oldChannel, nsIChannel* newChannel, uint32_t flags,
    nsIAsyncVerifyRedirectCallback* cb) {
  // In response to a redirect, we need to propagate the Range header.  See bug
  // 311595.  Any failure code returned from this function aborts the redirect.

  nsCOMPtr<nsIHttpChannel> http = do_QueryInterface(oldChannel);
  NS_ENSURE_STATE(http);

  nsCOMPtr<nsIHttpChannel> newHttpChannel = do_QueryInterface(newChannel);
  NS_ENSURE_STATE(newHttpChannel);

  constexpr auto rangeHdr = "Range"_ns;

  nsresult rv = ClearRequestHeader(newHttpChannel);
  if (NS_FAILED(rv)) return rv;

  if (!mExtraHeaders.IsEmpty()) {
    rv = AddExtraHeaders(http, mExtraHeaders);
    if (NS_FAILED(rv)) return rv;
  }

  // If we didn't have a Range header, then we must be doing a full download.
  nsAutoCString rangeVal;
  Unused << http->GetRequestHeader(rangeHdr, rangeVal);
  if (!rangeVal.IsEmpty()) {
    rv = newHttpChannel->SetRequestHeader(rangeHdr, rangeVal, false);
    NS_ENSURE_SUCCESS(rv, rv);
  }

  // A redirection changes the validator
  mPartialValidator.Truncate();

  if (mCacheBust) {
    rv = newHttpChannel->SetRequestHeader("Cache-Control"_ns, "no-cache"_ns,
                                          false);
    if (NS_FAILED(rv)) {
      LOG(
          ("nsIncrementalDownload::AsyncOnChannelRedirect\n"
           " failed to set request header: Cache-Control\n"));
    }
    rv = newHttpChannel->SetRequestHeader("Pragma"_ns, "no-cache"_ns, false);
    if (NS_FAILED(rv)) {
      LOG(
          ("nsIncrementalDownload::AsyncOnChannelRedirect\n"
           " failed to set request header: Pragma\n"));
    }
  }

  // Prepare to receive callback
  mRedirectCallback = cb;
  mNewRedirectChannel = newChannel;

  // Give the observer a chance to see this redirect notification.
  nsCOMPtr<nsIChannelEventSink> sink = do_GetInterface(mObserver);
  if (sink) {
    rv = sink->AsyncOnChannelRedirect(oldChannel, newChannel, flags, this);
    if (NS_FAILED(rv)) {
      mRedirectCallback = nullptr;
      mNewRedirectChannel = nullptr;
    }
    return rv;
  }
  (void)OnRedirectVerifyCallback(NS_OK);
  return NS_OK;
}

NS_IMETHODIMP
nsIncrementalDownload::OnRedirectVerifyCallback(nsresult result) {
  NS_ASSERTION(mRedirectCallback, "mRedirectCallback not set in callback");
  NS_ASSERTION(mNewRedirectChannel, "mNewRedirectChannel not set in callback");

  // Update mChannel, so we can Cancel the new channel.
  if (NS_SUCCEEDED(result)) mChannel = mNewRedirectChannel;

  mRedirectCallback->OnRedirectVerifyCallback(result);
  mRedirectCallback = nullptr;
  mNewRedirectChannel = nullptr;
  return NS_OK;
}

extern nsresult net_NewIncrementalDownload(const nsIID& iid, void** result) {
  RefPtr<nsIncrementalDownload> d = new nsIncrementalDownload();
  return d->QueryInterface(iid, result);
}

quality99%

¤ Dauer der Verarbeitung: 0.20 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.