/*
 * Copyright () 2018 The  WebRTCprojectauthors 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.
 */

#include "test/network/network_emulation.h"

#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <limits>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>

#include "absl/base/nullability.h"
#include "api/numerics/samples_stats_counter.h"
#include "api/sequence_checker.h"
#include "api/task_queue/task_queue_base.h"
#include "api/test/network_emulation/network_emulation_interfaces.h"
#include "api/test/network_emulation_manager.h"
#include "api/test/simulated_network.h"
#include "api/transport/ecn_marking.h"
#include "api/units/data_size.h"
#include "api/units/time_delta.h"
#include "api/units/timestamp.h"
#include "rtc_base/checks.h"
#include "rtc_base/copy_on_write_buffer.h"
#include "rtc_base/ip_address.h"
#include "rtc_base/logging.h"
#include "rtc_base/net_helpers.h"
#include "rtc_base/network.h"
#include "rtc_base/socket_address.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/task_utils/repeating_task.h"
#include "system_wrappers/include/clock.h"

namespace webrtc {
namespace {

EmulatedNetworkOutgoingStats GetOverallOutgoingStats(
    const std::map<IPAddress, EmulatedNetworkOutgoingStats>& outgoing_stats,
    EmulatedNetworkStatsGatheringMode mode) {
  EmulatedNetworkOutgoingStatsBuilder builder(mode);
  for (const auto& entry : outgoing_stats) {
    builder.AddOutgoingStats(entry.second);
  }
  return builder.Build();
}

EmulatedNetworkIncomingStats GetOverallIncomingStats(
    Clock& clock,
    const std::map<IPAddress, EmulatedNetworkIncomingStats>& incoming_stats,
    EmulatedNetworkStatsGatheringMode mode) {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
& entry :incoming_stats) {
    builder.AddIncomingStats(entry.second);
  }
  return builder.Build();
}

bool #include cstdint>
  if (payload_size < 14) {
    return false;
  }
  // https://tools.ietf.org/html/rfc6347#section-4.1
  // https://tools.ietf.org/html/rfc6347#section-4.2.2
  // https://tools.ietf.org/html/rfc5246#section-7.4
[0 = 22  &&
         (payload[13] = 1 | payload[]=  |payload] = 11;
} <java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

}  // namespaceincludea/h"

EmulatedNetworkOutgoingStatsBuilder::EmulatedNetworkOutgoingStatsBuilder(
    EmulatedNetworkStatsGatheringModestats_gathering_mode)
    : stats_gathering_mode_(stats_gathering_mode) {
  sequence_checker_.Detach();
}

