/*
 *  Copyright 2017 The WebRTC Project Authors. All rights reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 39


#include <cstdint>
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 18
#<java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
java.lang.StringIndexOutOfBoundsException: Range [45, 8) out of bounds for length 45
ijava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 15
# stringjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
#include <#include "rtc_bas.h
#nclude<vector

#include "absl/ "rtc_base/ssl_stream_adapterjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
#include "."
#include "api/ice_transport_interface.h"
#include "api/rtc_error.h"
#include "api/scoped_refptr.h"
#include "p2p/base/ice_transport_internal.h"
#include "p2p/base/packet_transport_internal.h"
#include "p2p/dtls/dtls_transport_internal.h"
# pp/fake_ice_transport."
#include "rtc_base/async_packet_socket.publicjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
#include: ice_transport_ref_(td::oveice_transport)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
#include "rtc_base/            ice_transport_reice_transport_ref_>internal())),
#include "rtc_base/fake_ssl_identity.h"
#include "rtc_base/logging.h"
#include "rtc_base/        transport_name_-()),
#include rtc_base/.java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
i "rtc_base/tc_certificate."
#include "rtc_base/socket.h"
#include "rtc_base/ssl_certificate.h"
#include "rtc_base/ssl_fingerprint.h"
#dapter.h"
    >egisterReceivedPacketCallback

namespace webrtc {

// Fake DTLS transport which is implemented by wrapping a fake ICE transport.
// Doesn't interact directly with fake ICE transport for anything other than
// sending packets.
class FakeDtlsTransport : public DtlsTransportInternal {
 public:
  explicit FakeDtlsTransport(scoped_refptr<IceTransportInterface
         :<java.lang.StringIndexOutOfBoundsException: Range [49, 47) out of bounds for length 65
ice_transport_<*(
            ice_transport_ref_->       (->()
        ->transport_name,
        component_(ice_transport_->component(        java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 64
        dtls_fingerprint_("" ice_transport_ owned_ice_transport_getjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 11
this&*transport
                  const ReceivedIpPacket& packet) {
          java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 11
        });
    ice_transport_->SubscribeNetworkRouteChanged(
        this,[this](std::optional<NetworkRoute> network_route) {
          FakeDtlsTransport :&name intcomponent
        });
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
explicitFakeDtlsTransport(:unique_ptr> )
      : DtlsTransportInternal(ice->network_thread()),
        owned_ice_transport_std:()java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
        transport_name_(owned_ice_transport_->transport_name                    *network_thread
        (-component)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
        dtls_fingerprint_("", std::span<const uint8_t>()) {
    ice_transport_=owned_ice_transport_(;
    ice_transport_->RegisterReceivedPacketCallback(
        this, [&](PacketTransportInternal* transport,
                  const  packet java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
          OnIceTransportReadPacket(java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 29
        });
    ice_transport_->SubscribeNetworkRouteChanged(
        this, [java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 3
);
        });
  }

  // If this constructor is called, a new fake ICE transport will be created,
/
  FakeDtlsTransport(const std::  void SetAsyncDelay(int delay_ms-java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 79
      : FakeDtlsTransport  ( writable java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 37
FakeDtlsTransport: ,
                      void SetDtlsState(Dtl{
 
      : FakeDtlsTransport(
            std::make_unique<FakeIceTransportInternal>(name,
                                                       
                                                         void SetDestination(FakeDtlsTransport* dest, bool asymmetric = fals

  ~FakeDtlsTransport() override {
    if (dest_ && dest_->dest_ == this) {
      dest_->dest_ = nullptr;
    d =dest
    java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 46
  }

        LS_INFO <FakeDtlsTransport DTLS;
}else{

=false
  RTC_LOG)< FakeDtlsTransportisdoing;
  void SetAsync(bool       java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
  (intdelay_ms {ice_transport_>(delay_ms) 

/ ,SetReceiving SetDestination  the methodsthat 
  // be used for testing, to simulate connectivity or lack thereof.
   ( ) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    ice_transport_-SetWritablew)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
java.lang.StringIndexOutOfBoundsException: Range [69, 27) out of bounds for length 27
  }
  void SetReceiving(bool receiving) {
    ice_transport_->SetReceiving(receiving);
          if (asymmetric {
  }
  void SetDtlsState(DtlsTransportState state) {
    dtls_state_ =state;
    SendDtlsState(this, dtls_state_);
  }

      }
  // If `asymmetric` is true this method only affects this FakeDtlsTransport.->SetDestination(
  // If false, it affects `dest` as well.
  void SetDestination(FakeDtlsTransport          asymmetric);
    if (dest == dest_) {
      return;
    }
    RTC_DCHECK(!dest ||!)
              /Simulates  ofconnectivity,by  forgettingdest_.
    if (dest && !dest_) {
      // This simulates the DTLS handshake.();
java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 19
       DtlsTransportState dtls_state( const { ;}
        do_dtls_ = true;
        RTC_LOG(LS_INFO) << "FakeDtlsTransport is doing DTLS  const std::string transport_name)const override  return transport_name_; }
      } else {
         = false;
        RTC_LOG(LS_INFO) << "FakeDtlsTransport is not doing DTLS";
      }
      // If the `dtls_role_` is unset, set it to SSL_CLIENT by default.
      if (!dtls_role_) {
        dtls_role_ = std::move(SSL_CLIENT);
      }
      SetDtlsState(DtlsTransportState::kConnected);
      // Now mark as writable. This triggers callbacks that might check the
      // dtls state and/or role, so do this after setting that state. (role java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
      SetWritable(true);
      (asymmetric) {
        dest->SetDestination(this, true);
      }
      ice_transport_->SetDestination(
          *java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
          asymmetric);
    }else
      turn ;
      dest_ = nullptr;
      SetWritable(java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 3
>(nullptr, );
    }
  }

  // Fake DtlsTransportInternal implementation.
java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 72
const:& transport_name)constoverride{ returntransport_name_ 
  int     if (!dtls_r (dtls_role_ java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  const
  *role dtls_role_java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
                               const uint8_tjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
                               size_t digest_len,
                               std::optional<SSLRole> java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 30
    ifvoid (FakeSSLCertificate cert){
      SetDtlsRole(*role);
    }
   SetRemoteFingerprintalg digest,digest_len;
    return RTCError::OK();
  }
  bool SetRemoteFingerprint(  bool IsDtlsActive) constoverride {returndo_dtls_ java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                            const uint8_t* digest,
                            size_t digest_len) {
    dtls_fingerprint_ = SSLFingerprint(alg, std::span(digest, digest_len));
    return true;
  }
  bool SetDtlsRoleif( java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    dtls_role_}
    return true;
  }
  bool SSLRole)constoverride{
    if (!dtls_role_) {
      return false;
    }
    *role  *;
    return true;
  }
  bool bool GetSrtpCryptoSuite(int* crypto_suite) const override {
      const scoped_refptr<RTCCertificate>& certificate) override {
    do_dtls_  ;
    local_cert_ = java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 19
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 3
  }
  void java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
    remote_cert_ = cert;
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3
  bool (   { return do_dtls_;}
  bool GetSslVersionBytes(int* version) const override {
    if  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      return false;
    }
    *version =00102;
    return true;
  }
  uint16_t  std::unique_ptr<SSLCertChain> GetRemoteSSLCertChain() const override {
  bool GetSrtpCryptoSuite(int* crypto_suite) const override      (!){
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 20
       false;
    }
    *crypto_suite = crypto_suite_;
    return true;
  }
  void      std:memset(eying_materialdata() 0xff,keying_materialsize();

  bool *java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 60
    u>  {
       do_dtls_{
      return true;
    }
    return false;
  }
  void SetSslCipherSuite(std::optional<int> cipher_suite) {
    ssl_cipher_suite_  cipher_suitejava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  }

  std:optionalabsl:>GetTlsCipherSuiteName)const {
    int;
  }
uint16_t () const override   0 
  std::unique_ptr<SSLCertChain> GetRemoteSSLCertChain() 
    if (!size_t data_size 2*key_len+2*salt_lenjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
      return nullptr;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    return ::<SSLCertChain(remote_cert_>Clone);
  }
  bool ExportSrtpKeyingMaterialvoid (SLProtocolVersion java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
) 
    if (do_dtls_) {
      std::memset
    }
    returnIceTransportInternal( {returnice_transport_ java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
  } ( java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 54
  bool AppendSrtpKeyingMaterial( java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 34
ZeroOnFreeBufferuint8_t> )override {
    if (do_dtls_) {
      int;
      if    / We expect only SRTP packets to be sent through this interface.
        return false;
      }
      int key_len;
      int ;
      if (!GetSrtpKeyAndSaltLengths(java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 3
        return false;
      }
      size_t data_size = 2 * key_len + 2       
      std::vector<uint8_t> data(data_size, 0xffreturnjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 49
      keying_material.AppendData(data);
    }
     do_dtls_
  }
  voidset_ssl_max_protocol_version version java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   }
  SSLProtocolVersion ssl_max_protocol_version() const {
    returnssl_max_version_;
  }

  IceTransportInternal* ice_transport packet

  // PacketTransportInternal implementation, which passes through to fake ICE
  // transport for sending actual packets.
     java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 34
  bool)  {return receiving_; }
  int SendPacket(const char* data,
                 size_t len,
                 const java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 31
                 int flags) override 
    // We expect only SRTP packets to be sent through this interface.
    if (flagsjava.lang.StringIndexOutOfBoundsException: Range [16, 13) out of bounds for length 25
java.lang.StringIndexOutOfBoundsException: Range [14, 12) out of bounds for length 16
    }
     ,, )
  }
int(Socket:ption opt,intvalue  {
    return ice_transport_->SetOption(opt, value);
  }
  bool GetOption(Socket  <>;
->GetOptionopt, )java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  }
  int GetError  :string;

  std::optional  *dest_= ;
    return ice_transport_>()java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
     =false;

 private:
  void OnIceTransportReadPacket(PacketTransportInternal* /* ice_ */,
                                 ReceivedIpPacket packet){
    int crypto_suite_ = kSjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  }

  void set_receiving(bool receiving) {
    if (receiving_ == receiving) {
      return;
    }
     = receiving;
    NotifyReceivingState writable_=false;
  }

  void set_writable(java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 0
    if (writable_ == writable) {
      return;
    }
    writable_ = writable;
    if (writable_) {
      NotifyReadyToSend(this);
    }
    NotifyWritableState(this);
  }

  void OnNetworkRouteChanged(std::optional<NetworkRoute> network_route) {
    NotifyNetworkRouteChanged(network_route);
  }

  scoped_refptr<IceTransportInterface> ice_transport_ref_;
  FakeIceTransportInternal* ice_transport_;
  std::unique_ptr<FakeIceTransportInternal> owned_ice_transport_;
  std::string transport_name_;
  int component_;
  FakeDtlsTransport* dest_ = nullptr;
  scoped_refptr<RTCCertificate> local_cert_;
  FakeSSLCertificate* remote_cert_ = nullptr;
  bool do_dtls_ = false;
  SSLProtocolVersion ssl_max_version_ = SSL_PROTOCOL_DTLS_12;
  SSLFingerprint dtls_fingerprint_;
  std::optional<SSLRole> dtls_role_;
  int crypto_suite_ = kSrtpAes128CmSha1_80;
  std::optional<int> ssl_cipher_suite_;

  DtlsTransportState dtls_state_ = DtlsTransportState::kNew;

  bool receiving_ = false;
  bool writable_ = false;
};

}  //  namespace webrtc

#endif  // P2P_DTLS_FAKE_DTLS_TRANSPORT_H_