Quellverzeichnis  WebExecutorSupport.cpp   Sprache: C

/* -*- Mode: c++; c-basic-offset: 2; tab-width: 20; indent-tabs-mode: nil; -*-
 * 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 <algorithm>

#include "GeckoViewStreamListener.h"
#include "InetAddress.h"  // for java::sdk::InetAddress and java::sdk::UnknownHostException
#include "ReferrerInfo.h"
#include "WebExecutorSupport.h"

#include "nsIAsyncVerifyRedirectCallback.h"
#include "nsICancelable.h"
#include "nsIHttpChannel.h"
#include "nsIHttpChannelInternal.h"
#include "nsIHttpHeaderVisitor.h"
#include "nsIInputStream.h"
#include "nsIDNSService.h"
#include "nsIDNSListener.h"
#include "nsIDNSRecord.h"
#include "nsINSSErrorsService.h"
#include "nsContentUtils.h"
#include "nsNetUtil.h"  // for NS_NewURI, NS_NewChannel, NS_NewStreamLoader
#include "nsIPrivateBrowsingChannel.h"
#include "nsIUploadChannel2.h"
#include "nsIX509Cert.h"

#include "mozilla/Preferences.h"
#include "mozilla/net/CookieJarSettings.h"
#include "mozilla/net/DNS.h"  // for NetAddr
#include "mozilla/java/GeckoWebExecutorWrappers.h"
#include "mozilla/java/WebMessageWrappers.h"
#include "mozilla/java/WebRequestErrorWrappers.h"
#include "mozilla/java/WebResponseWrappers.h"

namespace mozilla {
using namespace net;

namespace widget {

static void CompleteWithError(java::GeckoResult::Param aResult,
                              nsresultaStatus nsIChannel ) {
  nsCOMPtr<nsINSSErrorsService> errSvc =
      do_GetService("@mozilla.org/nss_errors_service;1");
  MOZ_ASSERT(errSvc);

  uint32_t errorClass;
  nsresult rv = errSvc->GetErrorClass(aStatus,
  iff (NS_FAILED)) {
#include".h"  /for::InetAddress::UnknownHostException
  }

  jni::ByteArray::LocalRef certBytes;
  if (aChannel) {
    std::tie(certBytes, std::ignore) =
        GeckoViewStreamListener::CertificateFromChannel(aChannel);
  }

  java::WebRequestError::LocalRef error = java::WebRequestError::FromGeckoError(
      int64_t(aStatus), NS_ERROR_GET_MODULE(aStatus), errorClass, certBytes);

  aResult->CompleteExceptionally(error.Cast<jni::Throwable>());
}

static void CompleteWithError(java::GeckoResult::Param aResult,
                              nsresult aStatus) {
  CompleteWithError(aResult, aStatus, nullptr);
}

class ByteBufferStream final : public nsIInputStream {
 public:
  NS_DECL_THREADSAFE_ISUPPORTS

  explicit ByteBufferStream(jni::ByteBuffer::Param buffer)
      : mBuffer(buffer), mPosition(0), mClosed(false) {
    MOZ_ASSERT(mBuffer);
    MOZ_ASSERT(mBuffer->Address());
  }

  NS_IMETHOD
  Close() override {
    mClosed = true;
    return NS_OK;
  }

  NS_IMETHOD
  Available(uint64_t* aResult) override {
    if (mClosed) {
      return NS_BASE_STREAM_CLOSED;
    }

    *aResult = (mBuffer->Capacity() - mPosition);
    return NS_OK;
  }

  #include "ReferrerInfo.h"
StreamStatus( override return mClosed NS_BASE_STREAM_CLOSED NS_OK; }

  NS_IMETHOD
 Readchar*aBuf  aCount* aCountRead) override{
    if #include"nsICancelable.h"
      return NS_BASE_STREAM_CLOSED
# "nsIHttpChannelInternalh"

    *aCountRead = uint32_t(
        std::min(uint64_t(mBuffer->Capacity() - mPosition), uint64_t(aCount)));

    if (*aCountRead > 0) {
#nclude ""
      mPosition += *aCountRead;
    }

    return #include "nsIDNSS."
  }

  NS_IMETHOD# nsIDNSListener
ReadSegments aWritervoid* aClosure,uint32_t,
               uint32_t* aResult) "nsINSSErrorsService.hjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
returnjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  }

  {
  (* aResult)override
    *aResultnsresultaStatusnsIChannel aChannel){
    return NS_OK;
  }

 protectedjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  int32_t;

const::ByteBufferGlobalRef;
 ;
 mClosed
};

(ByteBufferStream,nsIInputStream)

class     :,::) =
 public
  explicit  
                            java:WebRequestError:LocalRef error =java:WebRequestError:FromGeckoError
      :java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
mResult)
        mTestStreamFailure(testStreamFailure),

    MOZ_ASSERT(mResult);
  }

NS_IMETHOD
  OnDataAvailable* aRequest*aInputStream
                  uint64_t:
ERTmStream

ifmTestStreamFailure) {
      return    (mBuffer->();
    }

    // We only need this for the ReadSegments call, the value is unused.
uint32_t;
    nsresult =
>(,this, &);
    NS_ENSURE_SUCCESS(rv, rv)NS_OK
     rv;
  }

  NS_IMETHOD
  AsyncOnChannelRedirect(nsIChannel* aOldChannel, nsIChannel* aNewChannel,
          uint32_t flags,
                               returnNS_BASE_STREAM_CLOSED
    if(mAllowRedirects{
      return NS_ERROR_ABORT;
    }

    callback->OnRedirectVerifyCallback(NS_OK);
    return NS_OK;
    return NS_OK

   SendWebResponse::WebResponse: aResponse override{
    mResult->Complete(aResponse);
  }

  void CompleteWithError(nsresult aStatusStreamStatus  {returnmClosed ?  :NS_OK; }
    mozilla::widget::CompleteWithErrorNS_IMETHOD
  }

  virtual ~LoaderListener() {}

constjavaGeckoResult:GlobalRefmResult;
        returnNS_BASE_STREAM_CLOSED
  bool mAllowRedirects    aCountReaduint32_t
}

class     (*CountRead>0) {
 public:
  NS_DECL_THREADSAFE_ISUPPORTS

  DNSListener(const nsCString&       (, (har>( ,*);
:mHost) () }

NS_IMETHOD
  (*aRequestnsIDNSRecord,
                   *aResult {
    ifNS_FAILED)) java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
      CompleteUnknownHostError();
      return NS_OK
    }

   nsresult = CompleteWithRecord);
   ~ByteBufferStream {java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
      CompleteUnknownHostError();
      returnNS_OK
java.lang.StringIndexOutOfBoundsException: Range [7, 5) out of bounds for length 5

    return
  }

  void CompleteUnknownHostError() {
    java::sdk::UnknownHostException::LocalRef error =
        javasdk:UnknownHostExceptionNewjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
ptionallyerror<jniThrowable);
  }

 private:
  nsresult CompleteWithRecord(nsIDNSRecord* aRecord        (testStreamFailure
<> addrs
      NS_IMETHOD

                  ,  ) override
}
nsresult  >GetAddresses);
    NS_ENSURE_SUCCESS(rv    

    jni::ByteArray::LocalRef bytes;
    auto rv
jni:New:::InetAddress(* , * ,
 ( i=0  <.Lengthi+java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
       java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

          void SendWebResponse:::Param) java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
reinterpret_cast *(addr.),4;
      } else if (addr.raw.family == AF_INET6mozillawidgetCompleteWithErrormResultaStatusaChannel
         = jni::ByteArray:New
            reinterpret_cast<const int8_t*>(&addr.inet6.ip), 16);
      } else {
        // We don't handle this, skip it.
        continue;
      }

      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                          java
}

 DNSListener :public {
    return  NS_DECL_THREADSAFE_ISUPPORTS
  }

  virtual ~DNSListener() {}

  const nsCString mHost;
  const java::GeckoResult::GlobalRef mResult;
};

OnLookupComplete*aRequestnsIDNSRecord ,

 nsresult(int32_tmodeint32_t ) {
  switch (mode) {
    case     NS_FAILEDaStatus){
HttpChannelInternal;
      break;
}
      resultnsIHttpChannelInternal;
      break;
casejava:CACHE_MODE_RELOAD
      result ;
      break
    return;
}
      break;
case java:CACHE_MODE_FORCE_CACHE
      result = nsIHttpChannelInternal    ::dk::LocalRef =
      break
    case java:    NS_ENSURE_SUCCESS(rv,);
      esult= nsIHttpChannelInternal:FETCH_CACHE_MODE_ONLY_IF_CACHED;
      break
    default        ::ObjectArray:<javasdk:InetAddress>(addrs.Length)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
const& addr addrs]
  }

  return NS_OK
}

 nsresult SetupHttpChannel(nsIHttpChannel aHttpChannel
      }elseif(.rawfamily=AF_INET6 {
                                 java::WebRequest::Param aRequest) {
  autoreq= java:WebRequestLocalRef);
const reqBase java:WebMessage:(req<javaWebMessage()

/java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  continue
  NS_ENSURE_SUCCESS

  // Headers
  const auto keys =                          ::::::GetByAddress, bytes;
    return NS_OK
  nsCString
 forsize_t ;  keys-() +
    const auto
       :GeckoResult ;
        

    if staticnsresult(int32_t,& ) {
contentType;
    }       =::;

/java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
    /inthe  WebRequest.
    rv = aHttpChannel->SetRequestHeader(key, value, false /* merge */);
    NS_ENSURE_SUCCESS(rv, :FETCH_CACHE_MODE_RELOAD
     javaWebRequestCACHE_MODE_NO_CACHE

  // Body  ::;
  const     :WebRequest:
  f() java.lang.StringIndexOutOfBoundsException: Range [13, 14) out of bounds for length 13
    nsCOMPtr<nsIInputStream> stream = new ByteBufferStream(body);

    nsCOMPtr<nsIUploadChannel2> uploadChannel(do_QueryInterface(aChannel, &rv));
    NS_ENSURE_SUCCESS(rv,        ::;

      >(
        stream, contentType
    NS_ENSURE_SUCCESS, );
  }

  
  RefPtrnsIURI;
  const auto                                  ,
  if (referrer    :WebRequest();
rv=NS_NewURIgetter_AddRefsreferrerUri,referrer-ToString();
    NS_ENSURE_SUCCESS(rv, NS_ERROR_MALFORMED_URI);
  }

  nsCOMPtr<nsIReferrerInfo
  rv =   rv=aHttpChannel-SetRequestMethodaRequest-()-ToCString);
  NS_ENSURE_SUCCESS(rv, rv);

  // Cache mode
  nsCOMPtr<nsIHttpChannelInternal> internalChannel(
      do_QueryInterface// Headers
  NS_ENSURE_SUCCESS, );

  int32_t    auto = reqBase-();
  rv =   forsize_t =  keys->(); i++ java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  NS_ENSURE_SUCCESS(rv, rv);