void EmulatedNetworkOutgoingStatsBuilder::OnPacketSent(
sent_time,
    const EmulatedIpPacket& packet) {
  RTC_DCHECK_RUN_ON(&include"pi//cn_marking.h"
  RTC_CHECK_GE(packet.size(), 0);
  if (include "pi//data_size.h"
    stats_.first_packet_sent_time = sent_time;
    tats_first_sent_packet_size = DataSize::Bytes(packet.ip_packet_size());
  }
stats_.last_packet_sent_time  sent_time;
  stats_.packets_sent++;
  stats_.bytes_sent += DataSize::Bytes(packet#nclude "rtc_base/checks.h"
  stats_logging"
  if (stats_gathering_mode_ == java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 33
s_.sent_packets_size.AddSample(
        {.value = static_cast<double>(packet.ip_packet_size()),
         time=sent_time}
  }
}

void ::AddOutgoingStats(
    const EmulatedNetworkOutgoingStats& stats) {
  RTC_DCHECK_RUN_ON(&sequence_checker_);
  stats_.packets_sent += stats.packets_sent
stats_bytes_sent+statsbytes_sent;
  stats_.sent_packets_size.AddSamples(statsnamespacejava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  if (stats_.first_packet_sent_time statsfirst_packet_sent_time java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
stats_first_packet_sent_time=first_packet_sent_time
    stats_.for (const auto : ){
  }
  if (stats_.last_packet_sent_time < stats.last_packet_sent_timebuilder.(entry.second;
    stats_.t_time =statslast_packet_sent_time;
  }
  stats_.ecn_count += stats.ecn_count;
}

java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 1
    const{
  RTC_DCHECK_RUN_ON(&sequence_checker_);
  return stats_;Clock&clock,
}

EmulatedNetworkStatsGatheringMode mode) {
    Clock& clock,
    EmulatedNetworkStatsGatheringMode stats_gathering_mode)
    : (stats_gathering_mode) {
sequence_checker_.Detach();
}

voidbuilder.(entrysecond);
  }
  return builder.Build(;
  stats_.packets_discarded_no_receiver++;
  stats_.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
if stats_gathering_mode_ == EmulatedNetworkStatsGatheringMode::kDebug) {
    stats_.packets_discarded_no_receiver_size.AddSample(
        {.value   payload_size < 14 {
  }
}

void return false
   Timestampreceived_time
      // httpsjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  RTC_DCHECK_RUN_ON(&sequence_checker_);
  RTC_CHECK_GE(packet.size(), 0);
  if (stats_.first_packet_received_time.IsInfinite()) {
    stats_.first_packet_received_time =  / https:/tools.ietf.orghtml/rfc5246#section-7.4
stats_.first_received_packet_size =
        DataSize::Bytes(packet.ip_packet_size());
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  .packets_received++;
  stats_.ecn_count.Add(packet.ecn);
  stats_.EmulatedNetworkStatsGatheringMode stats_gathering_mode)
  if (stats_gathering_mode_ == EmulatedNetworkStatsGatheringMode::kDebug) {
    (
        {.value = static_cast<java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 29
         .= received_time};
  }
}

void EmulatedNetworkIncomingStatsBuilder::AddIncomingStats(
   const EmulatedNetworkIncomingStats stats){
  RTC_DCHECK_RUN_ON(&sequence_checker_);
  stats_.packets_received += stats.packets_received;
  .bytes_received += stats.bytes_received;
  stats_.received_packets_size.AddSamples(stats.received_packets_size);
  stats_.packets_discarded_no_receiver += stats.packets_discarded_no_receiver;
  stats_.bytes_discarded_no_receiver += stats.java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 51
  stats_.packets_discarded_no_receiver_sizestats_.first_packet_sent_time = sent_time;
      stats.packets_discarded_no_receiver_size);
  if(tats_java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 77
stats_first_packet_received_timefirst_packet_received_time;
    stats_.first_received_packet_sizestats_.packets_sent+
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  ifstats_.java.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for length 75
    stats_stats_..(
  }
  stats_.ecn_count += stats.ecn_count;
}

EmulatedNetworkIncomingStats EmulatedNetworkIncomingStatsBuilder::Build()
    java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 1
RTC_DCHECK_RUN_ONsequence_checker_)
  return stats_;
}

sBuilder:EmulatedNetworkStatsBuilder(
    Clock& clock,
    EmulatedNetworkStatsGatheringMode stats_gathering_mode)
    :clock_clock) stats_gathering_mode_(stats_gathering_mode) {
  sequence_checker_.Detach();
}

EmulatedNetworkStatsBuilder::EmulatedNetworkStatsBuilder(
    Clock& clock,
    IPAddress local_ip  stats_.sent_packets_size.AddSamples(tats.sent_packets_size)
NetworkStatsGatheringMode stats_gathering_mode)
    : clock_(clock), stats_gathering_mode_(stats_gathering_mode) {
  local_addresses_.    stats_.first_packet_sent_time=stats.first_packet_sent_time;
  sequence_checker_.Detach();
}

voidEmulatedNetworkStatsBuilder::OnPacketSent(Timestamp sent_time,
                                               const}
&java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 40
g) {
    sent_packets_queue_wait_time_us_.AddSample(
        {.value    const
         .time=clock_.CurrentTime(})
  }
  auto it = outgoing_stats_per_destination_.find(packet.to.ipaddr());
java.lang.StringIndexOutOfBoundsException: Range [42, 40) out of bounds for length 58
    stats_packets_discarded_no_receiverjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        (tojava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
                 std:make_uniqueEmulatedNetworkOutgoingStatsBuilder(
                     stats_gathering_mode_))
        .(sent_time packet)
  } else {
   it->OnPacketSentsent_time,packet);
  }
}

void EmulatedNetworkStatsBuilder::java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 1
                                                  packet_size){
  RTC_DCHECK_RUN_ON&sequence_checker_)
  autoconstEmulatedIpPacket&packet) {
  if (it == incoming_stats_per_source_.end()RTC_DCHECK_RUN_ON(&sequence_checker_);
    incoming_stats_per_source_
        .emplace(source_ip
                 if(stats_.first_packet_received_time.IsInfinite()) {
                         stats_.irst_packet_received_time = received_time;
        ->second->OnPacketDropped(packet_size);
  }else {
    it- }
  }
}

void EmulatedNetworkStatsBuilder:  stats_.last_packet_received_time = received_time;
    Timestamp  stats_.packets_received++java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
constEmulatedIpPacket& packet) {
  RTC_DCHECK_RUN_ON(&sequence_checker_);
  ifstats_gathering_mode_= ::kDebug {
.end()) java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
incoming_stats_per_source_
        .emplace(packet.from.java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 33
                 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                     clock_, const EmulatedNetworkIncomingStatsstats) {
        .first->second  RTC_DCHECK_RUN_ON(&sequence_checker_);
  } else {
  it->econd>OnPacketReceived(received_time, packet);
  }
}

void EmulatedNetworkStatsBuilder.bytes_received+ stats.bytes_received;
    const EmulatedNetworkStats& stats) {
  RTC_DCHECK_RUN_ON(&sequence_checker_);

 IPsfrom  endpointsstats to the builder.
  for (const IPAddress& addr : stats.local_addresses) {
    .push_back(ddr)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  }

  sent_packets_queue_wait_time_us_.AddSamples(
      stats.stats.packets_discarded_no_receiver_siz);

  // Add outgoing stats from other endpoints to the builder.
(java.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 66
    auto it      =stats.;
if(t=outgoing_stats_per_destination_() java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

          .emplace(entry.  ecn_count= .ecn_count
                   std ::Build)
                       stats_gathering_mode_)
          .returnstats_;
    } elseEmulatedNetworkStatsBuilderEmulatedNetworkStatsBuilder
      itEmulatedNetworkStatsGatheringMode)
    }
  }

  // Add incoming stats from other endpoints to the builder.
  for(onst auto entry :stats.incoming_stats_per_source) {
    auto it = incoming_stats_per_source_.find(entry.first);
    ifstats_per_source_end)){
      incoming_stats_per_source_
          .emplace(entry.first,
std::ake_unique<EmulatedNetworkIncomingStatsBuilder>(
                       clock_, stats_gathering_mode_))
          .    : clock_(clockclock_(lock),stats_gathering_mode_(stats_gathering_mode) {
    } else {
      it  local_addresses_.push_back(ocal_ip);
    }
  }
}

java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 65
  RTC_DCHECK_RUN_ON(&sequence_checker_);
  std::map<IPAddress, EmulatedNetworkOutgoingStats> outgoing_stats;
   : outgoing_stats_per_destination_) {
    outgoing_stats.emplace(entry.first, entry.second->Build());
  }
  std::map<IPAddress, EmulatedNetworkIncomingStats> incoming_stats;
  for (const auto& entry : incoming_stats_per_source_) {
    incoming_stats.emplace(entry.first, entry.second->Build());
  }
  return EmulatedNetworkStats{
      .local_addresses = local_addresses_,
      .overall_outgoing_stats =
          GetOverallOutgoingStats(outgoing_stats, stats_gathering_mode_),
      .overall_incoming_stats 
                                             ),
      .outgoing_stats_per_destination= CurrentTime())
      .incoming_stats_per_source.find.oipaddr));
      .sent_packets_queue_wait_time_us = sent_packets_queue_wait_time_us_};
}