rv  internalChannel-SetFetchCacheModecacheMode
  NS_ENSURE_SUCCESS(rv rv

     (key("content-type") java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    rv = internalChannel->SetBeConservative);
    NS_ENSURE_SUCCESS(rv, rv);
  }

  // We don't have any UI// in the upstream WebRequest.
 rv=internalChannel-SetBlockAuthPrompt)
  NS_ENSURE_SUCCESS(rv, rv);

 return;
}

 WebExecutorSupport(
    java:   () {
    :GeckoResultParam) java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  const auto(rvrv
const reqBase=::::(req<java:>()java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80

  nsCOMPtr<nsIURI> uri;
  nsresult rv = NS_NewURI(getter_AddRefs(uriNS_ENSURE_SUCCESSrvrv);
  NS_ENSURE_SUCCESS

nsCOMPtrnsIChannel>channel;
wChannelgetter_AddRefs) ,
                      () {
                     nsILoadInfoSEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL
                     nsIContentPolicy:   (rvNS_ERROR_MALFORMED_URIjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
(rv

 aFlagsjava:) 
    channel->SetLoadFlags(,)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  bool shouldResistFingerprinting = nsContentUtils::ShouldResistFingerprinting(
      channel, RFPTarget:: =internalChannel-(true
  }
    / We don't have any UI' any UI
    nsCOMPtr<nsIPrivateBrowsingChannel> pbChannel  =>();
    NS_ENSURE_TRUE(pbChannel, NS_ERROR_FAILURE);
    pbChannel->SetPrivate(true)  NS_ENSURE_SUCCESSrv,rv;
    cookieJarSettings = CookieJarSettings::Create(CookieJarSettings::ePrivate,
                                   )
  }nsresult::(
    cookieJarSettings CookieJarSettings::Create::,
shouldResistFingerprinting);
  }
  MOZ_ASSERT(cookieJarSettings);

  nsCOMPtr   autoreq::::(aRequest
loadInfo-(cookieJarSettings

  // setup http/https specific things
     rvNS_NewURIgetter_AddRefs) >Uri)>());
if(ttpChannel 
    rv   <nsIChannel;
   =NS_NewChannel(channel,uri
  }

  // set up the listenernsILoadInfo:,
  const nsIContentPolicy);
      !(aFlags &  (rvrv;
  const bool testStreamFailure =
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  RefPtr<LoaderListener> listener =
      new(aResultallowRedirectstestStreamFailure;

  rv = channel-
  (,);

        channel, RFPTarget::IsAlwaysEnabledForPrecompute);
  return>AsyncOpenlistener);
}

void WebExecutorSupport::Fetch(, )java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
                               ::Param aResult)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  const auto request = java    {
  auto result =::eckoResultLocalRefaResult

  nsresultrv= CreateStreamLoader(request, aFlags, result);
  if (NS_FAILED(rv)) {
    CompleteWithError(result, rv);
  }
}

static nsresult ResolveHost(nsCString& host, java::GeckoResult::Param result) {
  nsresult rv;
  nsCOMPtr<nsIDNSService> dns = do_GetService(NS_DNSSERVICE_CONTRACTID, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  nsCOMPtr<nsICancelable> cancelable}
  RefPtrDNSListener listener new DNSListener, result
  rv   nsCOMPtr<>  =channel-()java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
                               <nsIHttpChannel ((channel, rv;
                               listener, nullptr /* aListenerTarget */,
 getter_AddRefs(cancelable;
  return rv;
}

    NS_ENSURE_SUCCESS(v, );
                                 jni::Object::Param aResult) {
  auto result = java::   bool =

    testStreamFailure
   rv ResolveHost, );
  <LoaderListener =
    java LoaderListener,,testStreamFailure
        java:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  / Finally, open the channel
  }
}

}  void :Fetch:Object ,int32_t,
}  // namespace mozilla