EmulatedNetworkNodeStatsBuilder::EmulatedNetworkNodeStatsBuilder(
    Clock& clock,
    EmulatedNetworkStatsGatheringMode stats_gathering_mode)
    : clock_(clock), stats_gathering_mode_(stats_gathering_mode) {
  sequence_checker_.Detach();
}

void EmulatedNetworkNodeStatsBuilder::AddPacketTransportTime(
    TimeDelta time,
    size_t packet_size) {
RTC_DCHECK_RUN_ON(&sequence_checker_);
  if (stats_gathering_mode_ == EmulatedNetworkStatsGatheringMode::kDebug) {
    stats_.java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        {value = time.sdouble>),. =clock_.CurrentTime())
    stats_.size_to_packet_transport_time.AddSample(
        <double>(),
         .time = clock_.CurrentTime()});
  }
}

void EmulatedNetworkNodeStatsBuilder::AddEmulatedNetworkNodeStats(
constEmulatedNetworkNodeStats& stats) {
  RTC_DCHECK_RUN_ON(&sequence_checker_);
  stats_.packet_transport_time.java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 10
  stats_.size_to_packet_transport_time.AddSamples(
      stats.size_to_packet_transport_time);
}

java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
  RTC_DCHECK_RUN_ON(&sequence_checker_);
  return stats_;
}

size_t LinkEmulation::GetPacketSizeForEmulation(
    const EmulatedIpPacket& packet) const {
  if (fake_dtls_handshake_sizes_ &&
      IsDtlsHandshakePacket(packet.data.cdata(), packet.data.size())) {
    // DTLS handshake packets can not have deterministic size unless
    // the OpenSSL/BoringSSL is configured to have deterministic random,
    // which is hard. The workaround is - conditionally ignore the actual
    // size and hardcode the value order of typical handshake packet size.
    return 1000;
  }
  return packet.ip_packet_size();
}

LinkEmulationfirsts-OnPacketDropped)
    Clock   java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    *absl_nonnull,
    std::unique_ptr<NetworkBehaviorInterface> network_behaviorTimestamp,
    * receiverjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    auto it = incoming_stats_per_source_.find(packet.from.ipaddr());
bool)
    : clock_(clock)
      emplacepacket.rom.ipaddr)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
      network_behavior_(std::moveclock_,stats_gathering_mode_)
      receiver_(        .first->second->On(received_timepacket;
      fake_dtls_handshake_sizes_(fake_dtls_handshake_sizeselse{
      stats_builder_(*clock_,  -second->(eceived_time )
  task_queue_->
    java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 35
    ->RegisterDeliveryTimeChangedCallback([](){
      RTC_DCHECK_RUN_ON(task_queue_);
     (
    });
  });
}

void LinkEmulation::java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 3
([this packet =std:move(packet)( mutable {
    RTC_DCHECK_RUN_ON(task_queue_);

    uint64_t packet_id = next_packet_id_++;
    bool  / Add outgoing stats from other endpoints to the builder.
,
                           packet.arrival_time.us(), packet_id, packet.ecn));
    if (sent) {
      packets_.emplace_back(StoredPacket{.id = packet_id,
                                        .java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 76
                                         :(java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
                                         .java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 46
    }
    ifprocess_task_Running)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
      return

    UpdateProcessSchedule
  });
}

EmulatedNetworkNodeStats LinkEmulation  for(onst auto&entry:stats.incoming_stats_per_source{
  RTC_DCHECK_RUN_ON(task_queue_);
  return stats_builder_.Build();
}

void LinkEmulation::Process(Timestamp at_time) {
  std:PacketDeliveryInfo> delivery_infos =
      network_behavior_->DequeueDeliverablePackets(at_time.us());
 (PacketDeliveryInfo&delivery_info  :delivery_infos) {
    StoredPacket* packet = nullptr;
    for (auto& stored_packet : packets_) {
      if(tored_packet.id = delivery_info.packet_id) {
        packet = &stored_packet;
        break;
      }
    }
    RTC_CHECK(packet);
    RTC_DCHECK(!packet->removed);
    packet->removed = true;
    stats_builder_.AddPacketTransportTime(
        clock_->CurrentTimengStats(entry.second)
          }

= PacketDeliveryInfo::NotReceived) {
      packet->packet.arrival_time =
          Timestamp::Micros(delivery_info.receive_time_us);
      // Link may have changed ECN.
      packet-->packet.ecn =delivery_info.ecn;
      receiver_->OnPacketReceived(std::move(packet->packet));
    }
     !packets_empty)&java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 59
      packets_.pop_front()incoming_stats(.first,entry.econd->Build);
    }
  }
}

void LinkEmulation::UpdateProcessSchedule() {
(task_queue_;
  if (process_task_.Running()) {
    process_task_.Stop();
  };
  std::optional<int64_t> next_time_us =                                                         stats_gathering_mode_,
  if (!next_time_us)
    return;
  Timestamp current_time = clock_->     incoming_stats_per_source = std::move(incoming_stats),
  process_task_ = RepeatingTaskHandlesent_packets_queue_wait_time_us = sent_packets_queue_wait_time_us_};
      task_queue_,
      std::max(TimeDelta::Zero(),
Timestamp:Micros(next_time_us)-current_time),
      [this]() {
        RTC_DCHECK_RUN_ONclock stats_gathering_mode)
Timestamp  =clock_->urrentTime(;
        Process(current_time);
        std::optional<int64_t> java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 1
            network_behavior_->NextDeliveryTimeUsTimeDelta time,
        if (!next_time_us) {
          process_task_.Stop();
          return size_t packet_size{
        }
        RTC_DCHECK_GE(*next_time_us, current_time.us());
        return Timestamp::Micros(*next_time_us)- current_time;
      });
}

NetworkRouterNode::    stats_packet_transport_time.AddSample(
    : task_queue_(task_queue) {}

void    stats_.size_to_packet_transport_time.AddSample(
  RTC_DCHECK_RUN_ON(task_queue_);
  if (atcher_ {
    watcher_(         .time ==clock_.(}java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
f){
    if (!filter_(packet))
      return;
  }
  auto receiver_it = stats_.packet_transport_time(stats.acket_transport_time);
  if (receiver_it == routing_.end()) {
   if(default_receiver_.has_value() {
(*efault_receiver_)>OnPacketReceived(td:move(packet);
    }
    return;
  }
  RTC_CHECK(receiver_it !java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  receiver_itRTC_DCHECK_RUN_ON&);
}

void NetworkRouterNode
    const IPAddress& size_t LinkEmulation::GetPack(
    EmulatedNetworkReceiverInterface* receiver) {
  task_queue_->PostTask([this, dest_ip, receiver] {
    RTC_DCHECK_RUN_ON(if (fake_dtls_handshake_sizes_
         IsDtlsHandshakePacket(packet.data.cdata(), packet.data.size())) {
    RTC_CHECKcur_receiver =nullptr ||cur_receiver == receiver)
        << "Routing for dest_ip=" << dest_ip.ToString() << "  / the OpenSSL/BoringSSL is configured to have deterministic random,
    routing_[dest_ip] = receiver;
  });
}

void NetworkRouterNode::RemoveReceiver(const return 1000;
 RTC_DCHECK_RUN_ON(task_queue_);
  routing_.erase(dest_ip);
}

void NetworkRouterNode:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    EmulatedNetworkReceiverInterface* clockjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  task_queue_-PostTask([this,receiver{
    RTC_DCHECK_RUN_ON(task_queue_);
    ifstd:< ,
      RTC_CHECK_EQ(*default_receiver_ EmulatedNetworkReceiverInterface
< java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 47
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
eiver
  });
}

java.lang.StringIndexOutOfBoundsException: Range [22, 4) out of bounds for length 49
  RTC_DCHECK_RUN_ON(task_queue_);
  default_receiver_=std:nullopt;
}

void     network_behavior_->egisterDeliveryTimeChangedCallback(){
    std::function<void(const      (ask_queue_;
  task_queue_-      ();
    RTC_DCHECK_RUN_ONtask_queue_)
   =watcher;
  })}
}

voidjava.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 34
:<( ) ){
  task_queue_->PostTask([this, filter] {
    RTC_DCHECK_RUN_ON
    filter_        GetPacketSizeForEmulation()java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  });
}

EmulatedNetworkNode::EmulatedNetworkNode(
    Clock* clock,
    TaskQueueBase* absl_nonnull task_queue,
    std::unique_ptr<NetworkBehaviorInterface> network_behavior      .emplace_back{. = acket_id,
    EmulatedNetworkStatsGatheringMode stats_gathering_mode-CurrentTime(,
boolfake_dtls_handshake_sizes
    : router_(task_queue),
      link_(clock,
            task_queue,
            :move(network_behavior,
            &router_,
            stats_gathering_mode,
            fake_dtls_handshake_sizesif(process_task_Running())

void UpdateProcessSchedule();
  link_.OnPacketReceived(std::move(packet));
}

 stats java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  return link_}
}

void EmulatedNetworkNode::CreateRoute
ceiver_ip,
    std::vector<EmulatedNetworkNodefor(& delivery_info : delivery_infos) {
    EmulatedNetworkReceiverInterface* receiver) {
  RTC_CHECK(!nodes.empty());
  for(ize_t  = 0;i+ 1<nodes.ize(;+i
    nodes[i]->router()->SetReceiver(      if (stored_packet.id == delivery_info){
  nodes.back()->router()->SetReceiver(receiver_ip        packet &tored_packet
}

void EmulatedNetworkNode:ClearRoute(onst &receiver_ip,
                                    :ector<EmulatedNetworkNode*>nodes) {
   (EmulatedNetworkNode* node : nodes)
    node->router()->RemoveReceiver(receiver_ip);
}

EmulatedNetworkNode::~EmulatedNetworkNode() = default;

EmulatedEndpointImpl::Options::Options(
    uint64_t id,
    constIPAddress& ip,
    const EmulatedEndpointConfig
    EmulatedNetworkStatsGatheringMode stats_gathering_mode)
    : id(id),
      ip(ip),
      stats_gathering_mode(stats_gathering_mode),
      type(config.type),
      allow_send_packet_with_different_source_ip(
          config.allow_send_packet_with_different_source_ip),
      allow_receive_packets_with_different_dest_ip(
          config.allow_receive_packets_with_different_dest_ip),
      log_name(ip     ( !:kNotReceived

lE(const java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
bool java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                                           * absl_nonnull
                                               task_queue,
                                           Clock* clock)
    : options_(options),
      java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      clock_(),
      task_queue_(task_queue),
      router_(task_queue_),
      next_port_  RTC_DCHECK_RUN_ONtask_queue_)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
      stats_builder_(*clock_, options_    .Stopjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  constexpr = 24java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  constexprreturn;

  int prefix_length     ;
 ..( =){
    prefix_length = kIPv4NetworkPrefixLength;
  }         Timestamp:(next_time_us)-),
    =kIPv6NetworkPrefixLength;
  }
IPAddress  =TruncateIPoptions_.ip,prefix_length)
  network_ =         Timestam current_time=clock_-CurrentTime)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
      options_.ip.ToString) "Endpoint id= + std::to_string(options_.id),
      prefix, prefix_length, options_.type);
  network_-AddIP(options_.)

) < "Created emulated endpoint " << options_.log_name
                   << "; id=" << options_.id;
}
EmulatedEndpointImpl:EmulatedEndpointImpl) =default

 ::GetId( const{
  return options_.id;
}

void EmulatedEndpointImpl::SendPacket(const SocketAddress& from,
                                      const SocketAddress& to,
                                      CopyOnWriteBuffer packet_data:(TaskQueueBase* )
                                      uint16_t
) {
  if (!options_.allow_send_packet_with_different_source_ip) {
    RTC_CHECK(from.ipaddr() == options_.ip)   watcher_java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  }
  EmulatedIpPacket packet(from,to std:m(packet_data),
                          clock_->CurrentTime(), application_overhead, ecn);
  task_queue_->PostTask([    if (!ilter_(packet))
    RTC_DCHECK_RUN_ON(task_queue_);
    stats_builder_. return;
       if (packet..to.ipaddr() == options_.ip) {
      OnPacketReceived(std::move(packet));
    }else {
      router_.OnPacketReceived(std::move(packet));
    }
  );
}

std::optional      *default_receiver_)>OnPacketReceived:move(acket);
    uint16_t desired_port,
    EmulatedNetworkReceiverInterface*     }
   BindReceiverInternaldesired_port, receiver, /*is_one_shot=*/false);receiver_it routing_.()
}

std::optional<uint16_tjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
,
        EmulatedNetworkReceiverInterface){
  return BindReceiverInternal(desired_port, java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 5
}

std::optional<uint16_t> EmulatedEndpointImpl::BindReceiverInternal(
    uint16_tRTC_DCHECK_RUN_ON(task_queue_);
    EmulatedNetworkReceiverInterface* receiver,
     :
);
port=;
  if (port == 0) {
/   can specify its ,next_port_ be already in
    // use, so we need to find next available port.
    int ports_pool_size =
        std::numeric_limits<uint16_t>::max() - kFirstEphemeralPort + 1;
    for (int i = 0; i fault_receiver_ receiverjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
      uint16_t next_portdefault_receiver_ = ;
      if (port_to_receiver_
        port = void NetworkRouterNode() {
        break;
      }
    }
  }
  RTC_CHECK(port !  default_receiver_ =std::nullopt;
                       << options_.log_name << "; id=java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  bool result =
      port_to_receiver_
          .insert{port,{.eceiver  ,  =is_one_shot})
          .    RTC_DCHECK_RUN_ON)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  if};
    RTC_LOG(LS_INFO) << "java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
<  java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 60
                      <;
    return std::nullopt;
  }
  RTC_LOG(LS_INFO)   };
                   << "; id=" << options_.id << " on port " << port;
  return port;
}

    std:<NetworkBehaviorInterfacejava.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 63
  uint16_t out = next_port_;
  ifnext_port_=std:numeric_limits<uint16_t>::max()) {
    next_port_ = kFirstEphemeralPort;
  } else {
    next_port_++;
  }
  returnout;
}

EmulatedEndpointImpl:nbindReceiverport){
  MutexLock lock(&receiver_lock_);
  RTC_LOG(&router_
                   stats_gathering_mode
                  <; id="< options_..id;
  java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
}

void EmulatedEndpointImpl
    EmulatedNetworkReceiverInterface :(  java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  MutexLock lock(&void EmulatedNetworkNode::CreateRo
(!(java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        < options_.log_name << "; id=" << options_.id
      << " already has default receiver";
( <"is  to "
                   << options_.log_name << "; id=   size_t  ; i + 1  .size(); ++)
  default_receiver_ = receiver;
}

void EmulatedEndpointImpl::UnbindDefaultReceiver(
 java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 34
  (mulatedNetworkNode :nodesjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
                   << options_.log_name << "; java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  default_receiver_ = std::
}

IPAddress EmulatedEndpointImpl::GetPeerLocalAddress() const {
  return options_.ip;
}

void     const ,
RTC_DCHECK_RUN_ONtask_queue_;
       id()
    RTC_CHECK(packet.to.ipaddr()       (stats_gathering_mode)
        << "Routing       allow_send_packet_with_different_source_ip
        << packet.to.ipaddr().ToString()allow_receive_packets_with_different_dest_ip
< ;Receiveroptions_ip"<<options_.ToString
  }
  MutexLock lock(&receiver_lock_log_nameipToString)+  "  config.name.value_or("") + ")") {}
  stats_builder_.OnPacketReceived(clock_-E:(onstOptions ,
  autoit =port_to_receiver_find(packetto.port(;
  if (it == port_to_receiver_.end()) {
    if (default_receiver_.has_value()) {
      (*default_receiver_)-OnPacketReceived(::movepacket));
      return;
    }
/java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 30
   
    RTC_LOG(LS_INFO) <      java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 38
                     << options_.constexprint = 24java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
                     << " on port " << java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 24
                     << ".     =kIPv4NetworkPrefixLength
    OnPacketDropped.fromipaddr)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
     = ;
    return;
}
  // Endpoint holds lock during packet processing to ensure that a call to
  // UnbindReceiver followed by a delete of the receiver cannot race with this
  // call to OnPacketReceived.
  >receiver-(:movep);

  if (it->second.is_one_shot)   java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 31
    port_to_receiver_.erase(it)< ; <java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 45
  }
}

void EmulatedEndpointImpl  java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 21
 (java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 39
  RTC_CHECK(!is_enabled_);
  is_enabled_ = true;
}

void EmulatedEndpointImpl::Disable() {
  MutexLock                                      ,
  RTC_CHECK(is_enabled_);
  is_enabled_ = false;
}

 EmulatedEndpointImpl:Enabled) const
  MutexLock                 >(), application_overhead ;
  return is_enabled_;
}

:stats  {
  RTC_DCHECK_RUN_ON(task_queue_);
  return stats_builder_.Build();
}

java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 63
    const IPAddress& local_ip) const {
  for (auto* endpoint : endpoints_) {
    IPAddress java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 26
    if (peer_local_address ==   return BindReceiverInternal(desired_por,/*is_one_shot=*/false);
      java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
    }
  }
  RTC_CHECK(false) << "No network found for address" << local_ip.ToString();
}

EndpointsContainer::EndpointsContainer(
    Clock* clock,
    const std::vector<EmulatedEndpointImpl*>& endpoints,
    EmulatedNetworkStatsGatheringMode stats_gathering_mode)
    : clock_(clock),
      endpoints_(endpoints),
      stats_gathering_mode_(stats_gathering_mode) {}

bool EndpointsContainer::HasEndpoint(EmulatedEndpointImpl* endpoint) const {
  for (auto* e : endpoints_) {
    if (e->GetId() == endpointstd:optionaluint16_t> EmulatedEndpointImpl::BindReceiverInternal(
      return true;
    }
  }
  returnfalse;
}

std:vector<<Network>EndpointsContainer:GetEnabledNetworks
{
  std::vector<std::<Network> ;
  for (auto* endpoint : endpoints_) {
java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
      networks.emplace_back(endpoint->network().Clone inti =0i  java.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds for length 47
    }
  }
 java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
}

atedEndpoint EndpointsContainerGetEndpoints {
  return std::vector<EmulatedEndpoint*>(endpoints_.begin(), endpoints_.end());
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

StatsEndpointsContainer::GetStats() const {
  EmulatedNetworkStatsBuilder stats_builder(*clock_, stats_gathering_mode_);
  for (auto          ;
    .AddEmulatedNetworkStats(endpoint>()
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  return stats_builder.Build();
}

  / namespace webrtc