path
stringlengths 9
117
| type
stringclasses 2
values | project
stringclasses 10
values | commit_hash
stringlengths 40
40
| commit_message
stringlengths 1
137
| ground_truth
stringlengths 0
2.74k
| main_code
stringlengths 102
3.37k
| context
stringlengths 0
14.7k
|
|---|---|---|---|---|---|---|---|
aioquic.quic.packet_builder/QuicPacketBuilder._end_packet
|
Modified
|
aiortc~aioquic
|
74eaefda6dbd77eb3b393ab175f8aea3262b8961
|
[packet builder] pad all client datagrams containing INITIAL packets
|
<2>:<del>
<3>:<del> Returns `True` if the packet contains data, `False` otherwise.
<6>:<del> empty = True
<8>:<add> if packet_size > self._header_size or (self._datagram_padding and final):
<add> if self._is_client and self._packet_type == PACKET_TYPE_INITIAL:
<add> self._datagram_padding = True
<del> if packet_size > self._header_size:
<9>:<del> empty = False
<12>:<add> if self._datagram_padding and final:
<del> if self._pad_first_datagram:
<23>:<del> self._pad_first_datagram = False
|
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
+ def _end_packet(self, final: bool) -> None:
- def _end_packet(self) -> bool:
<0> """
<1> Ends the current packet.
<2>
<3> Returns `True` if the packet contains data, `False` otherwise.
<4> """
<5> buf = self.buffer
<6> empty = True
<7> packet_size = buf.tell() - self._packet_start
<8> if packet_size > self._header_size:
<9> empty = False
<10>
<11> # pad initial datagram
<12> if self._pad_first_datagram:
<13> if self.remaining_space:
<14> buf.push_bytes(bytes(self.remaining_space))
<15> packet_size = buf.tell() - self._packet_start
<16> self._packet.in_flight = True
<17>
<18> # log frame
<19> if self._quic_logger is not None:
<20> self._packet.quic_logger_frames.append(
<21> self._quic_logger.encode_padding_frame()
<22> )
<23> self._pad_first_datagram = False
<24>
<25> # write header
<26> if self._packet_long_header:
<27> length = (
<28> packet_size
<29> - self._header_size
<30> + PACKET_NUMBER_SEND_SIZE
<31> + self._packet_crypto.aead_tag_size
<32> )
<33>
<34> buf.seek(self._packet_start)
<35> buf.push_uint8(self._packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
<36> buf.push_uint32(self._version)
<37> buf.push_uint8(len(self._peer_cid))
<38> buf.push_bytes(self._peer_cid)
<39> buf.push_uint8(len(self._host_cid))
<40> buf.push_bytes(self._host_cid)
<41> if (self._packet_type & PACKET_TYPE_MASK) == PACKET_TYPE</s>
|
===========below chunk 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
+ def _end_packet(self, final: bool) -> None:
- def _end_packet(self) -> bool:
# offset: 1
buf.push_uint_var(len(self._peer_token))
buf.push_bytes(self._peer_token)
buf.push_uint16(length | 0x4000)
buf.push_uint16(self._packet_number & 0xFFFF)
else:
buf.seek(self._packet_start)
buf.push_uint8(
self._packet_type
| (self._spin_bit << 5)
| (self._packet_crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1)
)
buf.push_bytes(self._peer_cid)
buf.push_uint16(self._packet_number & 0xFFFF)
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
buf.seek(self._packet_start + packet_size)
buf.push_bytes(bytes(padding_size))
packet_size += padding_size
self._packet.in_flight = True
# log frame
if self._quic_logger is not None:
self._packet.quic_logger_frames.append(
self._quic_logger.encode_padding_frame()
)
# encrypt in place
plain = buf.data_slice(self._packet_start, self._packet_start + packet_size)
buf.seek(self._packet_start)
buf.push_bytes(
self._packet_crypto.encrypt_packet(
plain[0 : self._header_size],
plain[self._header_size : packet_size],
self._packet_number,
)
)
self._packet.sent_</s>
===========below chunk 1===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
+ def _end_packet(self, final: bool) -> None:
- def _end_packet(self) -> bool:
# offset: 2
<s>header_size : packet_size],
self._packet_number,
)
)
self._packet.sent_bytes = buf.tell() - self._packet_start
self._packets.append(self._packet)
if self._packet.in_flight:
self._datagram_flight_bytes += self._packet.sent_bytes
# short header packets cannot be coallesced, we need a new datagram
if not self._packet_long_header:
self._flush_current_datagram()
self._packet_number += 1
else:
# "cancel" the packet
buf.seek(self._packet_start)
self._packet = None
self.quic_logger_frames = None
return not empty
===========unchanged ref 0===========
at: aioquic.quic.packet_builder
PACKET_NUMBER_SEND_SIZE = 2
at: aioquic.quic.packet_builder.QuicPacketBuilder.__init__
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
self._is_client = is_client
self._peer_cid = peer_cid
self._peer_token = peer_token
self._quic_logger = quic_logger
self._spin_bit = spin_bit
self._version = version
self._datagram_flight_bytes = 0
self._datagram_padding = False
self._packets: List[QuicSentPacket] = []
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.quic.packet_builder.QuicPacketBuilder.flush
self._packets = []
at: aioquic.quic.packet_builder.QuicPacketBuilder.start_packet
buf = self.buffer
self._datagram_flight_bytes = 0
self._datagram_padding = False
self._header_size = header_size
self._packet = QuicSentPacket(
epoch=epoch,
in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
packet_type=packet_type,
)
self._packet_crypto = crypto
self._packet_long_header = packet_long_header
self._packet_start = packet_start
self._packet_type = packet_type
===========unchanged ref 1===========
self.quic_logger_frames = self._packet.quic_logger_frames
at: aioquic.quic.packet_builder.QuicSentPacket
in_flight: bool
sent_bytes: int = 0
quic_logger_frames: List[Dict] = field(default_factory=list)
===========changed ref 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
"""
Returns the assembled datagrams.
"""
if self._packet is not None:
+ self._end_packet(final=True)
- self._end_packet()
self._flush_current_datagram()
datagrams = self._datagrams
packets = self._packets
self._datagrams = []
self._packets = []
return datagrams, packets
===========changed ref 1===========
<s>.quic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
+ is_client: bool,
- pad_first_datagram: bool = False,
packet_number: int = 0,
peer_token: bytes = b"",
quic_logger: Optional[QuicLoggerTrace] = None,
spin_bit: bool = False,
):
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
+ self._is_client = is_client
- self._pad_first_datagram = pad_first_datagram
self._peer_cid = peer_cid
self._peer_token = peer_token
self._quic_logger = quic_logger
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._datagrams: List[bytes] = []
self._datagram_flight_bytes = 0
self._datagram_init = True
+ self._datagram_padding = False
self._packets: List[QuicSentPacket] = []
self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
|
tests.test_connection/QuicConnectionTest.test_connect_with_loss_2
|
Modified
|
aiortc~aioquic
|
74eaefda6dbd77eb3b393ab175f8aea3262b8961
|
[packet builder] pad all client datagrams containing INITIAL packets
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_2(self):
<0> def datagram_sizes(items):
<1> return [len(x[0]) for x in items]
<2>
<3> client_configuration = QuicConfiguration(is_client=True)
<4> client_configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
<5>
<6> client = QuicConnection(configuration=client_configuration)
<7> client._ack_delay = 0
<8>
<9> server_configuration = QuicConfiguration(is_client=False)
<10> server_configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
<11>
<12> server = QuicConnection(configuration=server_configuration)
<13> server._ack_delay = 0
<14>
<15> # client sends INITIAL
<16> now = 0.0
<17> client.connect(SERVER_ADDR, now=now)
<18> items = client.datagrams_to_send(now=now)
<19> self.assertEqual(datagram_sizes(items), [1280])
<20> self.assertEqual(client.get_timer(), 1.0)
<21>
<22> # server receives INITIAL, sends INITIAL + HANDSHAKE but second datagram is lost
<23> now = 0.1
<24> server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
<25> items = server.datagrams_to_send(now=now)
<26> self.assertEqual(datagram_sizes(items), [1280, 1084])
<27> self.assertEqual(server.get_timer(), 1.1)
<28> self.assertEqual(len(server._loss.spaces[0].sent_packets), 1)
<29> self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)
<30>
<31> # client only receives first datagram and sends ACKS
<32> now = 0.2
<33> client.receive_datagram(items[0][0], SERVER_ADDR, now=now)
<34> items = client.datagrams_to_send</s>
|
===========below chunk 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_2(self):
# offset: 1
self.assertEqual(datagram_sizes(items), [97])
self.assertAlmostEqual(client.get_timer(), 0.625)
# client PTO - padded HANDSHAKE
now = client.get_timer() # ~0.625
client.handle_timer(now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280])
self.assertAlmostEqual(client.get_timer(), 1.25)
# server receives padding, discards INITIAL
now = 0.725
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [])
self.assertAlmostEqual(server.get_timer(), 1.1)
self.assertEqual(len(server._loss.spaces[0].sent_packets), 0)
self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)
# ACKs are lost, server retransmits HANDSHAKE
now = server.get_timer()
server.handle_timer(now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280, 905])
self.assertAlmostEqual(server.get_timer(), 3.1)
self.assertEqual(len(server._loss.spaces[0].sent_packets), 0)
self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)
# handshake continues normally
now = 1.2
client.receive_datagram(items[0][0], SERVER_ADDR, now=now)
client.receive_datagram(items[1][0], SERVER_</s>
===========below chunk 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_2(self):
# offset: 2
<s>[0][0], SERVER_ADDR, now=now)
client.receive_datagram(items[1][0], SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [334])
self.assertAlmostEqual(client.get_timer(), 2.45)
self.assertEqual(type(client.next_event()), events.ProtocolNegotiated)
self.assertEqual(type(client.next_event()), events.HandshakeCompleted)
now = 1.3
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [228])
self.assertAlmostEqual(server.get_timer(), 1.825)
self.assertEqual(type(server.next_event()), events.ProtocolNegotiated)
self.assertEqual(type(server.next_event()), events.HandshakeCompleted)
now = 1.4
client.receive_datagram(items[0][0], SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [32])
self.assertAlmostEqual(client.get_timer(), 61.4) # idle timeout
===========unchanged ref 0===========
at: tests.test_connection
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
at: tests.utils
SERVER_CACERTFILE = os.path.join(os.path.dirname(__file__), "pycacert.pem")
SERVER_CERTFILE = os.path.join(os.path.dirname(__file__), "ssl_cert.pem")
SERVER_KEYFILE = os.path.join(os.path.dirname(__file__), "ssl_key.pem")
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertAlmostEqual(first: float, second: float, places: Optional[int]=..., msg: Any=..., delta: Optional[float]=...) -> None
assertAlmostEqual(first: datetime.datetime, second: datetime.datetime, places: Optional[int]=..., msg: Any=..., delta: Optional[datetime.timedelta]=...) -> None
===========changed ref 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
"""
Returns the assembled datagrams.
"""
if self._packet is not None:
+ self._end_packet(final=True)
- self._end_packet()
self._flush_current_datagram()
datagrams = self._datagrams
packets = self._packets
self._datagrams = []
self._packets = []
return datagrams, packets
===========changed ref 1===========
<s>.quic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
+ is_client: bool,
- pad_first_datagram: bool = False,
packet_number: int = 0,
peer_token: bytes = b"",
quic_logger: Optional[QuicLoggerTrace] = None,
spin_bit: bool = False,
):
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
+ self._is_client = is_client
- self._pad_first_datagram = pad_first_datagram
self._peer_cid = peer_cid
self._peer_token = peer_token
self._quic_logger = quic_logger
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._datagrams: List[bytes] = []
self._datagram_flight_bytes = 0
self._datagram_init = True
+ self._datagram_padding = False
self._packets: List[QuicSentPacket] = []
self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
|
|
tests.test_connection/QuicConnectionTest.test_receive_datagram_wrong_version
|
Modified
|
aiortc~aioquic
|
74eaefda6dbd77eb3b393ab175f8aea3262b8961
|
[packet builder] pad all client datagrams containing INITIAL packets
|
<4>:<add> is_client=False,
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_receive_datagram_wrong_version(self):
<0> client = create_standalone_client(self)
<1>
<2> builder = QuicPacketBuilder(
<3> host_cid=client._peer_cid,
<4> peer_cid=client.host_cid,
<5> version=0xFF000011, # DRAFT_16
<6> )
<7> crypto = CryptoPair()
<8> crypto.setup_initial(client.host_cid, is_client=False, version=client._version)
<9> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<10> builder.buffer.push_bytes(bytes(1200))
<11>
<12> for datagram in builder.flush()[0]:
<13> client.receive_datagram(datagram, SERVER_ADDR, now=time.time())
<14> self.assertEqual(drop(client), 0)
<15>
|
===========unchanged ref 0===========
at: tests.test_connection
SERVER_ADDR = ("2.3.4.5", 4433)
create_standalone_client(self)
drop(sender)
at: time
time() -> float
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
"""
Returns the assembled datagrams.
"""
if self._packet is not None:
+ self._end_packet(final=True)
- self._end_packet()
self._flush_current_datagram()
datagrams = self._datagrams
packets = self._packets
self._datagrams = []
self._packets = []
return datagrams, packets
===========changed ref 1===========
<s>.quic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
+ is_client: bool,
- pad_first_datagram: bool = False,
packet_number: int = 0,
peer_token: bytes = b"",
quic_logger: Optional[QuicLoggerTrace] = None,
spin_bit: bool = False,
):
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
+ self._is_client = is_client
- self._pad_first_datagram = pad_first_datagram
self._peer_cid = peer_cid
self._peer_token = peer_token
self._quic_logger = quic_logger
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._datagrams: List[bytes] = []
self._datagram_flight_bytes = 0
self._datagram_init = True
+ self._datagram_padding = False
self._packets: List[QuicSentPacket] = []
self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_2(self):
def datagram_sizes(items):
return [len(x[0]) for x in items]
client_configuration = QuicConfiguration(is_client=True)
client_configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
client = QuicConnection(configuration=client_configuration)
client._ack_delay = 0
server_configuration = QuicConfiguration(is_client=False)
server_configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
server = QuicConnection(configuration=server_configuration)
server._ack_delay = 0
# client sends INITIAL
now = 0.0
client.connect(SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280])
self.assertEqual(client.get_timer(), 1.0)
# server receives INITIAL, sends INITIAL + HANDSHAKE but second datagram is lost
now = 0.1
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280, 1084])
self.assertEqual(server.get_timer(), 1.1)
self.assertEqual(len(server._loss.spaces[0].sent_packets), 1)
self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)
# client only receives first datagram and sends ACKS
now = 0.2
client.receive_datagram(items[0][0], SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
+ self.assertEqual(datagram_sizes(items), [1280])
- self.assertEqual(datagram_</s>
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_2(self):
# offset: 1
<s>
+ self.assertEqual(datagram_sizes(items), [1280])
- self.assertEqual(datagram_sizes(items), [97])
self.assertAlmostEqual(client.get_timer(), 0.625)
# client PTO - padded HANDSHAKE
now = client.get_timer() # ~0.625
client.handle_timer(now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280])
self.assertAlmostEqual(client.get_timer(), 1.25)
# server receives padding, discards INITIAL
now = 0.725
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [])
self.assertAlmostEqual(server.get_timer(), 1.1)
self.assertEqual(len(server._loss.spaces[0].sent_packets), 0)
self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)
# ACKs are lost, server retransmits HANDSHAKE
now = server.get_timer()
server.handle_timer(now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280, 905])
self.assertAlmostEqual(server.get_timer(), 3.1)
self.assertEqual(len(server._loss.spaces[0].sent_packets), 0)
self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)</s>
|
aioquic.quic.connection/QuicConnection.datagrams_to_send
|
Modified
|
aiortc~aioquic
|
74eaefda6dbd77eb3b393ab175f8aea3262b8961
|
[packet builder] pad all client datagrams containing INITIAL packets
|
<14>:<add> is_client=self._is_client,
<15>:<del> pad_first_datagram=(
<16>:<del> self._is_client and self._state == QuicConnectionState.FIRSTFLIGHT
<17>:<del> ),
|
# module: aioquic.quic.connection
class QuicConnection:
def datagrams_to_send(self, now: float) -> List[Tuple[bytes, NetworkAddress]]:
<0> """
<1> Return a list of `(data, addr)` tuples of datagrams which need to be
<2> sent, and the network address to which they need to be sent.
<3>
<4> :param now: The current time.
<5> """
<6> network_path = self._network_paths[0]
<7>
<8> if self._state in END_STATES:
<9> return []
<10>
<11> # build datagrams
<12> builder = QuicPacketBuilder(
<13> host_cid=self.host_cid,
<14> packet_number=self._packet_number,
<15> pad_first_datagram=(
<16> self._is_client and self._state == QuicConnectionState.FIRSTFLIGHT
<17> ),
<18> peer_cid=self._peer_cid,
<19> peer_token=self._peer_token,
<20> quic_logger=self._quic_logger,
<21> spin_bit=self._spin_bit,
<22> version=self._version,
<23> )
<24> if self._close_pending:
<25> for epoch, packet_type in (
<26> (tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
<27> (tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
<28> (tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
<29> ):
<30> crypto = self._cryptos[epoch]
<31> if crypto.send.is_valid():
<32> builder.start_packet(packet_type, crypto)
<33> self._write_close_frame(
<34> builder=builder,
<35> error_code=self._close_event.error_code,
<36> frame_type=self._close_event.frame_type,
<37> reason_phrase=self._close_event.reason_phrase,
<38> )
<39> self._close_pending = False
<40> break
<41> self._close_begin(</s>
|
===========below chunk 0===========
# module: aioquic.quic.connection
class QuicConnection:
def datagrams_to_send(self, now: float) -> List[Tuple[bytes, NetworkAddress]]:
# offset: 1
else:
# congestion control
builder.max_flight_bytes = (
self._loss.congestion_window - self._loss.bytes_in_flight
)
if self._probe_pending and builder.max_flight_bytes < PACKET_MAX_SIZE:
builder.max_flight_bytes = PACKET_MAX_SIZE
# limit data on un-validated network paths
if not network_path.is_validated:
builder.max_total_bytes = (
network_path.bytes_received * 3 - network_path.bytes_sent
)
try:
if not self._handshake_confirmed:
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch)
self._write_application(builder, network_path, now)
except QuicPacketBuilderStop:
pass
datagrams, packets = builder.flush()
if datagrams:
self._packet_number = builder.packet_number
# register packets
sent_handshake = False
for packet in packets:
packet.sent_time = now
self._loss.on_packet_sent(
packet=packet, space=self._spaces[packet.epoch]
)
if packet.epoch == tls.Epoch.HANDSHAKE:
sent_handshake = True
# log packet
if self._quic_logger is not None:
self._quic_logger.log_event(
category="transport",
event="packet_sent",
data={
"packet_type": self._quic_logger.packet_type(
packet.packet_type
),
"header": {
"packet_number": str(packet.packet_number),
"packet_size": packet.sent_bytes,
"scid": dump_</s>
===========below chunk 1===========
# module: aioquic.quic.connection
class QuicConnection:
def datagrams_to_send(self, now: float) -> List[Tuple[bytes, NetworkAddress]]:
# offset: 2
<s>": str(packet.packet_number),
"packet_size": packet.sent_bytes,
"scid": dump_cid(self.host_cid)
if is_long_header(packet.packet_type)
else "",
"dcid": dump_cid(self._peer_cid),
},
"frames": packet.quic_logger_frames,
},
)
# check if we can discard initial keys
if sent_handshake and self._is_client:
self._discard_epoch(tls.Epoch.INITIAL)
# return datagrams to send and the destination network address
ret = []
for datagram in datagrams:
byte_length = len(datagram)
network_path.bytes_sent += byte_length
ret.append((datagram, network_path.addr))
if self._quic_logger is not None:
self._quic_logger.log_event(
category="transport",
event="datagrams_sent",
data={"byte_length": byte_length, "count": 1},
)
return ret
===========unchanged ref 0===========
at: aioquic.quic.connection
NetworkAddress = Any
dump_cid(cid: bytes) -> str
END_STATES = frozenset(
[
QuicConnectionState.CLOSING,
QuicConnectionState.DRAINING,
QuicConnectionState.TERMINATED,
]
)
at: aioquic.quic.connection.QuicConnection
_close_begin(is_initiator: bool, now: float) -> None
_discard_epoch(epoch: tls.Epoch) -> None
_write_application(builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float) -> None
_write_handshake(builder: QuicPacketBuilder, epoch: tls.Epoch) -> None
_write_close_frame(builder: QuicPacketBuilder, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None
at: aioquic.quic.connection.QuicConnection.__init__
self._is_client = configuration.is_client
self._close_event: Optional[events.ConnectionTerminated] = None
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._handshake_confirmed = False
self.host_cid = self._host_cids[0].cid
self._network_paths: List[QuicNetworkPath] = []
self._packet_number = 0
self._peer_cid = os.urandom(configuration.connection_id_length)
self._peer_token = b""
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
self._spaces: Dict[tls.Epoch, QuicPacketSpace] = {}
self._spin_bit = False
self._state = QuicConnectionState.FIRSTFLIGHT
self._version: Optional[int] = None
===========unchanged ref 1===========
self._loss = QuicPacketRecovery(
is_client_without_1rtt=self._is_client,
quic_logger=self._quic_logger,
send_probe=self._send_probe,
)
self._close_pending = False
self._probe_pending = False
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
at: aioquic.quic.connection.QuicConnection._handle_ack_frame
self._handshake_confirmed = True
at: aioquic.quic.connection.QuicConnection._handle_connection_close_frame
self._close_event = events.ConnectionTerminated(
error_code=error_code, frame_type=frame_type, reason_phrase=reason_phrase
)
at: aioquic.quic.connection.QuicConnection._initialize
self._cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self._spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
self._packet_number = 0
at: aioquic.quic.connection.QuicConnection._send_probe
self._probe_pending = True
at: aioquic.quic.connection.QuicConnection._set_state
self._state = state
at: aioquic.quic.connection.QuicConnection._write_application
self._probe_pending = False
at: aioquic.quic.connection.QuicConnection._write_handshake
self._probe_pending = False
at: aioquic.quic.connection.QuicConnection.change_connection_id
self._peer_cid = connection_id.cid
|
tests.test_packet_builder/create_builder
|
Modified
|
aiortc~aioquic
|
74eaefda6dbd77eb3b393ab175f8aea3262b8961
|
[packet builder] pad all client datagrams containing INITIAL packets
|
<2>:<add> is_client=is_client,
<3>:<del> pad_first_datagram=pad_first_datagram,
|
# module: tests.test_packet_builder
+ def create_builder(is_client=True):
- def create_builder(pad_first_datagram=False):
<0> return QuicPacketBuilder(
<1> host_cid=bytes(8),
<2> packet_number=0,
<3> pad_first_datagram=pad_first_datagram,
<4> peer_cid=bytes(8),
<5> peer_token=b"",
<6> spin_bit=False,
<7> version=QuicProtocolVersion.DRAFT_23,
<8> )
<9>
|
===========changed ref 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
"""
Returns the assembled datagrams.
"""
if self._packet is not None:
+ self._end_packet(final=True)
- self._end_packet()
self._flush_current_datagram()
datagrams = self._datagrams
packets = self._packets
self._datagrams = []
self._packets = []
return datagrams, packets
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_receive_datagram_wrong_version(self):
client = create_standalone_client(self)
builder = QuicPacketBuilder(
host_cid=client._peer_cid,
+ is_client=False,
peer_cid=client.host_cid,
version=0xFF000011, # DRAFT_16
)
crypto = CryptoPair()
crypto.setup_initial(client.host_cid, is_client=False, version=client._version)
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
builder.buffer.push_bytes(bytes(1200))
for datagram in builder.flush()[0]:
client.receive_datagram(datagram, SERVER_ADDR, now=time.time())
self.assertEqual(drop(client), 0)
===========changed ref 2===========
<s>.quic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
+ is_client: bool,
- pad_first_datagram: bool = False,
packet_number: int = 0,
peer_token: bytes = b"",
quic_logger: Optional[QuicLoggerTrace] = None,
spin_bit: bool = False,
):
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
+ self._is_client = is_client
- self._pad_first_datagram = pad_first_datagram
self._peer_cid = peer_cid
self._peer_token = peer_token
self._quic_logger = quic_logger
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._datagrams: List[bytes] = []
self._datagram_flight_bytes = 0
self._datagram_init = True
+ self._datagram_padding = False
self._packets: List[QuicSentPacket] = []
self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
===========changed ref 3===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
buf = self.buffer
# finish previous datagram
if self._packet is not None:
+ self._end_packet(final=False)
- self._end_packet()
# if there is too little space remaining, start a new datagram
# FIXME: the limit is arbitrary!
packet_start = buf.tell()
if self._buffer_capacity - packet_start < 128:
self._flush_current_datagram()
packet_start = 0
# initialize datagram if needed
if self._datagram_init:
if self.max_flight_bytes is not None:
remaining_flight_bytes = self.max_flight_bytes - self._flight_bytes
if remaining_flight_bytes < self._buffer_capacity:
self._buffer_capacity = remaining_flight_bytes
if self.max_total_bytes is not None:
remaining_total_bytes = self.max_total_bytes - self._total_bytes
if remaining_total_bytes < self._buffer_capacity:
self._buffer_capacity = remaining_total_bytes
self._datagram_flight_bytes = 0
self._datagram_init = False
+ self._datagram_padding = False
# calculate header size
packet_long_header = is_long_header(packet_type)
if packet_long_header:
header_size = 11 + len(self._peer_cid) + len(self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
token_length = len(self._peer_token)
header_size += size_uint_var(token_length) + token_length
else:
header_size = 3 + len(self._peer_cid)
# check we have enough space
if packet_start + header_size >= self._buffer</s>
===========changed ref 4===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
<s>(self._peer_cid)
# check we have enough space
if packet_start + header_size >= self._buffer_capacity:
raise QuicPacketBuilderStop
# determine ack epoch
if packet_type == PACKET_TYPE_INITIAL:
epoch = Epoch.INITIAL
elif packet_type == PACKET_TYPE_HANDSHAKE:
epoch = Epoch.HANDSHAKE
else:
epoch = Epoch.ONE_RTT
self._header_size = header_size
self._packet = QuicSentPacket(
epoch=epoch,
in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
packet_type=packet_type,
)
self._packet_crypto = crypto
self._packet_long_header = packet_long_header
self._packet_start = packet_start
self._packet_type = packet_type
self.quic_logger_frames = self._packet.quic_logger_frames
buf.seek(self._packet_start + self._header_size)
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_then_long_header
|
Modified
|
aiortc~aioquic
|
74eaefda6dbd77eb3b393ab175f8aea3262b8961
|
[packet builder] pad all client datagrams containing INITIAL packets
|
<27>:<add> self.assertEqual(len(datagrams[0]), 1280)
<del> self.assertEqual(len(datagrams[0]), 914)
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_long_header(self):
<0> builder = create_builder()
<1> crypto = create_crypto()
<2>
<3> # INITIAL
<4> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<5> self.assertEqual(builder.remaining_space, 1236)
<6> builder.start_frame(QuicFrameType.CRYPTO)
<7> builder.buffer.push_bytes(bytes(199))
<8> self.assertFalse(builder.packet_is_empty)
<9>
<10> # HANDSHAKE
<11> builder.start_packet(PACKET_TYPE_HANDSHAKE, crypto)
<12> self.assertEqual(builder.remaining_space, 993)
<13> builder.start_frame(QuicFrameType.CRYPTO)
<14> builder.buffer.push_bytes(bytes(299))
<15> self.assertFalse(builder.packet_is_empty)
<16>
<17> # ONE_RTT
<18> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<19> self.assertEqual(builder.remaining_space, 666)
<20> builder.start_frame(QuicFrameType.CRYPTO)
<21> builder.buffer.push_bytes(bytes(299))
<22> self.assertFalse(builder.packet_is_empty)
<23>
<24> # check datagrams
<25> datagrams, packets = builder.flush()
<26> self.assertEqual(len(datagrams), 1)
<27> self.assertEqual(len(datagrams[0]), 914)
<28> self.assertEqual(
<29> packets,
<30> [
<31> QuicSentPacket(
<32> epoch=Epoch.INITIAL,
<33> in_flight=True,
<34> is_ack_eliciting=True,
<35> is_crypto_packet=True,
<36> packet_number=0,
<37> packet_type=PACKET_TYPE_INITIAL,
<38> sent_bytes=244,
<39> ),
<40> QuicSentPacket(</s>
|
===========below chunk 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_long_header(self):
# offset: 1
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=1,
packet_type=PACKET_TYPE_HANDSHAKE,
sent_bytes=343,
),
QuicSentPacket(
epoch=Epoch.ONE_RTT,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=2,
packet_type=PACKET_TYPE_ONE_RTT,
sent_bytes=327,
),
],
)
===========unchanged ref 0===========
at: tests.test_packet_builder
create_builder(is_client=True)
create_crypto()
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_packet_builder
+ def create_builder(is_client=True):
- def create_builder(pad_first_datagram=False):
return QuicPacketBuilder(
host_cid=bytes(8),
+ is_client=is_client,
packet_number=0,
- pad_first_datagram=pad_first_datagram,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_23,
)
===========changed ref 1===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
- def test_long_header_padding(self):
- builder = create_builder(pad_first_datagram=True)
- crypto = create_crypto()
-
- # INITIAL, fully padded
- builder.start_packet(PACKET_TYPE_INITIAL, crypto)
- self.assertEqual(builder.remaining_space, 1236)
- builder.start_frame(QuicFrameType.CRYPTO)
- builder.buffer.push_bytes(bytes(100))
- self.assertFalse(builder.packet_is_empty)
-
- # INITIAL, empty
- builder.start_packet(PACKET_TYPE_INITIAL, crypto)
- self.assertTrue(builder.packet_is_empty)
-
- # check datagrams
- datagrams, packets = builder.flush()
- self.assertEqual(len(datagrams), 1)
- self.assertEqual(len(datagrams[0]), 1280)
- self.assertEqual(
- packets,
- [
- QuicSentPacket(
- epoch=Epoch.INITIAL,
- in_flight=True,
- is_ack_eliciting=True,
- is_crypto_packet=True,
- packet_number=0,
- packet_type=PACKET_TYPE_INITIAL,
- sent_bytes=1280,
- )
- ],
- )
-
===========changed ref 2===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
+ def test_long_header_initial_client(self):
+ builder = create_builder(is_client=True)
+ crypto = create_crypto()
+
+ # INITIAL
+ builder.start_packet(PACKET_TYPE_INITIAL, crypto)
+ self.assertEqual(builder.remaining_space, 1236)
+ builder.start_frame(QuicFrameType.CRYPTO)
+ builder.buffer.push_bytes(bytes(100))
+ self.assertFalse(builder.packet_is_empty)
+
+ # INITIAL, empty
+ builder.start_packet(PACKET_TYPE_INITIAL, crypto)
+ self.assertTrue(builder.packet_is_empty)
+
+ # check datagrams
+ datagrams, packets = builder.flush()
+ self.assertEqual(len(datagrams), 1)
+ self.assertEqual(len(datagrams[0]), 1280)
+ self.assertEqual(
+ packets,
+ [
+ QuicSentPacket(
+ epoch=Epoch.INITIAL,
+ in_flight=True,
+ is_ack_eliciting=True,
+ is_crypto_packet=True,
+ packet_number=0,
+ packet_type=PACKET_TYPE_INITIAL,
+ sent_bytes=145,
+ ),
+ QuicSentPacket(
+ epoch=Epoch.INITIAL,
+ in_flight=True,
+ is_ack_eliciting=False,
+ is_crypto_packet=False,
+ packet_number=1,
+ packet_type=PACKET_TYPE_INITIAL,
+ sent_bytes=1135,
+ )
+ ],
+ )
+
===========changed ref 3===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
+ def test_long_header_initial_client_2(self):
+ builder = create_builder(is_client=True)
+ crypto = create_crypto()
+
+ # INITIAL, full length
+ builder.start_packet(PACKET_TYPE_INITIAL, crypto)
+ self.assertEqual(builder.remaining_space, 1236)
+ builder.start_frame(QuicFrameType.CRYPTO)
+ builder.buffer.push_bytes(bytes(builder.remaining_space))
+ self.assertFalse(builder.packet_is_empty)
+
+ # INITIAL
+ builder.start_packet(PACKET_TYPE_INITIAL, crypto)
+ self.assertEqual(builder.remaining_space, 1236)
+ builder.start_frame(QuicFrameType.CRYPTO)
+ builder.buffer.push_bytes(bytes(100))
+ self.assertFalse(builder.packet_is_empty)
+
+ # INITIAL, empty
+ builder.start_packet(PACKET_TYPE_INITIAL, crypto)
+ self.assertTrue(builder.packet_is_empty)
+
+ # check datagrams
+ datagrams, packets = builder.flush()
+ self.assertEqual(len(datagrams), 2)
+ self.assertEqual(len(datagrams[0]), 1280)
+ self.assertEqual(len(datagrams[1]), 1280)
+ self.assertEqual(
+ packets,
+ [
+ QuicSentPacket(
+ epoch=Epoch.INITIAL,
+ in_flight=True,
+ is_ack_eliciting=True,
+ is_crypto_packet=True,
+ packet_number=0,
+ packet_type=PACKET_TYPE_INITIAL,
+ sent_bytes=1280,
+ ),
+ QuicSentPacket(
+ epoch=Epoch.INITIAL,
+ in_flight=True,
+ is_ack_</s>
|
aioquic.quic.packet_builder/QuicPacketBuilder.__init__
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<30>:<add> self._buffer = Buffer(PACKET_MAX_SIZE)
<del> self.buffer = Buffer(PACKET_MAX_SIZE)
|
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
is_client: bool,
packet_number: int = 0,
peer_token: bytes = b"",
quic_logger: Optional[QuicLoggerTrace] = None,
spin_bit: bool = False,
):
<0> self.max_flight_bytes: Optional[int] = None
<1> self.max_total_bytes: Optional[int] = None
<2> self.quic_logger_frames: Optional[List[Dict]] = None
<3>
<4> self._host_cid = host_cid
<5> self._is_client = is_client
<6> self._peer_cid = peer_cid
<7> self._peer_token = peer_token
<8> self._quic_logger = quic_logger
<9> self._spin_bit = spin_bit
<10> self._version = version
<11>
<12> # assembled datagrams and packets
<13> self._datagrams: List[bytes] = []
<14> self._datagram_flight_bytes = 0
<15> self._datagram_init = True
<16> self._datagram_padding = False
<17> self._packets: List[QuicSentPacket] = []
<18> self._flight_bytes = 0
<19> self._total_bytes = 0
<20>
<21> # current packet
<22> self._header_size = 0
<23> self._packet: Optional[QuicSentPacket] = None
<24> self._packet_crypto: Optional[CryptoPair] = None
<25> self._packet_long_header = False
<26> self._packet_number = packet_number
<27> self._packet_start = 0
<28> self._packet_type = 0
<29>
<30> self.buffer = Buffer(PACKET_MAX_SIZE)
<31> self._buffer_capacity = PACKET_MAX_SIZE
<32>
|
===========unchanged ref 0===========
at: aioquic.quic.packet_builder
PACKET_MAX_SIZE = 1280
QuicSentPacket(epoch: Epoch, in_flight: bool, is_ack_eliciting: bool, is_crypto_packet: bool, packet_number: int, packet_type: int, sent_time: Optional[float]=None, sent_bytes: int=0, delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]]=field(
default_factory=list
), quic_logger_frames: List[Dict]=field(default_factory=list))
at: aioquic.quic.packet_builder.QuicPacketBuilder._end_packet
self._datagram_padding = True
self._datagram_flight_bytes += self._packet.sent_bytes
self._packet_number += 1
self._packet = None
self.quic_logger_frames = None
at: aioquic.quic.packet_builder.QuicPacketBuilder._flush_current_datagram
self._flight_bytes += self._datagram_flight_bytes
self._total_bytes += datagram_bytes
self._datagram_init = True
at: aioquic.quic.packet_builder.QuicPacketBuilder.flush
self._datagrams = []
self._packets = []
at: aioquic.quic.packet_builder.QuicPacketBuilder.start_packet
self._buffer_capacity = remaining_flight_bytes
self._buffer_capacity = remaining_total_bytes
self._datagram_flight_bytes = 0
self._datagram_init = False
self._datagram_padding = False
self._header_size = header_size
self._packet = QuicSentPacket(
epoch=epoch,
in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
packet_type=packet_type,
)
self._packet_crypto = crypto
===========unchanged ref 1===========
self._packet_long_header = packet_long_header
self._packet_start = packet_start
self._packet_type = packet_type
self.quic_logger_frames = self._packet.quic_logger_frames
at: typing
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
|
aioquic.quic.packet_builder/QuicPacketBuilder.packet_is_empty
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<4>:<add> packet_size = self._buffer.tell() - self._packet_start
<del> packet_size = self.buffer.tell() - self._packet_start
|
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def packet_is_empty(self) -> bool:
<0> """
<1> Returns `True` if the current packet is empty.
<2> """
<3> assert self._packet is not None
<4> packet_size = self.buffer.tell() - self._packet_start
<5> return packet_size <= self._header_size
<6>
|
===========unchanged ref 0===========
at: aioquic.quic.packet_builder.QuicPacketBuilder.__init__
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_start = 0
self._buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.quic.packet_builder.QuicPacketBuilder._end_packet
self._packet = None
at: aioquic.quic.packet_builder.QuicPacketBuilder.start_packet
self._header_size = header_size
self._packet = QuicSentPacket(
epoch=epoch,
in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
packet_type=packet_type,
)
self._packet_start = packet_start
===========changed ref 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
is_client: bool,
packet_number: int = 0,
peer_token: bytes = b"",
quic_logger: Optional[QuicLoggerTrace] = None,
spin_bit: bool = False,
):
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
self._is_client = is_client
self._peer_cid = peer_cid
self._peer_token = peer_token
self._quic_logger = quic_logger
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._datagrams: List[bytes] = []
self._datagram_flight_bytes = 0
self._datagram_init = True
self._datagram_padding = False
self._packets: List[QuicSentPacket] = []
self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
+ self._buffer = Buffer(PACKET_MAX_SIZE)
- self.buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
|
aioquic.quic.packet_builder/QuicPacketBuilder.remaining_space
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<6>:<add> - self._buffer.tell()
<del> - self.buffer.tell()
|
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
<0> """
<1> Returns the remaining number of bytes which can be used in
<2> the current packet.
<3> """
<4> return (
<5> self._buffer_capacity
<6> - self.buffer.tell()
<7> - self._packet_crypto.aead_tag_size
<8> )
<9>
|
===========unchanged ref 0===========
at: aioquic.quic.packet_builder.QuicPacketBuilder.__init__
self._packet_crypto: Optional[CryptoPair] = None
self._buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
at: aioquic.quic.packet_builder.QuicPacketBuilder.start_packet
self._buffer_capacity = remaining_flight_bytes
self._buffer_capacity = remaining_total_bytes
self._packet_crypto = crypto
===========changed ref 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def packet_is_empty(self) -> bool:
"""
Returns `True` if the current packet is empty.
"""
assert self._packet is not None
+ packet_size = self._buffer.tell() - self._packet_start
- packet_size = self.buffer.tell() - self._packet_start
return packet_size <= self._header_size
===========changed ref 1===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
is_client: bool,
packet_number: int = 0,
peer_token: bytes = b"",
quic_logger: Optional[QuicLoggerTrace] = None,
spin_bit: bool = False,
):
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
self._is_client = is_client
self._peer_cid = peer_cid
self._peer_token = peer_token
self._quic_logger = quic_logger
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._datagrams: List[bytes] = []
self._datagram_flight_bytes = 0
self._datagram_init = True
self._datagram_padding = False
self._packets: List[QuicSentPacket] = []
self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
+ self._buffer = Buffer(PACKET_MAX_SIZE)
- self.buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
|
aioquic.quic.packet_builder/QuicPacketBuilder.start_frame
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<3>:<add> self._buffer.push_uint_var(frame_type)
<del> self.buffer.push_uint_var(frame_type)
<12>:<add> return self._buffer
|
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
+ ) -> Buffer:
- ) -> None:
<0> """
<1> Starts a new frame.
<2> """
<3> self.buffer.push_uint_var(frame_type)
<4> if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
<5> self._packet.is_ack_eliciting = True
<6> if frame_type not in NON_IN_FLIGHT_FRAME_TYPES:
<7> self._packet.in_flight = True
<8> if frame_type == QuicFrameType.CRYPTO:
<9> self._packet.is_crypto_packet = True
<10> if handler is not None:
<11> self._packet.delivery_handlers.append((handler, args))
<12>
|
===========unchanged ref 0===========
at: aioquic.quic.packet_builder
QuicDeliveryHandler = Callable[..., None]
at: aioquic.quic.packet_builder.QuicPacketBuilder.__init__
self._packet: Optional[QuicSentPacket] = None
self._buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.quic.packet_builder.QuicPacketBuilder._end_packet
self._packet = None
at: aioquic.quic.packet_builder.QuicPacketBuilder.start_packet
self._packet = QuicSentPacket(
epoch=epoch,
in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
packet_type=packet_type,
)
at: aioquic.quic.packet_builder.QuicSentPacket
epoch: Epoch
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
packet_type: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
quic_logger_frames: List[Dict] = field(default_factory=list)
at: typing
Sequence = _alias(collections.abc.Sequence, 1)
===========changed ref 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
"""
Returns the remaining number of bytes which can be used in
the current packet.
"""
return (
self._buffer_capacity
+ - self._buffer.tell()
- - self.buffer.tell()
- self._packet_crypto.aead_tag_size
)
===========changed ref 1===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def packet_is_empty(self) -> bool:
"""
Returns `True` if the current packet is empty.
"""
assert self._packet is not None
+ packet_size = self._buffer.tell() - self._packet_start
- packet_size = self.buffer.tell() - self._packet_start
return packet_size <= self._header_size
===========changed ref 2===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
is_client: bool,
packet_number: int = 0,
peer_token: bytes = b"",
quic_logger: Optional[QuicLoggerTrace] = None,
spin_bit: bool = False,
):
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
self._is_client = is_client
self._peer_cid = peer_cid
self._peer_token = peer_token
self._quic_logger = quic_logger
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._datagrams: List[bytes] = []
self._datagram_flight_bytes = 0
self._datagram_init = True
self._datagram_padding = False
self._packets: List[QuicSentPacket] = []
self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
+ self._buffer = Buffer(PACKET_MAX_SIZE)
- self.buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
|
aioquic.quic.packet_builder/QuicPacketBuilder.start_packet
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<3>:<add> buf = self._buffer
<del> buf = self.buffer
|
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
<0> """
<1> Starts a new packet.
<2> """
<3> buf = self.buffer
<4>
<5> # finish previous datagram
<6> if self._packet is not None:
<7> self._end_packet(final=False)
<8>
<9> # if there is too little space remaining, start a new datagram
<10> # FIXME: the limit is arbitrary!
<11> packet_start = buf.tell()
<12> if self._buffer_capacity - packet_start < 128:
<13> self._flush_current_datagram()
<14> packet_start = 0
<15>
<16> # initialize datagram if needed
<17> if self._datagram_init:
<18> if self.max_flight_bytes is not None:
<19> remaining_flight_bytes = self.max_flight_bytes - self._flight_bytes
<20> if remaining_flight_bytes < self._buffer_capacity:
<21> self._buffer_capacity = remaining_flight_bytes
<22> if self.max_total_bytes is not None:
<23> remaining_total_bytes = self.max_total_bytes - self._total_bytes
<24> if remaining_total_bytes < self._buffer_capacity:
<25> self._buffer_capacity = remaining_total_bytes
<26> self._datagram_flight_bytes = 0
<27> self._datagram_init = False
<28> self._datagram_padding = False
<29>
<30> # calculate header size
<31> packet_long_header = is_long_header(packet_type)
<32> if packet_long_header:
<33> header_size = 11 + len(self._peer_cid) + len(self._host_cid)
<34> if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
<35> token_length = len(self._peer_token)
<36> header_size += size_uint_var(token_length) + token_length
<37> else:
<38> header_size = 3 + len(self</s>
|
===========below chunk 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
# check we have enough space
if packet_start + header_size >= self._buffer_capacity:
raise QuicPacketBuilderStop
# determine ack epoch
if packet_type == PACKET_TYPE_INITIAL:
epoch = Epoch.INITIAL
elif packet_type == PACKET_TYPE_HANDSHAKE:
epoch = Epoch.HANDSHAKE
else:
epoch = Epoch.ONE_RTT
self._header_size = header_size
self._packet = QuicSentPacket(
epoch=epoch,
in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
packet_type=packet_type,
)
self._packet_crypto = crypto
self._packet_long_header = packet_long_header
self._packet_start = packet_start
self._packet_type = packet_type
self.quic_logger_frames = self._packet.quic_logger_frames
buf.seek(self._packet_start + self._header_size)
===========unchanged ref 0===========
at: aioquic.quic.packet_builder
QuicSentPacket(epoch: Epoch, in_flight: bool, is_ack_eliciting: bool, is_crypto_packet: bool, packet_number: int, packet_type: int, sent_time: Optional[float]=None, sent_bytes: int=0, delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]]=field(
default_factory=list
), quic_logger_frames: List[Dict]=field(default_factory=list))
QuicPacketBuilderStop(*args: object)
at: aioquic.quic.packet_builder.QuicPacketBuilder
_end_packet(self, final: bool) -> None
_end_packet(final: bool) -> None
_flush_current_datagram() -> None
_flush_current_datagram(self) -> None
at: aioquic.quic.packet_builder.QuicPacketBuilder.__init__
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
self._peer_cid = peer_cid
self._peer_token = peer_token
self._datagram_flight_bytes = 0
self._datagram_init = True
self._datagram_padding = False
self._flight_bytes = 0
self._total_bytes = 0
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self._buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
===========unchanged ref 1===========
at: aioquic.quic.packet_builder.QuicPacketBuilder._end_packet
self._datagram_padding = True
self._datagram_flight_bytes += self._packet.sent_bytes
self._packet_number += 1
self._packet = None
self.quic_logger_frames = None
at: aioquic.quic.packet_builder.QuicPacketBuilder._flush_current_datagram
self._flight_bytes += self._datagram_flight_bytes
self._total_bytes += datagram_bytes
self._datagram_init = True
at: aioquic.quic.packet_builder.QuicSentPacket
quic_logger_frames: List[Dict] = field(default_factory=list)
===========changed ref 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
"""
Returns the remaining number of bytes which can be used in
the current packet.
"""
return (
self._buffer_capacity
+ - self._buffer.tell()
- - self.buffer.tell()
- self._packet_crypto.aead_tag_size
)
===========changed ref 1===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def packet_is_empty(self) -> bool:
"""
Returns `True` if the current packet is empty.
"""
assert self._packet is not None
+ packet_size = self._buffer.tell() - self._packet_start
- packet_size = self.buffer.tell() - self._packet_start
return packet_size <= self._header_size
===========changed ref 2===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
+ ) -> Buffer:
- ) -> None:
"""
Starts a new frame.
"""
+ self._buffer.push_uint_var(frame_type)
- self.buffer.push_uint_var(frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
self._packet.is_ack_eliciting = True
if frame_type not in NON_IN_FLIGHT_FRAME_TYPES:
self._packet.in_flight = True
if frame_type == QuicFrameType.CRYPTO:
self._packet.is_crypto_packet = True
if handler is not None:
self._packet.delivery_handlers.append((handler, args))
+ return self._buffer
===========changed ref 3===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
is_client: bool,
packet_number: int = 0,
peer_token: bytes = b"",
quic_logger: Optional[QuicLoggerTrace] = None,
spin_bit: bool = False,
):
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
self._is_client = is_client
self._peer_cid = peer_cid
self._peer_token = peer_token
self._quic_logger = quic_logger
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._datagrams: List[bytes] = []
self._datagram_flight_bytes = 0
self._datagram_init = True
self._datagram_padding = False
self._packets: List[QuicSentPacket] = []
self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
+ self._buffer = Buffer(PACKET_MAX_SIZE)
- self.buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
|
aioquic.quic.packet_builder/QuicPacketBuilder._end_packet
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<3>:<add> buf = self._buffer
<del> buf = self.buffer
|
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def _end_packet(self, final: bool) -> None:
<0> """
<1> Ends the current packet.
<2> """
<3> buf = self.buffer
<4> packet_size = buf.tell() - self._packet_start
<5> if packet_size > self._header_size or (self._datagram_padding and final):
<6> if self._is_client and self._packet_type == PACKET_TYPE_INITIAL:
<7> self._datagram_padding = True
<8>
<9> # pad initial datagram
<10> if self._datagram_padding and final:
<11> if self.remaining_space:
<12> buf.push_bytes(bytes(self.remaining_space))
<13> packet_size = buf.tell() - self._packet_start
<14> self._packet.in_flight = True
<15>
<16> # log frame
<17> if self._quic_logger is not None:
<18> self._packet.quic_logger_frames.append(
<19> self._quic_logger.encode_padding_frame()
<20> )
<21>
<22> # write header
<23> if self._packet_long_header:
<24> length = (
<25> packet_size
<26> - self._header_size
<27> + PACKET_NUMBER_SEND_SIZE
<28> + self._packet_crypto.aead_tag_size
<29> )
<30>
<31> buf.seek(self._packet_start)
<32> buf.push_uint8(self._packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
<33> buf.push_uint32(self._version)
<34> buf.push_uint8(len(self._peer_cid))
<35> buf.push_bytes(self._peer_cid)
<36> buf.push_uint8(len(self._host_cid))
<37> buf.push_bytes(self._host_cid)
<38> if (self._packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
<39> buf.push_uint_var(len(</s>
|
===========below chunk 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def _end_packet(self, final: bool) -> None:
# offset: 1
buf.push_bytes(self._peer_token)
buf.push_uint16(length | 0x4000)
buf.push_uint16(self._packet_number & 0xFFFF)
else:
buf.seek(self._packet_start)
buf.push_uint8(
self._packet_type
| (self._spin_bit << 5)
| (self._packet_crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1)
)
buf.push_bytes(self._peer_cid)
buf.push_uint16(self._packet_number & 0xFFFF)
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
buf.seek(self._packet_start + packet_size)
buf.push_bytes(bytes(padding_size))
packet_size += padding_size
self._packet.in_flight = True
# log frame
if self._quic_logger is not None:
self._packet.quic_logger_frames.append(
self._quic_logger.encode_padding_frame()
)
# encrypt in place
plain = buf.data_slice(self._packet_start, self._packet_start + packet_size)
buf.seek(self._packet_start)
buf.push_bytes(
self._packet_crypto.encrypt_packet(
plain[0 : self._header_size],
plain[self._header_size : packet_size],
self._packet_number,
)
)
self._packet.sent_bytes = buf.tell() - self._packet_start
self._packets.append(self._packet)
if self._packet.in</s>
===========below chunk 1===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def _end_packet(self, final: bool) -> None:
# offset: 2
<s>.tell() - self._packet_start
self._packets.append(self._packet)
if self._packet.in_flight:
self._datagram_flight_bytes += self._packet.sent_bytes
# short header packets cannot be coallesced, we need a new datagram
if not self._packet_long_header:
self._flush_current_datagram()
self._packet_number += 1
else:
# "cancel" the packet
buf.seek(self._packet_start)
self._packet = None
self.quic_logger_frames = None
===========unchanged ref 0===========
at: aioquic.quic.packet_builder
PACKET_NUMBER_SEND_SIZE = 2
at: aioquic.quic.packet_builder.QuicPacketBuilder
_flush_current_datagram() -> None
_flush_current_datagram(self) -> None
at: aioquic.quic.packet_builder.QuicPacketBuilder.__init__
self._host_cid = host_cid
self._is_client = is_client
self._peer_cid = peer_cid
self._peer_token = peer_token
self._quic_logger = quic_logger
self._spin_bit = spin_bit
self._version = version
self._datagram_flight_bytes = 0
self._datagram_padding = False
self._packets: List[QuicSentPacket] = []
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self._buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.quic.packet_builder.QuicPacketBuilder.flush
self._packets = []
at: aioquic.quic.packet_builder.QuicPacketBuilder.start_packet
self._datagram_flight_bytes = 0
self._datagram_padding = False
self._header_size = header_size
self._packet = QuicSentPacket(
epoch=epoch,
in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
packet_type=packet_type,
)
self._packet_crypto = crypto
self._packet_long_header = packet_long_header
===========unchanged ref 1===========
self._packet_start = packet_start
self._packet_type = packet_type
at: aioquic.quic.packet_builder.QuicSentPacket
in_flight: bool
sent_bytes: int = 0
quic_logger_frames: List[Dict] = field(default_factory=list)
===========changed ref 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
"""
Returns the remaining number of bytes which can be used in
the current packet.
"""
return (
self._buffer_capacity
+ - self._buffer.tell()
- - self.buffer.tell()
- self._packet_crypto.aead_tag_size
)
===========changed ref 1===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def packet_is_empty(self) -> bool:
"""
Returns `True` if the current packet is empty.
"""
assert self._packet is not None
+ packet_size = self._buffer.tell() - self._packet_start
- packet_size = self.buffer.tell() - self._packet_start
return packet_size <= self._header_size
===========changed ref 2===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
+ ) -> Buffer:
- ) -> None:
"""
Starts a new frame.
"""
+ self._buffer.push_uint_var(frame_type)
- self.buffer.push_uint_var(frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
self._packet.is_ack_eliciting = True
if frame_type not in NON_IN_FLIGHT_FRAME_TYPES:
self._packet.in_flight = True
if frame_type == QuicFrameType.CRYPTO:
self._packet.is_crypto_packet = True
if handler is not None:
self._packet.delivery_handlers.append((handler, args))
+ return self._buffer
|
aioquic.quic.packet_builder/QuicPacketBuilder._flush_current_datagram
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<0>:<add> datagram_bytes = self._buffer.tell()
<del> datagram_bytes = self.buffer.tell()
<2>:<add> self._datagrams.append(self._buffer.data)
<del> self._datagrams.append(self.buffer.data)
<6>:<add> self._buffer.seek(0)
<del> self.buffer.seek(0)
|
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def _flush_current_datagram(self) -> None:
<0> datagram_bytes = self.buffer.tell()
<1> if datagram_bytes:
<2> self._datagrams.append(self.buffer.data)
<3> self._flight_bytes += self._datagram_flight_bytes
<4> self._total_bytes += datagram_bytes
<5> self._datagram_init = True
<6> self.buffer.seek(0)
<7>
|
===========unchanged ref 0===========
at: aioquic.quic.packet_builder.QuicPacketBuilder.__init__
self._datagrams: List[bytes] = []
self._datagram_flight_bytes = 0
self._datagram_init = True
self._flight_bytes = 0
self._total_bytes = 0
self._buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.quic.packet_builder.QuicPacketBuilder._end_packet
self._datagram_flight_bytes += self._packet.sent_bytes
at: aioquic.quic.packet_builder.QuicPacketBuilder.flush
self._datagrams = []
at: aioquic.quic.packet_builder.QuicPacketBuilder.start_packet
self._datagram_flight_bytes = 0
self._datagram_init = False
===========changed ref 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
"""
Returns the remaining number of bytes which can be used in
the current packet.
"""
return (
self._buffer_capacity
+ - self._buffer.tell()
- - self.buffer.tell()
- self._packet_crypto.aead_tag_size
)
===========changed ref 1===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def packet_is_empty(self) -> bool:
"""
Returns `True` if the current packet is empty.
"""
assert self._packet is not None
+ packet_size = self._buffer.tell() - self._packet_start
- packet_size = self.buffer.tell() - self._packet_start
return packet_size <= self._header_size
===========changed ref 2===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
+ ) -> Buffer:
- ) -> None:
"""
Starts a new frame.
"""
+ self._buffer.push_uint_var(frame_type)
- self.buffer.push_uint_var(frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
self._packet.is_ack_eliciting = True
if frame_type not in NON_IN_FLIGHT_FRAME_TYPES:
self._packet.in_flight = True
if frame_type == QuicFrameType.CRYPTO:
self._packet.is_crypto_packet = True
if handler is not None:
self._packet.delivery_handlers.append((handler, args))
+ return self._buffer
===========changed ref 3===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
is_client: bool,
packet_number: int = 0,
peer_token: bytes = b"",
quic_logger: Optional[QuicLoggerTrace] = None,
spin_bit: bool = False,
):
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
self._is_client = is_client
self._peer_cid = peer_cid
self._peer_token = peer_token
self._quic_logger = quic_logger
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._datagrams: List[bytes] = []
self._datagram_flight_bytes = 0
self._datagram_init = True
self._datagram_padding = False
self._packets: List[QuicSentPacket] = []
self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
+ self._buffer = Buffer(PACKET_MAX_SIZE)
- self.buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
===========changed ref 4===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
+ buf = self._buffer
- buf = self.buffer
# finish previous datagram
if self._packet is not None:
self._end_packet(final=False)
# if there is too little space remaining, start a new datagram
# FIXME: the limit is arbitrary!
packet_start = buf.tell()
if self._buffer_capacity - packet_start < 128:
self._flush_current_datagram()
packet_start = 0
# initialize datagram if needed
if self._datagram_init:
if self.max_flight_bytes is not None:
remaining_flight_bytes = self.max_flight_bytes - self._flight_bytes
if remaining_flight_bytes < self._buffer_capacity:
self._buffer_capacity = remaining_flight_bytes
if self.max_total_bytes is not None:
remaining_total_bytes = self.max_total_bytes - self._total_bytes
if remaining_total_bytes < self._buffer_capacity:
self._buffer_capacity = remaining_total_bytes
self._datagram_flight_bytes = 0
self._datagram_init = False
self._datagram_padding = False
# calculate header size
packet_long_header = is_long_header(packet_type)
if packet_long_header:
header_size = 11 + len(self._peer_cid) + len(self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
token_length = len(self._peer_token)
header_size += size_uint_var(token_length) + token_length
else:
header_size = 3 + len(self._peer_cid)
# check we have enough space
if packet_start + header_size >= self._buffer_capacity</s>
|
tests.test_connection/QuicConnectionTest.test_receive_datagram_wrong_version
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<11>:<add> buf = builder.start_frame(QuicFrameType.PADDING)
<add> buf.push_bytes(bytes(builder.remaining_space))
<del> builder.buffer.push_bytes(bytes(1200))
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_receive_datagram_wrong_version(self):
<0> client = create_standalone_client(self)
<1>
<2> builder = QuicPacketBuilder(
<3> host_cid=client._peer_cid,
<4> is_client=False,
<5> peer_cid=client.host_cid,
<6> version=0xFF000011, # DRAFT_16
<7> )
<8> crypto = CryptoPair()
<9> crypto.setup_initial(client.host_cid, is_client=False, version=client._version)
<10> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<11> builder.buffer.push_bytes(bytes(1200))
<12>
<13> for datagram in builder.flush()[0]:
<14> client.receive_datagram(datagram, SERVER_ADDR, now=time.time())
<15> self.assertEqual(drop(client), 0)
<16>
|
===========unchanged ref 0===========
at: tests.test_connection
SERVER_ADDR = ("2.3.4.5", 4433)
create_standalone_client(self)
drop(sender)
at: time
time() -> float
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
"""
Returns the remaining number of bytes which can be used in
the current packet.
"""
return (
self._buffer_capacity
+ - self._buffer.tell()
- - self.buffer.tell()
- self._packet_crypto.aead_tag_size
)
===========changed ref 1===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def packet_is_empty(self) -> bool:
"""
Returns `True` if the current packet is empty.
"""
assert self._packet is not None
+ packet_size = self._buffer.tell() - self._packet_start
- packet_size = self.buffer.tell() - self._packet_start
return packet_size <= self._header_size
===========changed ref 2===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def _flush_current_datagram(self) -> None:
+ datagram_bytes = self._buffer.tell()
- datagram_bytes = self.buffer.tell()
if datagram_bytes:
+ self._datagrams.append(self._buffer.data)
- self._datagrams.append(self.buffer.data)
self._flight_bytes += self._datagram_flight_bytes
self._total_bytes += datagram_bytes
self._datagram_init = True
+ self._buffer.seek(0)
- self.buffer.seek(0)
===========changed ref 3===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
+ ) -> Buffer:
- ) -> None:
"""
Starts a new frame.
"""
+ self._buffer.push_uint_var(frame_type)
- self.buffer.push_uint_var(frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
self._packet.is_ack_eliciting = True
if frame_type not in NON_IN_FLIGHT_FRAME_TYPES:
self._packet.in_flight = True
if frame_type == QuicFrameType.CRYPTO:
self._packet.is_crypto_packet = True
if handler is not None:
self._packet.delivery_handlers.append((handler, args))
+ return self._buffer
===========changed ref 4===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
is_client: bool,
packet_number: int = 0,
peer_token: bytes = b"",
quic_logger: Optional[QuicLoggerTrace] = None,
spin_bit: bool = False,
):
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
self._is_client = is_client
self._peer_cid = peer_cid
self._peer_token = peer_token
self._quic_logger = quic_logger
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._datagrams: List[bytes] = []
self._datagram_flight_bytes = 0
self._datagram_init = True
self._datagram_padding = False
self._packets: List[QuicSentPacket] = []
self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
+ self._buffer = Buffer(PACKET_MAX_SIZE)
- self.buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
===========changed ref 5===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
+ buf = self._buffer
- buf = self.buffer
# finish previous datagram
if self._packet is not None:
self._end_packet(final=False)
# if there is too little space remaining, start a new datagram
# FIXME: the limit is arbitrary!
packet_start = buf.tell()
if self._buffer_capacity - packet_start < 128:
self._flush_current_datagram()
packet_start = 0
# initialize datagram if needed
if self._datagram_init:
if self.max_flight_bytes is not None:
remaining_flight_bytes = self.max_flight_bytes - self._flight_bytes
if remaining_flight_bytes < self._buffer_capacity:
self._buffer_capacity = remaining_flight_bytes
if self.max_total_bytes is not None:
remaining_total_bytes = self.max_total_bytes - self._total_bytes
if remaining_total_bytes < self._buffer_capacity:
self._buffer_capacity = remaining_total_bytes
self._datagram_flight_bytes = 0
self._datagram_init = False
self._datagram_padding = False
# calculate header size
packet_long_header = is_long_header(packet_type)
if packet_long_header:
header_size = 11 + len(self._peer_cid) + len(self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
token_length = len(self._peer_token)
header_size += size_uint_var(token_length) + token_length
else:
header_size = 3 + len(self._peer_cid)
# check we have enough space
if packet_start + header_size >= self._buffer_capacity</s>
|
aioquic.quic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<11>:<del>
<12>:<del> buf = builder.buffer
<32>:<add> buf = builder.start_frame(QuicFrameType.PATH_CHALLENGE)
<del> builder.start_frame(QuicFrameType.PATH_CHALLENGE)
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
<0> crypto_stream: Optional[QuicStream] = None
<1> if self._cryptos[tls.Epoch.ONE_RTT].send.is_valid():
<2> crypto = self._cryptos[tls.Epoch.ONE_RTT]
<3> crypto_stream = self._crypto_streams[tls.Epoch.ONE_RTT]
<4> packet_type = PACKET_TYPE_ONE_RTT
<5> elif self._cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
<6> crypto = self._cryptos[tls.Epoch.ZERO_RTT]
<7> packet_type = PACKET_TYPE_ZERO_RTT
<8> else:
<9> return
<10> space = self._spaces[tls.Epoch.ONE_RTT]
<11>
<12> buf = builder.buffer
<13>
<14> while True:
<15> # write header
<16> builder.start_packet(packet_type, crypto)
<17>
<18> if self._handshake_complete:
<19> # ACK
<20> if space.ack_at is not None and space.ack_at <= now:
<21> self._write_ack_frame(builder=builder, space=space)
<22>
<23> # PATH CHALLENGE
<24> if (
<25> not network_path.is_validated
<26> and network_path.local_challenge is None
<27> ):
<28> self._logger.debug(
<29> "Network path %s sending challenge", network_path.addr
<30> )
<31> network_path.local_challenge = os.urandom(8)
<32> builder.start_frame(QuicFrameType.PATH_CHALLENGE)
<33> buf.push_bytes(network_path.local_challenge)
<34>
<35> # log frame
<36> if self._quic_logger is not None:
<37> builder.quic_logger_frames.append(
<38> self._quic_logger.encode</s>
|
===========below chunk 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
# offset: 1
data=network_path.local_challenge
)
)
# PATH RESPONSE
if network_path.remote_challenge is not None:
challenge = network_path.remote_challenge
builder.start_frame(QuicFrameType.PATH_RESPONSE)
buf.push_bytes(challenge)
network_path.remote_challenge = None
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_path_response_frame(data=challenge)
)
# NEW_CONNECTION_ID
for connection_id in self._host_cids:
if not connection_id.was_sent:
self._write_new_connection_id_frame(
builder=builder, connection_id=connection_id
)
# RETIRE_CONNECTION_ID
while self._retire_connection_ids:
sequence_number = self._retire_connection_ids.pop(0)
self._write_retire_connection_id_frame(
builder=builder, sequence_number=sequence_number
)
# STREAMS_BLOCKED
if self._streams_blocked_pending:
if self._streams_blocked_bidi:
self._write_streams_blocked_frame(
builder=builder,
frame_type=QuicFrameType.STREAMS_BLOCKED_BIDI,
limit=self._remote_max_streams_bidi,
)
if self._streams_blocked_uni:
self._write_streams_blocked_frame(
builder=builder,
frame_type=QuicFrameType.STREAMS_BLOCKED_UNI,
limit=self._remote_max_streams_uni,
)
self._streams_blocked_pending = False
# connection-</s>
===========below chunk 1===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
# offset: 2
<s>._remote_max_streams_uni,
)
self._streams_blocked_pending = False
# connection-level limits
self._write_connection_limits(builder=builder, space=space)
# stream-level limits
for stream in self._streams.values():
self._write_stream_limits(builder=builder, space=space, stream=stream)
# PING (user-request)
if self._ping_pending:
self._logger.info("Sending PING in packet %d", builder.packet_number)
self._write_ping_frame(builder, self._ping_pending)
self._ping_pending.clear()
# PING (probe)
if self._probe_pending:
self._logger.info(
"Sending PING (probe) in packet %d", builder.packet_number
)
self._write_ping_frame(builder)
self._probe_pending = False
# CRYPTO
if crypto_stream is not None and not crypto_stream.send_buffer_is_empty:
self._write_crypto_frame(
builder=builder, space=space, stream=crypto_stream
)
for stream in self._streams.values():
# STREAM
if not stream.is_blocked and not stream.send_buffer_is_empty:
self._remote_max_data_used += self._write_stream_frame(
builder=builder,
space=space,
stream=stream,
max_offset=min(
stream._send_highest
+ self._remote_max_data
- self._remote_max_data_used,
stream.max_stream_data_remote,
),
===========unchanged ref 0===========
at: aioquic.quic.connection
QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, is_validated: bool=False, local_challenge: Optional[bytes]=None, remote_challenge: Optional[bytes]=None)
at: aioquic.quic.connection.QuicConnection
_write_ack_frame(self, builder: QuicPacketBuilder, space: QuicPacketSpace)
_write_ack_frame(builder: QuicPacketBuilder, space: QuicPacketSpace)
_write_connection_limits(self, builder: QuicPacketBuilder, space: QuicPacketSpace) -> None
_write_connection_limits(builder: QuicPacketBuilder, space: QuicPacketSpace) -> None
_write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
_write_crypto_frame(self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
_write_new_connection_id_frame(builder: QuicPacketBuilder, connection_id: QuicConnectionId) -> None
_write_new_connection_id_frame(self, builder: QuicPacketBuilder, connection_id: QuicConnectionId) -> None
_write_ping_frame(builder: QuicPacketBuilder, uids: List[int]=[])
_write_ping_frame(self, builder: QuicPacketBuilder, uids: List[int]=[])
_write_retire_connection_id_frame(builder: QuicPacketBuilder, sequence_number: int) -> None
_write_stream_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream, max_offset: int) -> int
_write_stream_frame(self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream, max_offset: int) -> int
===========unchanged ref 1===========
_write_stream_limits(self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
_write_stream_limits(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
_write_streams_blocked_frame(builder: QuicPacketBuilder, frame_type: QuicFrameType, limit: int) -> None
_write_streams_blocked_frame(self, builder: QuicPacketBuilder, frame_type: QuicFrameType, limit: int) -> None
at: aioquic.quic.connection.QuicConnection.__init__
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
self._handshake_complete = False
self._host_cids = [
QuicConnectionId(
cid=os.urandom(configuration.connection_id_length),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._spaces: Dict[tls.Epoch, QuicPacketSpace] = {}
self._streams: Dict[int, QuicStream] = {}
self._streams_blocked_bidi: List[QuicStream] = []
self._streams_blocked_uni: List[QuicStream] = []
self._logger = QuicConnectionAdapter(
logger, {"id": dump_cid(logger_connection_id)}
)
|
aioquic.quic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<4>:<del> buf = builder.buffer
<27>:<add> buf = builder.start_frame(QuicFrameType.PADDING)
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
<0> crypto = self._cryptos[epoch]
<1> if not crypto.send.is_valid():
<2> return
<3>
<4> buf = builder.buffer
<5> crypto_stream = self._crypto_streams[epoch]
<6> space = self._spaces[epoch]
<7>
<8> while True:
<9> if epoch == tls.Epoch.INITIAL:
<10> packet_type = PACKET_TYPE_INITIAL
<11> else:
<12> packet_type = PACKET_TYPE_HANDSHAKE
<13> builder.start_packet(packet_type, crypto)
<14>
<15> # ACK
<16> if space.ack_at is not None:
<17> self._write_ack_frame(builder=builder, space=space)
<18>
<19> # CRYPTO
<20> if not crypto_stream.send_buffer_is_empty:
<21> self._write_crypto_frame(
<22> builder=builder, space=space, stream=crypto_stream
<23> )
<24>
<25> # PADDING (anti-deadlock packet)
<26> if self._probe_pending and self._is_client and epoch == tls.Epoch.HANDSHAKE:
<27> buf.push_bytes(bytes(builder.remaining_space))
<28> self._probe_pending = False
<29>
<30> if builder.packet_is_empty:
<31> break
<32>
|
===========unchanged ref 0===========
at: aioquic.quic.connection.QuicConnection
_write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
_write_crypto_frame(self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
at: aioquic.quic.connection.QuicConnection.__init__
self._is_client = configuration.is_client
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
self._spaces: Dict[tls.Epoch, QuicPacketSpace] = {}
self._probe_pending = False
at: aioquic.quic.connection.QuicConnection._initialize
self._crypto_streams = {
tls.Epoch.INITIAL: QuicStream(),
tls.Epoch.HANDSHAKE: QuicStream(),
tls.Epoch.ONE_RTT: QuicStream(),
}
self._spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.quic.connection.QuicConnection._send_probe
self._probe_pending = True
at: aioquic.quic.connection.QuicConnection._write_application
self._probe_pending = False
at: aioquic.quic.connection.QuicConnection._write_handshake
crypto = self._cryptos[epoch]
===========changed ref 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
"""
Returns the remaining number of bytes which can be used in
the current packet.
"""
return (
self._buffer_capacity
+ - self._buffer.tell()
- - self.buffer.tell()
- self._packet_crypto.aead_tag_size
)
===========changed ref 1===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def packet_is_empty(self) -> bool:
"""
Returns `True` if the current packet is empty.
"""
assert self._packet is not None
+ packet_size = self._buffer.tell() - self._packet_start
- packet_size = self.buffer.tell() - self._packet_start
return packet_size <= self._header_size
===========changed ref 2===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def _flush_current_datagram(self) -> None:
+ datagram_bytes = self._buffer.tell()
- datagram_bytes = self.buffer.tell()
if datagram_bytes:
+ self._datagrams.append(self._buffer.data)
- self._datagrams.append(self.buffer.data)
self._flight_bytes += self._datagram_flight_bytes
self._total_bytes += datagram_bytes
self._datagram_init = True
+ self._buffer.seek(0)
- self.buffer.seek(0)
===========changed ref 3===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
+ ) -> Buffer:
- ) -> None:
"""
Starts a new frame.
"""
+ self._buffer.push_uint_var(frame_type)
- self.buffer.push_uint_var(frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
self._packet.is_ack_eliciting = True
if frame_type not in NON_IN_FLIGHT_FRAME_TYPES:
self._packet.in_flight = True
if frame_type == QuicFrameType.CRYPTO:
self._packet.is_crypto_packet = True
if handler is not None:
self._packet.delivery_handlers.append((handler, args))
+ return self._buffer
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_receive_datagram_wrong_version(self):
client = create_standalone_client(self)
builder = QuicPacketBuilder(
host_cid=client._peer_cid,
is_client=False,
peer_cid=client.host_cid,
version=0xFF000011, # DRAFT_16
)
crypto = CryptoPair()
crypto.setup_initial(client.host_cid, is_client=False, version=client._version)
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
+ buf = builder.start_frame(QuicFrameType.PADDING)
+ buf.push_bytes(bytes(builder.remaining_space))
- builder.buffer.push_bytes(bytes(1200))
for datagram in builder.flush()[0]:
client.receive_datagram(datagram, SERVER_ADDR, now=time.time())
self.assertEqual(drop(client), 0)
===========changed ref 5===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
crypto_stream: Optional[QuicStream] = None
if self._cryptos[tls.Epoch.ONE_RTT].send.is_valid():
crypto = self._cryptos[tls.Epoch.ONE_RTT]
crypto_stream = self._crypto_streams[tls.Epoch.ONE_RTT]
packet_type = PACKET_TYPE_ONE_RTT
elif self._cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
crypto = self._cryptos[tls.Epoch.ZERO_RTT]
packet_type = PACKET_TYPE_ZERO_RTT
else:
return
space = self._spaces[tls.Epoch.ONE_RTT]
-
- buf = builder.buffer
while True:
# write header
builder.start_packet(packet_type, crypto)
if self._handshake_complete:
# ACK
if space.ack_at is not None and space.ack_at <= now:
self._write_ack_frame(builder=builder, space=space)
# PATH CHALLENGE
if (
not network_path.is_validated
and network_path.local_challenge is None
):
self._logger.debug(
"Network path %s sending challenge", network_path.addr
)
network_path.local_challenge = os.urandom(8)
+ buf = builder.start_frame(QuicFrameType.PATH_CHALLENGE)
- builder.start_frame(QuicFrameType.PATH_CHALLENGE)
buf.push_bytes(network_path.local_challenge)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_path_challenge_frame(
data=network_</s>
|
aioquic.quic.connection/QuicConnection._write_ack_frame
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<0>:<add> buf = builder.start_frame(
<del> builder.start_frame(
<5>:<add> push_ack_frame(buf, space.ack_queue, 0)
<del> push_ack_frame(builder.buffer, space.ack_queue, 0)
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_ack_frame(self, builder: QuicPacketBuilder, space: QuicPacketSpace):
<0> builder.start_frame(
<1> QuicFrameType.ACK,
<2> self._on_ack_delivery,
<3> (space, space.largest_received_packet),
<4> )
<5> push_ack_frame(builder.buffer, space.ack_queue, 0)
<6> space.ack_at = None
<7>
<8> # log frame
<9> if self._quic_logger is not None:
<10> builder.quic_logger_frames.append(
<11> self._quic_logger.encode_ack_frame(ranges=space.ack_queue, delay=0.0)
<12> )
<13>
|
===========unchanged ref 0===========
at: aioquic.quic.connection.QuicConnection
_on_ack_delivery(delivery: QuicDeliveryState, space: QuicPacketSpace, highest_acked: int) -> None
at: aioquic.quic.connection.QuicConnection.__init__
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
at: aioquic.quic.connection.QuicConnection._write_ack_frame
buf = builder.start_frame(
QuicFrameType.ACK,
self._on_ack_delivery,
(space, space.largest_received_packet),
)
===========changed ref 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
crypto = self._cryptos[epoch]
if not crypto.send.is_valid():
return
- buf = builder.buffer
crypto_stream = self._crypto_streams[epoch]
space = self._spaces[epoch]
while True:
if epoch == tls.Epoch.INITIAL:
packet_type = PACKET_TYPE_INITIAL
else:
packet_type = PACKET_TYPE_HANDSHAKE
builder.start_packet(packet_type, crypto)
# ACK
if space.ack_at is not None:
self._write_ack_frame(builder=builder, space=space)
# CRYPTO
if not crypto_stream.send_buffer_is_empty:
self._write_crypto_frame(
builder=builder, space=space, stream=crypto_stream
)
# PADDING (anti-deadlock packet)
if self._probe_pending and self._is_client and epoch == tls.Epoch.HANDSHAKE:
+ buf = builder.start_frame(QuicFrameType.PADDING)
buf.push_bytes(bytes(builder.remaining_space))
self._probe_pending = False
if builder.packet_is_empty:
break
===========changed ref 1===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
"""
Returns the remaining number of bytes which can be used in
the current packet.
"""
return (
self._buffer_capacity
+ - self._buffer.tell()
- - self.buffer.tell()
- self._packet_crypto.aead_tag_size
)
===========changed ref 2===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def packet_is_empty(self) -> bool:
"""
Returns `True` if the current packet is empty.
"""
assert self._packet is not None
+ packet_size = self._buffer.tell() - self._packet_start
- packet_size = self.buffer.tell() - self._packet_start
return packet_size <= self._header_size
===========changed ref 3===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def _flush_current_datagram(self) -> None:
+ datagram_bytes = self._buffer.tell()
- datagram_bytes = self.buffer.tell()
if datagram_bytes:
+ self._datagrams.append(self._buffer.data)
- self._datagrams.append(self.buffer.data)
self._flight_bytes += self._datagram_flight_bytes
self._total_bytes += datagram_bytes
self._datagram_init = True
+ self._buffer.seek(0)
- self.buffer.seek(0)
===========changed ref 4===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
+ ) -> Buffer:
- ) -> None:
"""
Starts a new frame.
"""
+ self._buffer.push_uint_var(frame_type)
- self.buffer.push_uint_var(frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
self._packet.is_ack_eliciting = True
if frame_type not in NON_IN_FLIGHT_FRAME_TYPES:
self._packet.in_flight = True
if frame_type == QuicFrameType.CRYPTO:
self._packet.is_crypto_packet = True
if handler is not None:
self._packet.delivery_handlers.append((handler, args))
+ return self._buffer
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_receive_datagram_wrong_version(self):
client = create_standalone_client(self)
builder = QuicPacketBuilder(
host_cid=client._peer_cid,
is_client=False,
peer_cid=client.host_cid,
version=0xFF000011, # DRAFT_16
)
crypto = CryptoPair()
crypto.setup_initial(client.host_cid, is_client=False, version=client._version)
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
+ buf = builder.start_frame(QuicFrameType.PADDING)
+ buf.push_bytes(bytes(builder.remaining_space))
- builder.buffer.push_bytes(bytes(1200))
for datagram in builder.flush()[0]:
client.receive_datagram(datagram, SERVER_ADDR, now=time.time())
self.assertEqual(drop(client), 0)
===========changed ref 6===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
is_client: bool,
packet_number: int = 0,
peer_token: bytes = b"",
quic_logger: Optional[QuicLoggerTrace] = None,
spin_bit: bool = False,
):
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
self._is_client = is_client
self._peer_cid = peer_cid
self._peer_token = peer_token
self._quic_logger = quic_logger
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._datagrams: List[bytes] = []
self._datagram_flight_bytes = 0
self._datagram_init = True
self._datagram_padding = False
self._packets: List[QuicSentPacket] = []
self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
+ self._buffer = Buffer(PACKET_MAX_SIZE)
- self.buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
|
aioquic.quic.connection/QuicConnection._write_close_frame
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<0>:<del> buf = builder.buffer
<1>:<del>
<5>:<add> buf = builder.start_frame(QuicFrameType.APPLICATION_CLOSE)
<del> builder.start_frame(QuicFrameType.APPLICATION_CLOSE)
<10>:<add> buf = builder.start_frame(QuicFrameType.TRANSPORT_CLOSE)
<del> builder.start_frame(QuicFrameType.TRANSPORT_CLOSE)
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_close_frame(
self,
builder: QuicPacketBuilder,
error_code: int,
frame_type: Optional[int],
reason_phrase: str,
) -> None:
<0> buf = builder.buffer
<1>
<2> reason_bytes = reason_phrase.encode("utf8")
<3>
<4> if frame_type is None:
<5> builder.start_frame(QuicFrameType.APPLICATION_CLOSE)
<6> buf.push_uint_var(error_code)
<7> buf.push_uint_var(len(reason_bytes))
<8> buf.push_bytes(reason_bytes)
<9> else:
<10> builder.start_frame(QuicFrameType.TRANSPORT_CLOSE)
<11> buf.push_uint_var(error_code)
<12> buf.push_uint_var(frame_type)
<13> buf.push_uint_var(len(reason_bytes))
<14> buf.push_bytes(reason_bytes)
<15>
<16> # log frame
<17> if self._quic_logger is not None:
<18> builder.quic_logger_frames.append(
<19> self._quic_logger.encode_connection_close_frame(
<20> error_code=error_code,
<21> frame_type=frame_type,
<22> reason_phrase=reason_phrase,
<23> )
<24> )
<25>
|
===========unchanged ref 0===========
at: aioquic.quic.connection.QuicConnection.__init__
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
===========changed ref 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_ack_frame(self, builder: QuicPacketBuilder, space: QuicPacketSpace):
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.ACK,
self._on_ack_delivery,
(space, space.largest_received_packet),
)
+ push_ack_frame(buf, space.ack_queue, 0)
- push_ack_frame(builder.buffer, space.ack_queue, 0)
space.ack_at = None
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_ack_frame(ranges=space.ack_queue, delay=0.0)
)
===========changed ref 1===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
crypto = self._cryptos[epoch]
if not crypto.send.is_valid():
return
- buf = builder.buffer
crypto_stream = self._crypto_streams[epoch]
space = self._spaces[epoch]
while True:
if epoch == tls.Epoch.INITIAL:
packet_type = PACKET_TYPE_INITIAL
else:
packet_type = PACKET_TYPE_HANDSHAKE
builder.start_packet(packet_type, crypto)
# ACK
if space.ack_at is not None:
self._write_ack_frame(builder=builder, space=space)
# CRYPTO
if not crypto_stream.send_buffer_is_empty:
self._write_crypto_frame(
builder=builder, space=space, stream=crypto_stream
)
# PADDING (anti-deadlock packet)
if self._probe_pending and self._is_client and epoch == tls.Epoch.HANDSHAKE:
+ buf = builder.start_frame(QuicFrameType.PADDING)
buf.push_bytes(bytes(builder.remaining_space))
self._probe_pending = False
if builder.packet_is_empty:
break
===========changed ref 2===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
"""
Returns the remaining number of bytes which can be used in
the current packet.
"""
return (
self._buffer_capacity
+ - self._buffer.tell()
- - self.buffer.tell()
- self._packet_crypto.aead_tag_size
)
===========changed ref 3===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def packet_is_empty(self) -> bool:
"""
Returns `True` if the current packet is empty.
"""
assert self._packet is not None
+ packet_size = self._buffer.tell() - self._packet_start
- packet_size = self.buffer.tell() - self._packet_start
return packet_size <= self._header_size
===========changed ref 4===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def _flush_current_datagram(self) -> None:
+ datagram_bytes = self._buffer.tell()
- datagram_bytes = self.buffer.tell()
if datagram_bytes:
+ self._datagrams.append(self._buffer.data)
- self._datagrams.append(self.buffer.data)
self._flight_bytes += self._datagram_flight_bytes
self._total_bytes += datagram_bytes
self._datagram_init = True
+ self._buffer.seek(0)
- self.buffer.seek(0)
===========changed ref 5===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
+ ) -> Buffer:
- ) -> None:
"""
Starts a new frame.
"""
+ self._buffer.push_uint_var(frame_type)
- self.buffer.push_uint_var(frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
self._packet.is_ack_eliciting = True
if frame_type not in NON_IN_FLIGHT_FRAME_TYPES:
self._packet.in_flight = True
if frame_type == QuicFrameType.CRYPTO:
self._packet.is_crypto_packet = True
if handler is not None:
self._packet.delivery_handlers.append((handler, args))
+ return self._buffer
===========changed ref 6===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_receive_datagram_wrong_version(self):
client = create_standalone_client(self)
builder = QuicPacketBuilder(
host_cid=client._peer_cid,
is_client=False,
peer_cid=client.host_cid,
version=0xFF000011, # DRAFT_16
)
crypto = CryptoPair()
crypto.setup_initial(client.host_cid, is_client=False, version=client._version)
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
+ buf = builder.start_frame(QuicFrameType.PADDING)
+ buf.push_bytes(bytes(builder.remaining_space))
- builder.buffer.push_bytes(bytes(1200))
for datagram in builder.flush()[0]:
client.receive_datagram(datagram, SERVER_ADDR, now=time.time())
self.assertEqual(drop(client), 0)
|
aioquic.quic.connection/QuicConnection._write_connection_limits
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<7>:<add> buf = builder.start_frame(
<add> QuicFrameType.MAX_DATA, self._on_max_data_delivery
<del> builder.start_frame(QuicFrameType.MAX_DATA, self._on_max_data_delivery)
<8>:<add> )
<add> buf.push_uint_var(self._local_max_data)
<del> builder.buffer.push_uint_var(self._local_max_data)
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_connection_limits(
self, builder: QuicPacketBuilder, space: QuicPacketSpace
) -> None:
<0> """
<1> Raise MAX_DATA if needed.
<2> """
<3> if self._local_max_data_used * 2 > self._local_max_data:
<4> self._local_max_data *= 2
<5> self._logger.debug("Local max_data raised to %d", self._local_max_data)
<6> if self._local_max_data_sent != self._local_max_data:
<7> builder.start_frame(QuicFrameType.MAX_DATA, self._on_max_data_delivery)
<8> builder.buffer.push_uint_var(self._local_max_data)
<9> self._local_max_data_sent = self._local_max_data
<10>
<11> # log frame
<12> if self._quic_logger is not None:
<13> builder.quic_logger_frames.append(
<14> self._quic_logger.encode_max_data_frame(self._local_max_data)
<15> )
<16>
|
===========unchanged ref 0===========
at: aioquic.quic.connection.QuicConnection
_on_max_data_delivery(delivery: QuicDeliveryState) -> None
at: aioquic.quic.connection.QuicConnection.__init__
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
self._logger = QuicConnectionAdapter(
logger, {"id": dump_cid(logger_connection_id)}
)
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
at: aioquic.quic.connection.QuicConnection._handle_stream_frame
self._local_max_data_used += newly_received
at: aioquic.quic.connection.QuicConnection._on_max_data_delivery
self._local_max_data_sent = 0
at: logging.LoggerAdapter
debug(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_ack_frame(self, builder: QuicPacketBuilder, space: QuicPacketSpace):
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.ACK,
self._on_ack_delivery,
(space, space.largest_received_packet),
)
+ push_ack_frame(buf, space.ack_queue, 0)
- push_ack_frame(builder.buffer, space.ack_queue, 0)
space.ack_at = None
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_ack_frame(ranges=space.ack_queue, delay=0.0)
)
===========changed ref 1===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_close_frame(
self,
builder: QuicPacketBuilder,
error_code: int,
frame_type: Optional[int],
reason_phrase: str,
) -> None:
- buf = builder.buffer
-
reason_bytes = reason_phrase.encode("utf8")
if frame_type is None:
+ buf = builder.start_frame(QuicFrameType.APPLICATION_CLOSE)
- builder.start_frame(QuicFrameType.APPLICATION_CLOSE)
buf.push_uint_var(error_code)
buf.push_uint_var(len(reason_bytes))
buf.push_bytes(reason_bytes)
else:
+ buf = builder.start_frame(QuicFrameType.TRANSPORT_CLOSE)
- builder.start_frame(QuicFrameType.TRANSPORT_CLOSE)
buf.push_uint_var(error_code)
buf.push_uint_var(frame_type)
buf.push_uint_var(len(reason_bytes))
buf.push_bytes(reason_bytes)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_connection_close_frame(
error_code=error_code,
frame_type=frame_type,
reason_phrase=reason_phrase,
)
)
===========changed ref 2===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
crypto = self._cryptos[epoch]
if not crypto.send.is_valid():
return
- buf = builder.buffer
crypto_stream = self._crypto_streams[epoch]
space = self._spaces[epoch]
while True:
if epoch == tls.Epoch.INITIAL:
packet_type = PACKET_TYPE_INITIAL
else:
packet_type = PACKET_TYPE_HANDSHAKE
builder.start_packet(packet_type, crypto)
# ACK
if space.ack_at is not None:
self._write_ack_frame(builder=builder, space=space)
# CRYPTO
if not crypto_stream.send_buffer_is_empty:
self._write_crypto_frame(
builder=builder, space=space, stream=crypto_stream
)
# PADDING (anti-deadlock packet)
if self._probe_pending and self._is_client and epoch == tls.Epoch.HANDSHAKE:
+ buf = builder.start_frame(QuicFrameType.PADDING)
buf.push_bytes(bytes(builder.remaining_space))
self._probe_pending = False
if builder.packet_is_empty:
break
===========changed ref 3===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
"""
Returns the remaining number of bytes which can be used in
the current packet.
"""
return (
self._buffer_capacity
+ - self._buffer.tell()
- - self.buffer.tell()
- self._packet_crypto.aead_tag_size
)
===========changed ref 4===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def packet_is_empty(self) -> bool:
"""
Returns `True` if the current packet is empty.
"""
assert self._packet is not None
+ packet_size = self._buffer.tell() - self._packet_start
- packet_size = self.buffer.tell() - self._packet_start
return packet_size <= self._header_size
===========changed ref 5===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def _flush_current_datagram(self) -> None:
+ datagram_bytes = self._buffer.tell()
- datagram_bytes = self.buffer.tell()
if datagram_bytes:
+ self._datagrams.append(self._buffer.data)
- self._datagrams.append(self.buffer.data)
self._flight_bytes += self._datagram_flight_bytes
self._total_bytes += datagram_bytes
self._datagram_init = True
+ self._buffer.seek(0)
- self.buffer.seek(0)
===========changed ref 6===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
+ ) -> Buffer:
- ) -> None:
"""
Starts a new frame.
"""
+ self._buffer.push_uint_var(frame_type)
- self.buffer.push_uint_var(frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
self._packet.is_ack_eliciting = True
if frame_type not in NON_IN_FLIGHT_FRAME_TYPES:
self._packet.in_flight = True
if frame_type == QuicFrameType.CRYPTO:
self._packet.is_crypto_packet = True
if handler is not None:
self._packet.delivery_handlers.append((handler, args))
+ return self._buffer
|
aioquic.quic.connection/QuicConnection._write_crypto_frame
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<0>:<del> buf = builder.buffer
<1>:<del>
<5>:<add> buf = builder.start_frame(
<del> builder.start_frame(
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_crypto_frame(
self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
<0> buf = builder.buffer
<1>
<2> frame_overhead = 3 + size_uint_var(stream.next_send_offset)
<3> frame = stream.get_frame(builder.remaining_space - frame_overhead)
<4> if frame is not None:
<5> builder.start_frame(
<6> QuicFrameType.CRYPTO,
<7> stream.on_data_delivery,
<8> (frame.offset, frame.offset + len(frame.data)),
<9> )
<10> buf.push_uint_var(frame.offset)
<11> buf.push_uint16(len(frame.data) | 0x4000)
<12> buf.push_bytes(frame.data)
<13>
<14> # log frame
<15> if self._quic_logger is not None:
<16> builder.quic_logger_frames.append(
<17> self._quic_logger.encode_crypto_frame(frame)
<18> )
<19>
|
===========unchanged ref 0===========
at: aioquic.quic.connection
QuicConnectionId(cid: bytes, sequence_number: int, stateless_reset_token: bytes=b"", was_sent: bool=False)
at: aioquic.quic.connection.QuicConnection.__init__
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
===========changed ref 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_ack_frame(self, builder: QuicPacketBuilder, space: QuicPacketSpace):
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.ACK,
self._on_ack_delivery,
(space, space.largest_received_packet),
)
+ push_ack_frame(buf, space.ack_queue, 0)
- push_ack_frame(builder.buffer, space.ack_queue, 0)
space.ack_at = None
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_ack_frame(ranges=space.ack_queue, delay=0.0)
)
===========changed ref 1===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_connection_limits(
self, builder: QuicPacketBuilder, space: QuicPacketSpace
) -> None:
"""
Raise MAX_DATA if needed.
"""
if self._local_max_data_used * 2 > self._local_max_data:
self._local_max_data *= 2
self._logger.debug("Local max_data raised to %d", self._local_max_data)
if self._local_max_data_sent != self._local_max_data:
+ buf = builder.start_frame(
+ QuicFrameType.MAX_DATA, self._on_max_data_delivery
- builder.start_frame(QuicFrameType.MAX_DATA, self._on_max_data_delivery)
+ )
+ buf.push_uint_var(self._local_max_data)
- builder.buffer.push_uint_var(self._local_max_data)
self._local_max_data_sent = self._local_max_data
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_max_data_frame(self._local_max_data)
)
===========changed ref 2===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_close_frame(
self,
builder: QuicPacketBuilder,
error_code: int,
frame_type: Optional[int],
reason_phrase: str,
) -> None:
- buf = builder.buffer
-
reason_bytes = reason_phrase.encode("utf8")
if frame_type is None:
+ buf = builder.start_frame(QuicFrameType.APPLICATION_CLOSE)
- builder.start_frame(QuicFrameType.APPLICATION_CLOSE)
buf.push_uint_var(error_code)
buf.push_uint_var(len(reason_bytes))
buf.push_bytes(reason_bytes)
else:
+ buf = builder.start_frame(QuicFrameType.TRANSPORT_CLOSE)
- builder.start_frame(QuicFrameType.TRANSPORT_CLOSE)
buf.push_uint_var(error_code)
buf.push_uint_var(frame_type)
buf.push_uint_var(len(reason_bytes))
buf.push_bytes(reason_bytes)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_connection_close_frame(
error_code=error_code,
frame_type=frame_type,
reason_phrase=reason_phrase,
)
)
===========changed ref 3===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
crypto = self._cryptos[epoch]
if not crypto.send.is_valid():
return
- buf = builder.buffer
crypto_stream = self._crypto_streams[epoch]
space = self._spaces[epoch]
while True:
if epoch == tls.Epoch.INITIAL:
packet_type = PACKET_TYPE_INITIAL
else:
packet_type = PACKET_TYPE_HANDSHAKE
builder.start_packet(packet_type, crypto)
# ACK
if space.ack_at is not None:
self._write_ack_frame(builder=builder, space=space)
# CRYPTO
if not crypto_stream.send_buffer_is_empty:
self._write_crypto_frame(
builder=builder, space=space, stream=crypto_stream
)
# PADDING (anti-deadlock packet)
if self._probe_pending and self._is_client and epoch == tls.Epoch.HANDSHAKE:
+ buf = builder.start_frame(QuicFrameType.PADDING)
buf.push_bytes(bytes(builder.remaining_space))
self._probe_pending = False
if builder.packet_is_empty:
break
===========changed ref 4===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
"""
Returns the remaining number of bytes which can be used in
the current packet.
"""
return (
self._buffer_capacity
+ - self._buffer.tell()
- - self.buffer.tell()
- self._packet_crypto.aead_tag_size
)
===========changed ref 5===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def packet_is_empty(self) -> bool:
"""
Returns `True` if the current packet is empty.
"""
assert self._packet is not None
+ packet_size = self._buffer.tell() - self._packet_start
- packet_size = self.buffer.tell() - self._packet_start
return packet_size <= self._header_size
===========changed ref 6===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def _flush_current_datagram(self) -> None:
+ datagram_bytes = self._buffer.tell()
- datagram_bytes = self.buffer.tell()
if datagram_bytes:
+ self._datagrams.append(self._buffer.data)
- self._datagrams.append(self.buffer.data)
self._flight_bytes += self._datagram_flight_bytes
self._total_bytes += datagram_bytes
self._datagram_init = True
+ self._buffer.seek(0)
- self.buffer.seek(0)
|
aioquic.quic.connection/QuicConnection._write_new_connection_id_frame
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<0>:<add> buf = builder.start_frame(
<del> builder.start_frame(
<11>:<add> push_new_connection_id_frame(buf, frame)
<del> push_new_connection_id_frame(builder.buffer, frame)
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_new_connection_id_frame(
self, builder: QuicPacketBuilder, connection_id: QuicConnectionId
) -> None:
<0> builder.start_frame(
<1> QuicFrameType.NEW_CONNECTION_ID,
<2> self._on_new_connection_id_delivery,
<3> (connection_id,),
<4> )
<5> frame = QuicNewConnectionIdFrame(
<6> sequence_number=connection_id.sequence_number,
<7> retire_prior_to=0, # FIXME
<8> connection_id=connection_id.cid,
<9> stateless_reset_token=connection_id.stateless_reset_token,
<10> )
<11> push_new_connection_id_frame(builder.buffer, frame)
<12> connection_id.was_sent = True
<13> self._events.append(events.ConnectionIdIssued(connection_id=connection_id.cid))
<14>
<15> # log frame
<16> if self._quic_logger is not None:
<17> builder.quic_logger_frames.append(
<18> self._quic_logger.encode_new_connection_id_frame(frame)
<19> )
<20>
|
===========unchanged ref 0===========
at: aioquic.quic.connection.QuicConnection
_on_new_connection_id_delivery(delivery: QuicDeliveryState, connection_id: QuicConnectionId) -> None
_on_ping_delivery(delivery: QuicDeliveryState, uids: Sequence[int]) -> None
at: aioquic.quic.connection.QuicConnection.__init__
self._events: Deque[events.QuicEvent] = deque()
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
at: aioquic.quic.connection.QuicConnection._write_new_connection_id_frame
buf = builder.start_frame(
QuicFrameType.NEW_CONNECTION_ID,
self._on_new_connection_id_delivery,
(connection_id,),
)
at: aioquic.quic.connection.QuicConnectionId
cid: bytes
sequence_number: int
stateless_reset_token: bytes = b""
was_sent: bool = False
at: collections.deque
append(x: _T) -> None
at: typing
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_crypto_frame(
self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
- buf = builder.buffer
-
frame_overhead = 3 + size_uint_var(stream.next_send_offset)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.CRYPTO,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
buf.push_uint_var(frame.offset)
buf.push_uint16(len(frame.data) | 0x4000)
buf.push_bytes(frame.data)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_crypto_frame(frame)
)
===========changed ref 1===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_ack_frame(self, builder: QuicPacketBuilder, space: QuicPacketSpace):
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.ACK,
self._on_ack_delivery,
(space, space.largest_received_packet),
)
+ push_ack_frame(buf, space.ack_queue, 0)
- push_ack_frame(builder.buffer, space.ack_queue, 0)
space.ack_at = None
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_ack_frame(ranges=space.ack_queue, delay=0.0)
)
===========changed ref 2===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_connection_limits(
self, builder: QuicPacketBuilder, space: QuicPacketSpace
) -> None:
"""
Raise MAX_DATA if needed.
"""
if self._local_max_data_used * 2 > self._local_max_data:
self._local_max_data *= 2
self._logger.debug("Local max_data raised to %d", self._local_max_data)
if self._local_max_data_sent != self._local_max_data:
+ buf = builder.start_frame(
+ QuicFrameType.MAX_DATA, self._on_max_data_delivery
- builder.start_frame(QuicFrameType.MAX_DATA, self._on_max_data_delivery)
+ )
+ buf.push_uint_var(self._local_max_data)
- builder.buffer.push_uint_var(self._local_max_data)
self._local_max_data_sent = self._local_max_data
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_max_data_frame(self._local_max_data)
)
===========changed ref 3===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_close_frame(
self,
builder: QuicPacketBuilder,
error_code: int,
frame_type: Optional[int],
reason_phrase: str,
) -> None:
- buf = builder.buffer
-
reason_bytes = reason_phrase.encode("utf8")
if frame_type is None:
+ buf = builder.start_frame(QuicFrameType.APPLICATION_CLOSE)
- builder.start_frame(QuicFrameType.APPLICATION_CLOSE)
buf.push_uint_var(error_code)
buf.push_uint_var(len(reason_bytes))
buf.push_bytes(reason_bytes)
else:
+ buf = builder.start_frame(QuicFrameType.TRANSPORT_CLOSE)
- builder.start_frame(QuicFrameType.TRANSPORT_CLOSE)
buf.push_uint_var(error_code)
buf.push_uint_var(frame_type)
buf.push_uint_var(len(reason_bytes))
buf.push_bytes(reason_bytes)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_connection_close_frame(
error_code=error_code,
frame_type=frame_type,
reason_phrase=reason_phrase,
)
)
===========changed ref 4===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
crypto = self._cryptos[epoch]
if not crypto.send.is_valid():
return
- buf = builder.buffer
crypto_stream = self._crypto_streams[epoch]
space = self._spaces[epoch]
while True:
if epoch == tls.Epoch.INITIAL:
packet_type = PACKET_TYPE_INITIAL
else:
packet_type = PACKET_TYPE_HANDSHAKE
builder.start_packet(packet_type, crypto)
# ACK
if space.ack_at is not None:
self._write_ack_frame(builder=builder, space=space)
# CRYPTO
if not crypto_stream.send_buffer_is_empty:
self._write_crypto_frame(
builder=builder, space=space, stream=crypto_stream
)
# PADDING (anti-deadlock packet)
if self._probe_pending and self._is_client and epoch == tls.Epoch.HANDSHAKE:
+ buf = builder.start_frame(QuicFrameType.PADDING)
buf.push_bytes(bytes(builder.remaining_space))
self._probe_pending = False
if builder.packet_is_empty:
break
|
aioquic.quic.connection/QuicConnection._write_retire_connection_id_frame
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<0>:<add> buf = builder.start_frame(
<del> builder.start_frame(
<5>:<add> buf.push_uint_var(sequence_number)
<del> builder.buffer.push_uint_var(sequence_number)
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_retire_connection_id_frame(
self, builder: QuicPacketBuilder, sequence_number: int
) -> None:
<0> builder.start_frame(
<1> QuicFrameType.RETIRE_CONNECTION_ID,
<2> self._on_retire_connection_id_delivery,
<3> (sequence_number,),
<4> )
<5> builder.buffer.push_uint_var(sequence_number)
<6>
<7> # log frame
<8> if self._quic_logger is not None:
<9> builder.quic_logger_frames.append(
<10> self._quic_logger.encode_retire_connection_id_frame(sequence_number)
<11> )
<12>
|
===========unchanged ref 0===========
at: aioquic.quic.connection.QuicConnection
_on_retire_connection_id_delivery(delivery: QuicDeliveryState, sequence_number: int) -> None
at: aioquic.quic.connection.QuicConnection.__init__
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
at: aioquic.quic.connection.QuicConnection._write_retire_connection_id_frame
buf = builder.start_frame(
QuicFrameType.RETIRE_CONNECTION_ID,
self._on_retire_connection_id_delivery,
(sequence_number,),
)
===========changed ref 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_crypto_frame(
self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
- buf = builder.buffer
-
frame_overhead = 3 + size_uint_var(stream.next_send_offset)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.CRYPTO,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
buf.push_uint_var(frame.offset)
buf.push_uint16(len(frame.data) | 0x4000)
buf.push_bytes(frame.data)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_crypto_frame(frame)
)
===========changed ref 1===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_new_connection_id_frame(
self, builder: QuicPacketBuilder, connection_id: QuicConnectionId
) -> None:
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.NEW_CONNECTION_ID,
self._on_new_connection_id_delivery,
(connection_id,),
)
frame = QuicNewConnectionIdFrame(
sequence_number=connection_id.sequence_number,
retire_prior_to=0, # FIXME
connection_id=connection_id.cid,
stateless_reset_token=connection_id.stateless_reset_token,
)
+ push_new_connection_id_frame(buf, frame)
- push_new_connection_id_frame(builder.buffer, frame)
connection_id.was_sent = True
self._events.append(events.ConnectionIdIssued(connection_id=connection_id.cid))
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_new_connection_id_frame(frame)
)
===========changed ref 2===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_ack_frame(self, builder: QuicPacketBuilder, space: QuicPacketSpace):
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.ACK,
self._on_ack_delivery,
(space, space.largest_received_packet),
)
+ push_ack_frame(buf, space.ack_queue, 0)
- push_ack_frame(builder.buffer, space.ack_queue, 0)
space.ack_at = None
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_ack_frame(ranges=space.ack_queue, delay=0.0)
)
===========changed ref 3===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_connection_limits(
self, builder: QuicPacketBuilder, space: QuicPacketSpace
) -> None:
"""
Raise MAX_DATA if needed.
"""
if self._local_max_data_used * 2 > self._local_max_data:
self._local_max_data *= 2
self._logger.debug("Local max_data raised to %d", self._local_max_data)
if self._local_max_data_sent != self._local_max_data:
+ buf = builder.start_frame(
+ QuicFrameType.MAX_DATA, self._on_max_data_delivery
- builder.start_frame(QuicFrameType.MAX_DATA, self._on_max_data_delivery)
+ )
+ buf.push_uint_var(self._local_max_data)
- builder.buffer.push_uint_var(self._local_max_data)
self._local_max_data_sent = self._local_max_data
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_max_data_frame(self._local_max_data)
)
===========changed ref 4===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_close_frame(
self,
builder: QuicPacketBuilder,
error_code: int,
frame_type: Optional[int],
reason_phrase: str,
) -> None:
- buf = builder.buffer
-
reason_bytes = reason_phrase.encode("utf8")
if frame_type is None:
+ buf = builder.start_frame(QuicFrameType.APPLICATION_CLOSE)
- builder.start_frame(QuicFrameType.APPLICATION_CLOSE)
buf.push_uint_var(error_code)
buf.push_uint_var(len(reason_bytes))
buf.push_bytes(reason_bytes)
else:
+ buf = builder.start_frame(QuicFrameType.TRANSPORT_CLOSE)
- builder.start_frame(QuicFrameType.TRANSPORT_CLOSE)
buf.push_uint_var(error_code)
buf.push_uint_var(frame_type)
buf.push_uint_var(len(reason_bytes))
buf.push_bytes(reason_bytes)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_connection_close_frame(
error_code=error_code,
frame_type=frame_type,
reason_phrase=reason_phrase,
)
)
|
aioquic.quic.connection/QuicConnection._write_stream_frame
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<0>:<del> buf = builder.buffer
<1>:<del>
<18>:<add> buf = builder.start_frame(
<del> builder.start_frame(
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_stream_frame(
self,
builder: QuicPacketBuilder,
space: QuicPacketSpace,
stream: QuicStream,
max_offset: int,
) -> int:
<0> buf = builder.buffer
<1>
<2> # the frame data size is constrained by our peer's MAX_DATA and
<3> # the space available in the current packet
<4> frame_overhead = (
<5> 3
<6> + size_uint_var(stream.stream_id)
<7> + (size_uint_var(stream.next_send_offset) if stream.next_send_offset else 0)
<8> )
<9> previous_send_highest = stream._send_highest
<10> frame = stream.get_frame(builder.remaining_space - frame_overhead, max_offset)
<11>
<12> if frame is not None:
<13> frame_type = QuicFrameType.STREAM_BASE | 2 # length
<14> if frame.offset:
<15> frame_type |= 4
<16> if frame.fin:
<17> frame_type |= 1
<18> builder.start_frame(
<19> frame_type,
<20> stream.on_data_delivery,
<21> (frame.offset, frame.offset + len(frame.data)),
<22> )
<23> buf.push_uint_var(stream.stream_id)
<24> if frame.offset:
<25> buf.push_uint_var(frame.offset)
<26> buf.push_uint16(len(frame.data) | 0x4000)
<27> buf.push_bytes(frame.data)
<28>
<29> # log frame
<30> if self._quic_logger is not None:
<31> builder.quic_logger_frames.append(
<32> self._quic_logger.encode_stream_frame(
<33> frame, stream_id=stream.stream_id
<34> )
<35> )
<36>
<37> return stream._send_highest - previous_send_highest
<38> else:
<39> return 0
<40>
|
===========unchanged ref 0===========
at: aioquic.quic.connection.QuicConnection.__init__
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
===========changed ref 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_retire_connection_id_frame(
self, builder: QuicPacketBuilder, sequence_number: int
) -> None:
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.RETIRE_CONNECTION_ID,
self._on_retire_connection_id_delivery,
(sequence_number,),
)
+ buf.push_uint_var(sequence_number)
- builder.buffer.push_uint_var(sequence_number)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_retire_connection_id_frame(sequence_number)
)
===========changed ref 1===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_crypto_frame(
self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
- buf = builder.buffer
-
frame_overhead = 3 + size_uint_var(stream.next_send_offset)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.CRYPTO,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
buf.push_uint_var(frame.offset)
buf.push_uint16(len(frame.data) | 0x4000)
buf.push_bytes(frame.data)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_crypto_frame(frame)
)
===========changed ref 2===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_new_connection_id_frame(
self, builder: QuicPacketBuilder, connection_id: QuicConnectionId
) -> None:
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.NEW_CONNECTION_ID,
self._on_new_connection_id_delivery,
(connection_id,),
)
frame = QuicNewConnectionIdFrame(
sequence_number=connection_id.sequence_number,
retire_prior_to=0, # FIXME
connection_id=connection_id.cid,
stateless_reset_token=connection_id.stateless_reset_token,
)
+ push_new_connection_id_frame(buf, frame)
- push_new_connection_id_frame(builder.buffer, frame)
connection_id.was_sent = True
self._events.append(events.ConnectionIdIssued(connection_id=connection_id.cid))
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_new_connection_id_frame(frame)
)
===========changed ref 3===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_ack_frame(self, builder: QuicPacketBuilder, space: QuicPacketSpace):
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.ACK,
self._on_ack_delivery,
(space, space.largest_received_packet),
)
+ push_ack_frame(buf, space.ack_queue, 0)
- push_ack_frame(builder.buffer, space.ack_queue, 0)
space.ack_at = None
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_ack_frame(ranges=space.ack_queue, delay=0.0)
)
===========changed ref 4===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_connection_limits(
self, builder: QuicPacketBuilder, space: QuicPacketSpace
) -> None:
"""
Raise MAX_DATA if needed.
"""
if self._local_max_data_used * 2 > self._local_max_data:
self._local_max_data *= 2
self._logger.debug("Local max_data raised to %d", self._local_max_data)
if self._local_max_data_sent != self._local_max_data:
+ buf = builder.start_frame(
+ QuicFrameType.MAX_DATA, self._on_max_data_delivery
- builder.start_frame(QuicFrameType.MAX_DATA, self._on_max_data_delivery)
+ )
+ buf.push_uint_var(self._local_max_data)
- builder.buffer.push_uint_var(self._local_max_data)
self._local_max_data_sent = self._local_max_data
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_max_data_frame(self._local_max_data)
)
===========changed ref 5===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_close_frame(
self,
builder: QuicPacketBuilder,
error_code: int,
frame_type: Optional[int],
reason_phrase: str,
) -> None:
- buf = builder.buffer
-
reason_bytes = reason_phrase.encode("utf8")
if frame_type is None:
+ buf = builder.start_frame(QuicFrameType.APPLICATION_CLOSE)
- builder.start_frame(QuicFrameType.APPLICATION_CLOSE)
buf.push_uint_var(error_code)
buf.push_uint_var(len(reason_bytes))
buf.push_bytes(reason_bytes)
else:
+ buf = builder.start_frame(QuicFrameType.TRANSPORT_CLOSE)
- builder.start_frame(QuicFrameType.TRANSPORT_CLOSE)
buf.push_uint_var(error_code)
buf.push_uint_var(frame_type)
buf.push_uint_var(len(reason_bytes))
buf.push_bytes(reason_bytes)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_connection_close_frame(
error_code=error_code,
frame_type=frame_type,
reason_phrase=reason_phrase,
)
)
|
aioquic.quic.connection/QuicConnection._write_stream_limits
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<18>:<add> buf = builder.start_frame(
<del> builder.start_frame(
<23>:<add> buf.push_uint_var(stream.stream_id)
<del> builder.buffer.push_uint_var(stream.stream_id)
<24>:<add> buf.push_uint_var(stream.max_stream_data_local)
<del> builder.buffer.push_uint_var(stream.max_stream_data_local)
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_stream_limits(
self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
<0> """
<1> Raise MAX_STREAM_DATA if needed.
<2>
<3> The only case where `stream.max_stream_data_local` is zero is for
<4> locally created unidirectional streams. We skip such streams to avoid
<5> spurious logging.
<6> """
<7> if (
<8> stream.max_stream_data_local
<9> and stream._recv_highest * 2 > stream.max_stream_data_local
<10> ):
<11> stream.max_stream_data_local *= 2
<12> self._logger.debug(
<13> "Stream %d local max_stream_data raised to %d",
<14> stream.stream_id,
<15> stream.max_stream_data_local,
<16> )
<17> if stream.max_stream_data_local_sent != stream.max_stream_data_local:
<18> builder.start_frame(
<19> QuicFrameType.MAX_STREAM_DATA,
<20> self._on_max_stream_data_delivery,
<21> (stream,),
<22> )
<23> builder.buffer.push_uint_var(stream.stream_id)
<24> builder.buffer.push_uint_var(stream.max_stream_data_local)
<25> stream.max_stream_data_local_sent = stream.max_stream_data_local
<26>
<27> # log frame
<28> if self._quic_logger is not None:
<29> builder.quic_logger_frames.append(
<30> self._quic_logger.encode_max_stream_data_frame(
<31> maximum=stream.max_stream_data_local, stream_id=stream.stream_id
<32> )
<33> )
<34>
|
===========unchanged ref 0===========
at: aioquic.quic.connection.QuicConnection
_on_max_stream_data_delivery(delivery: QuicDeliveryState, stream: QuicStream) -> None
at: aioquic.quic.connection.QuicConnection.__init__
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
self._logger = QuicConnectionAdapter(
logger, {"id": dump_cid(logger_connection_id)}
)
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
===========changed ref 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_retire_connection_id_frame(
self, builder: QuicPacketBuilder, sequence_number: int
) -> None:
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.RETIRE_CONNECTION_ID,
self._on_retire_connection_id_delivery,
(sequence_number,),
)
+ buf.push_uint_var(sequence_number)
- builder.buffer.push_uint_var(sequence_number)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_retire_connection_id_frame(sequence_number)
)
===========changed ref 1===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_crypto_frame(
self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
- buf = builder.buffer
-
frame_overhead = 3 + size_uint_var(stream.next_send_offset)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.CRYPTO,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
buf.push_uint_var(frame.offset)
buf.push_uint16(len(frame.data) | 0x4000)
buf.push_bytes(frame.data)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_crypto_frame(frame)
)
===========changed ref 2===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_new_connection_id_frame(
self, builder: QuicPacketBuilder, connection_id: QuicConnectionId
) -> None:
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.NEW_CONNECTION_ID,
self._on_new_connection_id_delivery,
(connection_id,),
)
frame = QuicNewConnectionIdFrame(
sequence_number=connection_id.sequence_number,
retire_prior_to=0, # FIXME
connection_id=connection_id.cid,
stateless_reset_token=connection_id.stateless_reset_token,
)
+ push_new_connection_id_frame(buf, frame)
- push_new_connection_id_frame(builder.buffer, frame)
connection_id.was_sent = True
self._events.append(events.ConnectionIdIssued(connection_id=connection_id.cid))
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_new_connection_id_frame(frame)
)
===========changed ref 3===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_ack_frame(self, builder: QuicPacketBuilder, space: QuicPacketSpace):
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.ACK,
self._on_ack_delivery,
(space, space.largest_received_packet),
)
+ push_ack_frame(buf, space.ack_queue, 0)
- push_ack_frame(builder.buffer, space.ack_queue, 0)
space.ack_at = None
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_ack_frame(ranges=space.ack_queue, delay=0.0)
)
===========changed ref 4===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_connection_limits(
self, builder: QuicPacketBuilder, space: QuicPacketSpace
) -> None:
"""
Raise MAX_DATA if needed.
"""
if self._local_max_data_used * 2 > self._local_max_data:
self._local_max_data *= 2
self._logger.debug("Local max_data raised to %d", self._local_max_data)
if self._local_max_data_sent != self._local_max_data:
+ buf = builder.start_frame(
+ QuicFrameType.MAX_DATA, self._on_max_data_delivery
- builder.start_frame(QuicFrameType.MAX_DATA, self._on_max_data_delivery)
+ )
+ buf.push_uint_var(self._local_max_data)
- builder.buffer.push_uint_var(self._local_max_data)
self._local_max_data_sent = self._local_max_data
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_max_data_frame(self._local_max_data)
)
|
aioquic.quic.connection/QuicConnection._write_streams_blocked_frame
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<0>:<add> buf = builder.start_frame(frame_type)
<del> builder.start_frame(frame_type)
<1>:<add> buf.push_uint_var(limit)
<del> builder.buffer.push_uint_var(limit)
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_streams_blocked_frame(
self, builder: QuicPacketBuilder, frame_type: QuicFrameType, limit: int
) -> None:
<0> builder.start_frame(frame_type)
<1> builder.buffer.push_uint_var(limit)
<2>
<3> # log frame
<4> if self._quic_logger is not None:
<5> builder.quic_logger_frames.append(
<6> self._quic_logger.encode_streams_blocked_frame(limit=limit)
<7> )
<8>
|
===========unchanged ref 0===========
at: aioquic.quic.connection.QuicConnection.__init__
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
===========changed ref 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_retire_connection_id_frame(
self, builder: QuicPacketBuilder, sequence_number: int
) -> None:
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.RETIRE_CONNECTION_ID,
self._on_retire_connection_id_delivery,
(sequence_number,),
)
+ buf.push_uint_var(sequence_number)
- builder.buffer.push_uint_var(sequence_number)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_retire_connection_id_frame(sequence_number)
)
===========changed ref 1===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_crypto_frame(
self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
- buf = builder.buffer
-
frame_overhead = 3 + size_uint_var(stream.next_send_offset)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.CRYPTO,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
buf.push_uint_var(frame.offset)
buf.push_uint16(len(frame.data) | 0x4000)
buf.push_bytes(frame.data)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_crypto_frame(frame)
)
===========changed ref 2===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_new_connection_id_frame(
self, builder: QuicPacketBuilder, connection_id: QuicConnectionId
) -> None:
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.NEW_CONNECTION_ID,
self._on_new_connection_id_delivery,
(connection_id,),
)
frame = QuicNewConnectionIdFrame(
sequence_number=connection_id.sequence_number,
retire_prior_to=0, # FIXME
connection_id=connection_id.cid,
stateless_reset_token=connection_id.stateless_reset_token,
)
+ push_new_connection_id_frame(buf, frame)
- push_new_connection_id_frame(builder.buffer, frame)
connection_id.was_sent = True
self._events.append(events.ConnectionIdIssued(connection_id=connection_id.cid))
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_new_connection_id_frame(frame)
)
===========changed ref 3===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_ack_frame(self, builder: QuicPacketBuilder, space: QuicPacketSpace):
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.ACK,
self._on_ack_delivery,
(space, space.largest_received_packet),
)
+ push_ack_frame(buf, space.ack_queue, 0)
- push_ack_frame(builder.buffer, space.ack_queue, 0)
space.ack_at = None
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_ack_frame(ranges=space.ack_queue, delay=0.0)
)
===========changed ref 4===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_stream_limits(
self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
"""
Raise MAX_STREAM_DATA if needed.
The only case where `stream.max_stream_data_local` is zero is for
locally created unidirectional streams. We skip such streams to avoid
spurious logging.
"""
if (
stream.max_stream_data_local
and stream._recv_highest * 2 > stream.max_stream_data_local
):
stream.max_stream_data_local *= 2
self._logger.debug(
"Stream %d local max_stream_data raised to %d",
stream.stream_id,
stream.max_stream_data_local,
)
if stream.max_stream_data_local_sent != stream.max_stream_data_local:
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.MAX_STREAM_DATA,
self._on_max_stream_data_delivery,
(stream,),
)
+ buf.push_uint_var(stream.stream_id)
- builder.buffer.push_uint_var(stream.stream_id)
+ buf.push_uint_var(stream.max_stream_data_local)
- builder.buffer.push_uint_var(stream.max_stream_data_local)
stream.max_stream_data_local_sent = stream.max_stream_data_local
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_max_stream_data_frame(
maximum=stream.max_stream_data_local, stream_id=stream.stream_id
)
)
===========changed ref 5===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_connection_limits(
self, builder: QuicPacketBuilder, space: QuicPacketSpace
) -> None:
"""
Raise MAX_DATA if needed.
"""
if self._local_max_data_used * 2 > self._local_max_data:
self._local_max_data *= 2
self._logger.debug("Local max_data raised to %d", self._local_max_data)
if self._local_max_data_sent != self._local_max_data:
+ buf = builder.start_frame(
+ QuicFrameType.MAX_DATA, self._on_max_data_delivery
- builder.start_frame(QuicFrameType.MAX_DATA, self._on_max_data_delivery)
+ )
+ buf.push_uint_var(self._local_max_data)
- builder.buffer.push_uint_var(self._local_max_data)
self._local_max_data_sent = self._local_max_data
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_max_data_frame(self._local_max_data)
)
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_empty
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<13>:<del> self.assertEqual(builder.buffer.tell(), 0)
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_empty(self):
<0> builder = create_builder()
<1> crypto = create_crypto()
<2>
<3> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<4> self.assertEqual(builder.remaining_space, 1236)
<5> self.assertTrue(builder.packet_is_empty)
<6>
<7> # check datagrams
<8> datagrams, packets = builder.flush()
<9> self.assertEqual(len(datagrams), 0)
<10> self.assertEqual(packets, [])
<11>
<12> # check builder
<13> self.assertEqual(builder.buffer.tell(), 0)
<14> self.assertEqual(builder.packet_number, 0)
<15>
|
===========unchanged ref 0===========
at: tests.test_packet_builder
create_builder(is_client=True)
create_crypto()
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
"""
Returns the remaining number of bytes which can be used in
the current packet.
"""
return (
self._buffer_capacity
+ - self._buffer.tell()
- - self.buffer.tell()
- self._packet_crypto.aead_tag_size
)
===========changed ref 1===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def packet_is_empty(self) -> bool:
"""
Returns `True` if the current packet is empty.
"""
assert self._packet is not None
+ packet_size = self._buffer.tell() - self._packet_start
- packet_size = self.buffer.tell() - self._packet_start
return packet_size <= self._header_size
===========changed ref 2===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_streams_blocked_frame(
self, builder: QuicPacketBuilder, frame_type: QuicFrameType, limit: int
) -> None:
+ buf = builder.start_frame(frame_type)
- builder.start_frame(frame_type)
+ buf.push_uint_var(limit)
- builder.buffer.push_uint_var(limit)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_streams_blocked_frame(limit=limit)
)
===========changed ref 3===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def _flush_current_datagram(self) -> None:
+ datagram_bytes = self._buffer.tell()
- datagram_bytes = self.buffer.tell()
if datagram_bytes:
+ self._datagrams.append(self._buffer.data)
- self._datagrams.append(self.buffer.data)
self._flight_bytes += self._datagram_flight_bytes
self._total_bytes += datagram_bytes
self._datagram_init = True
+ self._buffer.seek(0)
- self.buffer.seek(0)
===========changed ref 4===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_retire_connection_id_frame(
self, builder: QuicPacketBuilder, sequence_number: int
) -> None:
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.RETIRE_CONNECTION_ID,
self._on_retire_connection_id_delivery,
(sequence_number,),
)
+ buf.push_uint_var(sequence_number)
- builder.buffer.push_uint_var(sequence_number)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_retire_connection_id_frame(sequence_number)
)
===========changed ref 5===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_ack_frame(self, builder: QuicPacketBuilder, space: QuicPacketSpace):
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.ACK,
self._on_ack_delivery,
(space, space.largest_received_packet),
)
+ push_ack_frame(buf, space.ack_queue, 0)
- push_ack_frame(builder.buffer, space.ack_queue, 0)
space.ack_at = None
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_ack_frame(ranges=space.ack_queue, delay=0.0)
)
===========changed ref 6===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
+ ) -> Buffer:
- ) -> None:
"""
Starts a new frame.
"""
+ self._buffer.push_uint_var(frame_type)
- self.buffer.push_uint_var(frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
self._packet.is_ack_eliciting = True
if frame_type not in NON_IN_FLIGHT_FRAME_TYPES:
self._packet.in_flight = True
if frame_type == QuicFrameType.CRYPTO:
self._packet.is_crypto_packet = True
if handler is not None:
self._packet.delivery_handlers.append((handler, args))
+ return self._buffer
===========changed ref 7===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_crypto_frame(
self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
- buf = builder.buffer
-
frame_overhead = 3 + size_uint_var(stream.next_send_offset)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.CRYPTO,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
buf.push_uint_var(frame.offset)
buf.push_uint16(len(frame.data) | 0x4000)
buf.push_bytes(frame.data)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_crypto_frame(frame)
)
===========changed ref 8===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_receive_datagram_wrong_version(self):
client = create_standalone_client(self)
builder = QuicPacketBuilder(
host_cid=client._peer_cid,
is_client=False,
peer_cid=client.host_cid,
version=0xFF000011, # DRAFT_16
)
crypto = CryptoPair()
crypto.setup_initial(client.host_cid, is_client=False, version=client._version)
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
+ buf = builder.start_frame(QuicFrameType.PADDING)
+ buf.push_bytes(bytes(builder.remaining_space))
- builder.buffer.push_bytes(bytes(1200))
for datagram in builder.flush()[0]:
client.receive_datagram(datagram, SERVER_ADDR, now=time.time())
self.assertEqual(drop(client), 0)
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_initial_client
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<6>:<add> buf = builder.start_frame(QuicFrameType.CRYPTO)
<del> builder.start_frame(QuicFrameType.CRYPTO)
<7>:<add> buf.push_bytes(bytes(100))
<del> builder.buffer.push_bytes(bytes(100))
<38>:<add> ),
<del> )
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_client(self):
<0> builder = create_builder(is_client=True)
<1> crypto = create_crypto()
<2>
<3> # INITIAL
<4> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<5> self.assertEqual(builder.remaining_space, 1236)
<6> builder.start_frame(QuicFrameType.CRYPTO)
<7> builder.buffer.push_bytes(bytes(100))
<8> self.assertFalse(builder.packet_is_empty)
<9>
<10> # INITIAL, empty
<11> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<12> self.assertTrue(builder.packet_is_empty)
<13>
<14> # check datagrams
<15> datagrams, packets = builder.flush()
<16> self.assertEqual(len(datagrams), 1)
<17> self.assertEqual(len(datagrams[0]), 1280)
<18> self.assertEqual(
<19> packets,
<20> [
<21> QuicSentPacket(
<22> epoch=Epoch.INITIAL,
<23> in_flight=True,
<24> is_ack_eliciting=True,
<25> is_crypto_packet=True,
<26> packet_number=0,
<27> packet_type=PACKET_TYPE_INITIAL,
<28> sent_bytes=145,
<29> ),
<30> QuicSentPacket(
<31> epoch=Epoch.INITIAL,
<32> in_flight=True,
<33> is_ack_eliciting=False,
<34> is_crypto_packet=False,
<35> packet_number=1,
<36> packet_type=PACKET_TYPE_INITIAL,
<37> sent_bytes=1135,
<38> )
<39> ],
<40> )
<41>
|
===========unchanged ref 0===========
at: tests.test_packet_builder
create_builder(is_client=True)
create_crypto()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_empty(self):
builder = create_builder()
crypto = create_crypto()
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 0)
self.assertEqual(packets, [])
# check builder
- self.assertEqual(builder.buffer.tell(), 0)
self.assertEqual(builder.packet_number, 0)
===========changed ref 1===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
"""
Returns the remaining number of bytes which can be used in
the current packet.
"""
return (
self._buffer_capacity
+ - self._buffer.tell()
- - self.buffer.tell()
- self._packet_crypto.aead_tag_size
)
===========changed ref 2===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def packet_is_empty(self) -> bool:
"""
Returns `True` if the current packet is empty.
"""
assert self._packet is not None
+ packet_size = self._buffer.tell() - self._packet_start
- packet_size = self.buffer.tell() - self._packet_start
return packet_size <= self._header_size
===========changed ref 3===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_streams_blocked_frame(
self, builder: QuicPacketBuilder, frame_type: QuicFrameType, limit: int
) -> None:
+ buf = builder.start_frame(frame_type)
- builder.start_frame(frame_type)
+ buf.push_uint_var(limit)
- builder.buffer.push_uint_var(limit)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_streams_blocked_frame(limit=limit)
)
===========changed ref 4===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def _flush_current_datagram(self) -> None:
+ datagram_bytes = self._buffer.tell()
- datagram_bytes = self.buffer.tell()
if datagram_bytes:
+ self._datagrams.append(self._buffer.data)
- self._datagrams.append(self.buffer.data)
self._flight_bytes += self._datagram_flight_bytes
self._total_bytes += datagram_bytes
self._datagram_init = True
+ self._buffer.seek(0)
- self.buffer.seek(0)
===========changed ref 5===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_retire_connection_id_frame(
self, builder: QuicPacketBuilder, sequence_number: int
) -> None:
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.RETIRE_CONNECTION_ID,
self._on_retire_connection_id_delivery,
(sequence_number,),
)
+ buf.push_uint_var(sequence_number)
- builder.buffer.push_uint_var(sequence_number)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_retire_connection_id_frame(sequence_number)
)
===========changed ref 6===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_ack_frame(self, builder: QuicPacketBuilder, space: QuicPacketSpace):
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.ACK,
self._on_ack_delivery,
(space, space.largest_received_packet),
)
+ push_ack_frame(buf, space.ack_queue, 0)
- push_ack_frame(builder.buffer, space.ack_queue, 0)
space.ack_at = None
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_ack_frame(ranges=space.ack_queue, delay=0.0)
)
===========changed ref 7===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
+ ) -> Buffer:
- ) -> None:
"""
Starts a new frame.
"""
+ self._buffer.push_uint_var(frame_type)
- self.buffer.push_uint_var(frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
self._packet.is_ack_eliciting = True
if frame_type not in NON_IN_FLIGHT_FRAME_TYPES:
self._packet.in_flight = True
if frame_type == QuicFrameType.CRYPTO:
self._packet.is_crypto_packet = True
if handler is not None:
self._packet.delivery_handlers.append((handler, args))
+ return self._buffer
===========changed ref 8===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_crypto_frame(
self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
- buf = builder.buffer
-
frame_overhead = 3 + size_uint_var(stream.next_send_offset)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.CRYPTO,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
buf.push_uint_var(frame.offset)
buf.push_uint16(len(frame.data) | 0x4000)
buf.push_bytes(frame.data)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_crypto_frame(frame)
)
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_initial_client_2
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<6>:<add> buf = builder.start_frame(QuicFrameType.CRYPTO)
<del> builder.start_frame(QuicFrameType.CRYPTO)
<7>:<add> buf.push_bytes(bytes(builder.remaining_space))
<del> builder.buffer.push_bytes(bytes(builder.remaining_space))
<13>:<add> buf = builder.start_frame(QuicFrameType.CRYPTO)
<del> builder.start_frame(QuicFrameType.CRYPTO)
<14>:<add> buf.push_bytes(bytes(100))
<del> builder.buffer.push_bytes(bytes(100))
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_client_2(self):
<0> builder = create_builder(is_client=True)
<1> crypto = create_crypto()
<2>
<3> # INITIAL, full length
<4> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<5> self.assertEqual(builder.remaining_space, 1236)
<6> builder.start_frame(QuicFrameType.CRYPTO)
<7> builder.buffer.push_bytes(bytes(builder.remaining_space))
<8> self.assertFalse(builder.packet_is_empty)
<9>
<10> # INITIAL
<11> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<12> self.assertEqual(builder.remaining_space, 1236)
<13> builder.start_frame(QuicFrameType.CRYPTO)
<14> builder.buffer.push_bytes(bytes(100))
<15> self.assertFalse(builder.packet_is_empty)
<16>
<17> # INITIAL, empty
<18> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<19> self.assertTrue(builder.packet_is_empty)
<20>
<21> # check datagrams
<22> datagrams, packets = builder.flush()
<23> self.assertEqual(len(datagrams), 2)
<24> self.assertEqual(len(datagrams[0]), 1280)
<25> self.assertEqual(len(datagrams[1]), 1280)
<26> self.assertEqual(
<27> packets,
<28> [
<29> QuicSentPacket(
<30> epoch=Epoch.INITIAL,
<31> in_flight=True,
<32> is_ack_eliciting=True,
<33> is_crypto_packet=True,
<34> packet_number=0,
<35> packet_type=PACKET_TYPE_INITIAL,
<36> sent_bytes=1280,
<37> ),
<38> QuicSentPacket(
<39> epoch=Epoch.INITIAL,
<40> in_flight=True,
<41> is_ack_el</s>
|
===========below chunk 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_client_2(self):
# offset: 1
is_crypto_packet=True,
packet_number=1,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=145,
),
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=2,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=1135,
)
],
)
===========unchanged ref 0===========
at: tests.test_packet_builder
create_builder(is_client=True)
create_crypto()
at: tests.test_packet_builder.QuicPacketBuilderTest.test_long_header_initial_client
builder = create_builder(is_client=True)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_empty(self):
builder = create_builder()
crypto = create_crypto()
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 0)
self.assertEqual(packets, [])
# check builder
- self.assertEqual(builder.buffer.tell(), 0)
self.assertEqual(builder.packet_number, 0)
===========changed ref 1===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_client(self):
builder = create_builder(is_client=True)
crypto = create_crypto()
# INITIAL
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(100))
- builder.buffer.push_bytes(bytes(100))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=145,
),
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=1,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=1135,
+ ),
- )
],
)
===========changed ref 2===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
"""
Returns the remaining number of bytes which can be used in
the current packet.
"""
return (
self._buffer_capacity
+ - self._buffer.tell()
- - self.buffer.tell()
- self._packet_crypto.aead_tag_size
)
===========changed ref 3===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def packet_is_empty(self) -> bool:
"""
Returns `True` if the current packet is empty.
"""
assert self._packet is not None
+ packet_size = self._buffer.tell() - self._packet_start
- packet_size = self.buffer.tell() - self._packet_start
return packet_size <= self._header_size
===========changed ref 4===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_streams_blocked_frame(
self, builder: QuicPacketBuilder, frame_type: QuicFrameType, limit: int
) -> None:
+ buf = builder.start_frame(frame_type)
- builder.start_frame(frame_type)
+ buf.push_uint_var(limit)
- builder.buffer.push_uint_var(limit)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_streams_blocked_frame(limit=limit)
)
===========changed ref 5===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def _flush_current_datagram(self) -> None:
+ datagram_bytes = self._buffer.tell()
- datagram_bytes = self.buffer.tell()
if datagram_bytes:
+ self._datagrams.append(self._buffer.data)
- self._datagrams.append(self.buffer.data)
self._flight_bytes += self._datagram_flight_bytes
self._total_bytes += datagram_bytes
self._datagram_init = True
+ self._buffer.seek(0)
- self.buffer.seek(0)
===========changed ref 6===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_retire_connection_id_frame(
self, builder: QuicPacketBuilder, sequence_number: int
) -> None:
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.RETIRE_CONNECTION_ID,
self._on_retire_connection_id_delivery,
(sequence_number,),
)
+ buf.push_uint_var(sequence_number)
- builder.buffer.push_uint_var(sequence_number)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_retire_connection_id_frame(sequence_number)
)
===========changed ref 7===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_ack_frame(self, builder: QuicPacketBuilder, space: QuicPacketSpace):
+ buf = builder.start_frame(
- builder.start_frame(
QuicFrameType.ACK,
self._on_ack_delivery,
(space, space.largest_received_packet),
)
+ push_ack_frame(buf, space.ack_queue, 0)
- push_ack_frame(builder.buffer, space.ack_queue, 0)
space.ack_at = None
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_ack_frame(ranges=space.ack_queue, delay=0.0)
)
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_initial_server
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<6>:<add> buf = builder.start_frame(QuicFrameType.CRYPTO)
<del> builder.start_frame(QuicFrameType.CRYPTO)
<7>:<add> buf.push_bytes(bytes(100))
<del> builder.buffer.push_bytes(bytes(100))
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_server(self):
<0> builder = create_builder(is_client=False)
<1> crypto = create_crypto()
<2>
<3> # INITIAL
<4> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<5> self.assertEqual(builder.remaining_space, 1236)
<6> builder.start_frame(QuicFrameType.CRYPTO)
<7> builder.buffer.push_bytes(bytes(100))
<8> self.assertFalse(builder.packet_is_empty)
<9>
<10> # INITIAL, empty
<11> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<12> self.assertTrue(builder.packet_is_empty)
<13>
<14> # check datagrams
<15> datagrams, packets = builder.flush()
<16> self.assertEqual(len(datagrams), 1)
<17> self.assertEqual(len(datagrams[0]), 145)
<18> self.assertEqual(
<19> packets,
<20> [
<21> QuicSentPacket(
<22> epoch=Epoch.INITIAL,
<23> in_flight=True,
<24> is_ack_eliciting=True,
<25> is_crypto_packet=True,
<26> packet_number=0,
<27> packet_type=PACKET_TYPE_INITIAL,
<28> sent_bytes=145,
<29> )
<30> ],
<31> )
<32>
|
===========unchanged ref 0===========
at: tests.test_packet_builder
create_builder(is_client=True)
create_crypto()
at: tests.test_packet_builder.QuicPacketBuilderTest.test_long_header_initial_client_2
builder = create_builder(is_client=True)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_empty(self):
builder = create_builder()
crypto = create_crypto()
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 0)
self.assertEqual(packets, [])
# check builder
- self.assertEqual(builder.buffer.tell(), 0)
self.assertEqual(builder.packet_number, 0)
===========changed ref 1===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_client(self):
builder = create_builder(is_client=True)
crypto = create_crypto()
# INITIAL
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(100))
- builder.buffer.push_bytes(bytes(100))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=145,
),
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=1,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=1135,
+ ),
- )
],
)
===========changed ref 2===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_client_2(self):
builder = create_builder(is_client=True)
crypto = create_crypto()
# INITIAL, full length
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(builder.remaining_space))
- builder.buffer.push_bytes(bytes(builder.remaining_space))
self.assertFalse(builder.packet_is_empty)
# INITIAL
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(100))
- builder.buffer.push_bytes(bytes(100))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 2)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(len(datagrams[1]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=1280,
),</s>
===========changed ref 3===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_client_2(self):
# offset: 1
<s>number=0,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=1280,
),
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=1,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=145,
),
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=2,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=1135,
+ ),
- )
],
)
===========changed ref 4===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
"""
Returns the remaining number of bytes which can be used in
the current packet.
"""
return (
self._buffer_capacity
+ - self._buffer.tell()
- - self.buffer.tell()
- self._packet_crypto.aead_tag_size
)
===========changed ref 5===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
@property
def packet_is_empty(self) -> bool:
"""
Returns `True` if the current packet is empty.
"""
assert self._packet is not None
+ packet_size = self._buffer.tell() - self._packet_start
- packet_size = self.buffer.tell() - self._packet_start
return packet_size <= self._header_size
===========changed ref 6===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_streams_blocked_frame(
self, builder: QuicPacketBuilder, frame_type: QuicFrameType, limit: int
) -> None:
+ buf = builder.start_frame(frame_type)
- builder.start_frame(frame_type)
+ buf.push_uint_var(limit)
- builder.buffer.push_uint_var(limit)
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_streams_blocked_frame(limit=limit)
)
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_then_short_header
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<6>:<add> buf = builder.start_frame(QuicFrameType.CRYPTO)
<del> builder.start_frame(QuicFrameType.CRYPTO)
<7>:<add> buf.push_bytes(bytes(builder.remaining_space))
<del> builder.buffer.push_bytes(bytes(builder.remaining_space))
<17>:<add> buf = builder.start_frame(QuicFrameType.STREAM_BASE)
<del> builder.start_frame(QuicFrameType.STREAM_BASE)
<18>:<add> buf.push_bytes(bytes(builder.remaining_space))
<del> builder.buffer.push_bytes(bytes(builder.remaining_space))
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_short_header(self):
<0> builder = create_builder()
<1> crypto = create_crypto()
<2>
<3> # INITIAL, full length
<4> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<5> self.assertEqual(builder.remaining_space, 1236)
<6> builder.start_frame(QuicFrameType.CRYPTO)
<7> builder.buffer.push_bytes(bytes(builder.remaining_space))
<8> self.assertFalse(builder.packet_is_empty)
<9>
<10> # INITIAL, empty
<11> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<12> self.assertTrue(builder.packet_is_empty)
<13>
<14> # ONE_RTT, full length
<15> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<16> self.assertEqual(builder.remaining_space, 1253)
<17> builder.start_frame(QuicFrameType.STREAM_BASE)
<18> builder.buffer.push_bytes(bytes(builder.remaining_space))
<19> self.assertFalse(builder.packet_is_empty)
<20>
<21> # ONE_RTT, empty
<22> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<23> self.assertTrue(builder.packet_is_empty)
<24>
<25> # check datagrams
<26> datagrams, packets = builder.flush()
<27> self.assertEqual(len(datagrams), 2)
<28> self.assertEqual(len(datagrams[0]), 1280)
<29> self.assertEqual(len(datagrams[1]), 1280)
<30> self.assertEqual(
<31> packets,
<32> [
<33> QuicSentPacket(
<34> epoch=Epoch.INITIAL,
<35> in_flight=True,
<36> is_ack_eliciting=True,
<37> is_crypto_packet=True,
<38> packet_number=0,
<39> packet_type</s>
|
===========below chunk 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_short_header(self):
# offset: 1
sent_bytes=1280,
),
QuicSentPacket(
epoch=Epoch.ONE_RTT,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=False,
packet_number=1,
packet_type=PACKET_TYPE_ONE_RTT,
sent_bytes=1280,
),
],
)
===========unchanged ref 0===========
at: tests.test_packet_builder
create_builder(is_client=True)
create_crypto()
at: tests.test_packet_builder.QuicPacketBuilderTest.test_long_header_initial_server
builder = create_builder(is_client=False)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_empty(self):
builder = create_builder()
crypto = create_crypto()
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 0)
self.assertEqual(packets, [])
# check builder
- self.assertEqual(builder.buffer.tell(), 0)
self.assertEqual(builder.packet_number, 0)
===========changed ref 1===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_server(self):
builder = create_builder(is_client=False)
crypto = create_crypto()
# INITIAL
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(100))
- builder.buffer.push_bytes(bytes(100))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 145)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=145,
)
],
)
===========changed ref 2===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_client(self):
builder = create_builder(is_client=True)
crypto = create_crypto()
# INITIAL
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(100))
- builder.buffer.push_bytes(bytes(100))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=145,
),
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=1,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=1135,
+ ),
- )
],
)
===========changed ref 3===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_client_2(self):
builder = create_builder(is_client=True)
crypto = create_crypto()
# INITIAL, full length
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(builder.remaining_space))
- builder.buffer.push_bytes(bytes(builder.remaining_space))
self.assertFalse(builder.packet_is_empty)
# INITIAL
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(100))
- builder.buffer.push_bytes(bytes(100))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 2)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(len(datagrams[1]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=1280,
),</s>
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_then_long_header
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<6>:<add> buf = builder.start_frame(QuicFrameType.CRYPTO)
<del> builder.start_frame(QuicFrameType.CRYPTO)
<7>:<add> buf.push_bytes(bytes(199))
<del> builder.buffer.push_bytes(bytes(199))
<13>:<add> buf = builder.start_frame(QuicFrameType.CRYPTO)
<del> builder.start_frame(QuicFrameType.CRYPTO)
<14>:<add> buf.push_bytes(bytes(299))
<del> builder.buffer.push_bytes(bytes(299))
<20>:<add> buf = builder.start_frame(QuicFrameType.CRYPTO)
<del> builder.start_frame(QuicFrameType.CRYPTO)
<21>:<add> buf.push_bytes(bytes(299))
<del> builder.buffer.push_bytes(bytes(299))
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_long_header(self):
<0> builder = create_builder()
<1> crypto = create_crypto()
<2>
<3> # INITIAL
<4> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<5> self.assertEqual(builder.remaining_space, 1236)
<6> builder.start_frame(QuicFrameType.CRYPTO)
<7> builder.buffer.push_bytes(bytes(199))
<8> self.assertFalse(builder.packet_is_empty)
<9>
<10> # HANDSHAKE
<11> builder.start_packet(PACKET_TYPE_HANDSHAKE, crypto)
<12> self.assertEqual(builder.remaining_space, 993)
<13> builder.start_frame(QuicFrameType.CRYPTO)
<14> builder.buffer.push_bytes(bytes(299))
<15> self.assertFalse(builder.packet_is_empty)
<16>
<17> # ONE_RTT
<18> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<19> self.assertEqual(builder.remaining_space, 666)
<20> builder.start_frame(QuicFrameType.CRYPTO)
<21> builder.buffer.push_bytes(bytes(299))
<22> self.assertFalse(builder.packet_is_empty)
<23>
<24> # check datagrams
<25> datagrams, packets = builder.flush()
<26> self.assertEqual(len(datagrams), 1)
<27> self.assertEqual(len(datagrams[0]), 1280)
<28> self.assertEqual(
<29> packets,
<30> [
<31> QuicSentPacket(
<32> epoch=Epoch.INITIAL,
<33> in_flight=True,
<34> is_ack_eliciting=True,
<35> is_crypto_packet=True,
<36> packet_number=0,
<37> packet_type=PACKET_TYPE_INITIAL,
<38> sent_bytes=244,
<39> ),
<40> QuicSentPacket(</s>
|
===========below chunk 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_long_header(self):
# offset: 1
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=1,
packet_type=PACKET_TYPE_HANDSHAKE,
sent_bytes=343,
),
QuicSentPacket(
epoch=Epoch.ONE_RTT,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=2,
packet_type=PACKET_TYPE_ONE_RTT,
sent_bytes=693,
),
],
)
===========unchanged ref 0===========
at: tests.test_packet_builder
create_builder(is_client=True)
create_crypto()
at: tests.test_packet_builder.QuicPacketBuilderTest.test_long_header_then_short_header
builder = create_builder()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_empty(self):
builder = create_builder()
crypto = create_crypto()
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 0)
self.assertEqual(packets, [])
# check builder
- self.assertEqual(builder.buffer.tell(), 0)
self.assertEqual(builder.packet_number, 0)
===========changed ref 1===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_server(self):
builder = create_builder(is_client=False)
crypto = create_crypto()
# INITIAL
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(100))
- builder.buffer.push_bytes(bytes(100))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 145)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=145,
)
],
)
===========changed ref 2===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_client(self):
builder = create_builder(is_client=True)
crypto = create_crypto()
# INITIAL
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(100))
- builder.buffer.push_bytes(bytes(100))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=145,
),
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=1,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=1135,
+ ),
- )
],
)
===========changed ref 3===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_short_header(self):
builder = create_builder()
crypto = create_crypto()
# INITIAL, full length
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(builder.remaining_space))
- builder.buffer.push_bytes(bytes(builder.remaining_space))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# ONE_RTT, full length
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertEqual(builder.remaining_space, 1253)
+ buf = builder.start_frame(QuicFrameType.STREAM_BASE)
- builder.start_frame(QuicFrameType.STREAM_BASE)
+ buf.push_bytes(bytes(builder.remaining_space))
- builder.buffer.push_bytes(bytes(builder.remaining_space))
self.assertFalse(builder.packet_is_empty)
# ONE_RTT, empty
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 2)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(len(datagrams[1]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True</s>
|
tests.test_packet_builder/QuicPacketBuilderTest.test_short_header_empty
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<13>:<del> self.assertEqual(builder.buffer.tell(), 0)
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_empty(self):
<0> builder = create_builder()
<1> crypto = create_crypto()
<2>
<3> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<4> self.assertEqual(builder.remaining_space, 1253)
<5> self.assertTrue(builder.packet_is_empty)
<6>
<7> # check datagrams
<8> datagrams, packets = builder.flush()
<9> self.assertEqual(datagrams, [])
<10> self.assertEqual(packets, [])
<11>
<12> # check builder
<13> self.assertEqual(builder.buffer.tell(), 0)
<14> self.assertEqual(builder.packet_number, 0)
<15>
|
===========unchanged ref 0===========
at: tests.test_packet_builder
create_builder(is_client=True)
at: tests.test_packet_builder.QuicPacketBuilderTest.test_long_header_then_long_header
builder = create_builder()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_empty(self):
builder = create_builder()
crypto = create_crypto()
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 0)
self.assertEqual(packets, [])
# check builder
- self.assertEqual(builder.buffer.tell(), 0)
self.assertEqual(builder.packet_number, 0)
===========changed ref 1===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_server(self):
builder = create_builder(is_client=False)
crypto = create_crypto()
# INITIAL
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(100))
- builder.buffer.push_bytes(bytes(100))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 145)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=145,
)
],
)
===========changed ref 2===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_client(self):
builder = create_builder(is_client=True)
crypto = create_crypto()
# INITIAL
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(100))
- builder.buffer.push_bytes(bytes(100))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=145,
),
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=1,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=1135,
+ ),
- )
],
)
===========changed ref 3===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_short_header(self):
builder = create_builder()
crypto = create_crypto()
# INITIAL, full length
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(builder.remaining_space))
- builder.buffer.push_bytes(bytes(builder.remaining_space))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# ONE_RTT, full length
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertEqual(builder.remaining_space, 1253)
+ buf = builder.start_frame(QuicFrameType.STREAM_BASE)
- builder.start_frame(QuicFrameType.STREAM_BASE)
+ buf.push_bytes(bytes(builder.remaining_space))
- builder.buffer.push_bytes(bytes(builder.remaining_space))
self.assertFalse(builder.packet_is_empty)
# ONE_RTT, empty
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 2)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(len(datagrams[1]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True</s>
===========changed ref 4===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_short_header(self):
# offset: 1
<s>(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=1280,
),
QuicSentPacket(
epoch=Epoch.ONE_RTT,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=False,
packet_number=1,
packet_type=PACKET_TYPE_ONE_RTT,
sent_bytes=1280,
),
],
)
|
tests.test_packet_builder/QuicPacketBuilderTest.test_short_header_padding
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<6>:<add> buf = builder.start_frame(QuicFrameType.CRYPTO)
<del> builder.start_frame(QuicFrameType.CRYPTO)
<7>:<add> buf.push_bytes(bytes(builder.remaining_space))
<del> builder.buffer.push_bytes(bytes(builder.remaining_space))
<30>:<del> self.assertEqual(builder.buffer.tell(), 0)
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_padding(self):
<0> builder = create_builder()
<1> crypto = create_crypto()
<2>
<3> # ONE_RTT, full length
<4> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<5> self.assertEqual(builder.remaining_space, 1253)
<6> builder.start_frame(QuicFrameType.CRYPTO)
<7> builder.buffer.push_bytes(bytes(builder.remaining_space))
<8> self.assertFalse(builder.packet_is_empty)
<9>
<10> # check datagrams
<11> datagrams, packets = builder.flush()
<12> self.assertEqual(len(datagrams), 1)
<13> self.assertEqual(len(datagrams[0]), 1280)
<14> self.assertEqual(
<15> packets,
<16> [
<17> QuicSentPacket(
<18> epoch=Epoch.ONE_RTT,
<19> in_flight=True,
<20> is_ack_eliciting=True,
<21> is_crypto_packet=True,
<22> packet_number=0,
<23> packet_type=PACKET_TYPE_ONE_RTT,
<24> sent_bytes=1280,
<25> )
<26> ],
<27> )
<28>
<29> # check builder
<30> self.assertEqual(builder.buffer.tell(), 0)
<31> self.assertEqual(builder.packet_number, 1)
<32>
|
===========unchanged ref 0===========
at: tests.test_packet_builder
create_builder(is_client=True)
create_crypto()
at: tests.test_packet_builder.QuicPacketBuilderTest.test_short_header_empty
builder = create_builder()
crypto = create_crypto()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_empty(self):
builder = create_builder()
crypto = create_crypto()
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertEqual(builder.remaining_space, 1253)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(datagrams, [])
self.assertEqual(packets, [])
# check builder
- self.assertEqual(builder.buffer.tell(), 0)
self.assertEqual(builder.packet_number, 0)
===========changed ref 1===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_empty(self):
builder = create_builder()
crypto = create_crypto()
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 0)
self.assertEqual(packets, [])
# check builder
- self.assertEqual(builder.buffer.tell(), 0)
self.assertEqual(builder.packet_number, 0)
===========changed ref 2===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_server(self):
builder = create_builder(is_client=False)
crypto = create_crypto()
# INITIAL
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(100))
- builder.buffer.push_bytes(bytes(100))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 145)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=145,
)
],
)
===========changed ref 3===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_client(self):
builder = create_builder(is_client=True)
crypto = create_crypto()
# INITIAL
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(100))
- builder.buffer.push_bytes(bytes(100))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=145,
),
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=1,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=1135,
+ ),
- )
],
)
===========changed ref 4===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_short_header(self):
builder = create_builder()
crypto = create_crypto()
# INITIAL, full length
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(builder.remaining_space))
- builder.buffer.push_bytes(bytes(builder.remaining_space))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# ONE_RTT, full length
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertEqual(builder.remaining_space, 1253)
+ buf = builder.start_frame(QuicFrameType.STREAM_BASE)
- builder.start_frame(QuicFrameType.STREAM_BASE)
+ buf.push_bytes(bytes(builder.remaining_space))
- builder.buffer.push_bytes(bytes(builder.remaining_space))
self.assertFalse(builder.packet_is_empty)
# ONE_RTT, empty
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 2)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(len(datagrams[1]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True</s>
|
tests.test_packet_builder/QuicPacketBuilderTest.test_short_header_max_total_bytes_2
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<10>:<add> buf = builder.start_frame(QuicFrameType.CRYPTO)
<del> builder.start_frame(QuicFrameType.CRYPTO)
<11>:<del> self.assertEqual(builder.remaining_space, 772)
<12>:<add> buf.push_bytes(bytes(builder.remaining_space))
<del> builder.buffer.push_bytes(bytes(builder.remaining_space))
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_max_total_bytes_2(self):
<0> """
<1> max_total_bytes allows a short packet.
<2> """
<3> builder = create_builder()
<4> builder.max_total_bytes = 800
<5>
<6> crypto = create_crypto()
<7>
<8> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<9> self.assertEqual(builder.remaining_space, 773)
<10> builder.start_frame(QuicFrameType.CRYPTO)
<11> self.assertEqual(builder.remaining_space, 772)
<12> builder.buffer.push_bytes(bytes(builder.remaining_space))
<13> self.assertFalse(builder.packet_is_empty)
<14>
<15> with self.assertRaises(QuicPacketBuilderStop):
<16> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<17>
<18> # check datagrams
<19> datagrams, packets = builder.flush()
<20> self.assertEqual(len(datagrams), 1)
<21> self.assertEqual(len(datagrams[0]), 800)
<22> self.assertEqual(
<23> packets,
<24> [
<25> QuicSentPacket(
<26> epoch=Epoch.ONE_RTT,
<27> in_flight=True,
<28> is_ack_eliciting=True,
<29> is_crypto_packet=True,
<30> packet_number=0,
<31> packet_type=PACKET_TYPE_ONE_RTT,
<32> sent_bytes=800,
<33> )
<34> ],
<35> )
<36>
|
===========unchanged ref 0===========
at: tests.test_packet_builder
create_builder(is_client=True)
create_crypto()
at: tests.test_packet_builder.QuicPacketBuilderTest.test_short_header_max_total_bytes_1
builder = create_builder()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]
assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None
===========changed ref 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_empty(self):
builder = create_builder()
crypto = create_crypto()
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertEqual(builder.remaining_space, 1253)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(datagrams, [])
self.assertEqual(packets, [])
# check builder
- self.assertEqual(builder.buffer.tell(), 0)
self.assertEqual(builder.packet_number, 0)
===========changed ref 1===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_padding(self):
builder = create_builder()
crypto = create_crypto()
# ONE_RTT, full length
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertEqual(builder.remaining_space, 1253)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(builder.remaining_space))
- builder.buffer.push_bytes(bytes(builder.remaining_space))
self.assertFalse(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.ONE_RTT,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_ONE_RTT,
sent_bytes=1280,
)
],
)
# check builder
- self.assertEqual(builder.buffer.tell(), 0)
self.assertEqual(builder.packet_number, 1)
===========changed ref 2===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_empty(self):
builder = create_builder()
crypto = create_crypto()
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 0)
self.assertEqual(packets, [])
# check builder
- self.assertEqual(builder.buffer.tell(), 0)
self.assertEqual(builder.packet_number, 0)
===========changed ref 3===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_server(self):
builder = create_builder(is_client=False)
crypto = create_crypto()
# INITIAL
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(100))
- builder.buffer.push_bytes(bytes(100))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 145)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=145,
)
],
)
===========changed ref 4===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_client(self):
builder = create_builder(is_client=True)
crypto = create_crypto()
# INITIAL
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(100))
- builder.buffer.push_bytes(bytes(100))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=145,
),
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=1,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=1135,
+ ),
- )
],
)
|
tests.test_packet_builder/QuicPacketBuilderTest.test_short_header_max_total_bytes_3
|
Modified
|
aiortc~aioquic
|
7aa5565eccb06815b8f7f5d287243554a0a8088a
|
[packet builder] ensure start_frame is always called
|
<7>:<add> buf = builder.start_frame(QuicFrameType.CRYPTO)
<del> builder.start_frame(QuicFrameType.CRYPTO)
<8>:<del> self.assertEqual(builder.remaining_space, 1252)
<9>:<add> buf.push_bytes(bytes(builder.remaining_space))
<del> builder.buffer.push_bytes(bytes(builder.remaining_space))
<14>:<add> buf = builder.start_frame(QuicFrameType.CRYPTO)
<del> builder.start_frame(QuicFrameType.CRYPTO)
<15>:<del> self.assertEqual(builder.remaining_space, 692)
<16>:<add> buf.push_bytes(bytes(builder.remaining_space))
<del> builder.buffer.push_bytes(bytes(builder.remaining_space))
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_max_total_bytes_3(self):
<0> builder = create_builder()
<1> builder.max_total_bytes = 2000
<2>
<3> crypto = create_crypto()
<4>
<5> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<6> self.assertEqual(builder.remaining_space, 1253)
<7> builder.start_frame(QuicFrameType.CRYPTO)
<8> self.assertEqual(builder.remaining_space, 1252)
<9> builder.buffer.push_bytes(bytes(builder.remaining_space))
<10> self.assertFalse(builder.packet_is_empty)
<11>
<12> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<13> self.assertEqual(builder.remaining_space, 693)
<14> builder.start_frame(QuicFrameType.CRYPTO)
<15> self.assertEqual(builder.remaining_space, 692)
<16> builder.buffer.push_bytes(bytes(builder.remaining_space))
<17> self.assertFalse(builder.packet_is_empty)
<18>
<19> with self.assertRaises(QuicPacketBuilderStop):
<20> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<21>
<22> # check datagrams
<23> datagrams, packets = builder.flush()
<24> self.assertEqual(len(datagrams), 2)
<25> self.assertEqual(len(datagrams[0]), 1280)
<26> self.assertEqual(len(datagrams[1]), 720)
<27> self.assertEqual(
<28> packets,
<29> [
<30> QuicSentPacket(
<31> epoch=Epoch.ONE_RTT,
<32> in_flight=True,
<33> is_ack_eliciting=True,
<34> is_crypto_packet=True,
<35> packet_number=0,
<36> packet_type=PACKET_TYPE_ONE_RTT,
<37> sent_bytes</s>
|
===========below chunk 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_max_total_bytes_3(self):
# offset: 1
),
QuicSentPacket(
epoch=Epoch.ONE_RTT,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=1,
packet_type=PACKET_TYPE_ONE_RTT,
sent_bytes=720,
),
],
)
===========unchanged ref 0===========
at: tests.test_packet_builder
create_builder(is_client=True)
create_crypto()
at: tests.test_packet_builder.QuicPacketBuilderTest.test_short_header_max_total_bytes_2
builder = create_builder()
datagrams, packets = builder.flush()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]
assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None
===========changed ref 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_empty(self):
builder = create_builder()
crypto = create_crypto()
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertEqual(builder.remaining_space, 1253)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(datagrams, [])
self.assertEqual(packets, [])
# check builder
- self.assertEqual(builder.buffer.tell(), 0)
self.assertEqual(builder.packet_number, 0)
===========changed ref 1===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_max_total_bytes_2(self):
"""
max_total_bytes allows a short packet.
"""
builder = create_builder()
builder.max_total_bytes = 800
crypto = create_crypto()
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertEqual(builder.remaining_space, 773)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
- self.assertEqual(builder.remaining_space, 772)
+ buf.push_bytes(bytes(builder.remaining_space))
- builder.buffer.push_bytes(bytes(builder.remaining_space))
self.assertFalse(builder.packet_is_empty)
with self.assertRaises(QuicPacketBuilderStop):
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 800)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.ONE_RTT,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_ONE_RTT,
sent_bytes=800,
)
],
)
===========changed ref 2===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_padding(self):
builder = create_builder()
crypto = create_crypto()
# ONE_RTT, full length
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertEqual(builder.remaining_space, 1253)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(builder.remaining_space))
- builder.buffer.push_bytes(bytes(builder.remaining_space))
self.assertFalse(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.ONE_RTT,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_ONE_RTT,
sent_bytes=1280,
)
],
)
# check builder
- self.assertEqual(builder.buffer.tell(), 0)
self.assertEqual(builder.packet_number, 1)
===========changed ref 3===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_empty(self):
builder = create_builder()
crypto = create_crypto()
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 0)
self.assertEqual(packets, [])
# check builder
- self.assertEqual(builder.buffer.tell(), 0)
self.assertEqual(builder.packet_number, 0)
===========changed ref 4===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_server(self):
builder = create_builder(is_client=False)
crypto = create_crypto()
# INITIAL
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
- builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(100))
- builder.buffer.push_bytes(bytes(100))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 145)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=145,
)
],
)
|
aioquic.quic.connection/QuicConnection._payload_received
|
Modified
|
aiortc~aioquic
|
656204deb0f5488a42f17628c5053deb8dfc57a4
|
[connection] use dict for frame handlers
|
<13>:<add> except KeyError:
<del> except IndexError:
|
# module: aioquic.quic.connection
class QuicConnection:
def _payload_received(
self, context: QuicReceiveContext, plain: bytes
) -> Tuple[bool, bool]:
<0> """
<1> Handle a QUIC packet payload.
<2> """
<3> buf = Buffer(data=plain)
<4>
<5> is_ack_eliciting = False
<6> is_probing = None
<7> while not buf.eof():
<8> frame_type = buf.pull_uint_var()
<9>
<10> # check frame type is known
<11> try:
<12> frame_handler, frame_epochs = self.__frame_handlers[frame_type]
<13> except IndexError:
<14> raise QuicConnectionError(
<15> error_code=QuicErrorCode.PROTOCOL_VIOLATION,
<16> frame_type=frame_type,
<17> reason_phrase="Unknown frame type",
<18> )
<19>
<20> # check frame is allowed for the epoch
<21> if context.epoch not in frame_epochs:
<22> raise QuicConnectionError(
<23> error_code=QuicErrorCode.PROTOCOL_VIOLATION,
<24> frame_type=frame_type,
<25> reason_phrase="Unexpected frame type",
<26> )
<27>
<28> # handle the frame
<29> try:
<30> frame_handler(context, frame_type, buf)
<31> except BufferReadError:
<32> raise QuicConnectionError(
<33> error_code=QuicErrorCode.FRAME_ENCODING_ERROR,
<34> frame_type=frame_type,
<35> reason_phrase="Failed to parse frame",
<36> )
<37>
<38> # update ACK only / probing flags
<39> if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
<40> is_ack_eliciting = True
<41>
<42> if frame_type not in PROBING_FRAME_TYPES:
<43> is_probing = False
<44> elif is_probing is None:
<45> is_probing = True
<46>
<47> return is_ack_eliciting, bool(is_probing)
<48>
|
===========unchanged ref 0===========
at: aioquic.quic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath, quic_logger_frames: Optional[List[Any]], time: float)
===========unchanged ref 1===========
at: aioquic.quic.connection.QuicConnection.__init__
self.__frame_handlers = {
0x00: (self._handle_padding_frame, EPOCHS("IZHO")),
0x01: (self._handle_ping_frame, EPOCHS("IZHO")),
0x02: (self._handle_ack_frame, EPOCHS("IHO")),
0x03: (self._handle_ack_frame, EPOCHS("IHO")),
0x04: (self._handle_reset_stream_frame, EPOCHS("ZO")),
0x05: (self._handle_stop_sending_frame, EPOCHS("ZO")),
0x06: (self._handle_crypto_frame, EPOCHS("IHO")),
0x07: (self._handle_new_token_frame, EPOCHS("O")),
0x08: (self._handle_stream_frame, EPOCHS("ZO")),
0x09: (self._handle_stream_frame, EPOCHS("ZO")),
0x0A: (self._handle_stream_frame, EPOCHS("ZO")),
0x0B: (self._handle_stream_frame, EPOCHS("ZO")),
0x0C: (self._handle_stream_frame, EPOCHS("ZO")),
0x0D: (self._handle_stream_frame, EPOCHS("ZO")),
0x0E: (self._handle_stream_frame, EPOCHS("ZO")),
0x0F: (self._handle_stream_frame, EPOCHS("ZO")),
0x10: (self._handle_max_data_frame, EPOCHS("ZO")),
0x11: (self._handle_max_stream_data_frame, EPOCHS("ZO")),
0x12: (self._handle_max_streams_bidi_frame, EPOCHS("ZO")),
0x13: (self._handle_max_streams_uni_frame, EPOCHS("Z</s>
===========unchanged ref 2===========
at: aioquic.quic.connection.QuicReceiveContext
epoch: tls.Epoch
host_cid: bytes
network_path: QuicNetworkPath
quic_logger_frames: Optional[List[Any]]
time: float
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
===========changed ref 0===========
# module: aioquic.quic.connection
class QuicConnection:
def __init__(
self,
*,
configuration: QuicConfiguration,
logger_connection_id: Optional[bytes] = None,
original_connection_id: Optional[bytes] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
) -> None:
if configuration.is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
assert (
configuration.certificate is not None
), "SSL certificate is required for a server"
assert (
configuration.private_key is not None
), "SSL private key is required for a server"
# configuration
self._configuration = configuration
self._is_client = configuration.is_client
self._ack_delay = K_GRANULARITY
self._close_at: Optional[float] = None
self._close_event: Optional[events.ConnectionTerminated] = None
self._connect_called = False
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._crypto_buffers: Dict[tls.Epoch, Buffer] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
self._events: Deque[events.QuicEvent] = deque()
self._handshake_complete = False
self._handshake_confirmed = False
self._host_cids = [
QuicConnectionId(
cid=os.urandom(configuration.connection_id_length),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_ack_delay_exponent = 3
self._local_active_connection_id_limit</s>
===========changed ref 1===========
# module: aioquic.quic.connection
class QuicConnection:
def __init__(
self,
*,
configuration: QuicConfiguration,
logger_connection_id: Optional[bytes] = None,
original_connection_id: Optional[bytes] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
) -> None:
# offset: 1
<s>_seq = 1
self._local_ack_delay_exponent = 3
self._local_active_connection_id_limit = 8
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._loss_at: Optional[float] = None
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._packet_number = 0
self._parameters_received = False
self._peer_cid = os.urandom(configuration.connection_id_length)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self._peer_token = b""
self._quic_logger: Optional[QuicLoggerTrace] = None
self._remote_ack_delay_exponent = 3
self._remote_active_connection_id_limit = 0
self._remote_idle_timeout = 0.</s>
|
tests.test_connection/create_standalone_client
|
Modified
|
aiortc~aioquic
|
ace940222f38fd60b2ea1a355a8bc760f9467d07
|
[datagram] add support for sending / receiving DATAGRAM frames
|
<1>:<add> configuration=QuicConfiguration(
<add> is_client=True, quic_logger=QuicLogger(), **client_options
<add> )
<del> configuration=QuicConfiguration(is_client=True, quic_logger=QuicLogger())
|
# module: tests.test_connection
+ def create_standalone_client(self, **client_options):
- def create_standalone_client(self):
<0> client = QuicConnection(
<1> configuration=QuicConfiguration(is_client=True, quic_logger=QuicLogger())
<2> )
<3> client._ack_delay = 0
<4>
<5> # kick-off handshake
<6> client.connect(SERVER_ADDR, now=time.time())
<7> self.assertEqual(drop(client), 1)
<8>
<9> return client
<10>
|
===========unchanged ref 0===========
at: tests.test_connection
SERVER_ADDR = ("2.3.4.5", 4433)
drop(sender)
at: time
time() -> float
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.quic.logger
class QuicLoggerTrace:
+ def encode_datagram_frame(self, length: int) -> Dict:
+ return {
+ "frame_type": "datagram",
+ "length": length,
+ }
+
===========changed ref 1===========
# module: aioquic.quic.events
+ @dataclass
+ class DatagramFrameReceived(QuicEvent):
+ """
+ The DatagramFrameReceived event is fired when a DATAGRAM frame is received.
+ """
+
+ data: bytes
+ "The data which was received."
+
===========changed ref 2===========
# module: aioquic.quic.packet
PARAMS = {
0: ("original_connection_id", bytes),
1: ("idle_timeout", int),
2: ("stateless_reset_token", bytes),
3: ("max_packet_size", int),
4: ("initial_max_data", int),
5: ("initial_max_stream_data_bidi_local", int),
6: ("initial_max_stream_data_bidi_remote", int),
7: ("initial_max_stream_data_uni", int),
8: ("initial_max_streams_bidi", int),
9: ("initial_max_streams_uni", int),
10: ("ack_delay_exponent", int),
11: ("max_ack_delay", int),
12: ("disable_active_migration", bool),
13: ("preferred_address", QuicPreferredAddress),
14: ("active_connection_id_limit", int),
+ 32: ("max_datagram_frame_size", int),
3127: ("quantum_readiness", bytes),
}
===========changed ref 3===========
# module: aioquic.quic.packet
# FRAMES
class QuicFrameType(IntEnum):
PADDING = 0x00
PING = 0x01
ACK = 0x02
ACK_ECN = 0x03
RESET_STREAM = 0x04
STOP_SENDING = 0x05
CRYPTO = 0x06
NEW_TOKEN = 0x07
STREAM_BASE = 0x08
MAX_DATA = 0x10
MAX_STREAM_DATA = 0x11
MAX_STREAMS_BIDI = 0x12
MAX_STREAMS_UNI = 0x13
DATA_BLOCKED = 0x14
STREAM_DATA_BLOCKED = 0x15
STREAMS_BLOCKED_BIDI = 0x16
STREAMS_BLOCKED_UNI = 0x17
NEW_CONNECTION_ID = 0x18
RETIRE_CONNECTION_ID = 0x19
PATH_CHALLENGE = 0x1A
PATH_RESPONSE = 0x1B
TRANSPORT_CLOSE = 0x1C
APPLICATION_CLOSE = 0x1D
+ DATAGRAM = 0x30
+ DATAGRAM_WITH_LENGTH = 0x31
===========changed ref 4===========
# module: aioquic.quic.packet
@dataclass
class QuicTransportParameters:
original_connection_id: Optional[bytes] = None
idle_timeout: Optional[int] = None
stateless_reset_token: Optional[bytes] = None
max_packet_size: Optional[int] = None
initial_max_data: Optional[int] = None
initial_max_stream_data_bidi_local: Optional[int] = None
initial_max_stream_data_bidi_remote: Optional[int] = None
initial_max_stream_data_uni: Optional[int] = None
initial_max_streams_bidi: Optional[int] = None
initial_max_streams_uni: Optional[int] = None
ack_delay_exponent: Optional[int] = None
max_ack_delay: Optional[int] = None
disable_active_migration: Optional[bool] = False
preferred_address: Optional[QuicPreferredAddress] = None
active_connection_id_limit: Optional[int] = None
+ max_datagram_frame_size: Optional[int] = None
quantum_readiness: Optional[bytes] = None
===========changed ref 5===========
# module: aioquic.quic.configuration
@dataclass
class QuicConfiguration:
"""
A QUIC configuration.
"""
alpn_protocols: Optional[List[str]] = None
"""
A list of supported ALPN protocols.
"""
connection_id_length: int = 8
"""
The length in bytes of local connection IDs.
"""
idle_timeout: float = 60.0
"""
The idle timeout in seconds.
The connection is terminated if nothing is received for the given duration.
"""
is_client: bool = True
"""
Whether this is the client side of the QUIC connection.
"""
quic_logger: Optional[QuicLogger] = None
"""
The :class:`~aioquic.quic.logger.QuicLogger` instance to log events to.
"""
secrets_log_file: TextIO = None
"""
A file-like object in which to log traffic secrets.
This is useful to analyze traffic captures with Wireshark.
"""
server_name: Optional[str] = None
"""
The server name to send during the TLS handshake the Server Name Indication.
.. note:: This is only used by clients.
"""
session_ticket: Optional[SessionTicket] = None
"""
The TLS session ticket which should be used for session resumption.
"""
cadata: Optional[bytes] = None
cafile: Optional[str] = None
capath: Optional[str] = None
certificate: Any = None
certificate_chain: List[Any] = field(default_factory=list)
+ max_datagram_frame_size: Optional[int] = None
private_key: Any = None
quantum_readiness_test: bool = False
supported_versions: List[int] = field(
default_factory=lambda: [
QuicProtocolVersion.DRAFT_24,
QuicProtocolVersion.DRAFT_23,
]
)
verify_mode: Optional[int] = None
|
aioquic.quic.connection/QuicConnection._parse_transport_parameters
|
Modified
|
aiortc~aioquic
|
ace940222f38fd60b2ea1a355a8bc760f9467d07
|
[datagram] add support for sending / receiving DATAGRAM frames
|
# module: aioquic.quic.connection
class QuicConnection:
def _parse_transport_parameters(
self, data: bytes, from_session_ticket: bool = False
) -> None:
<0> quic_transport_parameters = pull_quic_transport_parameters(Buffer(data=data))
<1>
<2> # log event
<3> if self._quic_logger is not None and not from_session_ticket:
<4> self._quic_logger.log_event(
<5> category="transport",
<6> event="parameters_set",
<7> data=self._quic_logger.encode_transport_parameters(
<8> owner="remote", parameters=quic_transport_parameters
<9> ),
<10> )
<11>
<12> # validate remote parameters
<13> if (
<14> self._is_client
<15> and not from_session_ticket
<16> and (
<17> quic_transport_parameters.original_connection_id
<18> != self._original_connection_id
<19> )
<20> ):
<21> raise QuicConnectionError(
<22> error_code=QuicErrorCode.TRANSPORT_PARAMETER_ERROR,
<23> frame_type=QuicFrameType.CRYPTO,
<24> reason_phrase="original_connection_id does not match",
<25> )
<26>
<27> # store remote parameters
<28> if quic_transport_parameters.ack_delay_exponent is not None:
<29> self._remote_ack_delay_exponent = self._remote_ack_delay_exponent
<30> if quic_transport_parameters.active_connection_id_limit is not None:
<31> self._remote_active_connection_id_limit = (
<32> quic_transport_parameters.active_connection_id_limit
<33> )
<34> if quic_transport_parameters.idle_timeout is not None:
<35> self._remote_idle_timeout = quic_transport_parameters.idle_timeout / 1000.0
<36> if quic_transport_parameters.max_ack_delay is not None:
<37> self._loss.max_ack_delay = quic_transport_parameters.max_ack_delay / 1000.0</s>
|
===========below chunk 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _parse_transport_parameters(
self, data: bytes, from_session_ticket: bool = False
) -> None:
# offset: 1
"max_data",
"max_stream_data_bidi_local",
"max_stream_data_bidi_remote",
"max_stream_data_uni",
"max_streams_bidi",
"max_streams_uni",
]:
value = getattr(quic_transport_parameters, "initial_" + param)
if value is not None:
setattr(self, "_remote_" + param, value)
===========unchanged ref 0===========
at: aioquic.quic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicConnectionId(cid: bytes, sequence_number: int, stateless_reset_token: bytes=b"", was_sent: bool=False)
at: aioquic.quic.connection.QuicConnection.__init__
self._configuration = configuration
self._crypto_buffers: Dict[tls.Epoch, Buffer] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
self._host_cids = [
QuicConnectionId(
cid=os.urandom(configuration.connection_id_length),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self._host_cid_seq = 1
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
self._remote_active_connection_id_limit = 0
self._probe_pending = False
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
at: aioquic.quic.connection.QuicConnection._initialize
self._crypto_buffers = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
self._crypto_streams = {
tls.Epoch.INITIAL: QuicStream(),
tls.Epoch.HANDSHAKE: QuicStream(),
tls.Epoch.ONE_RTT: QuicStream(),
}
===========unchanged ref 1===========
at: aioquic.quic.connection.QuicConnection._parse_transport_parameters
self._remote_active_connection_id_limit = (
quic_transport_parameters.active_connection_id_limit
)
at: aioquic.quic.connection.QuicConnection._payload_received
buf = Buffer(data=plain)
frame_type = buf.pull_uint_var()
frame_handler, frame_epochs = self.__frame_handlers[frame_type]
at: aioquic.quic.connection.QuicConnection._write_application
self._probe_pending = False
at: aioquic.quic.connection.QuicConnection._write_handshake
self._probe_pending = False
at: aioquic.quic.connection.QuicConnectionId
cid: bytes
sequence_number: int
stateless_reset_token: bytes = b""
was_sent: bool = False
at: os
urandom(size: int, /) -> bytes
===========changed ref 0===========
# module: aioquic.quic.connection
class QuicConnection:
+ def _handle_datagram_frame(
+ self, context: QuicReceiveContext, frame_type: int, buf: Buffer
+ ) -> None:
+ """
+ Handle a DATAGRAM frame.
+ """
+ start = buf.tell()
+ if frame_type == QuicFrameType.DATAGRAM_WITH_LENGTH:
+ length = buf.pull_uint_var()
+ else:
+ length = buf.capacity - start
+ data = buf.pull_bytes(length)
+
+ # check frame is allowed
+ if (
+ self._configuration.max_datagram_frame_size is None
+ or buf.tell() - start >= self._configuration.max_datagram_frame_size
+ ):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.PROTOCOL_VIOLATION,
+ frame_type=frame_type,
+ reason_phrase="Unexpected DATAGRAM frame",
+ )
+
+ self._events.append(events.DatagramFrameReceived(data=data))
+
+ # log frame
+ if self._quic_logger is not None:
+ context.quic_logger_frames.append(
+ self._quic_logger.encode_datagram_frame(length=length)
+ )
+
===========changed ref 1===========
# module: aioquic.quic.connection
class QuicConnection:
+ def send_datagram_frame(self, data: bytes) -> None:
+ """
+ Send a DATAGRAM frame.
+
+ :param data: The data to be sent.
+ """
+ self._datagrams_pending.append(data)
+
===========changed ref 2===========
# module: aioquic.quic.logger
class QuicLoggerTrace:
+ def encode_datagram_frame(self, length: int) -> Dict:
+ return {
+ "frame_type": "datagram",
+ "length": length,
+ }
+
===========changed ref 3===========
# module: aioquic.quic.events
+ @dataclass
+ class DatagramFrameReceived(QuicEvent):
+ """
+ The DatagramFrameReceived event is fired when a DATAGRAM frame is received.
+ """
+
+ data: bytes
+ "The data which was received."
+
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_handle_datagram_frame(self):
+ client = create_standalone_client(self, max_datagram_frame_size=6)
+
+ client._handle_datagram_frame(
+ client_receive_context(client),
+ QuicFrameType.DATAGRAM,
+ Buffer(data=b"hello"),
+ )
+
+ self.assertEqual(
+ client.next_event(), events.DatagramFrameReceived(data=b"hello")
+ )
+
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_handle_datagram_frame_with_length(self):
+ client = create_standalone_client(self, max_datagram_frame_size=7)
+
+ client._handle_datagram_frame(
+ client_receive_context(client),
+ QuicFrameType.DATAGRAM_WITH_LENGTH,
+ Buffer(data=b"\x05hellojunk"),
+ )
+
+ self.assertEqual(
+ client.next_event(), events.DatagramFrameReceived(data=b"hello")
+ )
+
===========changed ref 6===========
# module: tests.test_connection
+ def create_standalone_client(self, **client_options):
- def create_standalone_client(self):
client = QuicConnection(
+ configuration=QuicConfiguration(
+ is_client=True, quic_logger=QuicLogger(), **client_options
+ )
- configuration=QuicConfiguration(is_client=True, quic_logger=QuicLogger())
)
client._ack_delay = 0
# kick-off handshake
client.connect(SERVER_ADDR, now=time.time())
self.assertEqual(drop(client), 1)
return client
|
|
aioquic.quic.connection/QuicConnection._serialize_transport_parameters
|
Modified
|
aiortc~aioquic
|
ace940222f38fd60b2ea1a355a8bc760f9467d07
|
[datagram] add support for sending / receiving DATAGRAM frames
|
<11>:<add> max_datagram_frame_size=self._configuration.max_datagram_frame_size,
|
# module: aioquic.quic.connection
class QuicConnection:
def _serialize_transport_parameters(self) -> bytes:
<0> quic_transport_parameters = QuicTransportParameters(
<1> ack_delay_exponent=self._local_ack_delay_exponent,
<2> active_connection_id_limit=self._local_active_connection_id_limit,
<3> idle_timeout=int(self._configuration.idle_timeout * 1000),
<4> initial_max_data=self._local_max_data,
<5> initial_max_stream_data_bidi_local=self._local_max_stream_data_bidi_local,
<6> initial_max_stream_data_bidi_remote=self._local_max_stream_data_bidi_remote,
<7> initial_max_stream_data_uni=self._local_max_stream_data_uni,
<8> initial_max_streams_bidi=self._local_max_streams_bidi,
<9> initial_max_streams_uni=self._local_max_streams_uni,
<10> max_ack_delay=25,
<11> quantum_readiness=b"Q" * 1200
<12> if self._configuration.quantum_readiness_test
<13> else None,
<14> )
<15> if not self._is_client:
<16> quic_transport_parameters.original_connection_id = (
<17> self._original_connection_id
<18> )
<19>
<20> # log event
<21> if self._quic_logger is not None:
<22> self._quic_logger.log_event(
<23> category="transport",
<24> event="parameters_set",
<25> data=self._quic_logger.encode_transport_parameters(
<26> owner="local", parameters=quic_transport_parameters
<27> ),
<28> )
<29>
<30> buf = Buffer(capacity=3 * PACKET_MAX_SIZE)
<31> push_quic_transport_parameters(buf, quic_transport_parameters)
<32> return buf.data
<33>
|
===========unchanged ref 0===========
at: aioquic.quic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
at: aioquic.quic.connection.QuicConnection.__init__
self._is_client = configuration.is_client
self._original_connection_id = original_connection_id
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
self._remote_ack_delay_exponent = 3
self._remote_active_connection_id_limit = 0
self._remote_idle_timeout = 0.0 # seconds
self._remote_max_datagram_frame_size: Optional[int] = None
self._loss = QuicPacketRecovery(
is_client_without_1rtt=self._is_client,
quic_logger=self._quic_logger,
send_probe=self._send_probe,
)
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
at: aioquic.quic.connection.QuicConnection._parse_transport_parameters
quic_transport_parameters = pull_quic_transport_parameters(Buffer(data=data))
at: aioquic.quic.connection.QuicConnection.receive_datagram
self._original_connection_id = self._peer_cid
===========changed ref 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _parse_transport_parameters(
self, data: bytes, from_session_ticket: bool = False
) -> None:
quic_transport_parameters = pull_quic_transport_parameters(Buffer(data=data))
# log event
if self._quic_logger is not None and not from_session_ticket:
self._quic_logger.log_event(
category="transport",
event="parameters_set",
data=self._quic_logger.encode_transport_parameters(
owner="remote", parameters=quic_transport_parameters
),
)
# validate remote parameters
if (
self._is_client
and not from_session_ticket
and (
quic_transport_parameters.original_connection_id
!= self._original_connection_id
)
):
raise QuicConnectionError(
error_code=QuicErrorCode.TRANSPORT_PARAMETER_ERROR,
frame_type=QuicFrameType.CRYPTO,
reason_phrase="original_connection_id does not match",
)
# store remote parameters
if quic_transport_parameters.ack_delay_exponent is not None:
self._remote_ack_delay_exponent = self._remote_ack_delay_exponent
if quic_transport_parameters.active_connection_id_limit is not None:
self._remote_active_connection_id_limit = (
quic_transport_parameters.active_connection_id_limit
)
if quic_transport_parameters.idle_timeout is not None:
self._remote_idle_timeout = quic_transport_parameters.idle_timeout / 1000.0
if quic_transport_parameters.max_ack_delay is not None:
self._loss.max_ack_delay = quic_transport_parameters.max_ack_delay / 1000.0
+ self._remote_max_datagram_frame_size = (
+ quic_transport_parameters.max_datagram_frame_size
+ </s>
===========changed ref 1===========
# module: aioquic.quic.connection
class QuicConnection:
def _parse_transport_parameters(
self, data: bytes, from_session_ticket: bool = False
) -> None:
# offset: 1
<s>_datagram_frame_size = (
+ quic_transport_parameters.max_datagram_frame_size
+ )
for param in [
"max_data",
"max_stream_data_bidi_local",
"max_stream_data_bidi_remote",
"max_stream_data_uni",
"max_streams_bidi",
"max_streams_uni",
]:
value = getattr(quic_transport_parameters, "initial_" + param)
if value is not None:
setattr(self, "_remote_" + param, value)
===========changed ref 2===========
# module: aioquic.quic.connection
class QuicConnection:
+ def _handle_datagram_frame(
+ self, context: QuicReceiveContext, frame_type: int, buf: Buffer
+ ) -> None:
+ """
+ Handle a DATAGRAM frame.
+ """
+ start = buf.tell()
+ if frame_type == QuicFrameType.DATAGRAM_WITH_LENGTH:
+ length = buf.pull_uint_var()
+ else:
+ length = buf.capacity - start
+ data = buf.pull_bytes(length)
+
+ # check frame is allowed
+ if (
+ self._configuration.max_datagram_frame_size is None
+ or buf.tell() - start >= self._configuration.max_datagram_frame_size
+ ):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.PROTOCOL_VIOLATION,
+ frame_type=frame_type,
+ reason_phrase="Unexpected DATAGRAM frame",
+ )
+
+ self._events.append(events.DatagramFrameReceived(data=data))
+
+ # log frame
+ if self._quic_logger is not None:
+ context.quic_logger_frames.append(
+ self._quic_logger.encode_datagram_frame(length=length)
+ )
+
===========changed ref 3===========
# module: aioquic.quic.logger
class QuicLoggerTrace:
+ def encode_datagram_frame(self, length: int) -> Dict:
+ return {
+ "frame_type": "datagram",
+ "length": length,
+ }
+
===========changed ref 4===========
# module: aioquic.quic.connection
class QuicConnection:
+ def send_datagram_frame(self, data: bytes) -> None:
+ """
+ Send a DATAGRAM frame.
+
+ :param data: The data to be sent.
+ """
+ self._datagrams_pending.append(data)
+
===========changed ref 5===========
# module: aioquic.quic.events
+ @dataclass
+ class DatagramFrameReceived(QuicEvent):
+ """
+ The DatagramFrameReceived event is fired when a DATAGRAM frame is received.
+ """
+
+ data: bytes
+ "The data which was received."
+
===========changed ref 6===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_handle_datagram_frame(self):
+ client = create_standalone_client(self, max_datagram_frame_size=6)
+
+ client._handle_datagram_frame(
+ client_receive_context(client),
+ QuicFrameType.DATAGRAM,
+ Buffer(data=b"hello"),
+ )
+
+ self.assertEqual(
+ client.next_event(), events.DatagramFrameReceived(data=b"hello")
+ )
+
|
aioquic.quic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
ace940222f38fd60b2ea1a355a8bc760f9467d07
|
[datagram] add support for sending / receiving DATAGRAM frames
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
<0> crypto_stream: Optional[QuicStream] = None
<1> if self._cryptos[tls.Epoch.ONE_RTT].send.is_valid():
<2> crypto = self._cryptos[tls.Epoch.ONE_RTT]
<3> crypto_stream = self._crypto_streams[tls.Epoch.ONE_RTT]
<4> packet_type = PACKET_TYPE_ONE_RTT
<5> elif self._cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
<6> crypto = self._cryptos[tls.Epoch.ZERO_RTT]
<7> packet_type = PACKET_TYPE_ZERO_RTT
<8> else:
<9> return
<10> space = self._spaces[tls.Epoch.ONE_RTT]
<11>
<12> while True:
<13> # write header
<14> builder.start_packet(packet_type, crypto)
<15>
<16> if self._handshake_complete:
<17> # ACK
<18> if space.ack_at is not None and space.ack_at <= now:
<19> self._write_ack_frame(builder=builder, space=space)
<20>
<21> # PATH CHALLENGE
<22> if (
<23> not network_path.is_validated
<24> and network_path.local_challenge is None
<25> ):
<26> self._logger.debug(
<27> "Network path %s sending challenge", network_path.addr
<28> )
<29> network_path.local_challenge = os.urandom(8)
<30> buf = builder.start_frame(QuicFrameType.PATH_CHALLENGE)
<31> buf.push_bytes(network_path.local_challenge)
<32>
<33> # log frame
<34> if self._quic_logger is not None:
<35> builder.quic_logger_frames.append(
<36> self._quic_logger.encode_path_challenge_frame(
</s>
|
===========below chunk 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
# offset: 1
)
)
# PATH RESPONSE
if network_path.remote_challenge is not None:
challenge = network_path.remote_challenge
buf = builder.start_frame(QuicFrameType.PATH_RESPONSE)
buf.push_bytes(challenge)
network_path.remote_challenge = None
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_path_response_frame(data=challenge)
)
# NEW_CONNECTION_ID
for connection_id in self._host_cids:
if not connection_id.was_sent:
self._write_new_connection_id_frame(
builder=builder, connection_id=connection_id
)
# RETIRE_CONNECTION_ID
while self._retire_connection_ids:
sequence_number = self._retire_connection_ids.pop(0)
self._write_retire_connection_id_frame(
builder=builder, sequence_number=sequence_number
)
# STREAMS_BLOCKED
if self._streams_blocked_pending:
if self._streams_blocked_bidi:
self._write_streams_blocked_frame(
builder=builder,
frame_type=QuicFrameType.STREAMS_BLOCKED_BIDI,
limit=self._remote_max_streams_bidi,
)
if self._streams_blocked_uni:
self._write_streams_blocked_frame(
builder=builder,
frame_type=QuicFrameType.STREAMS_BLOCKED_UNI,
limit=self._remote_max_streams_uni,
)
self._streams_blocked_pending = False
# connection-level limits
self._write_connection</s>
===========below chunk 1===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
# offset: 2
<s>,
)
self._streams_blocked_pending = False
# connection-level limits
self._write_connection_limits(builder=builder, space=space)
# stream-level limits
for stream in self._streams.values():
self._write_stream_limits(builder=builder, space=space, stream=stream)
# PING (user-request)
if self._ping_pending:
self._logger.info("Sending PING in packet %d", builder.packet_number)
self._write_ping_frame(builder, self._ping_pending)
self._ping_pending.clear()
# PING (probe)
if self._probe_pending:
self._logger.info(
"Sending PING (probe) in packet %d", builder.packet_number
)
self._write_ping_frame(builder)
self._probe_pending = False
# CRYPTO
if crypto_stream is not None and not crypto_stream.send_buffer_is_empty:
self._write_crypto_frame(
builder=builder, space=space, stream=crypto_stream
)
for stream in self._streams.values():
# STREAM
if not stream.is_blocked and not stream.send_buffer_is_empty:
self._remote_max_data_used += self._write_stream_frame(
builder=builder,
space=space,
stream=stream,
max_offset=min(
stream._send_highest
+ self._remote_max_data
- self._remote_max_data_used,
stream.max_stream_data_remote,
),
)
if builder.packet_
===========unchanged ref 0===========
at: aioquic.quic.connection
SECRETS_LABELS = [
[
None,
"QUIC_CLIENT_EARLY_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
[
None,
None,
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
],
]
QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, is_validated: bool=False, local_challenge: Optional[bytes]=None, remote_challenge: Optional[bytes]=None)
at: aioquic.quic.connection.QuicConnection
_write_ack_frame(builder: QuicPacketBuilder, space: QuicPacketSpace)
_write_new_connection_id_frame(builder: QuicPacketBuilder, connection_id: QuicConnectionId) -> None
_write_retire_connection_id_frame(builder: QuicPacketBuilder, sequence_number: int) -> None
_write_streams_blocked_frame(builder: QuicPacketBuilder, frame_type: QuicFrameType, limit: int) -> None
at: aioquic.quic.connection.QuicConnection.__init__
self._configuration = configuration
self._is_client = configuration.is_client
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
self._handshake_complete = False
self._host_cids = [
QuicConnectionId(
cid=os.urandom(configuration.connection_id_length),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
===========unchanged ref 1===========
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._spaces: Dict[tls.Epoch, QuicPacketSpace] = {}
self._streams_blocked_bidi: List[QuicStream] = []
self._streams_blocked_uni: List[QuicStream] = []
self._version: Optional[int] = None
self._logger = QuicConnectionAdapter(
logger, {"id": dump_cid(logger_connection_id)}
)
self._retire_connection_ids: List[int] = []
self._streams_blocked_pending = False
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
at: aioquic.quic.connection.QuicConnection._create_stream
self._streams_blocked_pending = True
at: aioquic.quic.connection.QuicConnection._handle_crypto_frame
self._handshake_complete = True
at: aioquic.quic.connection.QuicConnection._handle_max_streams_bidi_frame
self._remote_max_streams_bidi = max_streams
at: aioquic.quic.connection.QuicConnection._handle_max_streams_uni_frame
self._remote_max_streams_uni = max_streams
|
|
examples.http3_server/HttpServerProtocol.quic_event_received
|
Modified
|
aiortc~aioquic
|
4351bfceb244587cc916dbfaa6ed62c80d9d36d7
|
[http3 server] respond to SiDUCK quacks
|
<5>:<add> elif isinstance(event, DatagramFrameReceived):
<add> if event.data == b"quack":
<add> self._quic.send_datagram_frame(b"quack-ack")
|
# module: examples.http3_server
class HttpServerProtocol(QuicConnectionProtocol):
def quic_event_received(self, event: QuicEvent):
<0> if isinstance(event, ProtocolNegotiated):
<1> if event.alpn_protocol.startswith("h3-"):
<2> self._http = H3Connection(self._quic)
<3> elif event.alpn_protocol.startswith("hq-"):
<4> self._http = H0Connection(self._quic)
<5>
<6> # pass event to the HTTP layer
<7> if self._http is not None:
<8> for http_event in self._http.handle_event(event):
<9> self.http_event_received(http_event)
<10>
|
===========unchanged ref 0===========
at: examples.http3_server.HttpServerProtocol.__init__
self._http: Optional[HttpConnection] = None
|
tests.test_connection/QuicConnectionTest.test_connect
|
Modified
|
aiortc~aioquic
|
55035e0dd5cf79fc3051e83f11b8546a2a09ba74
|
[datagram] respect congestion control
|
<2>:<del> event = client.next_event()
<3>:<del> self.assertEqual(type(event), events.ProtocolNegotiated)
<4>:<del> self.assertEqual(event.alpn_protocol, None)
<5>:<del> event = client.next_event()
<6>:<del> self.assertEqual(type(event), events.HandshakeCompleted)
<7>:<del> self.assertEqual(event.alpn_protocol, None)
<8>:<del> self.assertEqual(event.early_data_accepted, False)
<9>:<del> self.assertEqual(event.session_resumed, False)
<10>:<del> for i in range(7):
<11>:<del> self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
<12>:<del> self.assertIsNone(client.next_event())
<13>:<del>
<14>:<del> event = server.next_event()
<15>:<del> self.assertEqual(type(event), events.ProtocolNegotiated)
<16>:<del> self.assertEqual(event.alpn_protocol, None)
<17>:<del> event = server.next_event()
<18>:<del> self.assertEqual(type(event), events.HandshakeCompleted)
<19>:<del> self.assertEqual(event.alpn_protocol, None)
<20>:<del> self.assertEqual(event.early_data_accepted, False)
<21>:<del> self.assertEqual(event.session_resumed, False)
<22>:<del> for i in range(7):
<23>:<del> self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
<24>:<del> self.assertIsNone(server.next_event())
<25>:<add> self.check_handshake(client=client, server=server)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect(self):
<0> with client_and_server() as (client, server):
<1> # check handshake completed
<2> event = client.next_event()
<3> self.assertEqual(type(event), events.ProtocolNegotiated)
<4> self.assertEqual(event.alpn_protocol, None)
<5> event = client.next_event()
<6> self.assertEqual(type(event), events.HandshakeCompleted)
<7> self.assertEqual(event.alpn_protocol, None)
<8> self.assertEqual(event.early_data_accepted, False)
<9> self.assertEqual(event.session_resumed, False)
<10> for i in range(7):
<11> self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
<12> self.assertIsNone(client.next_event())
<13>
<14> event = server.next_event()
<15> self.assertEqual(type(event), events.ProtocolNegotiated)
<16> self.assertEqual(event.alpn_protocol, None)
<17> event = server.next_event()
<18> self.assertEqual(type(event), events.HandshakeCompleted)
<19> self.assertEqual(event.alpn_protocol, None)
<20> self.assertEqual(event.early_data_accepted, False)
<21> self.assertEqual(event.session_resumed, False)
<22> for i in range(7):
<23> self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
<24> self.assertIsNone(server.next_event())
<25>
<26> # check each endpoint has available connection IDs for the peer
<27> self.assertEqual(
<28> sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<29> )
<30> self.assertEqual(
<31> sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<32> )
<33>
<34> </s>
|
===========below chunk 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect(self):
# offset: 1
client.close()
self.assertEqual(transfer(client, server), 1)
# check connection closes on the client side
client.handle_timer(client.get_timer())
event = client.next_event()
self.assertEqual(type(event), events.ConnectionTerminated)
self.assertEqual(event.error_code, QuicErrorCode.NO_ERROR)
self.assertEqual(event.frame_type, None)
self.assertEqual(event.reason_phrase, "")
self.assertIsNone(client.next_event())
# check connection closes on the server side
server.handle_timer(server.get_timer())
event = server.next_event()
self.assertEqual(type(event), events.ConnectionTerminated)
self.assertEqual(event.error_code, QuicErrorCode.NO_ERROR)
self.assertEqual(event.frame_type, None)
self.assertEqual(event.reason_phrase, "")
self.assertIsNone(server.next_event())
# check client log
client_log = client.configuration.quic_logger.to_dict()
self.assertGreater(len(client_log["traces"][0]["events"]), 20)
# check server log
server_log = server.configuration.quic_logger.to_dict()
self.assertGreater(len(server_log["traces"][0]["events"]), 20)
===========unchanged ref 0===========
at: tests.test_connection
client_and_server(client_kwargs={}, client_options={}, client_patch=lambda x: None, handshake=True, server_kwargs={}, server_certfile=SERVER_CERTFILE, server_keyfile=SERVER_KEYFILE, server_options={}, server_patch=lambda x: None, transport_options={})
sequence_numbers(connection_ids)
transfer(sender, receiver)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertIsNone(obj: Any, msg: Any=...) -> None
assertGreater(a: Any, b: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def check_handshake(self, client, server, alpn_protocol=None):
+ """
+ Check handshake completed.
+ """
+ event = client.next_event()
+ self.assertEqual(type(event), events.ProtocolNegotiated)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ event = client.next_event()
+ self.assertEqual(type(event), events.HandshakeCompleted)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ self.assertEqual(event.early_data_accepted, False)
+ self.assertEqual(event.session_resumed, False)
+ for i in range(7):
+ self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
+ self.assertIsNone(client.next_event())
+
+ event = server.next_event()
+ self.assertEqual(type(event), events.ProtocolNegotiated)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ event = server.next_event()
+ self.assertEqual(type(event), events.HandshakeCompleted)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ for i in range(7):
+ self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
+ self.assertIsNone(server.next_event())
+
|
tests.test_connection/QuicConnectionTest.test_connect_with_alpn
|
Modified
|
aiortc~aioquic
|
55035e0dd5cf79fc3051e83f11b8546a2a09ba74
|
[datagram] respect congestion control
|
<5>:<del> event = client.next_event()
<6>:<del> self.assertEqual(type(event), events.ProtocolNegotiated)
<7>:<del> self.assertEqual(event.alpn_protocol, "hq-23")
<8>:<del> event = client.next_event()
<9>:<del> self.assertEqual(type(event), events.HandshakeCompleted)
<10>:<del> self.assertEqual(event.alpn_protocol, "hq-23")
<11>:<del> for i in range(7):
<12>:<del> self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
<13>:<del> self.assertIsNone(client.next_event())
<14>:<add> self.check_handshake(client=client, server=server, alpn_protocol="hq-23")
<15>:<del> event = server.next_event()
<16>:<del> self.assertEqual(type(event), events.ProtocolNegotiated)
<17>:<del> self.assertEqual(event.alpn_protocol, "hq-23")
<18>:<del> event = server.next_event()
<19>:<del> self.assertEqual(type(event), events.HandshakeCompleted)
<20>:<del> self.assertEqual(event.alpn_protocol, "hq-23")
<21>:<del> for i in range(7):
<22>:<del> self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
<23>:<del> self.assertIsNone(server.next_event())
<24>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_alpn(self):
<0> with client_and_server(
<1> client_options={"alpn_protocols": ["h3-23", "hq-23"]},
<2> server_options={"alpn_protocols": ["hq-23"]},
<3> ) as (client, server):
<4> # check handshake completed
<5> event = client.next_event()
<6> self.assertEqual(type(event), events.ProtocolNegotiated)
<7> self.assertEqual(event.alpn_protocol, "hq-23")
<8> event = client.next_event()
<9> self.assertEqual(type(event), events.HandshakeCompleted)
<10> self.assertEqual(event.alpn_protocol, "hq-23")
<11> for i in range(7):
<12> self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
<13> self.assertIsNone(client.next_event())
<14>
<15> event = server.next_event()
<16> self.assertEqual(type(event), events.ProtocolNegotiated)
<17> self.assertEqual(event.alpn_protocol, "hq-23")
<18> event = server.next_event()
<19> self.assertEqual(type(event), events.HandshakeCompleted)
<20> self.assertEqual(event.alpn_protocol, "hq-23")
<21> for i in range(7):
<22> self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
<23> self.assertIsNone(server.next_event())
<24>
|
===========unchanged ref 0===========
at: tests.test_connection
client_and_server(client_kwargs={}, client_options={}, client_patch=lambda x: None, handshake=True, server_kwargs={}, server_certfile=SERVER_CERTFILE, server_keyfile=SERVER_KEYFILE, server_options={}, server_patch=lambda x: None, transport_options={})
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertIsNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def check_handshake(self, client, server, alpn_protocol=None):
+ """
+ Check handshake completed.
+ """
+ event = client.next_event()
+ self.assertEqual(type(event), events.ProtocolNegotiated)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ event = client.next_event()
+ self.assertEqual(type(event), events.HandshakeCompleted)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ self.assertEqual(event.early_data_accepted, False)
+ self.assertEqual(event.session_resumed, False)
+ for i in range(7):
+ self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
+ self.assertIsNone(client.next_event())
+
+ event = server.next_event()
+ self.assertEqual(type(event), events.ProtocolNegotiated)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ event = server.next_event()
+ self.assertEqual(type(event), events.HandshakeCompleted)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ for i in range(7):
+ self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
+ self.assertIsNone(server.next_event())
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect(self):
with client_and_server() as (client, server):
# check handshake completed
- event = client.next_event()
- self.assertEqual(type(event), events.ProtocolNegotiated)
- self.assertEqual(event.alpn_protocol, None)
- event = client.next_event()
- self.assertEqual(type(event), events.HandshakeCompleted)
- self.assertEqual(event.alpn_protocol, None)
- self.assertEqual(event.early_data_accepted, False)
- self.assertEqual(event.session_resumed, False)
- for i in range(7):
- self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
- self.assertIsNone(client.next_event())
-
- event = server.next_event()
- self.assertEqual(type(event), events.ProtocolNegotiated)
- self.assertEqual(event.alpn_protocol, None)
- event = server.next_event()
- self.assertEqual(type(event), events.HandshakeCompleted)
- self.assertEqual(event.alpn_protocol, None)
- self.assertEqual(event.early_data_accepted, False)
- self.assertEqual(event.session_resumed, False)
- for i in range(7):
- self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
- self.assertIsNone(server.next_event())
+ self.check_handshake(client=client, server=server)
# check each endpoint has available connection IDs for the peer
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
self.assertEqual(
sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]</s>
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect(self):
# offset: 1
<s>(
sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
# client closes the connection
client.close()
self.assertEqual(transfer(client, server), 1)
# check connection closes on the client side
client.handle_timer(client.get_timer())
event = client.next_event()
self.assertEqual(type(event), events.ConnectionTerminated)
self.assertEqual(event.error_code, QuicErrorCode.NO_ERROR)
self.assertEqual(event.frame_type, None)
self.assertEqual(event.reason_phrase, "")
self.assertIsNone(client.next_event())
# check connection closes on the server side
server.handle_timer(server.get_timer())
event = server.next_event()
self.assertEqual(type(event), events.ConnectionTerminated)
self.assertEqual(event.error_code, QuicErrorCode.NO_ERROR)
self.assertEqual(event.frame_type, None)
self.assertEqual(event.reason_phrase, "")
self.assertIsNone(server.next_event())
# check client log
client_log = client.configuration.quic_logger.to_dict()
self.assertGreater(len(client_log["traces"][0]["events"]), 20)
# check server log
server_log = server.configuration.quic_logger.to_dict()
self.assertGreater(len(server_log["traces"][0]["events"]), 20)
|
tests.test_connection/QuicConnectionTest.test_connect_with_secrets_log
|
Modified
|
aiortc~aioquic
|
55035e0dd5cf79fc3051e83f11b8546a2a09ba74
|
[datagram] respect congestion control
|
<6>:<add> # check handshake completed
<add> self.check_handshake(client=client, server=server)
<add>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_secrets_log(self):
<0> client_log_file = io.StringIO()
<1> server_log_file = io.StringIO()
<2> with client_and_server(
<3> client_options={"secrets_log_file": client_log_file},
<4> server_options={"secrets_log_file": server_log_file},
<5> ) as (client, server):
<6> # check secrets were logged
<7> client_log = client_log_file.getvalue()
<8> server_log = server_log_file.getvalue()
<9> self.assertEqual(client_log, server_log)
<10> labels = []
<11> for line in client_log.splitlines():
<12> labels.append(line.split()[0])
<13> self.assertEqual(
<14> labels,
<15> [
<16> "QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
<17> "QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
<18> "QUIC_SERVER_TRAFFIC_SECRET_0",
<19> "QUIC_CLIENT_TRAFFIC_SECRET_0",
<20> ],
<21> )
<22>
|
===========unchanged ref 0===========
at: io
StringIO(initial_value: Optional[str]=..., newline: Optional[str]=...)
at: io.StringIO
getvalue(self) -> str
at: tests.test_connection
client_and_server(client_kwargs={}, client_options={}, client_patch=lambda x: None, handshake=True, server_kwargs={}, server_certfile=SERVER_CERTFILE, server_keyfile=SERVER_KEYFILE, server_options={}, server_patch=lambda x: None, transport_options={})
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def check_handshake(self, client, server, alpn_protocol=None):
+ """
+ Check handshake completed.
+ """
+ event = client.next_event()
+ self.assertEqual(type(event), events.ProtocolNegotiated)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ event = client.next_event()
+ self.assertEqual(type(event), events.HandshakeCompleted)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ self.assertEqual(event.early_data_accepted, False)
+ self.assertEqual(event.session_resumed, False)
+ for i in range(7):
+ self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
+ self.assertIsNone(client.next_event())
+
+ event = server.next_event()
+ self.assertEqual(type(event), events.ProtocolNegotiated)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ event = server.next_event()
+ self.assertEqual(type(event), events.HandshakeCompleted)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ for i in range(7):
+ self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
+ self.assertIsNone(server.next_event())
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_alpn(self):
with client_and_server(
client_options={"alpn_protocols": ["h3-23", "hq-23"]},
server_options={"alpn_protocols": ["hq-23"]},
) as (client, server):
# check handshake completed
- event = client.next_event()
- self.assertEqual(type(event), events.ProtocolNegotiated)
- self.assertEqual(event.alpn_protocol, "hq-23")
- event = client.next_event()
- self.assertEqual(type(event), events.HandshakeCompleted)
- self.assertEqual(event.alpn_protocol, "hq-23")
- for i in range(7):
- self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
- self.assertIsNone(client.next_event())
+ self.check_handshake(client=client, server=server, alpn_protocol="hq-23")
- event = server.next_event()
- self.assertEqual(type(event), events.ProtocolNegotiated)
- self.assertEqual(event.alpn_protocol, "hq-23")
- event = server.next_event()
- self.assertEqual(type(event), events.HandshakeCompleted)
- self.assertEqual(event.alpn_protocol, "hq-23")
- for i in range(7):
- self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
- self.assertIsNone(server.next_event())
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect(self):
with client_and_server() as (client, server):
# check handshake completed
- event = client.next_event()
- self.assertEqual(type(event), events.ProtocolNegotiated)
- self.assertEqual(event.alpn_protocol, None)
- event = client.next_event()
- self.assertEqual(type(event), events.HandshakeCompleted)
- self.assertEqual(event.alpn_protocol, None)
- self.assertEqual(event.early_data_accepted, False)
- self.assertEqual(event.session_resumed, False)
- for i in range(7):
- self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
- self.assertIsNone(client.next_event())
-
- event = server.next_event()
- self.assertEqual(type(event), events.ProtocolNegotiated)
- self.assertEqual(event.alpn_protocol, None)
- event = server.next_event()
- self.assertEqual(type(event), events.HandshakeCompleted)
- self.assertEqual(event.alpn_protocol, None)
- self.assertEqual(event.early_data_accepted, False)
- self.assertEqual(event.session_resumed, False)
- for i in range(7):
- self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
- self.assertIsNone(server.next_event())
+ self.check_handshake(client=client, server=server)
# check each endpoint has available connection IDs for the peer
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
self.assertEqual(
sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]</s>
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect(self):
# offset: 1
<s>(
sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
# client closes the connection
client.close()
self.assertEqual(transfer(client, server), 1)
# check connection closes on the client side
client.handle_timer(client.get_timer())
event = client.next_event()
self.assertEqual(type(event), events.ConnectionTerminated)
self.assertEqual(event.error_code, QuicErrorCode.NO_ERROR)
self.assertEqual(event.frame_type, None)
self.assertEqual(event.reason_phrase, "")
self.assertIsNone(client.next_event())
# check connection closes on the server side
server.handle_timer(server.get_timer())
event = server.next_event()
self.assertEqual(type(event), events.ConnectionTerminated)
self.assertEqual(event.error_code, QuicErrorCode.NO_ERROR)
self.assertEqual(event.frame_type, None)
self.assertEqual(event.reason_phrase, "")
self.assertIsNone(server.next_event())
# check client log
client_log = client.configuration.quic_logger.to_dict()
self.assertGreater(len(client_log["traces"][0]["events"]), 20)
# check server log
server_log = server.configuration.quic_logger.to_dict()
self.assertGreater(len(server_log["traces"][0]["events"]), 20)
|
tests.test_connection/QuicConnectionTest.test_connect_with_cert_chain
|
Modified
|
aiortc~aioquic
|
55035e0dd5cf79fc3051e83f11b8546a2a09ba74
|
[datagram] respect congestion control
|
<4>:<add> # check handshake completed
<add> self.check_handshake(client=client, server=server)
<del> pass
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_cert_chain(self):
<0> with client_and_server(server_certfile=SERVER_CERTFILE_WITH_CHAIN) as (
<1> client,
<2> server,
<3> ):
<4> pass
<5>
|
===========unchanged ref 0===========
at: tests.test_connection
client_and_server(client_kwargs={}, client_options={}, client_patch=lambda x: None, handshake=True, server_kwargs={}, server_certfile=SERVER_CERTFILE, server_keyfile=SERVER_KEYFILE, server_options={}, server_patch=lambda x: None, transport_options={})
at: tests.utils
SERVER_CERTFILE_WITH_CHAIN = os.path.join(
os.path.dirname(__file__), "ssl_cert_with_chain.pem"
)
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_secrets_log(self):
client_log_file = io.StringIO()
server_log_file = io.StringIO()
with client_and_server(
client_options={"secrets_log_file": client_log_file},
server_options={"secrets_log_file": server_log_file},
) as (client, server):
+ # check handshake completed
+ self.check_handshake(client=client, server=server)
+
# check secrets were logged
client_log = client_log_file.getvalue()
server_log = server_log_file.getvalue()
self.assertEqual(client_log, server_log)
labels = []
for line in client_log.splitlines():
labels.append(line.split()[0])
self.assertEqual(
labels,
[
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
)
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def check_handshake(self, client, server, alpn_protocol=None):
+ """
+ Check handshake completed.
+ """
+ event = client.next_event()
+ self.assertEqual(type(event), events.ProtocolNegotiated)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ event = client.next_event()
+ self.assertEqual(type(event), events.HandshakeCompleted)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ self.assertEqual(event.early_data_accepted, False)
+ self.assertEqual(event.session_resumed, False)
+ for i in range(7):
+ self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
+ self.assertIsNone(client.next_event())
+
+ event = server.next_event()
+ self.assertEqual(type(event), events.ProtocolNegotiated)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ event = server.next_event()
+ self.assertEqual(type(event), events.HandshakeCompleted)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ for i in range(7):
+ self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
+ self.assertIsNone(server.next_event())
+
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_alpn(self):
with client_and_server(
client_options={"alpn_protocols": ["h3-23", "hq-23"]},
server_options={"alpn_protocols": ["hq-23"]},
) as (client, server):
# check handshake completed
- event = client.next_event()
- self.assertEqual(type(event), events.ProtocolNegotiated)
- self.assertEqual(event.alpn_protocol, "hq-23")
- event = client.next_event()
- self.assertEqual(type(event), events.HandshakeCompleted)
- self.assertEqual(event.alpn_protocol, "hq-23")
- for i in range(7):
- self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
- self.assertIsNone(client.next_event())
+ self.check_handshake(client=client, server=server, alpn_protocol="hq-23")
- event = server.next_event()
- self.assertEqual(type(event), events.ProtocolNegotiated)
- self.assertEqual(event.alpn_protocol, "hq-23")
- event = server.next_event()
- self.assertEqual(type(event), events.HandshakeCompleted)
- self.assertEqual(event.alpn_protocol, "hq-23")
- for i in range(7):
- self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
- self.assertIsNone(server.next_event())
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect(self):
with client_and_server() as (client, server):
# check handshake completed
- event = client.next_event()
- self.assertEqual(type(event), events.ProtocolNegotiated)
- self.assertEqual(event.alpn_protocol, None)
- event = client.next_event()
- self.assertEqual(type(event), events.HandshakeCompleted)
- self.assertEqual(event.alpn_protocol, None)
- self.assertEqual(event.early_data_accepted, False)
- self.assertEqual(event.session_resumed, False)
- for i in range(7):
- self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
- self.assertIsNone(client.next_event())
-
- event = server.next_event()
- self.assertEqual(type(event), events.ProtocolNegotiated)
- self.assertEqual(event.alpn_protocol, None)
- event = server.next_event()
- self.assertEqual(type(event), events.HandshakeCompleted)
- self.assertEqual(event.alpn_protocol, None)
- self.assertEqual(event.early_data_accepted, False)
- self.assertEqual(event.session_resumed, False)
- for i in range(7):
- self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
- self.assertIsNone(server.next_event())
+ self.check_handshake(client=client, server=server)
# check each endpoint has available connection IDs for the peer
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
self.assertEqual(
sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]</s>
|
tests.test_connection/QuicConnectionTest.test_datagram_frame
|
Modified
|
aiortc~aioquic
|
55035e0dd5cf79fc3051e83f11b8546a2a09ba74
|
[datagram] respect congestion control
|
<1>:<add> client_options={"max_datagram_frame_size": 65536},
<del> client_options={"max_datagram_frame_size": 1200},
<2>:<add> server_options={"max_datagram_frame_size": 65536},
<del> server_options={"max_datagram_frame_size": 1200},
<5>:<del> event = client.next_event()
<6>:<del> self.assertEqual(type(event), events.ProtocolNegotiated)
<7>:<del> self.assertEqual(event.alpn_protocol, None)
<8>:<del> event = client.next_event()
<9>:<del> self.assertEqual(type(event), events.HandshakeCompleted)
<10>:<del> self.assertEqual(event.alpn_protocol, None)
<11>:<del> self.assertEqual(event.early_data_accepted, False)
<12>:<del> self.assertEqual(event.session_resumed, False)
<13>:<del> for i in range(7):
<14>:<del> self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
<15>:<del> self.assertIsNone(client.next_event())
<16>:<del>
<17>:<del> event = server.next_event()
<18>:<del> self.assertEqual(type(event), events.ProtocolNegotiated)
<19>:<del> self.assertEqual(event.alpn_protocol, None)
<20>:<del> event = server.next_event()
<21>:<del> self.assertEqual(type(event), events.HandshakeCompleted)
<22>:<del> self.assertEqual(event.alpn_protocol, None)
<23>:<del> for i in range(7):
<24>:<del> self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
<25>:<del> self.assertIsNone(server.next_event())
<26>:<add> self.check_handshake(client=client, server=server, alpn_protocol=None)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_datagram_frame(self):
<0> with client_and_server(
<1> client_options={"max_datagram_frame_size": 1200},
<2> server_options={"max_datagram_frame_size": 1200},
<3> ) as (client, server):
<4> # check handshake completed
<5> event = client.next_event()
<6> self.assertEqual(type(event), events.ProtocolNegotiated)
<7> self.assertEqual(event.alpn_protocol, None)
<8> event = client.next_event()
<9> self.assertEqual(type(event), events.HandshakeCompleted)
<10> self.assertEqual(event.alpn_protocol, None)
<11> self.assertEqual(event.early_data_accepted, False)
<12> self.assertEqual(event.session_resumed, False)
<13> for i in range(7):
<14> self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
<15> self.assertIsNone(client.next_event())
<16>
<17> event = server.next_event()
<18> self.assertEqual(type(event), events.ProtocolNegotiated)
<19> self.assertEqual(event.alpn_protocol, None)
<20> event = server.next_event()
<21> self.assertEqual(type(event), events.HandshakeCompleted)
<22> self.assertEqual(event.alpn_protocol, None)
<23> for i in range(7):
<24> self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
<25> self.assertIsNone(server.next_event())
<26>
<27> # send datagram
<28> client.send_datagram_frame(b"hello")
<29> self.assertEqual(transfer(client, server), 1)
<30>
<31> event = server.next_event()
<32> self.assertEqual(type(event), events.DatagramFrameReceived)
<33> self.assertEqual(event.data, b"hello")
<34>
|
===========unchanged ref 0===========
at: tests.test_connection
client_and_server(client_kwargs={}, client_options={}, client_patch=lambda x: None, handshake=True, server_kwargs={}, server_certfile=SERVER_CERTFILE, server_keyfile=SERVER_KEYFILE, server_options={}, server_patch=lambda x: None, transport_options={})
transfer(sender, receiver)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertIsNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_cert_chain(self):
with client_and_server(server_certfile=SERVER_CERTFILE_WITH_CHAIN) as (
client,
server,
):
+ # check handshake completed
+ self.check_handshake(client=client, server=server)
- pass
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_secrets_log(self):
client_log_file = io.StringIO()
server_log_file = io.StringIO()
with client_and_server(
client_options={"secrets_log_file": client_log_file},
server_options={"secrets_log_file": server_log_file},
) as (client, server):
+ # check handshake completed
+ self.check_handshake(client=client, server=server)
+
# check secrets were logged
client_log = client_log_file.getvalue()
server_log = server_log_file.getvalue()
self.assertEqual(client_log, server_log)
labels = []
for line in client_log.splitlines():
labels.append(line.split()[0])
self.assertEqual(
labels,
[
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
)
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def check_handshake(self, client, server, alpn_protocol=None):
+ """
+ Check handshake completed.
+ """
+ event = client.next_event()
+ self.assertEqual(type(event), events.ProtocolNegotiated)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ event = client.next_event()
+ self.assertEqual(type(event), events.HandshakeCompleted)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ self.assertEqual(event.early_data_accepted, False)
+ self.assertEqual(event.session_resumed, False)
+ for i in range(7):
+ self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
+ self.assertIsNone(client.next_event())
+
+ event = server.next_event()
+ self.assertEqual(type(event), events.ProtocolNegotiated)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ event = server.next_event()
+ self.assertEqual(type(event), events.HandshakeCompleted)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ for i in range(7):
+ self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
+ self.assertIsNone(server.next_event())
+
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_alpn(self):
with client_and_server(
client_options={"alpn_protocols": ["h3-23", "hq-23"]},
server_options={"alpn_protocols": ["hq-23"]},
) as (client, server):
# check handshake completed
- event = client.next_event()
- self.assertEqual(type(event), events.ProtocolNegotiated)
- self.assertEqual(event.alpn_protocol, "hq-23")
- event = client.next_event()
- self.assertEqual(type(event), events.HandshakeCompleted)
- self.assertEqual(event.alpn_protocol, "hq-23")
- for i in range(7):
- self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
- self.assertIsNone(client.next_event())
+ self.check_handshake(client=client, server=server, alpn_protocol="hq-23")
- event = server.next_event()
- self.assertEqual(type(event), events.ProtocolNegotiated)
- self.assertEqual(event.alpn_protocol, "hq-23")
- event = server.next_event()
- self.assertEqual(type(event), events.HandshakeCompleted)
- self.assertEqual(event.alpn_protocol, "hq-23")
- for i in range(7):
- self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
- self.assertIsNone(server.next_event())
-
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect(self):
with client_and_server() as (client, server):
# check handshake completed
- event = client.next_event()
- self.assertEqual(type(event), events.ProtocolNegotiated)
- self.assertEqual(event.alpn_protocol, None)
- event = client.next_event()
- self.assertEqual(type(event), events.HandshakeCompleted)
- self.assertEqual(event.alpn_protocol, None)
- self.assertEqual(event.early_data_accepted, False)
- self.assertEqual(event.session_resumed, False)
- for i in range(7):
- self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
- self.assertIsNone(client.next_event())
-
- event = server.next_event()
- self.assertEqual(type(event), events.ProtocolNegotiated)
- self.assertEqual(event.alpn_protocol, None)
- event = server.next_event()
- self.assertEqual(type(event), events.HandshakeCompleted)
- self.assertEqual(event.alpn_protocol, None)
- self.assertEqual(event.early_data_accepted, False)
- self.assertEqual(event.session_resumed, False)
- for i in range(7):
- self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
- self.assertIsNone(server.next_event())
+ self.check_handshake(client=client, server=server)
# check each endpoint has available connection IDs for the peer
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
self.assertEqual(
sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]</s>
|
aioquic.quic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
55035e0dd5cf79fc3051e83f11b8546a2a09ba74
|
[datagram] respect congestion control
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
<0> crypto_stream: Optional[QuicStream] = None
<1> if self._cryptos[tls.Epoch.ONE_RTT].send.is_valid():
<2> crypto = self._cryptos[tls.Epoch.ONE_RTT]
<3> crypto_stream = self._crypto_streams[tls.Epoch.ONE_RTT]
<4> packet_type = PACKET_TYPE_ONE_RTT
<5> elif self._cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
<6> crypto = self._cryptos[tls.Epoch.ZERO_RTT]
<7> packet_type = PACKET_TYPE_ZERO_RTT
<8> else:
<9> return
<10> space = self._spaces[tls.Epoch.ONE_RTT]
<11>
<12> while True:
<13> # write header
<14> builder.start_packet(packet_type, crypto)
<15>
<16> if self._handshake_complete:
<17> # ACK
<18> if space.ack_at is not None and space.ack_at <= now:
<19> self._write_ack_frame(builder=builder, space=space)
<20>
<21> # PATH CHALLENGE
<22> if (
<23> not network_path.is_validated
<24> and network_path.local_challenge is None
<25> ):
<26> self._logger.debug(
<27> "Network path %s sending challenge", network_path.addr
<28> )
<29> network_path.local_challenge = os.urandom(8)
<30> buf = builder.start_frame(QuicFrameType.PATH_CHALLENGE)
<31> buf.push_bytes(network_path.local_challenge)
<32>
<33> # log frame
<34> if self._quic_logger is not None:
<35> builder.quic_logger_frames.append(
<36> self._quic_logger.encode_path_challenge_frame(
</s>
|
===========below chunk 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
# offset: 1
)
)
# PATH RESPONSE
if network_path.remote_challenge is not None:
challenge = network_path.remote_challenge
buf = builder.start_frame(QuicFrameType.PATH_RESPONSE)
buf.push_bytes(challenge)
network_path.remote_challenge = None
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_path_response_frame(data=challenge)
)
# NEW_CONNECTION_ID
for connection_id in self._host_cids:
if not connection_id.was_sent:
self._write_new_connection_id_frame(
builder=builder, connection_id=connection_id
)
# RETIRE_CONNECTION_ID
while self._retire_connection_ids:
sequence_number = self._retire_connection_ids.pop(0)
self._write_retire_connection_id_frame(
builder=builder, sequence_number=sequence_number
)
# STREAMS_BLOCKED
if self._streams_blocked_pending:
if self._streams_blocked_bidi:
self._write_streams_blocked_frame(
builder=builder,
frame_type=QuicFrameType.STREAMS_BLOCKED_BIDI,
limit=self._remote_max_streams_bidi,
)
if self._streams_blocked_uni:
self._write_streams_blocked_frame(
builder=builder,
frame_type=QuicFrameType.STREAMS_BLOCKED_UNI,
limit=self._remote_max_streams_uni,
)
self._streams_blocked_pending = False
# connection-level limits
self._write_connection</s>
===========below chunk 1===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
# offset: 2
<s>,
)
self._streams_blocked_pending = False
# connection-level limits
self._write_connection_limits(builder=builder, space=space)
# stream-level limits
for stream in self._streams.values():
self._write_stream_limits(builder=builder, space=space, stream=stream)
# PING (user-request)
if self._ping_pending:
self._logger.info("Sending PING in packet %d", builder.packet_number)
self._write_ping_frame(builder, self._ping_pending)
self._ping_pending.clear()
# PING (probe)
if self._probe_pending:
self._logger.info(
"Sending PING (probe) in packet %d", builder.packet_number
)
self._write_ping_frame(builder)
self._probe_pending = False
# CRYPTO
if crypto_stream is not None and not crypto_stream.send_buffer_is_empty:
self._write_crypto_frame(
builder=builder, space=space, stream=crypto_stream
)
# DATAGRAM
while self._datagrams_pending:
self._write_datagram_frame(
builder=builder,
data=self._datagrams_pending.popleft(),
frame_type=QuicFrameType.DATAGRAM_WITH_LENGTH,
)
for stream in self._streams.values():
# STREAM
if not stream.is_blocked and not stream.send_buffer_is_empty:
self._remote_max_data_used += self._write_stream_frame(
builder=builder,
space</s>
===========below chunk 2===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
# offset: 3
<s>,
stream=stream,
max_offset=min(
stream._send_highest
+ self._remote_max_data
- self._remote_max_data_used,
stream.max_stream_data_remote,
),
)
if builder.packet_is_empty:
break
===========unchanged ref 0===========
at: aioquic.quic.connection
QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, is_validated: bool=False, local_challenge: Optional[bytes]=None, remote_challenge: Optional[bytes]=None)
at: aioquic.quic.connection.QuicConnection
_write_ack_frame(builder: QuicPacketBuilder, space: QuicPacketSpace)
_write_connection_limits(builder: QuicPacketBuilder, space: QuicPacketSpace) -> None
_write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
_write_datagram_frame(builder: QuicPacketBuilder, data: bytes, frame_type: QuicFrameType) -> bool
_write_datagram_frame(self, builder: QuicPacketBuilder, data: bytes, frame_type: QuicFrameType) -> bool
_write_new_connection_id_frame(builder: QuicPacketBuilder, connection_id: QuicConnectionId) -> None
_write_ping_frame(builder: QuicPacketBuilder, uids: List[int]=[])
_write_retire_connection_id_frame(builder: QuicPacketBuilder, sequence_number: int) -> None
_write_stream_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream, max_offset: int) -> int
_write_stream_limits(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
_write_streams_blocked_frame(builder: QuicPacketBuilder, frame_type: QuicFrameType, limit: int) -> None
at: aioquic.quic.connection.QuicConnection.__init__
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
self._handshake_complete = False
|
|
aioquic.quic.connection/QuicConnection._write_datagram_frame
|
Modified
|
aiortc~aioquic
|
55035e0dd5cf79fc3051e83f11b8546a2a09ba74
|
[datagram] respect congestion control
|
<0>:<add> """
<add> Write a DATAGRAM frame.
<add>
<add> Returns True if the frame was processed, False otherwise.
<add> """
<2>:<add> frame_size = 1 + size_uint_var(length) + length
<add>
<add> if frame_size > builder.remaining_space:
<add> # not enough space left, retry later
<add> return False
<add>
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_datagram_frame(
self, builder: QuicPacketBuilder, data: bytes, frame_type: QuicFrameType
+ ) -> bool:
- ) -> None:
<0> assert frame_type == QuicFrameType.DATAGRAM_WITH_LENGTH
<1> length = len(data)
<2> buf = builder.start_frame(frame_type)
<3> buf.push_uint_var(length)
<4> buf.push_bytes(data)
<5>
<6> # log frame
<7> if self._quic_logger is not None:
<8> builder.quic_logger_frames.append(
<9> self._quic_logger.encode_datagram_frame(length=length)
<10> )
<11>
|
===========unchanged ref 0===========
at: aioquic.quic.connection.QuicConnection.__init__
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
at: aioquic.quic.connection.QuicConnection._write_crypto_frame
frame = stream.get_frame(builder.remaining_space - frame_overhead)
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_cert_chain(self):
with client_and_server(server_certfile=SERVER_CERTFILE_WITH_CHAIN) as (
client,
server,
):
+ # check handshake completed
+ self.check_handshake(client=client, server=server)
- pass
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_secrets_log(self):
client_log_file = io.StringIO()
server_log_file = io.StringIO()
with client_and_server(
client_options={"secrets_log_file": client_log_file},
server_options={"secrets_log_file": server_log_file},
) as (client, server):
+ # check handshake completed
+ self.check_handshake(client=client, server=server)
+
# check secrets were logged
client_log = client_log_file.getvalue()
server_log = server_log_file.getvalue()
self.assertEqual(client_log, server_log)
labels = []
for line in client_log.splitlines():
labels.append(line.split()[0])
self.assertEqual(
labels,
[
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
)
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_datagram_frame_2(self):
+ # payload which exactly fills an entire packet
+ payload = b"Z" * 1250
+
+ with client_and_server(
+ client_options={"max_datagram_frame_size": 65536},
+ server_options={"max_datagram_frame_size": 65536},
+ ) as (client, server):
+ # check handshake completed
+ self.check_handshake(client=client, server=server, alpn_protocol=None)
+
+ # queue 20 datagrams
+ for i in range(20):
+ client.send_datagram_frame(payload)
+
+ # client can only 11 datagrams are sent due to congestion control
+ self.assertEqual(transfer(client, server), 11)
+ for i in range(11):
+ event = server.next_event()
+ self.assertEqual(type(event), events.DatagramFrameReceived)
+ self.assertEqual(event.data, payload)
+
+ # server sends ACK
+ self.assertEqual(transfer(server, client), 1)
+
+ # client sends remaining datagrams
+ self.assertEqual(transfer(client, server), 9)
+ for i in range(9):
+ event = server.next_event()
+ self.assertEqual(type(event), events.DatagramFrameReceived)
+ self.assertEqual(event.data, payload)
+
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def check_handshake(self, client, server, alpn_protocol=None):
+ """
+ Check handshake completed.
+ """
+ event = client.next_event()
+ self.assertEqual(type(event), events.ProtocolNegotiated)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ event = client.next_event()
+ self.assertEqual(type(event), events.HandshakeCompleted)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ self.assertEqual(event.early_data_accepted, False)
+ self.assertEqual(event.session_resumed, False)
+ for i in range(7):
+ self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
+ self.assertIsNone(client.next_event())
+
+ event = server.next_event()
+ self.assertEqual(type(event), events.ProtocolNegotiated)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ event = server.next_event()
+ self.assertEqual(type(event), events.HandshakeCompleted)
+ self.assertEqual(event.alpn_protocol, alpn_protocol)
+ for i in range(7):
+ self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
+ self.assertIsNone(server.next_event())
+
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_alpn(self):
with client_and_server(
client_options={"alpn_protocols": ["h3-23", "hq-23"]},
server_options={"alpn_protocols": ["hq-23"]},
) as (client, server):
# check handshake completed
- event = client.next_event()
- self.assertEqual(type(event), events.ProtocolNegotiated)
- self.assertEqual(event.alpn_protocol, "hq-23")
- event = client.next_event()
- self.assertEqual(type(event), events.HandshakeCompleted)
- self.assertEqual(event.alpn_protocol, "hq-23")
- for i in range(7):
- self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
- self.assertIsNone(client.next_event())
+ self.check_handshake(client=client, server=server, alpn_protocol="hq-23")
- event = server.next_event()
- self.assertEqual(type(event), events.ProtocolNegotiated)
- self.assertEqual(event.alpn_protocol, "hq-23")
- event = server.next_event()
- self.assertEqual(type(event), events.HandshakeCompleted)
- self.assertEqual(event.alpn_protocol, "hq-23")
- for i in range(7):
- self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
- self.assertIsNone(server.next_event())
-
|
examples.siduck_client/run
|
Modified
|
aiortc~aioquic
|
6e3c072484254b5a5b606858209a5ea292039ea6
|
[siduck] log sending quack and receiving quack-ack
|
<4>:<add> logger.info("sending quack")
<5>:<add> logger.info("received quack-ack")
|
# module: examples.siduck_client
def run(configuration: QuicConfiguration, host: str, port: int) -> None:
<0> async with connect(
<1> host, port, configuration=configuration, create_protocol=SiduckClient
<2> ) as client:
<3> client = cast(SiduckClient, client)
<4> await client.quack()
<5>
|
===========unchanged ref 0===========
at: examples.siduck_client
SiduckClient(*args, **kwargs)
|
tests.test_asyncio/HighLevelTest.run_server
|
Modified
|
aiortc~aioquic
|
dc5419aaae3d743e820666a556ff917c2d0164d9
|
[tests] ensure server is shutdown after each test
|
<3>:<add> self.server = await serve(
<del> return await serve(
<10>:<add> return self.server
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def run_server(self, configuration=None, **kwargs):
<0> if configuration is None:
<1> configuration = QuicConfiguration(is_client=False)
<2> configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
<3> return await serve(
<4> host="::",
<5> port="4433",
<6> configuration=configuration,
<7> stream_handler=handle_stream,
<8> **kwargs
<9> )
<10>
|
===========unchanged ref 0===========
at: tests.test_asyncio.HighLevelTest.run_client
reader, writer = await client.create_stream()
at: tests.utils
SERVER_CERTFILE = os.path.join(os.path.dirname(__file__), "ssl_cert.pem")
SERVER_KEYFILE = os.path.join(os.path.dirname(__file__), "ssl_key.pem")
===========changed ref 0===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def setUp(self):
+ self.server = None
+
===========changed ref 1===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def tearDown(self):
+ if self.server is not None:
+ self.server.close()
+
|
tests.test_asyncio/HighLevelTest.test_connect_and_serve
|
Modified
|
aiortc~aioquic
|
dc5419aaae3d743e820666a556ff917c2d0164d9
|
[tests] ensure server is shutdown after each test
|
<0>:<del> server, response = run(
<1>:<del> asyncio.gather(self.run_server(), self.run_client("127.0.0.1"))
<2>:<del> )
<3>:<add> run(self.run_server())
<add> response = run(self.run_client("127.0.0.1"))
<4>:<del> server.close()
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve(self):
<0> server, response = run(
<1> asyncio.gather(self.run_server(), self.run_client("127.0.0.1"))
<2> )
<3> self.assertEqual(response, b"gnip")
<4> server.close()
<5>
|
===========unchanged ref 0===========
at: tests.test_asyncio
handle_stream(reader, writer)
at: tests.test_asyncio.HighLevelTest.run_server
configuration = QuicConfiguration(is_client=False)
===========changed ref 0===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def setUp(self):
+ self.server = None
+
===========changed ref 1===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def tearDown(self):
+ if self.server is not None:
+ self.server.close()
+
===========changed ref 2===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def run_server(self, configuration=None, **kwargs):
if configuration is None:
configuration = QuicConfiguration(is_client=False)
configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
+ self.server = await serve(
- return await serve(
host="::",
port="4433",
configuration=configuration,
stream_handler=handle_stream,
**kwargs
)
+ return self.server
|
tests.test_asyncio/HighLevelTest.test_connect_and_serve_ec_certificate
|
Modified
|
aiortc~aioquic
|
dc5419aaae3d743e820666a556ff917c2d0164d9
|
[tests] ensure server is shutdown after each test
|
<2>:<del> server, response = run(
<3>:<del> asyncio.gather(
<4>:<add> run(
<add> self.run_server(
<del> self.run_server(
<5>:<add> configuration=QuicConfiguration(
<del> configuration=QuicConfiguration(
<6>:<del> certificate=certificate,
<7>:<del> private_key=private_key,
<8>:<del> is_client=False,
<9>:<del> )
<10>:<add> certificate=certificate, private_key=private_key, is_client=False,
<add> )
<del> ),
<11>:<add> )
<add> )
<add>
<add> response = run(
<add> self.run_client(
<del> self.run_client(
<12>:<add> "127.0.0.1",
<del> "127.0.0.1",
<13>:<add> cadata=certificate.public_bytes(serialization.Encoding.PEM),
<del> cadata=certificate.public_bytes(serialization.Encoding.PEM),
<14>:<add> cafile=None,
<del> cafile=None,
<15>:<del> ),
<20>:<del> server.close()
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_ec_certificate(self):
<0> certificate, private_key = generate_ec_certificate(common_name="localhost")
<1>
<2> server, response = run(
<3> asyncio.gather(
<4> self.run_server(
<5> configuration=QuicConfiguration(
<6> certificate=certificate,
<7> private_key=private_key,
<8> is_client=False,
<9> )
<10> ),
<11> self.run_client(
<12> "127.0.0.1",
<13> cadata=certificate.public_bytes(serialization.Encoding.PEM),
<14> cafile=None,
<15> ),
<16> )
<17> )
<18>
<19> self.assertEqual(response, b"gnip")
<20> server.close()
<21>
|
===========unchanged ref 0===========
at: tests.test_asyncio.HighLevelTest
run_client(host, port=4433, cadata=None, cafile=SERVER_CACERTFILE, configuration=None, request=b"ping", **kwargs)
run_server(self, configuration=None, **kwargs)
run_server(configuration=None, **kwargs)
at: tests.utils
generate_ec_certificate(common_name, curve=ec.SECP256R1, alternative_names=[])
run(coro)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def run_server(self, configuration=None, **kwargs):
if configuration is None:
configuration = QuicConfiguration(is_client=False)
configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
+ self.server = await serve(
- return await serve(
host="::",
port="4433",
configuration=configuration,
stream_handler=handle_stream,
**kwargs
)
+ return self.server
===========changed ref 1===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def setUp(self):
+ self.server = None
+
===========changed ref 2===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def tearDown(self):
+ if self.server is not None:
+ self.server.close()
+
===========changed ref 3===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
|
tests.test_asyncio/HighLevelTest.test_connect_and_serve_large
|
Modified
|
aiortc~aioquic
|
dc5419aaae3d743e820666a556ff917c2d0164d9
|
[tests] ensure server is shutdown after each test
|
<4>:<del> server, response = run(
<5>:<del> asyncio.gather(
<6>:<add> run(self.run_server())
<add> response = run(self.run_client("127.0.0.1", request=data))
<del> self.run_server(), self.run_client("127.0.0.1", request=data)
<7>:<del> )
<8>:<del> )
<10>:<del> server.close()
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_large(self):
<0> """
<1> Transfer enough data to require raising MAX_DATA and MAX_STREAM_DATA.
<2> """
<3> data = b"Z" * 2097152
<4> server, response = run(
<5> asyncio.gather(
<6> self.run_server(), self.run_client("127.0.0.1", request=data)
<7> )
<8> )
<9> self.assertEqual(response, data)
<10> server.close()
<11>
|
===========unchanged ref 0===========
at: tests.test_asyncio.HighLevelTest
run_client(host, port=4433, cadata=None, cafile=SERVER_CACERTFILE, configuration=None, request=b"ping", **kwargs)
run_server(self, configuration=None, **kwargs)
run_server(configuration=None, **kwargs)
at: tests.test_asyncio.HighLevelTest.test_connect_and_serve_ec_certificate
response = run(
self.run_client(
"127.0.0.1",
cadata=certificate.public_bytes(serialization.Encoding.PEM),
cafile=None,
)
)
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def run_server(self, configuration=None, **kwargs):
if configuration is None:
configuration = QuicConfiguration(is_client=False)
configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
+ self.server = await serve(
- return await serve(
host="::",
port="4433",
configuration=configuration,
stream_handler=handle_stream,
**kwargs
)
+ return self.server
===========changed ref 1===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def setUp(self):
+ self.server = None
+
===========changed ref 2===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def tearDown(self):
+ if self.server is not None:
+ self.server.close()
+
===========changed ref 3===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 4===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_ec_certificate(self):
certificate, private_key = generate_ec_certificate(common_name="localhost")
- server, response = run(
- asyncio.gather(
+ run(
+ self.run_server(
- self.run_server(
+ configuration=QuicConfiguration(
- configuration=QuicConfiguration(
- certificate=certificate,
- private_key=private_key,
- is_client=False,
- )
+ certificate=certificate, private_key=private_key, is_client=False,
+ )
- ),
+ )
+ )
+
+ response = run(
+ self.run_client(
- self.run_client(
+ "127.0.0.1",
- "127.0.0.1",
+ cadata=certificate.public_bytes(serialization.Encoding.PEM),
- cadata=certificate.public_bytes(serialization.Encoding.PEM),
+ cafile=None,
- cafile=None,
- ),
)
)
self.assertEqual(response, b"gnip")
- server.close()
|
tests.test_asyncio/HighLevelTest.test_connect_and_serve_without_client_configuration
|
Modified
|
aiortc~aioquic
|
dc5419aaae3d743e820666a556ff917c2d0164d9
|
[tests] ensure server is shutdown after each test
|
<4>:<add> run(self.run_server())
<del> server = run(self.run_server())
<7>:<del> server.close()
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_without_client_configuration(self):
<0> async def run_client_without_config(host, port=4433):
<1> async with connect(host, port) as client:
<2> await client.ping()
<3>
<4> server = run(self.run_server())
<5> with self.assertRaises(ConnectionError):
<6> run(run_client_without_config("127.0.0.1"))
<7> server.close()
<8>
|
===========unchanged ref 0===========
at: tests.test_asyncio.HighLevelTest
run_server(self, configuration=None, **kwargs)
run_server(configuration=None, **kwargs)
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]
assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None
===========changed ref 0===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def run_server(self, configuration=None, **kwargs):
if configuration is None:
configuration = QuicConfiguration(is_client=False)
configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
+ self.server = await serve(
- return await serve(
host="::",
port="4433",
configuration=configuration,
stream_handler=handle_stream,
**kwargs
)
+ return self.server
===========changed ref 1===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def setUp(self):
+ self.server = None
+
===========changed ref 2===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def tearDown(self):
+ if self.server is not None:
+ self.server.close()
+
===========changed ref 3===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 4===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_large(self):
"""
Transfer enough data to require raising MAX_DATA and MAX_STREAM_DATA.
"""
data = b"Z" * 2097152
- server, response = run(
- asyncio.gather(
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1", request=data))
- self.run_server(), self.run_client("127.0.0.1", request=data)
- )
- )
self.assertEqual(response, data)
- server.close()
===========changed ref 5===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_ec_certificate(self):
certificate, private_key = generate_ec_certificate(common_name="localhost")
- server, response = run(
- asyncio.gather(
+ run(
+ self.run_server(
- self.run_server(
+ configuration=QuicConfiguration(
- configuration=QuicConfiguration(
- certificate=certificate,
- private_key=private_key,
- is_client=False,
- )
+ certificate=certificate, private_key=private_key, is_client=False,
+ )
- ),
+ )
+ )
+
+ response = run(
+ self.run_client(
- self.run_client(
+ "127.0.0.1",
- "127.0.0.1",
+ cadata=certificate.public_bytes(serialization.Encoding.PEM),
- cadata=certificate.public_bytes(serialization.Encoding.PEM),
+ cafile=None,
- cafile=None,
- ),
)
)
self.assertEqual(response, b"gnip")
- server.close()
|
tests.test_asyncio/HighLevelTest.test_connect_and_serve_writelines
|
Modified
|
aiortc~aioquic
|
dc5419aaae3d743e820666a556ff917c2d0164d9
|
[tests] ensure server is shutdown after each test
|
<12>:<del> server, response = run(
<13>:<del> asyncio.gather(self.run_server(), run_client_writelines("127.0.0.1"))
<14>:<del> )
<15>:<add> run(self.run_server())
<add> response = run(run_client_writelines("127.0.0.1"))
<16>:<del> server.close()
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_writelines(self):
<0> async def run_client_writelines(host, port=4433):
<1> configuration = QuicConfiguration(is_client=True)
<2> configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
<3> async with connect(host, port, configuration=configuration) as client:
<4> reader, writer = await client.create_stream()
<5> assert writer.can_write_eof() is True
<6>
<7> writer.writelines([b"01234567", b"89012345"])
<8> writer.write_eof()
<9>
<10> return await reader.read()
<11>
<12> server, response = run(
<13> asyncio.gather(self.run_server(), run_client_writelines("127.0.0.1"))
<14> )
<15> self.assertEqual(response, b"5432109876543210")
<16> server.close()
<17>
|
===========unchanged ref 0===========
at: tests.test_asyncio
sendto_with_loss(self, data, addr=None)
at: tests.test_asyncio.HighLevelTest
run_server(self, configuration=None, **kwargs)
run_server(configuration=None, **kwargs)
at: tests.utils
run(coro)
SERVER_CACERTFILE = os.path.join(os.path.dirname(__file__), "pycacert.pem")
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
at: unittest.mock
_patcher(target: Any, new: _T, spec: Optional[Any]=..., create: bool=..., spec_set: Optional[Any]=..., autospec: Optional[Any]=..., new_callable: Optional[Any]=..., **kwargs: Any) -> _patch[_T]
_patcher(target: Any, *, spec: Optional[Any]=..., create: bool=..., spec_set: Optional[Any]=..., autospec: Optional[Any]=..., new_callable: Optional[Any]=..., **kwargs: Any) -> _patch[Union[MagicMock, AsyncMock]]
===========changed ref 0===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def run_server(self, configuration=None, **kwargs):
if configuration is None:
configuration = QuicConfiguration(is_client=False)
configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
+ self.server = await serve(
- return await serve(
host="::",
port="4433",
configuration=configuration,
stream_handler=handle_stream,
**kwargs
)
+ return self.server
===========changed ref 1===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def setUp(self):
+ self.server = None
+
===========changed ref 2===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_without_client_configuration(self):
async def run_client_without_config(host, port=4433):
async with connect(host, port) as client:
await client.ping()
+ run(self.run_server())
- server = run(self.run_server())
with self.assertRaises(ConnectionError):
run(run_client_without_config("127.0.0.1"))
- server.close()
===========changed ref 3===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def tearDown(self):
+ if self.server is not None:
+ self.server.close()
+
===========changed ref 4===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 5===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_large(self):
"""
Transfer enough data to require raising MAX_DATA and MAX_STREAM_DATA.
"""
data = b"Z" * 2097152
- server, response = run(
- asyncio.gather(
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1", request=data))
- self.run_server(), self.run_client("127.0.0.1", request=data)
- )
- )
self.assertEqual(response, data)
- server.close()
===========changed ref 6===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_ec_certificate(self):
certificate, private_key = generate_ec_certificate(common_name="localhost")
- server, response = run(
- asyncio.gather(
+ run(
+ self.run_server(
- self.run_server(
+ configuration=QuicConfiguration(
- configuration=QuicConfiguration(
- certificate=certificate,
- private_key=private_key,
- is_client=False,
- )
+ certificate=certificate, private_key=private_key, is_client=False,
+ )
- ),
+ )
+ )
+
+ response = run(
+ self.run_client(
- self.run_client(
+ "127.0.0.1",
- "127.0.0.1",
+ cadata=certificate.public_bytes(serialization.Encoding.PEM),
- cadata=certificate.public_bytes(serialization.Encoding.PEM),
+ cafile=None,
- cafile=None,
- ),
)
)
self.assertEqual(response, b"gnip")
- server.close()
|
tests.test_asyncio/HighLevelTest.test_connect_and_serve_with_packet_loss
|
Modified
|
aiortc~aioquic
|
dc5419aaae3d743e820666a556ff917c2d0164d9
|
[tests] ensure server is shutdown after each test
|
<10>:<add> run(self.run_server(configuration=server_configuration, stateless_retry=True))
<11>:<add> response = run(
<del> server, response = run(
<12>:<del> asyncio.gather(
<13>:<add> self.run_client(
<del> self.run_server(
<14>:<add> "127.0.0.1",
<add> configuration=QuicConfiguration(
<add> is_client=True, idle_timeout=300.0, quic_logger=QuicLogger()
<del> configuration=server_configuration, stateless_retry=True
<16>:<del> self.run_client(
<17>:<del> "127.0.0.1",
<18>:<del> configuration=QuicConfiguration(
<19>:<del> is_client=True, idle_timeout=300.0, quic_logger=QuicLogger()
<20>:<del> ),
<21>:<add> request=data,
<del> request=data,
<22>:<del> ),
<26>:<del> server.close()
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
@patch("socket.socket.sendto", new_callable=lambda: sendto_with_loss)
def test_connect_and_serve_with_packet_loss(self, mock_sendto):
<0> """
<1> This test ensures handshake success and stream data is successfully sent
<2> and received in the presence of packet loss (randomized 25% in each direction).
<3> """
<4> data = b"Z" * 65536
<5>
<6> server_configuration = QuicConfiguration(
<7> idle_timeout=300.0, is_client=False, quic_logger=QuicLogger()
<8> )
<9> server_configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
<10>
<11> server, response = run(
<12> asyncio.gather(
<13> self.run_server(
<14> configuration=server_configuration, stateless_retry=True
<15> ),
<16> self.run_client(
<17> "127.0.0.1",
<18> configuration=QuicConfiguration(
<19> is_client=True, idle_timeout=300.0, quic_logger=QuicLogger()
<20> ),
<21> request=data,
<22> ),
<23> )
<24> )
<25> self.assertEqual(response, data)
<26> server.close()
<27>
|
===========unchanged ref 0===========
at: tests.test_asyncio
SessionTicketStore()
at: tests.test_asyncio.HighLevelTest
run_client(host, port=4433, cadata=None, cafile=SERVER_CACERTFILE, configuration=None, request=b"ping", **kwargs)
run_server(self, configuration=None, **kwargs)
run_server(configuration=None, **kwargs)
at: tests.utils
run(coro)
SERVER_CERTFILE = os.path.join(os.path.dirname(__file__), "ssl_cert.pem")
SERVER_KEYFILE = os.path.join(os.path.dirname(__file__), "ssl_key.pem")
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def run_server(self, configuration=None, **kwargs):
if configuration is None:
configuration = QuicConfiguration(is_client=False)
configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
+ self.server = await serve(
- return await serve(
host="::",
port="4433",
configuration=configuration,
stream_handler=handle_stream,
**kwargs
)
+ return self.server
===========changed ref 1===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def setUp(self):
+ self.server = None
+
===========changed ref 2===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_without_client_configuration(self):
async def run_client_without_config(host, port=4433):
async with connect(host, port) as client:
await client.ping()
+ run(self.run_server())
- server = run(self.run_server())
with self.assertRaises(ConnectionError):
run(run_client_without_config("127.0.0.1"))
- server.close()
===========changed ref 3===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def tearDown(self):
+ if self.server is not None:
+ self.server.close()
+
===========changed ref 4===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 5===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_large(self):
"""
Transfer enough data to require raising MAX_DATA and MAX_STREAM_DATA.
"""
data = b"Z" * 2097152
- server, response = run(
- asyncio.gather(
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1", request=data))
- self.run_server(), self.run_client("127.0.0.1", request=data)
- )
- )
self.assertEqual(response, data)
- server.close()
===========changed ref 6===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_writelines(self):
async def run_client_writelines(host, port=4433):
configuration = QuicConfiguration(is_client=True)
configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
async with connect(host, port, configuration=configuration) as client:
reader, writer = await client.create_stream()
assert writer.can_write_eof() is True
writer.writelines([b"01234567", b"89012345"])
writer.write_eof()
return await reader.read()
- server, response = run(
- asyncio.gather(self.run_server(), run_client_writelines("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(run_client_writelines("127.0.0.1"))
self.assertEqual(response, b"5432109876543210")
- server.close()
===========changed ref 7===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_ec_certificate(self):
certificate, private_key = generate_ec_certificate(common_name="localhost")
- server, response = run(
- asyncio.gather(
+ run(
+ self.run_server(
- self.run_server(
+ configuration=QuicConfiguration(
- configuration=QuicConfiguration(
- certificate=certificate,
- private_key=private_key,
- is_client=False,
- )
+ certificate=certificate, private_key=private_key, is_client=False,
+ )
- ),
+ )
+ )
+
+ response = run(
+ self.run_client(
- self.run_client(
+ "127.0.0.1",
- "127.0.0.1",
+ cadata=certificate.public_bytes(serialization.Encoding.PEM),
- cadata=certificate.public_bytes(serialization.Encoding.PEM),
+ cafile=None,
- cafile=None,
- ),
)
)
self.assertEqual(response, b"gnip")
- server.close()
|
tests.test_asyncio/HighLevelTest.test_connect_and_serve_with_session_ticket
|
Modified
|
aiortc~aioquic
|
dc5419aaae3d743e820666a556ff917c2d0164d9
|
[tests] ensure server is shutdown after each test
|
<0>:<add> # start server
<7>:<del> # first request
<8>:<del> server, response = run(
<9>:<del> asyncio.gather(
<10>:<del> self.run_server(session_ticket_handler=store.add),
<11>:<del> self.run_client("127.0.0.1", session_ticket_handler=save_ticket),
<12>:<add> run(
<add> self.run_server(
<add> session_ticket_fetcher=store.pop, session_ticket_handler=store.add
<14>:<add>
<add> # first request
<add> response = run(
<add> self.run_client("127.0.0.1", session_ticket_handler=save_ticket),
<add> )
<15>:<del> server.close()
<20>:<del> server, response = run(
<21>:<del> asyncio.gather(
<22>:<del> self.run_server(session_ticket_fetcher=store.pop),
<23>:<add> run(
<add> self.run_client(
<del> self.run_client(
<24>:<add> "127.0.0.1",
<del> "127.0.0.1",
<25>:<add> configuration=QuicConfiguration(
<del> configuration=QuicConfiguration(
<26>:<add> is_client=True, session_ticket=client_ticket
<del> is_client=True, session_ticket=client_ticket
<27>:<del> ),
<32>:<del> server.close()
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_session_ticket(self):
<0> client_ticket = None
<1> store = SessionTicketStore()
<2>
<3> def save_ticket(t):
<4> nonlocal client_ticket
<5> client_ticket = t
<6>
<7> # first request
<8> server, response = run(
<9> asyncio.gather(
<10> self.run_server(session_ticket_handler=store.add),
<11> self.run_client("127.0.0.1", session_ticket_handler=save_ticket),
<12> )
<13> )
<14> self.assertEqual(response, b"gnip")
<15> server.close()
<16>
<17> self.assertIsNotNone(client_ticket)
<18>
<19> # second request
<20> server, response = run(
<21> asyncio.gather(
<22> self.run_server(session_ticket_fetcher=store.pop),
<23> self.run_client(
<24> "127.0.0.1",
<25> configuration=QuicConfiguration(
<26> is_client=True, session_ticket=client_ticket
<27> ),
<28> ),
<29> )
<30> )
<31> self.assertEqual(response, b"gnip")
<32> server.close()
<33>
|
===========unchanged ref 0===========
at: tests.test_asyncio.HighLevelTest
run_client(host, port=4433, cadata=None, cafile=SERVER_CACERTFILE, configuration=None, request=b"ping", **kwargs)
run_server(self, configuration=None, **kwargs)
run_server(configuration=None, **kwargs)
at: tests.test_asyncio.HighLevelTest.test_connect_and_serve_with_session_ticket
client_ticket = None
store = SessionTicketStore()
save_ticket(t)
at: tests.test_asyncio.SessionTicketStore
add(ticket)
pop(label)
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertIsNotNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def run_server(self, configuration=None, **kwargs):
if configuration is None:
configuration = QuicConfiguration(is_client=False)
configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
+ self.server = await serve(
- return await serve(
host="::",
port="4433",
configuration=configuration,
stream_handler=handle_stream,
**kwargs
)
+ return self.server
===========changed ref 1===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def setUp(self):
+ self.server = None
+
===========changed ref 2===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_without_client_configuration(self):
async def run_client_without_config(host, port=4433):
async with connect(host, port) as client:
await client.ping()
+ run(self.run_server())
- server = run(self.run_server())
with self.assertRaises(ConnectionError):
run(run_client_without_config("127.0.0.1"))
- server.close()
===========changed ref 3===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def tearDown(self):
+ if self.server is not None:
+ self.server.close()
+
===========changed ref 4===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 5===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_large(self):
"""
Transfer enough data to require raising MAX_DATA and MAX_STREAM_DATA.
"""
data = b"Z" * 2097152
- server, response = run(
- asyncio.gather(
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1", request=data))
- self.run_server(), self.run_client("127.0.0.1", request=data)
- )
- )
self.assertEqual(response, data)
- server.close()
===========changed ref 6===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_writelines(self):
async def run_client_writelines(host, port=4433):
configuration = QuicConfiguration(is_client=True)
configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
async with connect(host, port, configuration=configuration) as client:
reader, writer = await client.create_stream()
assert writer.can_write_eof() is True
writer.writelines([b"01234567", b"89012345"])
writer.write_eof()
return await reader.read()
- server, response = run(
- asyncio.gather(self.run_server(), run_client_writelines("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(run_client_writelines("127.0.0.1"))
self.assertEqual(response, b"5432109876543210")
- server.close()
===========changed ref 7===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
@patch("socket.socket.sendto", new_callable=lambda: sendto_with_loss)
def test_connect_and_serve_with_packet_loss(self, mock_sendto):
"""
This test ensures handshake success and stream data is successfully sent
and received in the presence of packet loss (randomized 25% in each direction).
"""
data = b"Z" * 65536
server_configuration = QuicConfiguration(
idle_timeout=300.0, is_client=False, quic_logger=QuicLogger()
)
server_configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
+ run(self.run_server(configuration=server_configuration, stateless_retry=True))
+ response = run(
- server, response = run(
- asyncio.gather(
+ self.run_client(
- self.run_server(
+ "127.0.0.1",
+ configuration=QuicConfiguration(
+ is_client=True, idle_timeout=300.0, quic_logger=QuicLogger()
- configuration=server_configuration, stateless_retry=True
),
- self.run_client(
- "127.0.0.1",
- configuration=QuicConfiguration(
- is_client=True, idle_timeout=300.0, quic_logger=QuicLogger()
- ),
+ request=data,
- request=data,
- ),
)
)
self.assertEqual(response, data)
- server.close()
===========changed ref 8===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_ec_certificate(self):
certificate, private_key = generate_ec_certificate(common_name="localhost")
- server, response = run(
- asyncio.gather(
+ run(
+ self.run_server(
- self.run_server(
+ configuration=QuicConfiguration(
- configuration=QuicConfiguration(
- certificate=certificate,
- private_key=private_key,
- is_client=False,
- )
+ certificate=certificate, private_key=private_key, is_client=False,
+ )
- ),
+ )
+ )
+
+ response = run(
+ self.run_client(
- self.run_client(
+ "127.0.0.1",
- "127.0.0.1",
+ cadata=certificate.public_bytes(serialization.Encoding.PEM),
- cadata=certificate.public_bytes(serialization.Encoding.PEM),
+ cafile=None,
- cafile=None,
- ),
)
)
self.assertEqual(response, b"gnip")
- server.close()
|
tests.test_asyncio/HighLevelTest.test_connect_and_serve_with_sni
|
Modified
|
aiortc~aioquic
|
dc5419aaae3d743e820666a556ff917c2d0164d9
|
[tests] ensure server is shutdown after each test
|
<0>:<del> server, response = run(
<1>:<del> asyncio.gather(self.run_server(), self.run_client("localhost"))
<2>:<del> )
<3>:<add> run(self.run_server())
<add> response = run(self.run_client("localhost"))
<4>:<del> server.close()
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_sni(self):
<0> server, response = run(
<1> asyncio.gather(self.run_server(), self.run_client("localhost"))
<2> )
<3> self.assertEqual(response, b"gnip")
<4> server.close()
<5>
|
===========changed ref 0===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def setUp(self):
+ self.server = None
+
===========changed ref 1===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_without_client_configuration(self):
async def run_client_without_config(host, port=4433):
async with connect(host, port) as client:
await client.ping()
+ run(self.run_server())
- server = run(self.run_server())
with self.assertRaises(ConnectionError):
run(run_client_without_config("127.0.0.1"))
- server.close()
===========changed ref 2===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def tearDown(self):
+ if self.server is not None:
+ self.server.close()
+
===========changed ref 3===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 4===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_large(self):
"""
Transfer enough data to require raising MAX_DATA and MAX_STREAM_DATA.
"""
data = b"Z" * 2097152
- server, response = run(
- asyncio.gather(
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1", request=data))
- self.run_server(), self.run_client("127.0.0.1", request=data)
- )
- )
self.assertEqual(response, data)
- server.close()
===========changed ref 5===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def run_server(self, configuration=None, **kwargs):
if configuration is None:
configuration = QuicConfiguration(is_client=False)
configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
+ self.server = await serve(
- return await serve(
host="::",
port="4433",
configuration=configuration,
stream_handler=handle_stream,
**kwargs
)
+ return self.server
===========changed ref 6===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_writelines(self):
async def run_client_writelines(host, port=4433):
configuration = QuicConfiguration(is_client=True)
configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
async with connect(host, port, configuration=configuration) as client:
reader, writer = await client.create_stream()
assert writer.can_write_eof() is True
writer.writelines([b"01234567", b"89012345"])
writer.write_eof()
return await reader.read()
- server, response = run(
- asyncio.gather(self.run_server(), run_client_writelines("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(run_client_writelines("127.0.0.1"))
self.assertEqual(response, b"5432109876543210")
- server.close()
===========changed ref 7===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
@patch("socket.socket.sendto", new_callable=lambda: sendto_with_loss)
def test_connect_and_serve_with_packet_loss(self, mock_sendto):
"""
This test ensures handshake success and stream data is successfully sent
and received in the presence of packet loss (randomized 25% in each direction).
"""
data = b"Z" * 65536
server_configuration = QuicConfiguration(
idle_timeout=300.0, is_client=False, quic_logger=QuicLogger()
)
server_configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
+ run(self.run_server(configuration=server_configuration, stateless_retry=True))
+ response = run(
- server, response = run(
- asyncio.gather(
+ self.run_client(
- self.run_server(
+ "127.0.0.1",
+ configuration=QuicConfiguration(
+ is_client=True, idle_timeout=300.0, quic_logger=QuicLogger()
- configuration=server_configuration, stateless_retry=True
),
- self.run_client(
- "127.0.0.1",
- configuration=QuicConfiguration(
- is_client=True, idle_timeout=300.0, quic_logger=QuicLogger()
- ),
+ request=data,
- request=data,
- ),
)
)
self.assertEqual(response, data)
- server.close()
===========changed ref 8===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_ec_certificate(self):
certificate, private_key = generate_ec_certificate(common_name="localhost")
- server, response = run(
- asyncio.gather(
+ run(
+ self.run_server(
- self.run_server(
+ configuration=QuicConfiguration(
- configuration=QuicConfiguration(
- certificate=certificate,
- private_key=private_key,
- is_client=False,
- )
+ certificate=certificate, private_key=private_key, is_client=False,
+ )
- ),
+ )
+ )
+
+ response = run(
+ self.run_client(
- self.run_client(
+ "127.0.0.1",
- "127.0.0.1",
+ cadata=certificate.public_bytes(serialization.Encoding.PEM),
- cadata=certificate.public_bytes(serialization.Encoding.PEM),
+ cafile=None,
- cafile=None,
- ),
)
)
self.assertEqual(response, b"gnip")
- server.close()
|
tests.test_asyncio/HighLevelTest.test_connect_and_serve_with_stateless_retry
|
Modified
|
aiortc~aioquic
|
dc5419aaae3d743e820666a556ff917c2d0164d9
|
[tests] ensure server is shutdown after each test
|
<0>:<del> server, response = run(
<1>:<del> asyncio.gather(
<2>:<del> self.run_server(stateless_retry=True), self.run_client("127.0.0.1")
<3>:<del> )
<4>:<del> )
<5>:<add> run(self.run_server())
<add> response = run(self.run_client("127.0.0.1"))
<6>:<del> server.close()
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_stateless_retry(self):
<0> server, response = run(
<1> asyncio.gather(
<2> self.run_server(stateless_retry=True), self.run_client("127.0.0.1")
<3> )
<4> )
<5> self.assertEqual(response, b"gnip")
<6> server.close()
<7>
|
===========unchanged ref 0===========
at: tests.test_asyncio.HighLevelTest
run_client(host, port=4433, cadata=None, cafile=SERVER_CACERTFILE, configuration=None, request=b"ping", **kwargs)
run_server(self, configuration=None, **kwargs)
run_server(configuration=None, **kwargs)
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]
assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None
===========changed ref 0===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def run_server(self, configuration=None, **kwargs):
if configuration is None:
configuration = QuicConfiguration(is_client=False)
configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
+ self.server = await serve(
- return await serve(
host="::",
port="4433",
configuration=configuration,
stream_handler=handle_stream,
**kwargs
)
+ return self.server
===========changed ref 1===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_sni(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("localhost"))
- )
+ run(self.run_server())
+ response = run(self.run_client("localhost"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 2===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def setUp(self):
+ self.server = None
+
===========changed ref 3===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_without_client_configuration(self):
async def run_client_without_config(host, port=4433):
async with connect(host, port) as client:
await client.ping()
+ run(self.run_server())
- server = run(self.run_server())
with self.assertRaises(ConnectionError):
run(run_client_without_config("127.0.0.1"))
- server.close()
===========changed ref 4===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def tearDown(self):
+ if self.server is not None:
+ self.server.close()
+
===========changed ref 5===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 6===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_large(self):
"""
Transfer enough data to require raising MAX_DATA and MAX_STREAM_DATA.
"""
data = b"Z" * 2097152
- server, response = run(
- asyncio.gather(
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1", request=data))
- self.run_server(), self.run_client("127.0.0.1", request=data)
- )
- )
self.assertEqual(response, data)
- server.close()
===========changed ref 7===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_writelines(self):
async def run_client_writelines(host, port=4433):
configuration = QuicConfiguration(is_client=True)
configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
async with connect(host, port, configuration=configuration) as client:
reader, writer = await client.create_stream()
assert writer.can_write_eof() is True
writer.writelines([b"01234567", b"89012345"])
writer.write_eof()
return await reader.read()
- server, response = run(
- asyncio.gather(self.run_server(), run_client_writelines("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(run_client_writelines("127.0.0.1"))
self.assertEqual(response, b"5432109876543210")
- server.close()
===========changed ref 8===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
@patch("socket.socket.sendto", new_callable=lambda: sendto_with_loss)
def test_connect_and_serve_with_packet_loss(self, mock_sendto):
"""
This test ensures handshake success and stream data is successfully sent
and received in the presence of packet loss (randomized 25% in each direction).
"""
data = b"Z" * 65536
server_configuration = QuicConfiguration(
idle_timeout=300.0, is_client=False, quic_logger=QuicLogger()
)
server_configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
+ run(self.run_server(configuration=server_configuration, stateless_retry=True))
+ response = run(
- server, response = run(
- asyncio.gather(
+ self.run_client(
- self.run_server(
+ "127.0.0.1",
+ configuration=QuicConfiguration(
+ is_client=True, idle_timeout=300.0, quic_logger=QuicLogger()
- configuration=server_configuration, stateless_retry=True
),
- self.run_client(
- "127.0.0.1",
- configuration=QuicConfiguration(
- is_client=True, idle_timeout=300.0, quic_logger=QuicLogger()
- ),
+ request=data,
- request=data,
- ),
)
)
self.assertEqual(response, data)
- server.close()
===========changed ref 9===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_ec_certificate(self):
certificate, private_key = generate_ec_certificate(common_name="localhost")
- server, response = run(
- asyncio.gather(
+ run(
+ self.run_server(
- self.run_server(
+ configuration=QuicConfiguration(
- configuration=QuicConfiguration(
- certificate=certificate,
- private_key=private_key,
- is_client=False,
- )
+ certificate=certificate, private_key=private_key, is_client=False,
+ )
- ),
+ )
+ )
+
+ response = run(
+ self.run_client(
- self.run_client(
+ "127.0.0.1",
- "127.0.0.1",
+ cadata=certificate.public_bytes(serialization.Encoding.PEM),
- cadata=certificate.public_bytes(serialization.Encoding.PEM),
+ cafile=None,
- cafile=None,
- ),
)
)
self.assertEqual(response, b"gnip")
- server.close()
|
tests.test_asyncio/HighLevelTest.test_connect_and_serve_with_stateless_retry_bad_original_connection_id
|
Modified
|
aiortc~aioquic
|
dc5419aaae3d743e820666a556ff917c2d0164d9
|
[tests] ensure server is shutdown after each test
|
<10>:<del> server = run(
<11>:<add> run(self.run_server(create_protocol=create_protocol, stateless_retry=True))
<del> self.run_server(create_protocol=create_protocol, stateless_retry=True)
<12>:<del> )
<15>:<del> server.close()
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_stateless_retry_bad_original_connection_id(self):
<0> """
<1> If the server's transport parameters do not have the correct
<2> original_connection_id the connection fail.
<3> """
<4>
<5> def create_protocol(*args, **kwargs):
<6> protocol = QuicConnectionProtocol(*args, **kwargs)
<7> protocol._quic._original_connection_id = None
<8> return protocol
<9>
<10> server = run(
<11> self.run_server(create_protocol=create_protocol, stateless_retry=True)
<12> )
<13> with self.assertRaises(ConnectionError):
<14> run(self.run_client("127.0.0.1"))
<15> server.close()
<16>
|
===========unchanged ref 0===========
at: tests.test_asyncio.HighLevelTest
run_client(host, port=4433, cadata=None, cafile=SERVER_CACERTFILE, configuration=None, request=b"ping", **kwargs)
run_server(self, configuration=None, **kwargs)
run_server(configuration=None, **kwargs)
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]
assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None
at: unittest.mock
_patcher(target: Any, new: _T, spec: Optional[Any]=..., create: bool=..., spec_set: Optional[Any]=..., autospec: Optional[Any]=..., new_callable: Optional[Any]=..., **kwargs: Any) -> _patch[_T]
_patcher(target: Any, *, spec: Optional[Any]=..., create: bool=..., spec_set: Optional[Any]=..., autospec: Optional[Any]=..., new_callable: Optional[Any]=..., **kwargs: Any) -> _patch[Union[MagicMock, AsyncMock]]
===========changed ref 0===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def run_server(self, configuration=None, **kwargs):
if configuration is None:
configuration = QuicConfiguration(is_client=False)
configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
+ self.server = await serve(
- return await serve(
host="::",
port="4433",
configuration=configuration,
stream_handler=handle_stream,
**kwargs
)
+ return self.server
===========changed ref 1===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_sni(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("localhost"))
- )
+ run(self.run_server())
+ response = run(self.run_client("localhost"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 2===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_stateless_retry(self):
- server, response = run(
- asyncio.gather(
- self.run_server(stateless_retry=True), self.run_client("127.0.0.1")
- )
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 3===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def setUp(self):
+ self.server = None
+
===========changed ref 4===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_without_client_configuration(self):
async def run_client_without_config(host, port=4433):
async with connect(host, port) as client:
await client.ping()
+ run(self.run_server())
- server = run(self.run_server())
with self.assertRaises(ConnectionError):
run(run_client_without_config("127.0.0.1"))
- server.close()
===========changed ref 5===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def tearDown(self):
+ if self.server is not None:
+ self.server.close()
+
===========changed ref 6===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 7===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_large(self):
"""
Transfer enough data to require raising MAX_DATA and MAX_STREAM_DATA.
"""
data = b"Z" * 2097152
- server, response = run(
- asyncio.gather(
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1", request=data))
- self.run_server(), self.run_client("127.0.0.1", request=data)
- )
- )
self.assertEqual(response, data)
- server.close()
===========changed ref 8===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_writelines(self):
async def run_client_writelines(host, port=4433):
configuration = QuicConfiguration(is_client=True)
configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
async with connect(host, port, configuration=configuration) as client:
reader, writer = await client.create_stream()
assert writer.can_write_eof() is True
writer.writelines([b"01234567", b"89012345"])
writer.write_eof()
return await reader.read()
- server, response = run(
- asyncio.gather(self.run_server(), run_client_writelines("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(run_client_writelines("127.0.0.1"))
self.assertEqual(response, b"5432109876543210")
- server.close()
===========changed ref 9===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
@patch("socket.socket.sendto", new_callable=lambda: sendto_with_loss)
def test_connect_and_serve_with_packet_loss(self, mock_sendto):
"""
This test ensures handshake success and stream data is successfully sent
and received in the presence of packet loss (randomized 25% in each direction).
"""
data = b"Z" * 65536
server_configuration = QuicConfiguration(
idle_timeout=300.0, is_client=False, quic_logger=QuicLogger()
)
server_configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
+ run(self.run_server(configuration=server_configuration, stateless_retry=True))
+ response = run(
- server, response = run(
- asyncio.gather(
+ self.run_client(
- self.run_server(
+ "127.0.0.1",
+ configuration=QuicConfiguration(
+ is_client=True, idle_timeout=300.0, quic_logger=QuicLogger()
- configuration=server_configuration, stateless_retry=True
),
- self.run_client(
- "127.0.0.1",
- configuration=QuicConfiguration(
- is_client=True, idle_timeout=300.0, quic_logger=QuicLogger()
- ),
+ request=data,
- request=data,
- ),
)
)
self.assertEqual(response, data)
- server.close()
|
tests.test_asyncio/HighLevelTest.test_connect_and_serve_with_stateless_retry_bad
|
Modified
|
aiortc~aioquic
|
dc5419aaae3d743e820666a556ff917c2d0164d9
|
[tests] ensure server is shutdown after each test
|
<2>:<add> run(self.run_server(stateless_retry=True))
<del> server = run(self.run_server(stateless_retry=True))
<10>:<del> server.close()
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
@patch("aioquic.quic.retry.QuicRetryTokenHandler.validate_token")
def test_connect_and_serve_with_stateless_retry_bad(self, mock_validate):
<0> mock_validate.side_effect = ValueError("Decryption failed.")
<1>
<2> server = run(self.run_server(stateless_retry=True))
<3> with self.assertRaises(ConnectionError):
<4> run(
<5> self.run_client(
<6> "127.0.0.1",
<7> configuration=QuicConfiguration(is_client=True, idle_timeout=4.0),
<8> )
<9> )
<10> server.close()
<11>
|
===========unchanged ref 0===========
at: tests.test_asyncio.HighLevelTest
run_client(host, port=4433, cadata=None, cafile=SERVER_CACERTFILE, configuration=None, request=b"ping", **kwargs)
at: tests.test_asyncio.HighLevelTest.test_connect_and_serve_with_version_negotiation
response = run(
self.run_client(
"127.0.0.1",
configuration=QuicConfiguration(
is_client=True,
quic_logger=QuicLogger(),
supported_versions=[0x1A2A3A4A, QuicProtocolVersion.DRAFT_23],
),
),
)
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]
assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None
===========changed ref 0===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_sni(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("localhost"))
- )
+ run(self.run_server())
+ response = run(self.run_client("localhost"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 1===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_stateless_retry(self):
- server, response = run(
- asyncio.gather(
- self.run_server(stateless_retry=True), self.run_client("127.0.0.1")
- )
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 2===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_stateless_retry_bad_original_connection_id(self):
"""
If the server's transport parameters do not have the correct
original_connection_id the connection fail.
"""
def create_protocol(*args, **kwargs):
protocol = QuicConnectionProtocol(*args, **kwargs)
protocol._quic._original_connection_id = None
return protocol
- server = run(
+ run(self.run_server(create_protocol=create_protocol, stateless_retry=True))
- self.run_server(create_protocol=create_protocol, stateless_retry=True)
- )
with self.assertRaises(ConnectionError):
run(self.run_client("127.0.0.1"))
- server.close()
===========changed ref 3===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def setUp(self):
+ self.server = None
+
===========changed ref 4===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_without_client_configuration(self):
async def run_client_without_config(host, port=4433):
async with connect(host, port) as client:
await client.ping()
+ run(self.run_server())
- server = run(self.run_server())
with self.assertRaises(ConnectionError):
run(run_client_without_config("127.0.0.1"))
- server.close()
===========changed ref 5===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def tearDown(self):
+ if self.server is not None:
+ self.server.close()
+
===========changed ref 6===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 7===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_large(self):
"""
Transfer enough data to require raising MAX_DATA and MAX_STREAM_DATA.
"""
data = b"Z" * 2097152
- server, response = run(
- asyncio.gather(
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1", request=data))
- self.run_server(), self.run_client("127.0.0.1", request=data)
- )
- )
self.assertEqual(response, data)
- server.close()
===========changed ref 8===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def run_server(self, configuration=None, **kwargs):
if configuration is None:
configuration = QuicConfiguration(is_client=False)
configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
+ self.server = await serve(
- return await serve(
host="::",
port="4433",
configuration=configuration,
stream_handler=handle_stream,
**kwargs
)
+ return self.server
===========changed ref 9===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_writelines(self):
async def run_client_writelines(host, port=4433):
configuration = QuicConfiguration(is_client=True)
configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
async with connect(host, port, configuration=configuration) as client:
reader, writer = await client.create_stream()
assert writer.can_write_eof() is True
writer.writelines([b"01234567", b"89012345"])
writer.write_eof()
return await reader.read()
- server, response = run(
- asyncio.gather(self.run_server(), run_client_writelines("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(run_client_writelines("127.0.0.1"))
self.assertEqual(response, b"5432109876543210")
- server.close()
|
tests.test_asyncio/HighLevelTest.test_connect_and_serve_with_version_negotiation
|
Modified
|
aiortc~aioquic
|
dc5419aaae3d743e820666a556ff917c2d0164d9
|
[tests] ensure server is shutdown after each test
|
<0>:<add> run(self.run_server())
<add> response = run(
<del> server, response = run(
<1>:<del> asyncio.gather(
<2>:<del> self.run_server(),
<3>:<add> self.run_client(
<del> self.run_client(
<4>:<add> "127.0.0.1",
<del> "127.0.0.1",
<5>:<add> configuration=QuicConfiguration(
<del> configuration=QuicConfiguration(
<6>:<add> is_client=True,
<del> is_client=True,
<7>:<add> quic_logger=QuicLogger(),
<del> quic_logger=QuicLogger(),
<8>:<add> supported_versions=[0x1A2A3A4A, QuicProtocolVersion.DRAFT_23],
<del> supported_versions=[0x1A2A3A4A, QuicProtocolVersion.DRAFT_23],
<9>:<del> ),
<11>:<add> ),
<del> )
<14>:<del> server.close()
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_version_negotiation(self):
<0> server, response = run(
<1> asyncio.gather(
<2> self.run_server(),
<3> self.run_client(
<4> "127.0.0.1",
<5> configuration=QuicConfiguration(
<6> is_client=True,
<7> quic_logger=QuicLogger(),
<8> supported_versions=[0x1A2A3A4A, QuicProtocolVersion.DRAFT_23],
<9> ),
<10> ),
<11> )
<12> )
<13> self.assertEqual(response, b"gnip")
<14> server.close()
<15>
|
===========unchanged ref 0===========
at: tests.test_asyncio.HighLevelTest
run_server(self, configuration=None, **kwargs)
run_server(configuration=None, **kwargs)
at: tests.utils
run(coro)
SERVER_CACERTFILE = os.path.join(os.path.dirname(__file__), "pycacert.pem")
===========changed ref 0===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def run_server(self, configuration=None, **kwargs):
if configuration is None:
configuration = QuicConfiguration(is_client=False)
configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
+ self.server = await serve(
- return await serve(
host="::",
port="4433",
configuration=configuration,
stream_handler=handle_stream,
**kwargs
)
+ return self.server
===========changed ref 1===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_sni(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("localhost"))
- )
+ run(self.run_server())
+ response = run(self.run_client("localhost"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 2===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
@patch("aioquic.quic.retry.QuicRetryTokenHandler.validate_token")
def test_connect_and_serve_with_stateless_retry_bad(self, mock_validate):
mock_validate.side_effect = ValueError("Decryption failed.")
+ run(self.run_server(stateless_retry=True))
- server = run(self.run_server(stateless_retry=True))
with self.assertRaises(ConnectionError):
run(
self.run_client(
"127.0.0.1",
configuration=QuicConfiguration(is_client=True, idle_timeout=4.0),
)
)
- server.close()
===========changed ref 3===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_stateless_retry(self):
- server, response = run(
- asyncio.gather(
- self.run_server(stateless_retry=True), self.run_client("127.0.0.1")
- )
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 4===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_stateless_retry_bad_original_connection_id(self):
"""
If the server's transport parameters do not have the correct
original_connection_id the connection fail.
"""
def create_protocol(*args, **kwargs):
protocol = QuicConnectionProtocol(*args, **kwargs)
protocol._quic._original_connection_id = None
return protocol
- server = run(
+ run(self.run_server(create_protocol=create_protocol, stateless_retry=True))
- self.run_server(create_protocol=create_protocol, stateless_retry=True)
- )
with self.assertRaises(ConnectionError):
run(self.run_client("127.0.0.1"))
- server.close()
===========changed ref 5===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def setUp(self):
+ self.server = None
+
===========changed ref 6===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_without_client_configuration(self):
async def run_client_without_config(host, port=4433):
async with connect(host, port) as client:
await client.ping()
+ run(self.run_server())
- server = run(self.run_server())
with self.assertRaises(ConnectionError):
run(run_client_without_config("127.0.0.1"))
- server.close()
===========changed ref 7===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def tearDown(self):
+ if self.server is not None:
+ self.server.close()
+
===========changed ref 8===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 9===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_large(self):
"""
Transfer enough data to require raising MAX_DATA and MAX_STREAM_DATA.
"""
data = b"Z" * 2097152
- server, response = run(
- asyncio.gather(
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1", request=data))
- self.run_server(), self.run_client("127.0.0.1", request=data)
- )
- )
self.assertEqual(response, data)
- server.close()
===========changed ref 10===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_writelines(self):
async def run_client_writelines(host, port=4433):
configuration = QuicConfiguration(is_client=True)
configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
async with connect(host, port, configuration=configuration) as client:
reader, writer = await client.create_stream()
assert writer.can_write_eof() is True
writer.writelines([b"01234567", b"89012345"])
writer.write_eof()
return await reader.read()
- server, response = run(
- asyncio.gather(self.run_server(), run_client_writelines("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(run_client_writelines("127.0.0.1"))
self.assertEqual(response, b"5432109876543210")
- server.close()
|
tests.test_asyncio/HighLevelTest.test_change_connection_id
|
Modified
|
aiortc~aioquic
|
dc5419aaae3d743e820666a556ff917c2d0164d9
|
[tests] ensure server is shutdown after each test
|
<0>:<add> async def run_client_change_connection_id(host, port=4433):
<del> async def run_client_key_update(host, port=4433):
<8>:<del> server, _ = run(
<9>:<del> asyncio.gather(
<10>:<del> self.run_server(stateless_retry=False),
<11>:<del> run_client_key_update("127.0.0.1"),
<12>:<del> )
<13>:<del> )
<14>:<del> server.close()
<15>:<add> run(self.run_server())
<add> run(run_client_change_connection_id("127.0.0.1"))
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_change_connection_id(self):
<0> async def run_client_key_update(host, port=4433):
<1> configuration = QuicConfiguration(is_client=True)
<2> configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
<3> async with connect(host, port, configuration=configuration) as client:
<4> await client.ping()
<5> client.change_connection_id()
<6> await client.ping()
<7>
<8> server, _ = run(
<9> asyncio.gather(
<10> self.run_server(stateless_retry=False),
<11> run_client_key_update("127.0.0.1"),
<12> )
<13> )
<14> server.close()
<15>
|
===========unchanged ref 0===========
at: tests.test_asyncio.HighLevelTest
run_server(self, configuration=None, **kwargs)
run_server(configuration=None, **kwargs)
at: tests.test_asyncio.HighLevelTest.test_key_update
run_client_key_update(host, port=4433)
at: tests.utils
run(coro)
SERVER_CACERTFILE = os.path.join(os.path.dirname(__file__), "pycacert.pem")
===========changed ref 0===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def run_server(self, configuration=None, **kwargs):
if configuration is None:
configuration = QuicConfiguration(is_client=False)
configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
+ self.server = await serve(
- return await serve(
host="::",
port="4433",
configuration=configuration,
stream_handler=handle_stream,
**kwargs
)
+ return self.server
===========changed ref 1===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_sni(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("localhost"))
- )
+ run(self.run_server())
+ response = run(self.run_client("localhost"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 2===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
@patch("aioquic.quic.retry.QuicRetryTokenHandler.validate_token")
def test_connect_and_serve_with_stateless_retry_bad(self, mock_validate):
mock_validate.side_effect = ValueError("Decryption failed.")
+ run(self.run_server(stateless_retry=True))
- server = run(self.run_server(stateless_retry=True))
with self.assertRaises(ConnectionError):
run(
self.run_client(
"127.0.0.1",
configuration=QuicConfiguration(is_client=True, idle_timeout=4.0),
)
)
- server.close()
===========changed ref 3===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_stateless_retry(self):
- server, response = run(
- asyncio.gather(
- self.run_server(stateless_retry=True), self.run_client("127.0.0.1")
- )
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 4===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_stateless_retry_bad_original_connection_id(self):
"""
If the server's transport parameters do not have the correct
original_connection_id the connection fail.
"""
def create_protocol(*args, **kwargs):
protocol = QuicConnectionProtocol(*args, **kwargs)
protocol._quic._original_connection_id = None
return protocol
- server = run(
+ run(self.run_server(create_protocol=create_protocol, stateless_retry=True))
- self.run_server(create_protocol=create_protocol, stateless_retry=True)
- )
with self.assertRaises(ConnectionError):
run(self.run_client("127.0.0.1"))
- server.close()
===========changed ref 5===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_version_negotiation(self):
+ run(self.run_server())
+ response = run(
- server, response = run(
- asyncio.gather(
- self.run_server(),
+ self.run_client(
- self.run_client(
+ "127.0.0.1",
- "127.0.0.1",
+ configuration=QuicConfiguration(
- configuration=QuicConfiguration(
+ is_client=True,
- is_client=True,
+ quic_logger=QuicLogger(),
- quic_logger=QuicLogger(),
+ supported_versions=[0x1A2A3A4A, QuicProtocolVersion.DRAFT_23],
- supported_versions=[0x1A2A3A4A, QuicProtocolVersion.DRAFT_23],
- ),
),
+ ),
- )
)
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 6===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def setUp(self):
+ self.server = None
+
===========changed ref 7===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_without_client_configuration(self):
async def run_client_without_config(host, port=4433):
async with connect(host, port) as client:
await client.ping()
+ run(self.run_server())
- server = run(self.run_server())
with self.assertRaises(ConnectionError):
run(run_client_without_config("127.0.0.1"))
- server.close()
===========changed ref 8===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def tearDown(self):
+ if self.server is not None:
+ self.server.close()
+
===========changed ref 9===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 10===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_large(self):
"""
Transfer enough data to require raising MAX_DATA and MAX_STREAM_DATA.
"""
data = b"Z" * 2097152
- server, response = run(
- asyncio.gather(
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1", request=data))
- self.run_server(), self.run_client("127.0.0.1", request=data)
- )
- )
self.assertEqual(response, data)
- server.close()
|
tests.test_asyncio/HighLevelTest.test_key_update
|
Modified
|
aiortc~aioquic
|
dc5419aaae3d743e820666a556ff917c2d0164d9
|
[tests] ensure server is shutdown after each test
|
<8>:<del> server, _ = run(
<9>:<del> asyncio.gather(
<10>:<del> self.run_server(stateless_retry=False),
<11>:<add> run(self.run_server())
<add> run(run_client_key_update("127.0.0.1"))
<del> run_client_key_update("127.0.0.1"),
<12>:<del> )
<13>:<del> )
<14>:<del> server.close()
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_key_update(self):
<0> async def run_client_key_update(host, port=4433):
<1> configuration = QuicConfiguration(is_client=True)
<2> configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
<3> async with connect(host, port, configuration=configuration) as client:
<4> await client.ping()
<5> client.request_key_update()
<6> await client.ping()
<7>
<8> server, _ = run(
<9> asyncio.gather(
<10> self.run_server(stateless_retry=False),
<11> run_client_key_update("127.0.0.1"),
<12> )
<13> )
<14> server.close()
<15>
|
===========unchanged ref 0===========
at: asyncio.tasks
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: bool=...) -> Future[
Tuple[Union[_T1, BaseException], Union[_T2, BaseException], Union[_T3, BaseException], Union[_T4, BaseException]]
]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[Tuple[_T1, _T2, _T3, _T4]]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[Tuple[_T1, _T2]]
gather(coro_or_future1: _FutureT[Any], coro_or_future2: _FutureT[Any], coro_or_future3: _FutureT[Any], coro_or_future4: _FutureT[Any], coro_or_future5: _FutureT[Any], coro_or_future6: _FutureT[Any], *coros_or_futures: _FutureT[Any], loop: Optional[AbstractEventLoop]=..., return_exceptions: bool=...) -> Future[List[Any]]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[</s>
===========unchanged ref 1===========
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_asyncio.HighLevelTest
run_server(self, configuration=None, **kwargs)
run_server(configuration=None, **kwargs)
at: tests.test_asyncio.HighLevelTest.test_ping_parallel
run_client_ping(host, port=4433)
at: tests.utils
run(coro)
===========changed ref 0===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def run_server(self, configuration=None, **kwargs):
if configuration is None:
configuration = QuicConfiguration(is_client=False)
configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
+ self.server = await serve(
- return await serve(
host="::",
port="4433",
configuration=configuration,
stream_handler=handle_stream,
**kwargs
)
+ return self.server
===========changed ref 1===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_sni(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("localhost"))
- )
+ run(self.run_server())
+ response = run(self.run_client("localhost"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 2===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
@patch("aioquic.quic.retry.QuicRetryTokenHandler.validate_token")
def test_connect_and_serve_with_stateless_retry_bad(self, mock_validate):
mock_validate.side_effect = ValueError("Decryption failed.")
+ run(self.run_server(stateless_retry=True))
- server = run(self.run_server(stateless_retry=True))
with self.assertRaises(ConnectionError):
run(
self.run_client(
"127.0.0.1",
configuration=QuicConfiguration(is_client=True, idle_timeout=4.0),
)
)
- server.close()
===========changed ref 3===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_stateless_retry(self):
- server, response = run(
- asyncio.gather(
- self.run_server(stateless_retry=True), self.run_client("127.0.0.1")
- )
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 4===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_change_connection_id(self):
+ async def run_client_change_connection_id(host, port=4433):
- async def run_client_key_update(host, port=4433):
configuration = QuicConfiguration(is_client=True)
configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
async with connect(host, port, configuration=configuration) as client:
await client.ping()
client.change_connection_id()
await client.ping()
- server, _ = run(
- asyncio.gather(
- self.run_server(stateless_retry=False),
- run_client_key_update("127.0.0.1"),
- )
- )
- server.close()
+ run(self.run_server())
+ run(run_client_change_connection_id("127.0.0.1"))
===========changed ref 5===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_stateless_retry_bad_original_connection_id(self):
"""
If the server's transport parameters do not have the correct
original_connection_id the connection fail.
"""
def create_protocol(*args, **kwargs):
protocol = QuicConnectionProtocol(*args, **kwargs)
protocol._quic._original_connection_id = None
return protocol
- server = run(
+ run(self.run_server(create_protocol=create_protocol, stateless_retry=True))
- self.run_server(create_protocol=create_protocol, stateless_retry=True)
- )
with self.assertRaises(ConnectionError):
run(self.run_client("127.0.0.1"))
- server.close()
===========changed ref 6===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_version_negotiation(self):
+ run(self.run_server())
+ response = run(
- server, response = run(
- asyncio.gather(
- self.run_server(),
+ self.run_client(
- self.run_client(
+ "127.0.0.1",
- "127.0.0.1",
+ configuration=QuicConfiguration(
- configuration=QuicConfiguration(
+ is_client=True,
- is_client=True,
+ quic_logger=QuicLogger(),
- quic_logger=QuicLogger(),
+ supported_versions=[0x1A2A3A4A, QuicProtocolVersion.DRAFT_23],
- supported_versions=[0x1A2A3A4A, QuicProtocolVersion.DRAFT_23],
- ),
),
+ ),
- )
)
self.assertEqual(response, b"gnip")
- server.close()
|
tests.test_asyncio/HighLevelTest.test_ping
|
Modified
|
aiortc~aioquic
|
dc5419aaae3d743e820666a556ff917c2d0164d9
|
[tests] ensure server is shutdown after each test
|
<7>:<del> server, _ = run(
<8>:<del> asyncio.gather(
<9>:<del> self.run_server(stateless_retry=False), run_client_ping("127.0.0.1")
<10>:<del> )
<11>:<del> )
<12>:<del> server.close()
<13>:<add> run(self.run_server())
<add> run(run_client_ping("127.0.0.1"))
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_ping(self):
<0> async def run_client_ping(host, port=4433):
<1> configuration = QuicConfiguration(is_client=True)
<2> configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
<3> async with connect(host, port, configuration=configuration) as client:
<4> await client.ping()
<5> await client.ping()
<6>
<7> server, _ = run(
<8> asyncio.gather(
<9> self.run_server(stateless_retry=False), run_client_ping("127.0.0.1")
<10> )
<11> )
<12> server.close()
<13>
|
===========changed ref 0===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_sni(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("localhost"))
- )
+ run(self.run_server())
+ response = run(self.run_client("localhost"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 1===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
@patch("aioquic.quic.retry.QuicRetryTokenHandler.validate_token")
def test_connect_and_serve_with_stateless_retry_bad(self, mock_validate):
mock_validate.side_effect = ValueError("Decryption failed.")
+ run(self.run_server(stateless_retry=True))
- server = run(self.run_server(stateless_retry=True))
with self.assertRaises(ConnectionError):
run(
self.run_client(
"127.0.0.1",
configuration=QuicConfiguration(is_client=True, idle_timeout=4.0),
)
)
- server.close()
===========changed ref 2===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_key_update(self):
async def run_client_key_update(host, port=4433):
configuration = QuicConfiguration(is_client=True)
configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
async with connect(host, port, configuration=configuration) as client:
await client.ping()
client.request_key_update()
await client.ping()
- server, _ = run(
- asyncio.gather(
- self.run_server(stateless_retry=False),
+ run(self.run_server())
+ run(run_client_key_update("127.0.0.1"))
- run_client_key_update("127.0.0.1"),
- )
- )
- server.close()
===========changed ref 3===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_stateless_retry(self):
- server, response = run(
- asyncio.gather(
- self.run_server(stateless_retry=True), self.run_client("127.0.0.1")
- )
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 4===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_change_connection_id(self):
+ async def run_client_change_connection_id(host, port=4433):
- async def run_client_key_update(host, port=4433):
configuration = QuicConfiguration(is_client=True)
configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
async with connect(host, port, configuration=configuration) as client:
await client.ping()
client.change_connection_id()
await client.ping()
- server, _ = run(
- asyncio.gather(
- self.run_server(stateless_retry=False),
- run_client_key_update("127.0.0.1"),
- )
- )
- server.close()
+ run(self.run_server())
+ run(run_client_change_connection_id("127.0.0.1"))
===========changed ref 5===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_stateless_retry_bad_original_connection_id(self):
"""
If the server's transport parameters do not have the correct
original_connection_id the connection fail.
"""
def create_protocol(*args, **kwargs):
protocol = QuicConnectionProtocol(*args, **kwargs)
protocol._quic._original_connection_id = None
return protocol
- server = run(
+ run(self.run_server(create_protocol=create_protocol, stateless_retry=True))
- self.run_server(create_protocol=create_protocol, stateless_retry=True)
- )
with self.assertRaises(ConnectionError):
run(self.run_client("127.0.0.1"))
- server.close()
===========changed ref 6===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_version_negotiation(self):
+ run(self.run_server())
+ response = run(
- server, response = run(
- asyncio.gather(
- self.run_server(),
+ self.run_client(
- self.run_client(
+ "127.0.0.1",
- "127.0.0.1",
+ configuration=QuicConfiguration(
- configuration=QuicConfiguration(
+ is_client=True,
- is_client=True,
+ quic_logger=QuicLogger(),
- quic_logger=QuicLogger(),
+ supported_versions=[0x1A2A3A4A, QuicProtocolVersion.DRAFT_23],
- supported_versions=[0x1A2A3A4A, QuicProtocolVersion.DRAFT_23],
- ),
),
+ ),
- )
)
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 7===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def setUp(self):
+ self.server = None
+
===========changed ref 8===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_without_client_configuration(self):
async def run_client_without_config(host, port=4433):
async with connect(host, port) as client:
await client.ping()
+ run(self.run_server())
- server = run(self.run_server())
with self.assertRaises(ConnectionError):
run(run_client_without_config("127.0.0.1"))
- server.close()
===========changed ref 9===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def tearDown(self):
+ if self.server is not None:
+ self.server.close()
+
===========changed ref 10===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("127.0.0.1"))
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 11===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_large(self):
"""
Transfer enough data to require raising MAX_DATA and MAX_STREAM_DATA.
"""
data = b"Z" * 2097152
- server, response = run(
- asyncio.gather(
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1", request=data))
- self.run_server(), self.run_client("127.0.0.1", request=data)
- )
- )
self.assertEqual(response, data)
- server.close()
|
tests.test_asyncio/HighLevelTest.test_ping_parallel
|
Modified
|
aiortc~aioquic
|
dc5419aaae3d743e820666a556ff917c2d0164d9
|
[tests] ensure server is shutdown after each test
|
<7>:<del> server, _ = run(
<8>:<del> asyncio.gather(
<9>:<del> self.run_server(stateless_retry=False), run_client_ping("127.0.0.1")
<10>:<del> )
<11>:<del> )
<12>:<del> server.close()
<13>:<add> run(self.run_server())
<add> run(run_client_ping("127.0.0.1"))
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_ping_parallel(self):
<0> async def run_client_ping(host, port=4433):
<1> configuration = QuicConfiguration(is_client=True)
<2> configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
<3> async with connect(host, port, configuration=configuration) as client:
<4> coros = [client.ping() for x in range(16)]
<5> await asyncio.gather(*coros)
<6>
<7> server, _ = run(
<8> asyncio.gather(
<9> self.run_server(stateless_retry=False), run_client_ping("127.0.0.1")
<10> )
<11> )
<12> server.close()
<13>
|
===========changed ref 0===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_ping(self):
async def run_client_ping(host, port=4433):
configuration = QuicConfiguration(is_client=True)
configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
async with connect(host, port, configuration=configuration) as client:
await client.ping()
await client.ping()
- server, _ = run(
- asyncio.gather(
- self.run_server(stateless_retry=False), run_client_ping("127.0.0.1")
- )
- )
- server.close()
+ run(self.run_server())
+ run(run_client_ping("127.0.0.1"))
===========changed ref 1===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_sni(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("localhost"))
- )
+ run(self.run_server())
+ response = run(self.run_client("localhost"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 2===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
@patch("aioquic.quic.retry.QuicRetryTokenHandler.validate_token")
def test_connect_and_serve_with_stateless_retry_bad(self, mock_validate):
mock_validate.side_effect = ValueError("Decryption failed.")
+ run(self.run_server(stateless_retry=True))
- server = run(self.run_server(stateless_retry=True))
with self.assertRaises(ConnectionError):
run(
self.run_client(
"127.0.0.1",
configuration=QuicConfiguration(is_client=True, idle_timeout=4.0),
)
)
- server.close()
===========changed ref 3===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_key_update(self):
async def run_client_key_update(host, port=4433):
configuration = QuicConfiguration(is_client=True)
configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
async with connect(host, port, configuration=configuration) as client:
await client.ping()
client.request_key_update()
await client.ping()
- server, _ = run(
- asyncio.gather(
- self.run_server(stateless_retry=False),
+ run(self.run_server())
+ run(run_client_key_update("127.0.0.1"))
- run_client_key_update("127.0.0.1"),
- )
- )
- server.close()
===========changed ref 4===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_stateless_retry(self):
- server, response = run(
- asyncio.gather(
- self.run_server(stateless_retry=True), self.run_client("127.0.0.1")
- )
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 5===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_change_connection_id(self):
+ async def run_client_change_connection_id(host, port=4433):
- async def run_client_key_update(host, port=4433):
configuration = QuicConfiguration(is_client=True)
configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
async with connect(host, port, configuration=configuration) as client:
await client.ping()
client.change_connection_id()
await client.ping()
- server, _ = run(
- asyncio.gather(
- self.run_server(stateless_retry=False),
- run_client_key_update("127.0.0.1"),
- )
- )
- server.close()
+ run(self.run_server())
+ run(run_client_change_connection_id("127.0.0.1"))
===========changed ref 6===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_stateless_retry_bad_original_connection_id(self):
"""
If the server's transport parameters do not have the correct
original_connection_id the connection fail.
"""
def create_protocol(*args, **kwargs):
protocol = QuicConnectionProtocol(*args, **kwargs)
protocol._quic._original_connection_id = None
return protocol
- server = run(
+ run(self.run_server(create_protocol=create_protocol, stateless_retry=True))
- self.run_server(create_protocol=create_protocol, stateless_retry=True)
- )
with self.assertRaises(ConnectionError):
run(self.run_client("127.0.0.1"))
- server.close()
===========changed ref 7===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_version_negotiation(self):
+ run(self.run_server())
+ response = run(
- server, response = run(
- asyncio.gather(
- self.run_server(),
+ self.run_client(
- self.run_client(
+ "127.0.0.1",
- "127.0.0.1",
+ configuration=QuicConfiguration(
- configuration=QuicConfiguration(
+ is_client=True,
- is_client=True,
+ quic_logger=QuicLogger(),
- quic_logger=QuicLogger(),
+ supported_versions=[0x1A2A3A4A, QuicProtocolVersion.DRAFT_23],
- supported_versions=[0x1A2A3A4A, QuicProtocolVersion.DRAFT_23],
- ),
),
+ ),
- )
)
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 8===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def setUp(self):
+ self.server = None
+
===========changed ref 9===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_without_client_configuration(self):
async def run_client_without_config(host, port=4433):
async with connect(host, port) as client:
await client.ping()
+ run(self.run_server())
- server = run(self.run_server())
with self.assertRaises(ConnectionError):
run(run_client_without_config("127.0.0.1"))
- server.close()
===========changed ref 10===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def tearDown(self):
+ if self.server is not None:
+ self.server.close()
+
|
tests.test_asyncio/HighLevelTest.test_server_receives_garbage
|
Modified
|
aiortc~aioquic
|
dc5419aaae3d743e820666a556ff917c2d0164d9
|
[tests] ensure server is shutdown after each test
|
<0>:<add> server = run(self.run_server())
<del> server = run(self.run_server(stateless_retry=False))
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_server_receives_garbage(self):
<0> server = run(self.run_server(stateless_retry=False))
<1> server.datagram_received(binascii.unhexlify("c00000000080"), ("1.2.3.4", 1234))
<2> server.close()
<3>
|
===========changed ref 0===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_ping_parallel(self):
async def run_client_ping(host, port=4433):
configuration = QuicConfiguration(is_client=True)
configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
async with connect(host, port, configuration=configuration) as client:
coros = [client.ping() for x in range(16)]
await asyncio.gather(*coros)
- server, _ = run(
- asyncio.gather(
- self.run_server(stateless_retry=False), run_client_ping("127.0.0.1")
- )
- )
- server.close()
+ run(self.run_server())
+ run(run_client_ping("127.0.0.1"))
===========changed ref 1===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_ping(self):
async def run_client_ping(host, port=4433):
configuration = QuicConfiguration(is_client=True)
configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
async with connect(host, port, configuration=configuration) as client:
await client.ping()
await client.ping()
- server, _ = run(
- asyncio.gather(
- self.run_server(stateless_retry=False), run_client_ping("127.0.0.1")
- )
- )
- server.close()
+ run(self.run_server())
+ run(run_client_ping("127.0.0.1"))
===========changed ref 2===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_sni(self):
- server, response = run(
- asyncio.gather(self.run_server(), self.run_client("localhost"))
- )
+ run(self.run_server())
+ response = run(self.run_client("localhost"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 3===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
@patch("aioquic.quic.retry.QuicRetryTokenHandler.validate_token")
def test_connect_and_serve_with_stateless_retry_bad(self, mock_validate):
mock_validate.side_effect = ValueError("Decryption failed.")
+ run(self.run_server(stateless_retry=True))
- server = run(self.run_server(stateless_retry=True))
with self.assertRaises(ConnectionError):
run(
self.run_client(
"127.0.0.1",
configuration=QuicConfiguration(is_client=True, idle_timeout=4.0),
)
)
- server.close()
===========changed ref 4===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_key_update(self):
async def run_client_key_update(host, port=4433):
configuration = QuicConfiguration(is_client=True)
configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
async with connect(host, port, configuration=configuration) as client:
await client.ping()
client.request_key_update()
await client.ping()
- server, _ = run(
- asyncio.gather(
- self.run_server(stateless_retry=False),
+ run(self.run_server())
+ run(run_client_key_update("127.0.0.1"))
- run_client_key_update("127.0.0.1"),
- )
- )
- server.close()
===========changed ref 5===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_stateless_retry(self):
- server, response = run(
- asyncio.gather(
- self.run_server(stateless_retry=True), self.run_client("127.0.0.1")
- )
- )
+ run(self.run_server())
+ response = run(self.run_client("127.0.0.1"))
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 6===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_change_connection_id(self):
+ async def run_client_change_connection_id(host, port=4433):
- async def run_client_key_update(host, port=4433):
configuration = QuicConfiguration(is_client=True)
configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
async with connect(host, port, configuration=configuration) as client:
await client.ping()
client.change_connection_id()
await client.ping()
- server, _ = run(
- asyncio.gather(
- self.run_server(stateless_retry=False),
- run_client_key_update("127.0.0.1"),
- )
- )
- server.close()
+ run(self.run_server())
+ run(run_client_change_connection_id("127.0.0.1"))
===========changed ref 7===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_stateless_retry_bad_original_connection_id(self):
"""
If the server's transport parameters do not have the correct
original_connection_id the connection fail.
"""
def create_protocol(*args, **kwargs):
protocol = QuicConnectionProtocol(*args, **kwargs)
protocol._quic._original_connection_id = None
return protocol
- server = run(
+ run(self.run_server(create_protocol=create_protocol, stateless_retry=True))
- self.run_server(create_protocol=create_protocol, stateless_retry=True)
- )
with self.assertRaises(ConnectionError):
run(self.run_client("127.0.0.1"))
- server.close()
===========changed ref 8===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
def test_connect_and_serve_with_version_negotiation(self):
+ run(self.run_server())
+ response = run(
- server, response = run(
- asyncio.gather(
- self.run_server(),
+ self.run_client(
- self.run_client(
+ "127.0.0.1",
- "127.0.0.1",
+ configuration=QuicConfiguration(
- configuration=QuicConfiguration(
+ is_client=True,
- is_client=True,
+ quic_logger=QuicLogger(),
- quic_logger=QuicLogger(),
+ supported_versions=[0x1A2A3A4A, QuicProtocolVersion.DRAFT_23],
- supported_versions=[0x1A2A3A4A, QuicProtocolVersion.DRAFT_23],
- ),
),
+ ),
- )
)
self.assertEqual(response, b"gnip")
- server.close()
===========changed ref 9===========
# module: tests.test_asyncio
class HighLevelTest(TestCase):
+ def setUp(self):
+ self.server = None
+
|
aioquic.quic.packet_builder/QuicPacketBuilder.__init__
|
Modified
|
aiortc~aioquic
|
d023426fb38dfcbd694bbdb51a2b5d789b1ad2af
|
[packet builder] pad INITIAL packets instead of creating new ones
|
<16>:<del> self._datagram_padding = False
|
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
is_client: bool,
packet_number: int = 0,
peer_token: bytes = b"",
quic_logger: Optional[QuicLoggerTrace] = None,
spin_bit: bool = False,
):
<0> self.max_flight_bytes: Optional[int] = None
<1> self.max_total_bytes: Optional[int] = None
<2> self.quic_logger_frames: Optional[List[Dict]] = None
<3>
<4> self._host_cid = host_cid
<5> self._is_client = is_client
<6> self._peer_cid = peer_cid
<7> self._peer_token = peer_token
<8> self._quic_logger = quic_logger
<9> self._spin_bit = spin_bit
<10> self._version = version
<11>
<12> # assembled datagrams and packets
<13> self._datagrams: List[bytes] = []
<14> self._datagram_flight_bytes = 0
<15> self._datagram_init = True
<16> self._datagram_padding = False
<17> self._packets: List[QuicSentPacket] = []
<18> self._flight_bytes = 0
<19> self._total_bytes = 0
<20>
<21> # current packet
<22> self._header_size = 0
<23> self._packet: Optional[QuicSentPacket] = None
<24> self._packet_crypto: Optional[CryptoPair] = None
<25> self._packet_long_header = False
<26> self._packet_number = packet_number
<27> self._packet_start = 0
<28> self._packet_type = 0
<29>
<30> self._buffer = Buffer(PACKET_MAX_SIZE)
<31> self._buffer_capacity = PACKET_MAX_SIZE
<32>
|
===========unchanged ref 0===========
at: aioquic.quic.packet_builder
PACKET_MAX_SIZE = 1280
QuicSentPacket(epoch: Epoch, in_flight: bool, is_ack_eliciting: bool, is_crypto_packet: bool, packet_number: int, packet_type: int, sent_time: Optional[float]=None, sent_bytes: int=0, delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]]=field(
default_factory=list
), quic_logger_frames: List[Dict]=field(default_factory=list))
at: aioquic.quic.packet_builder.QuicPacketBuilder._end_packet
self._datagram_flight_bytes += self._packet.sent_bytes
self._packet_number += 1
self._packet = None
self.quic_logger_frames = None
at: aioquic.quic.packet_builder.QuicPacketBuilder._flush_current_datagram
self._flight_bytes += self._datagram_flight_bytes
self._total_bytes += datagram_bytes
self._datagram_init = True
at: aioquic.quic.packet_builder.QuicPacketBuilder.flush
self._datagrams = []
self._packets = []
at: aioquic.quic.packet_builder.QuicPacketBuilder.start_packet
self._buffer_capacity = remaining_flight_bytes
self._buffer_capacity = remaining_total_bytes
self._datagram_flight_bytes = 0
self._datagram_init = False
self._header_size = header_size
self._packet = QuicSentPacket(
epoch=epoch,
in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
packet_type=packet_type,
)
self._packet_crypto = crypto
self._packet_long_header = packet_long_header
===========unchanged ref 1===========
self._packet_start = packet_start
self._packet_type = packet_type
self.quic_logger_frames = self._packet.quic_logger_frames
at: typing
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
|
aioquic.quic.packet_builder/QuicPacketBuilder.flush
|
Modified
|
aiortc~aioquic
|
d023426fb38dfcbd694bbdb51a2b5d789b1ad2af
|
[packet builder] pad INITIAL packets instead of creating new ones
|
<4>:<add> self._end_packet()
<del> self._end_packet(final=True)
|
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
<0> """
<1> Returns the assembled datagrams.
<2> """
<3> if self._packet is not None:
<4> self._end_packet(final=True)
<5> self._flush_current_datagram()
<6>
<7> datagrams = self._datagrams
<8> packets = self._packets
<9> self._datagrams = []
<10> self._packets = []
<11> return datagrams, packets
<12>
|
===========unchanged ref 0===========
at: aioquic.quic.packet_builder.QuicPacketBuilder
_end_packet() -> None
_end_packet(self) -> None
_flush_current_datagram() -> None
_flush_current_datagram(self) -> None
at: aioquic.quic.packet_builder.QuicPacketBuilder.__init__
self._datagrams: List[bytes] = []
self._packets: List[QuicSentPacket] = []
self._packet: Optional[QuicSentPacket] = None
at: aioquic.quic.packet_builder.QuicPacketBuilder._end_packet
self._packet = None
at: aioquic.quic.packet_builder.QuicPacketBuilder.start_packet
self._packet = QuicSentPacket(
epoch=epoch,
in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
packet_type=packet_type,
)
===========changed ref 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
is_client: bool,
packet_number: int = 0,
peer_token: bytes = b"",
quic_logger: Optional[QuicLoggerTrace] = None,
spin_bit: bool = False,
):
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
self._is_client = is_client
self._peer_cid = peer_cid
self._peer_token = peer_token
self._quic_logger = quic_logger
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._datagrams: List[bytes] = []
self._datagram_flight_bytes = 0
self._datagram_init = True
- self._datagram_padding = False
self._packets: List[QuicSentPacket] = []
self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self._buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
|
aioquic.quic.packet_builder/QuicPacketBuilder.start_packet
|
Modified
|
aiortc~aioquic
|
d023426fb38dfcbd694bbdb51a2b5d789b1ad2af
|
[packet builder] pad INITIAL packets instead of creating new ones
|
<7>:<add> self._end_packet()
<del> self._end_packet(final=False)
<28>:<del> self._datagram_padding = False
|
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
<0> """
<1> Starts a new packet.
<2> """
<3> buf = self._buffer
<4>
<5> # finish previous datagram
<6> if self._packet is not None:
<7> self._end_packet(final=False)
<8>
<9> # if there is too little space remaining, start a new datagram
<10> # FIXME: the limit is arbitrary!
<11> packet_start = buf.tell()
<12> if self._buffer_capacity - packet_start < 128:
<13> self._flush_current_datagram()
<14> packet_start = 0
<15>
<16> # initialize datagram if needed
<17> if self._datagram_init:
<18> if self.max_flight_bytes is not None:
<19> remaining_flight_bytes = self.max_flight_bytes - self._flight_bytes
<20> if remaining_flight_bytes < self._buffer_capacity:
<21> self._buffer_capacity = remaining_flight_bytes
<22> if self.max_total_bytes is not None:
<23> remaining_total_bytes = self.max_total_bytes - self._total_bytes
<24> if remaining_total_bytes < self._buffer_capacity:
<25> self._buffer_capacity = remaining_total_bytes
<26> self._datagram_flight_bytes = 0
<27> self._datagram_init = False
<28> self._datagram_padding = False
<29>
<30> # calculate header size
<31> packet_long_header = is_long_header(packet_type)
<32> if packet_long_header:
<33> header_size = 11 + len(self._peer_cid) + len(self._host_cid)
<34> if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
<35> token_length = len(self._peer_token)
<36> header_size += size_uint_var(token_length) + token_length
<37> else:
<38> header_size = 3 + len(self</s>
|
===========below chunk 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
# check we have enough space
if packet_start + header_size >= self._buffer_capacity:
raise QuicPacketBuilderStop
# determine ack epoch
if packet_type == PACKET_TYPE_INITIAL:
epoch = Epoch.INITIAL
elif packet_type == PACKET_TYPE_HANDSHAKE:
epoch = Epoch.HANDSHAKE
else:
epoch = Epoch.ONE_RTT
self._header_size = header_size
self._packet = QuicSentPacket(
epoch=epoch,
in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
packet_type=packet_type,
)
self._packet_crypto = crypto
self._packet_long_header = packet_long_header
self._packet_start = packet_start
self._packet_type = packet_type
self.quic_logger_frames = self._packet.quic_logger_frames
buf.seek(self._packet_start + self._header_size)
===========unchanged ref 0===========
at: aioquic.quic.packet_builder
QuicSentPacket(epoch: Epoch, in_flight: bool, is_ack_eliciting: bool, is_crypto_packet: bool, packet_number: int, packet_type: int, sent_time: Optional[float]=None, sent_bytes: int=0, delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]]=field(
default_factory=list
), quic_logger_frames: List[Dict]=field(default_factory=list))
QuicPacketBuilderStop(*args: object)
at: aioquic.quic.packet_builder.QuicPacketBuilder
_flush_current_datagram() -> None
_flush_current_datagram(self) -> None
at: aioquic.quic.packet_builder.QuicPacketBuilder.__init__
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
self._peer_cid = peer_cid
self._peer_token = peer_token
self._datagram_flight_bytes = 0
self._datagram_init = True
self._flight_bytes = 0
self._total_bytes = 0
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self._buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
at: aioquic.quic.packet_builder.QuicPacketBuilder._end_packet
self._datagram_flight_bytes += self._packet.sent_bytes
self._packet_number += 1
===========unchanged ref 1===========
self._packet = None
self.quic_logger_frames = None
at: aioquic.quic.packet_builder.QuicPacketBuilder._flush_current_datagram
self._flight_bytes += self._datagram_flight_bytes
self._total_bytes += datagram_bytes
self._datagram_init = True
at: aioquic.quic.packet_builder.QuicSentPacket
epoch: Epoch
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
packet_type: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
quic_logger_frames: List[Dict] = field(default_factory=list)
===========changed ref 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
"""
Returns the assembled datagrams.
"""
if self._packet is not None:
+ self._end_packet()
- self._end_packet(final=True)
self._flush_current_datagram()
datagrams = self._datagrams
packets = self._packets
self._datagrams = []
self._packets = []
return datagrams, packets
===========changed ref 1===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
is_client: bool,
packet_number: int = 0,
peer_token: bytes = b"",
quic_logger: Optional[QuicLoggerTrace] = None,
spin_bit: bool = False,
):
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
self._is_client = is_client
self._peer_cid = peer_cid
self._peer_token = peer_token
self._quic_logger = quic_logger
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._datagrams: List[bytes] = []
self._datagram_flight_bytes = 0
self._datagram_init = True
- self._datagram_padding = False
self._packets: List[QuicSentPacket] = []
self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self._buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
|
aioquic.quic.packet_builder/QuicPacketBuilder._end_packet
|
Modified
|
aiortc~aioquic
|
d023426fb38dfcbd694bbdb51a2b5d789b1ad2af
|
[packet builder] pad INITIAL packets instead of creating new ones
|
<5>:<add> if packet_size > self._header_size:
<add> # pad initial datagram
<del> if packet_size > self._header_size or (self._datagram_padding and final):
<7>:<del> self._datagram_padding = True
<8>:<del>
<9>:<del> # pad initial datagram
<10>:<del> if self._datagram_padding and final:
|
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
+ def _end_packet(self) -> None:
- def _end_packet(self, final: bool) -> None:
<0> """
<1> Ends the current packet.
<2> """
<3> buf = self._buffer
<4> packet_size = buf.tell() - self._packet_start
<5> if packet_size > self._header_size or (self._datagram_padding and final):
<6> if self._is_client and self._packet_type == PACKET_TYPE_INITIAL:
<7> self._datagram_padding = True
<8>
<9> # pad initial datagram
<10> if self._datagram_padding and final:
<11> if self.remaining_space:
<12> buf.push_bytes(bytes(self.remaining_space))
<13> packet_size = buf.tell() - self._packet_start
<14> self._packet.in_flight = True
<15>
<16> # log frame
<17> if self._quic_logger is not None:
<18> self._packet.quic_logger_frames.append(
<19> self._quic_logger.encode_padding_frame()
<20> )
<21>
<22> # write header
<23> if self._packet_long_header:
<24> length = (
<25> packet_size
<26> - self._header_size
<27> + PACKET_NUMBER_SEND_SIZE
<28> + self._packet_crypto.aead_tag_size
<29> )
<30>
<31> buf.seek(self._packet_start)
<32> buf.push_uint8(self._packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
<33> buf.push_uint32(self._version)
<34> buf.push_uint8(len(self._peer_cid))
<35> buf.push_bytes(self._peer_cid)
<36> buf.push_uint8(len(self._host_cid))
<37> buf.push_bytes(self._host_cid)
<38> if (self._packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_</s>
|
===========below chunk 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
+ def _end_packet(self) -> None:
- def _end_packet(self, final: bool) -> None:
# offset: 1
buf.push_uint_var(len(self._peer_token))
buf.push_bytes(self._peer_token)
buf.push_uint16(length | 0x4000)
buf.push_uint16(self._packet_number & 0xFFFF)
else:
buf.seek(self._packet_start)
buf.push_uint8(
self._packet_type
| (self._spin_bit << 5)
| (self._packet_crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1)
)
buf.push_bytes(self._peer_cid)
buf.push_uint16(self._packet_number & 0xFFFF)
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
buf.seek(self._packet_start + packet_size)
buf.push_bytes(bytes(padding_size))
packet_size += padding_size
self._packet.in_flight = True
# log frame
if self._quic_logger is not None:
self._packet.quic_logger_frames.append(
self._quic_logger.encode_padding_frame()
)
# encrypt in place
plain = buf.data_slice(self._packet_start, self._packet_start + packet_size)
buf.seek(self._packet_start)
buf.push_bytes(
self._packet_crypto.encrypt_packet(
plain[0 : self._header_size],
plain[self._header_size : packet_size],
self._packet_number,
)
)
self._packet.sent_</s>
===========below chunk 1===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
+ def _end_packet(self) -> None:
- def _end_packet(self, final: bool) -> None:
# offset: 2
<s>header_size : packet_size],
self._packet_number,
)
)
self._packet.sent_bytes = buf.tell() - self._packet_start
self._packets.append(self._packet)
if self._packet.in_flight:
self._datagram_flight_bytes += self._packet.sent_bytes
# short header packets cannot be coallesced, we need a new datagram
if not self._packet_long_header:
self._flush_current_datagram()
self._packet_number += 1
else:
# "cancel" the packet
buf.seek(self._packet_start)
self._packet = None
self.quic_logger_frames = None
===========unchanged ref 0===========
at: aioquic.quic.packet_builder
PACKET_NUMBER_SEND_SIZE = 2
at: aioquic.quic.packet_builder.QuicPacketBuilder.__init__
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
self._is_client = is_client
self._peer_cid = peer_cid
self._peer_token = peer_token
self._quic_logger = quic_logger
self._spin_bit = spin_bit
self._version = version
self._datagrams: List[bytes] = []
self._datagram_flight_bytes = 0
self._packets: List[QuicSentPacket] = []
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self._buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.quic.packet_builder.QuicPacketBuilder.flush
self._datagrams = []
self._packets = []
at: aioquic.quic.packet_builder.QuicPacketBuilder.start_packet
self._datagram_flight_bytes = 0
self._header_size = header_size
self._packet = QuicSentPacket(
epoch=epoch,
in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
packet_type=packet_type,
)
self._packet_crypto = crypto
self._packet_long_header = packet_long_header
self._packet_start = packet_start
self._packet_type = packet_type
===========unchanged ref 1===========
self.quic_logger_frames = self._packet.quic_logger_frames
at: aioquic.quic.packet_builder.QuicSentPacket
in_flight: bool
sent_bytes: int = 0
quic_logger_frames: List[Dict] = field(default_factory=list)
===========changed ref 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
"""
Returns the assembled datagrams.
"""
if self._packet is not None:
+ self._end_packet()
- self._end_packet(final=True)
self._flush_current_datagram()
datagrams = self._datagrams
packets = self._packets
self._datagrams = []
self._packets = []
return datagrams, packets
===========changed ref 1===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
is_client: bool,
packet_number: int = 0,
peer_token: bytes = b"",
quic_logger: Optional[QuicLoggerTrace] = None,
spin_bit: bool = False,
):
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
self._is_client = is_client
self._peer_cid = peer_cid
self._peer_token = peer_token
self._quic_logger = quic_logger
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._datagrams: List[bytes] = []
self._datagram_flight_bytes = 0
self._datagram_init = True
- self._datagram_padding = False
self._packets: List[QuicSentPacket] = []
self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self._buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
|
tests.test_connection/QuicConnectionTest.test_connect_with_loss_1
|
Modified
|
aiortc~aioquic
|
d023426fb38dfcbd694bbdb51a2b5d789b1ad2af
|
[packet builder] pad INITIAL packets instead of creating new ones
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_1(self):
<0> """
<1> Check connection is established even in the client's INITIAL is lost.
<2> """
<3>
<4> def datagram_sizes(items):
<5> return [len(x[0]) for x in items]
<6>
<7> client_configuration = QuicConfiguration(is_client=True)
<8> client_configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
<9>
<10> client = QuicConnection(configuration=client_configuration)
<11> client._ack_delay = 0
<12>
<13> server_configuration = QuicConfiguration(is_client=False)
<14> server_configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
<15>
<16> server = QuicConnection(configuration=server_configuration)
<17> server._ack_delay = 0
<18>
<19> # client sends INITIAL
<20> now = 0.0
<21> client.connect(SERVER_ADDR, now=now)
<22> items = client.datagrams_to_send(now=now)
<23> self.assertEqual(datagram_sizes(items), [1280])
<24> self.assertEqual(client.get_timer(), 1.0)
<25>
<26> # INITIAL is lost
<27> now = 1.0
<28> client.handle_timer(now=now)
<29> items = client.datagrams_to_send(now=now)
<30> self.assertEqual(datagram_sizes(items), [1280])
<31> self.assertEqual(client.get_timer(), 3.0)
<32>
<33> # server receives INITIAL, sends INITIAL + HANDSHAKE
<34> now = 1.1
<35> server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
<36> items = server.datagrams_to_send(now=now)
<37> self.assertEqual(datagram_sizes(items), [1280, 1084])
<38> self.assertEqual(server.get_timer(), 2.1)
<39> self.assertEqual</s>
|
===========below chunk 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_1(self):
# offset: 1
self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)
# handshake continues normally
now = 1.2
client.receive_datagram(items[0][0], SERVER_ADDR, now=now)
client.receive_datagram(items[1][0], SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280, 223])
self.assertAlmostEqual(client.get_timer(), 1.825)
now = 1.3
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
server.receive_datagram(items[1][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [276])
self.assertAlmostEqual(server.get_timer(), 1.825)
self.assertEqual(len(server._loss.spaces[0].sent_packets), 0)
self.assertEqual(len(server._loss.spaces[1].sent_packets), 1)
now = 1.4
client.receive_datagram(items[0][0], SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [32])
self.assertAlmostEqual(client.get_timer(), 61.4) # idle timeout
self.assertEqual(type(client.next_event()), events.ProtocolNegotiated)
self.assertEqual(type(client.next_event()), events.HandshakeCompleted)
now = 1.5
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_</s>
===========below chunk 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_1(self):
# offset: 2
<s>_datagram(items[0][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [])
self.assertAlmostEqual(server.get_timer(), 61.5) # idle timeout
self.assertEqual(type(server.next_event()), events.ProtocolNegotiated)
self.assertEqual(type(server.next_event()), events.HandshakeCompleted)
===========unchanged ref 0===========
at: tests.test_connection
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
at: tests.utils
SERVER_CACERTFILE = os.path.join(os.path.dirname(__file__), "pycacert.pem")
SERVER_CERTFILE = os.path.join(os.path.dirname(__file__), "ssl_cert.pem")
SERVER_KEYFILE = os.path.join(os.path.dirname(__file__), "ssl_key.pem")
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertAlmostEqual(first: float, second: float, places: Optional[int]=..., msg: Any=..., delta: Optional[float]=...) -> None
assertAlmostEqual(first: datetime.datetime, second: datetime.datetime, places: Optional[int]=..., msg: Any=..., delta: Optional[datetime.timedelta]=...) -> None
===========changed ref 0===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
"""
Returns the assembled datagrams.
"""
if self._packet is not None:
+ self._end_packet()
- self._end_packet(final=True)
self._flush_current_datagram()
datagrams = self._datagrams
packets = self._packets
self._datagrams = []
self._packets = []
return datagrams, packets
===========changed ref 1===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
is_client: bool,
packet_number: int = 0,
peer_token: bytes = b"",
quic_logger: Optional[QuicLoggerTrace] = None,
spin_bit: bool = False,
):
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
self._is_client = is_client
self._peer_cid = peer_cid
self._peer_token = peer_token
self._quic_logger = quic_logger
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._datagrams: List[bytes] = []
self._datagram_flight_bytes = 0
self._datagram_init = True
- self._datagram_padding = False
self._packets: List[QuicSentPacket] = []
self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self._buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
|
|
tests.test_connection/QuicConnectionTest.test_connect_with_loss_2
|
Modified
|
aiortc~aioquic
|
d023426fb38dfcbd694bbdb51a2b5d789b1ad2af
|
[packet builder] pad INITIAL packets instead of creating new ones
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_2(self):
<0> def datagram_sizes(items):
<1> return [len(x[0]) for x in items]
<2>
<3> client_configuration = QuicConfiguration(is_client=True)
<4> client_configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
<5>
<6> client = QuicConnection(configuration=client_configuration)
<7> client._ack_delay = 0
<8>
<9> server_configuration = QuicConfiguration(is_client=False)
<10> server_configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
<11>
<12> server = QuicConnection(configuration=server_configuration)
<13> server._ack_delay = 0
<14>
<15> # client sends INITIAL
<16> now = 0.0
<17> client.connect(SERVER_ADDR, now=now)
<18> items = client.datagrams_to_send(now=now)
<19> self.assertEqual(datagram_sizes(items), [1280])
<20> self.assertEqual(client.get_timer(), 1.0)
<21>
<22> # server receives INITIAL, sends INITIAL + HANDSHAKE but second datagram is lost
<23> now = 0.1
<24> server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
<25> items = server.datagrams_to_send(now=now)
<26> self.assertEqual(datagram_sizes(items), [1280, 1084])
<27> self.assertEqual(server.get_timer(), 1.1)
<28> self.assertEqual(len(server._loss.spaces[0].sent_packets), 1)
<29> self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)
<30>
<31> # client only receives first datagram and sends ACKS
<32> now = 0.2
<33> client.receive_datagram(items[0][0], SERVER_ADDR, now=now)
<34> items = client.datagrams_to_send</s>
|
===========below chunk 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_2(self):
# offset: 1
self.assertEqual(datagram_sizes(items), [1280])
self.assertAlmostEqual(client.get_timer(), 0.625)
# client PTO - padded HANDSHAKE
now = client.get_timer() # ~0.625
client.handle_timer(now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280])
self.assertAlmostEqual(client.get_timer(), 1.25)
# server receives padding, discards INITIAL
now = 0.725
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [])
self.assertAlmostEqual(server.get_timer(), 1.1)
self.assertEqual(len(server._loss.spaces[0].sent_packets), 0)
self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)
# ACKs are lost, server retransmits HANDSHAKE
now = server.get_timer()
server.handle_timer(now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280, 905])
self.assertAlmostEqual(server.get_timer(), 3.1)
self.assertEqual(len(server._loss.spaces[0].sent_packets), 0)
self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)
# handshake continues normally
now = 1.2
client.receive_datagram(items[0][0], SERVER_ADDR, now=now)
client.receive_datagram(items[1][0], SERVER</s>
===========below chunk 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_2(self):
# offset: 2
<s>items[0][0], SERVER_ADDR, now=now)
client.receive_datagram(items[1][0], SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [334])
self.assertAlmostEqual(client.get_timer(), 2.45)
self.assertEqual(type(client.next_event()), events.ProtocolNegotiated)
self.assertEqual(type(client.next_event()), events.HandshakeCompleted)
now = 1.3
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [228])
self.assertAlmostEqual(server.get_timer(), 1.825)
self.assertEqual(type(server.next_event()), events.ProtocolNegotiated)
self.assertEqual(type(server.next_event()), events.HandshakeCompleted)
now = 1.4
client.receive_datagram(items[0][0], SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [32])
self.assertAlmostEqual(client.get_timer(), 61.4) # idle timeout
===========unchanged ref 0===========
at: tests.test_connection
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
at: tests.utils
SERVER_CACERTFILE = os.path.join(os.path.dirname(__file__), "pycacert.pem")
SERVER_CERTFILE = os.path.join(os.path.dirname(__file__), "ssl_cert.pem")
SERVER_KEYFILE = os.path.join(os.path.dirname(__file__), "ssl_key.pem")
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertAlmostEqual(first: float, second: float, places: Optional[int]=..., msg: Any=..., delta: Optional[float]=...) -> None
assertAlmostEqual(first: datetime.datetime, second: datetime.datetime, places: Optional[int]=..., msg: Any=..., delta: Optional[datetime.timedelta]=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_1(self):
"""
Check connection is established even in the client's INITIAL is lost.
"""
def datagram_sizes(items):
return [len(x[0]) for x in items]
client_configuration = QuicConfiguration(is_client=True)
client_configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
client = QuicConnection(configuration=client_configuration)
client._ack_delay = 0
server_configuration = QuicConfiguration(is_client=False)
server_configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
server = QuicConnection(configuration=server_configuration)
server._ack_delay = 0
# client sends INITIAL
now = 0.0
client.connect(SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280])
self.assertEqual(client.get_timer(), 1.0)
# INITIAL is lost
now = 1.0
client.handle_timer(now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280])
self.assertEqual(client.get_timer(), 3.0)
# server receives INITIAL, sends INITIAL + HANDSHAKE
now = 1.1
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280, 1084])
self.assertEqual(server.get_timer(), 2.1)
self.assertEqual(len(server._loss.spaces[0].sent_packets), 1)
self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)</s>
|
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_initial_client_2
|
Modified
|
aiortc~aioquic
|
d023426fb38dfcbd694bbdb51a2b5d789b1ad2af
|
[packet builder] pad INITIAL packets instead of creating new ones
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_client_2(self):
<0> builder = create_builder(is_client=True)
<1> crypto = create_crypto()
<2>
<3> # INITIAL, full length
<4> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<5> self.assertEqual(builder.remaining_space, 1236)
<6> buf = builder.start_frame(QuicFrameType.CRYPTO)
<7> buf.push_bytes(bytes(builder.remaining_space))
<8> self.assertFalse(builder.packet_is_empty)
<9>
<10> # INITIAL
<11> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<12> self.assertEqual(builder.remaining_space, 1236)
<13> buf = builder.start_frame(QuicFrameType.CRYPTO)
<14> buf.push_bytes(bytes(100))
<15> self.assertFalse(builder.packet_is_empty)
<16>
<17> # INITIAL, empty
<18> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<19> self.assertTrue(builder.packet_is_empty)
<20>
<21> # check datagrams
<22> datagrams, packets = builder.flush()
<23> self.assertEqual(len(datagrams), 2)
<24> self.assertEqual(len(datagrams[0]), 1280)
<25> self.assertEqual(len(datagrams[1]), 1280)
<26> self.assertEqual(
<27> packets,
<28> [
<29> QuicSentPacket(
<30> epoch=Epoch.INITIAL,
<31> in_flight=True,
<32> is_ack_eliciting=True,
<33> is_crypto_packet=True,
<34> packet_number=0,
<35> packet_type=PACKET_TYPE_INITIAL,
<36> sent_bytes=1280,
<37> ),
<38> QuicSentPacket(
<39> epoch=Epoch.INITIAL,
<40> in_flight=True,
<41> is_ack_el</s>
|
===========below chunk 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_client_2(self):
# offset: 1
is_crypto_packet=True,
packet_number=1,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=145,
),
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=2,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=1135,
),
],
)
# check builder
self.assertEqual(builder.packet_number, 3)
===========unchanged ref 0===========
at: tests.test_packet_builder
create_builder(is_client=False)
create_crypto()
at: tests.test_packet_builder.QuicPacketBuilderTest.test_long_header_initial_client_2
builder = create_builder(is_client=True)
crypto = create_crypto()
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
+ def test_long_header_padding(self):
+ builder = create_builder(is_client=True)
+ crypto = create_crypto()
+
+ # INITIAL, fully padded
+ builder.start_packet(PACKET_TYPE_INITIAL, crypto)
+ self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(100))
+ self.assertFalse(builder.packet_is_empty)
+
+ # INITIAL, empty
+ builder.start_packet(PACKET_TYPE_INITIAL, crypto)
+ self.assertTrue(builder.packet_is_empty)
+
+ # check datagrams
+ datagrams, packets = builder.flush()
+ self.assertEqual(len(datagrams), 1)
+ self.assertEqual(len(datagrams[0]), 1280)
+ self.assertEqual(
+ packets,
+ [
+ QuicSentPacket(
+ epoch=Epoch.INITIAL,
+ in_flight=True,
+ is_ack_eliciting=True,
+ is_crypto_packet=True,
+ packet_number=0,
+ packet_type=PACKET_TYPE_INITIAL,
+ sent_bytes=1280,
+ )
+ ],
+ )
+
+ # check builder
+ self.assertEqual(builder.packet_number, 1)
+
===========changed ref 1===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
- def test_long_header_initial_client(self):
- builder = create_builder(is_client=True)
- crypto = create_crypto()
-
- # INITIAL
- builder.start_packet(PACKET_TYPE_INITIAL, crypto)
- self.assertEqual(builder.remaining_space, 1236)
- buf = builder.start_frame(QuicFrameType.CRYPTO)
- buf.push_bytes(bytes(100))
- self.assertFalse(builder.packet_is_empty)
-
- # INITIAL, empty
- builder.start_packet(PACKET_TYPE_INITIAL, crypto)
- self.assertTrue(builder.packet_is_empty)
-
- # check datagrams
- datagrams, packets = builder.flush()
- self.assertEqual(len(datagrams), 1)
- self.assertEqual(len(datagrams[0]), 1280)
- self.assertEqual(
- packets,
- [
- QuicSentPacket(
- epoch=Epoch.INITIAL,
- in_flight=True,
- is_ack_eliciting=True,
- is_crypto_packet=True,
- packet_number=0,
- packet_type=PACKET_TYPE_INITIAL,
- sent_bytes=145,
- ),
- QuicSentPacket(
- epoch=Epoch.INITIAL,
- in_flight=True,
- is_ack_eliciting=False,
- is_crypto_packet=False,
- packet_number=1,
- packet_type=PACKET_TYPE_INITIAL,
- sent_bytes=1135,
- ),
- ],
- )
-
- # check builder
- self.assertEqual(builder.packet_number, 2)
-
===========changed ref 2===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
"""
Returns the assembled datagrams.
"""
if self._packet is not None:
+ self._end_packet()
- self._end_packet(final=True)
self._flush_current_datagram()
datagrams = self._datagrams
packets = self._packets
self._datagrams = []
self._packets = []
return datagrams, packets
===========changed ref 3===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
is_client: bool,
packet_number: int = 0,
peer_token: bytes = b"",
quic_logger: Optional[QuicLoggerTrace] = None,
spin_bit: bool = False,
):
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
self.quic_logger_frames: Optional[List[Dict]] = None
self._host_cid = host_cid
self._is_client = is_client
self._peer_cid = peer_cid
self._peer_token = peer_token
self._quic_logger = quic_logger
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._datagrams: List[bytes] = []
self._datagram_flight_bytes = 0
self._datagram_init = True
- self._datagram_padding = False
self._packets: List[QuicSentPacket] = []
self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self._buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
|
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_initial_server
|
Modified
|
aiortc~aioquic
|
d023426fb38dfcbd694bbdb51a2b5d789b1ad2af
|
[packet builder] pad INITIAL packets instead of creating new ones
|
<0>:<add> builder = create_builder()
<del> builder = create_builder(is_client=False)
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_server(self):
<0> builder = create_builder(is_client=False)
<1> crypto = create_crypto()
<2>
<3> # INITIAL
<4> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<5> self.assertEqual(builder.remaining_space, 1236)
<6> buf = builder.start_frame(QuicFrameType.CRYPTO)
<7> buf.push_bytes(bytes(100))
<8> self.assertFalse(builder.packet_is_empty)
<9>
<10> # INITIAL, empty
<11> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<12> self.assertTrue(builder.packet_is_empty)
<13>
<14> # check datagrams
<15> datagrams, packets = builder.flush()
<16> self.assertEqual(len(datagrams), 1)
<17> self.assertEqual(len(datagrams[0]), 145)
<18> self.assertEqual(
<19> packets,
<20> [
<21> QuicSentPacket(
<22> epoch=Epoch.INITIAL,
<23> in_flight=True,
<24> is_ack_eliciting=True,
<25> is_crypto_packet=True,
<26> packet_number=0,
<27> packet_type=PACKET_TYPE_INITIAL,
<28> sent_bytes=145,
<29> )
<30> ],
<31> )
<32>
<33> # check builder
<34> self.assertEqual(builder.packet_number, 1)
<35>
|
===========unchanged ref 0===========
at: tests.test_packet_builder
create_builder(is_client=False)
create_crypto()
at: tests.test_packet_builder.QuicPacketBuilderTest.test_long_header_initial_server
builder = create_builder()
datagrams, packets = builder.flush()
datagrams, packets = builder.flush()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
+ def test_long_header_padding(self):
+ builder = create_builder(is_client=True)
+ crypto = create_crypto()
+
+ # INITIAL, fully padded
+ builder.start_packet(PACKET_TYPE_INITIAL, crypto)
+ self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(100))
+ self.assertFalse(builder.packet_is_empty)
+
+ # INITIAL, empty
+ builder.start_packet(PACKET_TYPE_INITIAL, crypto)
+ self.assertTrue(builder.packet_is_empty)
+
+ # check datagrams
+ datagrams, packets = builder.flush()
+ self.assertEqual(len(datagrams), 1)
+ self.assertEqual(len(datagrams[0]), 1280)
+ self.assertEqual(
+ packets,
+ [
+ QuicSentPacket(
+ epoch=Epoch.INITIAL,
+ in_flight=True,
+ is_ack_eliciting=True,
+ is_crypto_packet=True,
+ packet_number=0,
+ packet_type=PACKET_TYPE_INITIAL,
+ sent_bytes=1280,
+ )
+ ],
+ )
+
+ # check builder
+ self.assertEqual(builder.packet_number, 1)
+
===========changed ref 1===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
- def test_long_header_initial_client(self):
- builder = create_builder(is_client=True)
- crypto = create_crypto()
-
- # INITIAL
- builder.start_packet(PACKET_TYPE_INITIAL, crypto)
- self.assertEqual(builder.remaining_space, 1236)
- buf = builder.start_frame(QuicFrameType.CRYPTO)
- buf.push_bytes(bytes(100))
- self.assertFalse(builder.packet_is_empty)
-
- # INITIAL, empty
- builder.start_packet(PACKET_TYPE_INITIAL, crypto)
- self.assertTrue(builder.packet_is_empty)
-
- # check datagrams
- datagrams, packets = builder.flush()
- self.assertEqual(len(datagrams), 1)
- self.assertEqual(len(datagrams[0]), 1280)
- self.assertEqual(
- packets,
- [
- QuicSentPacket(
- epoch=Epoch.INITIAL,
- in_flight=True,
- is_ack_eliciting=True,
- is_crypto_packet=True,
- packet_number=0,
- packet_type=PACKET_TYPE_INITIAL,
- sent_bytes=145,
- ),
- QuicSentPacket(
- epoch=Epoch.INITIAL,
- in_flight=True,
- is_ack_eliciting=False,
- is_crypto_packet=False,
- packet_number=1,
- packet_type=PACKET_TYPE_INITIAL,
- sent_bytes=1135,
- ),
- ],
- )
-
- # check builder
- self.assertEqual(builder.packet_number, 2)
-
===========changed ref 2===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_client_2(self):
builder = create_builder(is_client=True)
crypto = create_crypto()
# INITIAL, full length
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
buf = builder.start_frame(QuicFrameType.CRYPTO)
buf.push_bytes(bytes(builder.remaining_space))
self.assertFalse(builder.packet_is_empty)
# INITIAL
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
buf = builder.start_frame(QuicFrameType.CRYPTO)
buf.push_bytes(bytes(100))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 2)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(len(datagrams[1]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=1280,
),
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=1,
packet_type=PACKET_TYPE_INITIAL,
+ sent_</s>
===========changed ref 3===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_client_2(self):
# offset: 1
<s>packet=True,
packet_number=1,
packet_type=PACKET_TYPE_INITIAL,
+ sent_bytes=1280,
- sent_bytes=145,
- ),
- QuicSentPacket(
- epoch=Epoch.INITIAL,
- in_flight=True,
- is_ack_eliciting=False,
- is_crypto_packet=False,
- packet_number=2,
- packet_type=PACKET_TYPE_INITIAL,
- sent_bytes=1135,
),
],
)
# check builder
+ self.assertEqual(builder.packet_number, 2)
- self.assertEqual(builder.packet_number, 3)
===========changed ref 4===========
# module: aioquic.quic.packet_builder
class QuicPacketBuilder:
def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
"""
Returns the assembled datagrams.
"""
if self._packet is not None:
+ self._end_packet()
- self._end_packet(final=True)
self._flush_current_datagram()
datagrams = self._datagrams
packets = self._packets
self._datagrams = []
self._packets = []
return datagrams, packets
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_then_long_header
|
Modified
|
aiortc~aioquic
|
d023426fb38dfcbd694bbdb51a2b5d789b1ad2af
|
[packet builder] pad INITIAL packets instead of creating new ones
|
<27>:<add> self.assertEqual(len(datagrams[0]), 914)
<del> self.assertEqual(len(datagrams[0]), 1280)
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_long_header(self):
<0> builder = create_builder()
<1> crypto = create_crypto()
<2>
<3> # INITIAL
<4> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<5> self.assertEqual(builder.remaining_space, 1236)
<6> buf = builder.start_frame(QuicFrameType.CRYPTO)
<7> buf.push_bytes(bytes(199))
<8> self.assertFalse(builder.packet_is_empty)
<9>
<10> # HANDSHAKE
<11> builder.start_packet(PACKET_TYPE_HANDSHAKE, crypto)
<12> self.assertEqual(builder.remaining_space, 993)
<13> buf = builder.start_frame(QuicFrameType.CRYPTO)
<14> buf.push_bytes(bytes(299))
<15> self.assertFalse(builder.packet_is_empty)
<16>
<17> # ONE_RTT
<18> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<19> self.assertEqual(builder.remaining_space, 666)
<20> buf = builder.start_frame(QuicFrameType.CRYPTO)
<21> buf.push_bytes(bytes(299))
<22> self.assertFalse(builder.packet_is_empty)
<23>
<24> # check datagrams
<25> datagrams, packets = builder.flush()
<26> self.assertEqual(len(datagrams), 1)
<27> self.assertEqual(len(datagrams[0]), 1280)
<28> self.assertEqual(
<29> packets,
<30> [
<31> QuicSentPacket(
<32> epoch=Epoch.INITIAL,
<33> in_flight=True,
<34> is_ack_eliciting=True,
<35> is_crypto_packet=True,
<36> packet_number=0,
<37> packet_type=PACKET_TYPE_INITIAL,
<38> sent_bytes=244,
<39> ),
<40> QuicSentPacket(</s>
|
===========below chunk 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_long_header(self):
# offset: 1
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=1,
packet_type=PACKET_TYPE_HANDSHAKE,
sent_bytes=343,
),
QuicSentPacket(
epoch=Epoch.ONE_RTT,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=2,
packet_type=PACKET_TYPE_ONE_RTT,
sent_bytes=693,
),
],
)
# check builder
self.assertEqual(builder.packet_number, 3)
===========unchanged ref 0===========
at: tests.test_packet_builder
create_builder(is_client=False)
create_crypto()
at: tests.test_packet_builder.QuicPacketBuilderTest.test_long_header_then_long_header
builder = create_builder()
crypto = create_crypto()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_initial_server(self):
+ builder = create_builder()
- builder = create_builder(is_client=False)
crypto = create_crypto()
# INITIAL
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1236)
buf = builder.start_frame(QuicFrameType.CRYPTO)
buf.push_bytes(bytes(100))
self.assertFalse(builder.packet_is_empty)
# INITIAL, empty
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertTrue(builder.packet_is_empty)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 145)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
packet_type=PACKET_TYPE_INITIAL,
sent_bytes=145,
)
],
)
# check builder
self.assertEqual(builder.packet_number, 1)
===========changed ref 1===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
+ def test_long_header_padding(self):
+ builder = create_builder(is_client=True)
+ crypto = create_crypto()
+
+ # INITIAL, fully padded
+ builder.start_packet(PACKET_TYPE_INITIAL, crypto)
+ self.assertEqual(builder.remaining_space, 1236)
+ buf = builder.start_frame(QuicFrameType.CRYPTO)
+ buf.push_bytes(bytes(100))
+ self.assertFalse(builder.packet_is_empty)
+
+ # INITIAL, empty
+ builder.start_packet(PACKET_TYPE_INITIAL, crypto)
+ self.assertTrue(builder.packet_is_empty)
+
+ # check datagrams
+ datagrams, packets = builder.flush()
+ self.assertEqual(len(datagrams), 1)
+ self.assertEqual(len(datagrams[0]), 1280)
+ self.assertEqual(
+ packets,
+ [
+ QuicSentPacket(
+ epoch=Epoch.INITIAL,
+ in_flight=True,
+ is_ack_eliciting=True,
+ is_crypto_packet=True,
+ packet_number=0,
+ packet_type=PACKET_TYPE_INITIAL,
+ sent_bytes=1280,
+ )
+ ],
+ )
+
+ # check builder
+ self.assertEqual(builder.packet_number, 1)
+
===========changed ref 2===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
- def test_long_header_initial_client(self):
- builder = create_builder(is_client=True)
- crypto = create_crypto()
-
- # INITIAL
- builder.start_packet(PACKET_TYPE_INITIAL, crypto)
- self.assertEqual(builder.remaining_space, 1236)
- buf = builder.start_frame(QuicFrameType.CRYPTO)
- buf.push_bytes(bytes(100))
- self.assertFalse(builder.packet_is_empty)
-
- # INITIAL, empty
- builder.start_packet(PACKET_TYPE_INITIAL, crypto)
- self.assertTrue(builder.packet_is_empty)
-
- # check datagrams
- datagrams, packets = builder.flush()
- self.assertEqual(len(datagrams), 1)
- self.assertEqual(len(datagrams[0]), 1280)
- self.assertEqual(
- packets,
- [
- QuicSentPacket(
- epoch=Epoch.INITIAL,
- in_flight=True,
- is_ack_eliciting=True,
- is_crypto_packet=True,
- packet_number=0,
- packet_type=PACKET_TYPE_INITIAL,
- sent_bytes=145,
- ),
- QuicSentPacket(
- epoch=Epoch.INITIAL,
- in_flight=True,
- is_ack_eliciting=False,
- is_crypto_packet=False,
- packet_number=1,
- packet_type=PACKET_TYPE_INITIAL,
- sent_bytes=1135,
- ),
- ],
- )
-
- # check builder
- self.assertEqual(builder.packet_number, 2)
-
|
tests.test_asyncio/HighLevelTest.test_connect_and_serve_with_packet_loss
|
Modified
|
aiortc~aioquic
|
f60aa2d6b13fefb84b19bfa1a7365bf621f51e5b
|
[tests] disable stateless retry for packet loss test case
|
<10>:<add> run(self.run_server(configuration=server_configuration))
<del> run(self.run_server(configuration=server_configuration, stateless_retry=True))
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
@patch("socket.socket.sendto", new_callable=lambda: sendto_with_loss)
def test_connect_and_serve_with_packet_loss(self, mock_sendto):
<0> """
<1> This test ensures handshake success and stream data is successfully sent
<2> and received in the presence of packet loss (randomized 25% in each direction).
<3> """
<4> data = b"Z" * 65536
<5>
<6> server_configuration = QuicConfiguration(
<7> idle_timeout=300.0, is_client=False, quic_logger=QuicLogger()
<8> )
<9> server_configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
<10> run(self.run_server(configuration=server_configuration, stateless_retry=True))
<11>
<12> response = run(
<13> self.run_client(
<14> "127.0.0.1",
<15> configuration=QuicConfiguration(
<16> is_client=True, idle_timeout=300.0, quic_logger=QuicLogger()
<17> ),
<18> request=data,
<19> )
<20> )
<21> self.assertEqual(response, data)
<22>
|
===========unchanged ref 0===========
at: tests.test_asyncio
sendto_with_loss(self, data, addr=None)
at: tests.test_asyncio.HighLevelTest
run_client(host, port=4433, cadata=None, cafile=SERVER_CACERTFILE, configuration=None, request=b"ping", **kwargs)
run_server(configuration=None, **kwargs)
at: tests.utils
run(coro)
SERVER_CERTFILE = os.path.join(os.path.dirname(__file__), "ssl_cert.pem")
SERVER_KEYFILE = os.path.join(os.path.dirname(__file__), "ssl_key.pem")
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
at: unittest.mock
_patcher(target: Any, new: _T, spec: Optional[Any]=..., create: bool=..., spec_set: Optional[Any]=..., autospec: Optional[Any]=..., new_callable: Optional[Any]=..., **kwargs: Any) -> _patch[_T]
_patcher(target: Any, *, spec: Optional[Any]=..., create: bool=..., spec_set: Optional[Any]=..., autospec: Optional[Any]=..., new_callable: Optional[Any]=..., **kwargs: Any) -> _patch[Union[MagicMock, AsyncMock]]
|
tests.test_connection/QuicConnectionTest.test_connect_with_loss_1
|
Modified
|
aiortc~aioquic
|
8bae99972ca6ddba5e6fdbf9c8350a7de3a76436
|
[recovery] send PING for probe in HANDSHAKE
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_1(self):
<0> """
<1> Check connection is established even in the client's INITIAL is lost.
<2> """
<3>
<4> def datagram_sizes(items):
<5> return [len(x[0]) for x in items]
<6>
<7> client_configuration = QuicConfiguration(is_client=True)
<8> client_configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
<9>
<10> client = QuicConnection(configuration=client_configuration)
<11> client._ack_delay = 0
<12>
<13> server_configuration = QuicConfiguration(is_client=False)
<14> server_configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
<15>
<16> server = QuicConnection(configuration=server_configuration)
<17> server._ack_delay = 0
<18>
<19> # client sends INITIAL
<20> now = 0.0
<21> client.connect(SERVER_ADDR, now=now)
<22> items = client.datagrams_to_send(now=now)
<23> self.assertEqual(datagram_sizes(items), [1280])
<24> self.assertEqual(client.get_timer(), 1.0)
<25>
<26> # INITIAL is lost
<27> now = 1.0
<28> client.handle_timer(now=now)
<29> items = client.datagrams_to_send(now=now)
<30> self.assertEqual(datagram_sizes(items), [1280])
<31> self.assertEqual(client.get_timer(), 3.0)
<32>
<33> # server receives INITIAL, sends INITIAL + HANDSHAKE
<34> now = 1.1
<35> server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
<36> items = server.datagrams_to_send(now=now)
<37> self.assertEqual(datagram_sizes(items), [1280, 1084])
<38> self.assertEqual(server.get_timer(), 2.1)
<39> self.assertEqual</s>
|
===========below chunk 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_1(self):
# offset: 1
self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)
# handshake continues normally
now = 1.2
client.receive_datagram(items[0][0], SERVER_ADDR, now=now)
client.receive_datagram(items[1][0], SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280, 1280, 223])
self.assertAlmostEqual(client.get_timer(), 1.825)
now = 1.3
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
server.receive_datagram(items[1][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [271])
self.assertAlmostEqual(server.get_timer(), 1.825)
self.assertEqual(len(server._loss.spaces[0].sent_packets), 0)
self.assertEqual(len(server._loss.spaces[1].sent_packets), 1)
now = 1.4
client.receive_datagram(items[0][0], SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [32])
self.assertAlmostEqual(client.get_timer(), 1.725)
self.assertEqual(type(client.next_event()), events.ProtocolNegotiated)
self.assertEqual(type(client.next_event()), events.HandshakeCompleted)
now = 1.5
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_</s>
===========below chunk 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_1(self):
# offset: 2
<s>_datagram(items[0][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [])
self.assertAlmostEqual(server.get_timer(), 61.5) # idle timeout
self.assertEqual(type(server.next_event()), events.ProtocolNegotiated)
self.assertEqual(type(server.next_event()), events.HandshakeCompleted)
===========unchanged ref 0===========
at: tests.test_connection
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
at: tests.utils
SERVER_CACERTFILE = os.path.join(os.path.dirname(__file__), "pycacert.pem")
SERVER_CERTFILE = os.path.join(os.path.dirname(__file__), "ssl_cert.pem")
SERVER_KEYFILE = os.path.join(os.path.dirname(__file__), "ssl_key.pem")
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertAlmostEqual(first: float, second: float, places: Optional[int]=..., msg: Any=..., delta: Optional[float]=...) -> None
assertAlmostEqual(first: datetime.datetime, second: datetime.datetime, places: Optional[int]=..., msg: Any=..., delta: Optional[datetime.timedelta]=...) -> None
|
|
tests.test_connection/QuicConnectionTest.test_connect_with_loss_2
|
Modified
|
aiortc~aioquic
|
8bae99972ca6ddba5e6fdbf9c8350a7de3a76436
|
[recovery] send PING for probe in HANDSHAKE
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_2(self):
<0> def datagram_sizes(items):
<1> return [len(x[0]) for x in items]
<2>
<3> client_configuration = QuicConfiguration(is_client=True)
<4> client_configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
<5>
<6> client = QuicConnection(configuration=client_configuration)
<7> client._ack_delay = 0
<8>
<9> server_configuration = QuicConfiguration(is_client=False)
<10> server_configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
<11>
<12> server = QuicConnection(configuration=server_configuration)
<13> server._ack_delay = 0
<14>
<15> # client sends INITIAL
<16> now = 0.0
<17> client.connect(SERVER_ADDR, now=now)
<18> items = client.datagrams_to_send(now=now)
<19> self.assertEqual(datagram_sizes(items), [1280])
<20> self.assertEqual(client.get_timer(), 1.0)
<21>
<22> # server receives INITIAL, sends INITIAL + HANDSHAKE but second datagram is lost
<23> now = 0.1
<24> server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
<25> items = server.datagrams_to_send(now=now)
<26> self.assertEqual(datagram_sizes(items), [1280, 1084])
<27> self.assertEqual(server.get_timer(), 1.1)
<28> self.assertEqual(len(server._loss.spaces[0].sent_packets), 1)
<29> self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)
<30>
<31> # client only receives first datagram and sends ACKS
<32> now = 0.2
<33> client.receive_datagram(items[0][0], SERVER_ADDR, now=now)
<34> items = client.datagrams_to_send</s>
|
===========below chunk 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_2(self):
# offset: 1
self.assertEqual(datagram_sizes(items), [1280, 48])
self.assertAlmostEqual(client.get_timer(), 0.625)
# client PTO - padded HANDSHAKE
now = client.get_timer() # ~0.625
client.handle_timer(now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280])
self.assertAlmostEqual(client.get_timer(), 1.25)
# server receives padding, discards INITIAL
now = 0.725
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [])
self.assertAlmostEqual(server.get_timer(), 1.1)
self.assertEqual(len(server._loss.spaces[0].sent_packets), 0)
self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)
# ACKs are lost, server retransmits HANDSHAKE
now = server.get_timer()
server.handle_timer(now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280, 905])
self.assertAlmostEqual(server.get_timer(), 3.1)
self.assertEqual(len(server._loss.spaces[0].sent_packets), 0)
self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)
# handshake continues normally
now = 1.2
client.receive_datagram(items[0][0], SERVER_ADDR, now=now)
client.receive_datagram(items[1][0</s>
===========below chunk 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_2(self):
# offset: 2
<s>agram(items[0][0], SERVER_ADDR, now=now)
client.receive_datagram(items[1][0], SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [334])
self.assertAlmostEqual(client.get_timer(), 2.45)
self.assertEqual(type(client.next_event()), events.ProtocolNegotiated)
self.assertEqual(type(client.next_event()), events.HandshakeCompleted)
now = 1.3
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [228])
self.assertAlmostEqual(server.get_timer(), 1.825)
self.assertEqual(type(server.next_event()), events.ProtocolNegotiated)
self.assertEqual(type(server.next_event()), events.HandshakeCompleted)
now = 1.4
client.receive_datagram(items[0][0], SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [32])
self.assertAlmostEqual(client.get_timer(), 61.4) # idle timeout
===========unchanged ref 0===========
at: tests.test_connection
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
at: tests.utils
SERVER_CACERTFILE = os.path.join(os.path.dirname(__file__), "pycacert.pem")
SERVER_CERTFILE = os.path.join(os.path.dirname(__file__), "ssl_cert.pem")
SERVER_KEYFILE = os.path.join(os.path.dirname(__file__), "ssl_key.pem")
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertAlmostEqual(first: float, second: float, places: Optional[int]=..., msg: Any=..., delta: Optional[float]=...) -> None
assertAlmostEqual(first: datetime.datetime, second: datetime.datetime, places: Optional[int]=..., msg: Any=..., delta: Optional[datetime.timedelta]=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_1(self):
"""
Check connection is established even in the client's INITIAL is lost.
"""
def datagram_sizes(items):
return [len(x[0]) for x in items]
client_configuration = QuicConfiguration(is_client=True)
client_configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
client = QuicConnection(configuration=client_configuration)
client._ack_delay = 0
server_configuration = QuicConfiguration(is_client=False)
server_configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
server = QuicConnection(configuration=server_configuration)
server._ack_delay = 0
# client sends INITIAL
now = 0.0
client.connect(SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280])
self.assertEqual(client.get_timer(), 1.0)
# INITIAL is lost
now = 1.0
client.handle_timer(now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280])
self.assertEqual(client.get_timer(), 3.0)
# server receives INITIAL, sends INITIAL + HANDSHAKE
now = 1.1
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280, 1084])
self.assertEqual(server.get_timer(), 2.1)
self.assertEqual(len(server._loss.spaces[0].sent_packets), 1)
self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)</s>
|
|
aioquic.quic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
8bae99972ca6ddba5e6fdbf9c8350a7de3a76436
|
[recovery] send PING for probe in HANDSHAKE
|
<20>:<add> if self._write_crypto_frame(
<del> self._write_crypto_frame(
<22>:<add> ):
<add> self._probe_pending = False
<add>
<add> # PING (probe)
<add> if self._probe_pending and epoch == tls.Epoch.HANDSHAKE:
<add> self._logger.info(
<add> "Sending PING (probe) in packet %d", builder.packet_number
<23>:<del>
<24>:<del> # PADDING (anti-deadlock packet)
<25>:<del> if self._probe_pending and self._is_client and epoch == tls.Epoch.HANDSHAKE:
<26>:<del> buf = builder.start_frame(QuicFrameType.PADDING)
<27>:<del> buf.push_bytes(bytes(builder.remaining_space))
<28>:<add> self._write_ping_frame(builder)
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
<0> crypto = self._cryptos[epoch]
<1> if not crypto.send.is_valid():
<2> return
<3>
<4> crypto_stream = self._crypto_streams[epoch]
<5> space = self._spaces[epoch]
<6>
<7> while True:
<8> if epoch == tls.Epoch.INITIAL:
<9> packet_type = PACKET_TYPE_INITIAL
<10> else:
<11> packet_type = PACKET_TYPE_HANDSHAKE
<12> builder.start_packet(packet_type, crypto)
<13>
<14> # ACK
<15> if space.ack_at is not None:
<16> self._write_ack_frame(builder=builder, space=space)
<17>
<18> # CRYPTO
<19> if not crypto_stream.send_buffer_is_empty:
<20> self._write_crypto_frame(
<21> builder=builder, space=space, stream=crypto_stream
<22> )
<23>
<24> # PADDING (anti-deadlock packet)
<25> if self._probe_pending and self._is_client and epoch == tls.Epoch.HANDSHAKE:
<26> buf = builder.start_frame(QuicFrameType.PADDING)
<27> buf.push_bytes(bytes(builder.remaining_space))
<28> self._probe_pending = False
<29>
<30> if builder.packet_is_empty:
<31> break
<32>
|
===========unchanged ref 0===========
at: aioquic.quic.connection.QuicConnection
_write_ack_frame(builder: QuicPacketBuilder, space: QuicPacketSpace)
_write_crypto_frame(self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> bool
_write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> bool
_write_ping_frame(builder: QuicPacketBuilder, uids: List[int]=[])
at: aioquic.quic.connection.QuicConnection.__init__
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
self._spaces: Dict[tls.Epoch, QuicPacketSpace] = {}
self._logger = QuicConnectionAdapter(
logger, {"id": dump_cid(logger_connection_id)}
)
self._probe_pending = False
at: aioquic.quic.connection.QuicConnection._initialize
self._cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self._crypto_streams = {
tls.Epoch.INITIAL: QuicStream(),
tls.Epoch.HANDSHAKE: QuicStream(),
tls.Epoch.ONE_RTT: QuicStream(),
}
self._spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.quic.connection.QuicConnection._send_probe
self._probe_pending = True
at: aioquic.quic.connection.QuicConnection._write_application
self._probe_pending = False
at: logging.LoggerAdapter
logger: Logger
===========unchanged ref 1===========
extra: Mapping[str, Any]
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_1(self):
"""
Check connection is established even in the client's INITIAL is lost.
"""
def datagram_sizes(items):
return [len(x[0]) for x in items]
client_configuration = QuicConfiguration(is_client=True)
client_configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
client = QuicConnection(configuration=client_configuration)
client._ack_delay = 0
server_configuration = QuicConfiguration(is_client=False)
server_configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
server = QuicConnection(configuration=server_configuration)
server._ack_delay = 0
# client sends INITIAL
now = 0.0
client.connect(SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280])
self.assertEqual(client.get_timer(), 1.0)
# INITIAL is lost
now = 1.0
client.handle_timer(now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280])
self.assertEqual(client.get_timer(), 3.0)
# server receives INITIAL, sends INITIAL + HANDSHAKE
now = 1.1
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280, 1084])
self.assertEqual(server.get_timer(), 2.1)
self.assertEqual(len(server._loss.spaces[0].sent_packets), 1)
self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)</s>
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_1(self):
# offset: 1
<s>].sent_packets), 1)
self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)
# handshake continues normally
now = 1.2
client.receive_datagram(items[0][0], SERVER_ADDR, now=now)
client.receive_datagram(items[1][0], SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
+ self.assertEqual(datagram_sizes(items), [1280, 327])
- self.assertEqual(datagram_sizes(items), [1280, 1280, 223])
self.assertAlmostEqual(client.get_timer(), 1.825)
now = 1.3
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
server.receive_datagram(items[1][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
+ self.assertEqual(datagram_sizes(items), [276])
- self.assertEqual(datagram_sizes(items), [271])
self.assertAlmostEqual(server.get_timer(), 1.825)
self.assertEqual(len(server._loss.spaces[0].sent_packets), 0)
self.assertEqual(len(server._loss.spaces[1].sent_packets), 1)
now = 1.4
client.receive_datagram(items[0][0], SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [32])
+ self.assertAlmostEqual(client.get_timer(), 61.4) #</s>
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_1(self):
# offset: 2
<s>
- self.assertAlmostEqual(client.get_timer(), 1.725)
self.assertEqual(type(client.next_event()), events.ProtocolNegotiated)
self.assertEqual(type(client.next_event()), events.HandshakeCompleted)
now = 1.5
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [])
self.assertAlmostEqual(server.get_timer(), 61.5) # idle timeout
self.assertEqual(type(server.next_event()), events.ProtocolNegotiated)
self.assertEqual(type(server.next_event()), events.HandshakeCompleted)
|
aioquic.quic.connection/QuicConnection._write_crypto_frame
|
Modified
|
aiortc~aioquic
|
8bae99972ca6ddba5e6fdbf9c8350a7de3a76436
|
[recovery] send PING for probe in HANDSHAKE
|
<17>:<add> return True
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_crypto_frame(
self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
+ ) -> bool:
- ) -> None:
<0> frame_overhead = 3 + size_uint_var(stream.next_send_offset)
<1> frame = stream.get_frame(builder.remaining_space - frame_overhead)
<2> if frame is not None:
<3> buf = builder.start_frame(
<4> QuicFrameType.CRYPTO,
<5> stream.on_data_delivery,
<6> (frame.offset, frame.offset + len(frame.data)),
<7> )
<8> buf.push_uint_var(frame.offset)
<9> buf.push_uint16(len(frame.data) | 0x4000)
<10> buf.push_bytes(frame.data)
<11>
<12> # log frame
<13> if self._quic_logger is not None:
<14> builder.quic_logger_frames.append(
<15> self._quic_logger.encode_crypto_frame(frame)
<16> )
<17>
|
===========unchanged ref 0===========
at: aioquic.quic.connection.QuicConnection.__init__
self._local_max_data = MAX_DATA_WINDOW
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
at: aioquic.quic.connection.QuicConnection._write_connection_limits
self._local_max_data *= 2
===========changed ref 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
crypto = self._cryptos[epoch]
if not crypto.send.is_valid():
return
crypto_stream = self._crypto_streams[epoch]
space = self._spaces[epoch]
while True:
if epoch == tls.Epoch.INITIAL:
packet_type = PACKET_TYPE_INITIAL
else:
packet_type = PACKET_TYPE_HANDSHAKE
builder.start_packet(packet_type, crypto)
# ACK
if space.ack_at is not None:
self._write_ack_frame(builder=builder, space=space)
# CRYPTO
if not crypto_stream.send_buffer_is_empty:
+ if self._write_crypto_frame(
- self._write_crypto_frame(
builder=builder, space=space, stream=crypto_stream
+ ):
+ self._probe_pending = False
+
+ # PING (probe)
+ if self._probe_pending and epoch == tls.Epoch.HANDSHAKE:
+ self._logger.info(
+ "Sending PING (probe) in packet %d", builder.packet_number
)
-
- # PADDING (anti-deadlock packet)
- if self._probe_pending and self._is_client and epoch == tls.Epoch.HANDSHAKE:
- buf = builder.start_frame(QuicFrameType.PADDING)
- buf.push_bytes(bytes(builder.remaining_space))
+ self._write_ping_frame(builder)
self._probe_pending = False
if builder.packet_is_empty:
break
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_1(self):
"""
Check connection is established even in the client's INITIAL is lost.
"""
def datagram_sizes(items):
return [len(x[0]) for x in items]
client_configuration = QuicConfiguration(is_client=True)
client_configuration.load_verify_locations(cafile=SERVER_CACERTFILE)
client = QuicConnection(configuration=client_configuration)
client._ack_delay = 0
server_configuration = QuicConfiguration(is_client=False)
server_configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
server = QuicConnection(configuration=server_configuration)
server._ack_delay = 0
# client sends INITIAL
now = 0.0
client.connect(SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280])
self.assertEqual(client.get_timer(), 1.0)
# INITIAL is lost
now = 1.0
client.handle_timer(now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280])
self.assertEqual(client.get_timer(), 3.0)
# server receives INITIAL, sends INITIAL + HANDSHAKE
now = 1.1
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [1280, 1084])
self.assertEqual(server.get_timer(), 2.1)
self.assertEqual(len(server._loss.spaces[0].sent_packets), 1)
self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)</s>
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_1(self):
# offset: 1
<s>].sent_packets), 1)
self.assertEqual(len(server._loss.spaces[1].sent_packets), 2)
# handshake continues normally
now = 1.2
client.receive_datagram(items[0][0], SERVER_ADDR, now=now)
client.receive_datagram(items[1][0], SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
+ self.assertEqual(datagram_sizes(items), [1280, 327])
- self.assertEqual(datagram_sizes(items), [1280, 1280, 223])
self.assertAlmostEqual(client.get_timer(), 1.825)
now = 1.3
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
server.receive_datagram(items[1][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
+ self.assertEqual(datagram_sizes(items), [276])
- self.assertEqual(datagram_sizes(items), [271])
self.assertAlmostEqual(server.get_timer(), 1.825)
self.assertEqual(len(server._loss.spaces[0].sent_packets), 0)
self.assertEqual(len(server._loss.spaces[1].sent_packets), 1)
now = 1.4
client.receive_datagram(items[0][0], SERVER_ADDR, now=now)
items = client.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [32])
+ self.assertAlmostEqual(client.get_timer(), 61.4) #</s>
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_loss_1(self):
# offset: 2
<s>
- self.assertAlmostEqual(client.get_timer(), 1.725)
self.assertEqual(type(client.next_event()), events.ProtocolNegotiated)
self.assertEqual(type(client.next_event()), events.HandshakeCompleted)
now = 1.5
server.receive_datagram(items[0][0], CLIENT_ADDR, now=now)
items = server.datagrams_to_send(now=now)
self.assertEqual(datagram_sizes(items), [])
self.assertAlmostEqual(server.get_timer(), 61.5) # idle timeout
self.assertEqual(type(server.next_event()), events.ProtocolNegotiated)
self.assertEqual(type(server.next_event()), events.HandshakeCompleted)
|
aioquic.quic.connection/QuicConnection._get_or_create_stream
|
Modified
|
aiortc~aioquic
|
25719c59916bd85bae4292dd4d1e6959e0c832da
|
[connection] rework some log messages
|
<32>:<add> self._logger.debug("Stream %d created by peer" % stream_id)
<del> self._logger.info("Stream %d created by peer" % stream_id)
|
# module: aioquic.quic.connection
class QuicConnection:
def _get_or_create_stream(self, frame_type: int, stream_id: int) -> QuicStream:
<0> """
<1> Get or create a stream in response to a received frame.
<2> """
<3> stream = self._streams.get(stream_id, None)
<4> if stream is None:
<5> # check initiator
<6> if stream_is_client_initiated(stream_id) == self._is_client:
<7> raise QuicConnectionError(
<8> error_code=QuicErrorCode.STREAM_STATE_ERROR,
<9> frame_type=frame_type,
<10> reason_phrase="Wrong stream initiator",
<11> )
<12>
<13> # determine limits
<14> if stream_is_unidirectional(stream_id):
<15> max_stream_data_local = self._local_max_stream_data_uni
<16> max_stream_data_remote = 0
<17> max_streams = self._local_max_streams_uni
<18> else:
<19> max_stream_data_local = self._local_max_stream_data_bidi_remote
<20> max_stream_data_remote = self._remote_max_stream_data_bidi_local
<21> max_streams = self._local_max_streams_bidi
<22>
<23> # check max streams
<24> if stream_id // 4 >= max_streams:
<25> raise QuicConnectionError(
<26> error_code=QuicErrorCode.STREAM_LIMIT_ERROR,
<27> frame_type=frame_type,
<28> reason_phrase="Too many streams open",
<29> )
<30>
<31> # create stream
<32> self._logger.info("Stream %d created by peer" % stream_id)
<33> stream = self._streams[stream_id] = QuicStream(
<34> stream_id=stream_id,
<35> max_stream_data_local=max_stream_data_local,
<36> max_stream_data_remote=max_stream_data_remote,
<37> )
<38> return stream
<39>
|
===========unchanged ref 0===========
at: aioquic.quic.connection
stream_is_client_initiated(stream_id: int) -> bool
stream_is_unidirectional(stream_id: int) -> bool
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
at: aioquic.quic.connection.QuicConnection.__init__
self._is_client = configuration.is_client
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._remote_max_stream_data_bidi_local = 0
self._streams: Dict[int, QuicStream] = {}
self._logger = QuicConnectionAdapter(
logger, {"id": dump_cid(logger_connection_id)}
)
at: logging.LoggerAdapter
logger: Logger
extra: Mapping[str, Any]
debug(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
at: typing.Mapping
get(key: _KT, default: Union[_VT_co, _T]) -> Union[_VT_co, _T]
get(key: _KT) -> Optional[_VT_co]
|
aioquic.quic.connection/QuicConnection._on_ping_delivery
|
Modified
|
aiortc~aioquic
|
25719c59916bd85bae4292dd4d1e6959e0c832da
|
[connection] rework some log messages
|
<4>:<add> self._logger.debug("Received PING%s response", "" if uids else " (probe)")
<del> self._logger.info("Received PING response")
|
# module: aioquic.quic.connection
class QuicConnection:
def _on_ping_delivery(
self, delivery: QuicDeliveryState, uids: Sequence[int]
) -> None:
<0> """
<1> Callback when a PING frame is acknowledged or lost.
<2> """
<3> if delivery == QuicDeliveryState.ACKED:
<4> self._logger.info("Received PING response")
<5> for uid in uids:
<6> self._events.append(events.PingAcknowledged(uid=uid))
<7> else:
<8> self._ping_pending.extend(uids)
<9>
|
===========unchanged ref 0===========
at: aioquic.quic.connection.QuicConnection.__init__
self._events: Deque[events.QuicEvent] = deque()
self._logger = QuicConnectionAdapter(
logger, {"id": dump_cid(logger_connection_id)}
)
self._ping_pending: List[int] = []
at: collections.deque
append(x: _T) -> None
at: logging.LoggerAdapter
debug(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
at: typing
Sequence = _alias(collections.abc.Sequence, 1)
===========changed ref 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _get_or_create_stream(self, frame_type: int, stream_id: int) -> QuicStream:
"""
Get or create a stream in response to a received frame.
"""
stream = self._streams.get(stream_id, None)
if stream is None:
# check initiator
if stream_is_client_initiated(stream_id) == self._is_client:
raise QuicConnectionError(
error_code=QuicErrorCode.STREAM_STATE_ERROR,
frame_type=frame_type,
reason_phrase="Wrong stream initiator",
)
# determine limits
if stream_is_unidirectional(stream_id):
max_stream_data_local = self._local_max_stream_data_uni
max_stream_data_remote = 0
max_streams = self._local_max_streams_uni
else:
max_stream_data_local = self._local_max_stream_data_bidi_remote
max_stream_data_remote = self._remote_max_stream_data_bidi_local
max_streams = self._local_max_streams_bidi
# check max streams
if stream_id // 4 >= max_streams:
raise QuicConnectionError(
error_code=QuicErrorCode.STREAM_LIMIT_ERROR,
frame_type=frame_type,
reason_phrase="Too many streams open",
)
# create stream
+ self._logger.debug("Stream %d created by peer" % stream_id)
- self._logger.info("Stream %d created by peer" % stream_id)
stream = self._streams[stream_id] = QuicStream(
stream_id=stream_id,
max_stream_data_local=max_stream_data_local,
max_stream_data_remote=max_stream_data_remote,
)
return stream
|
aioquic.quic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
25719c59916bd85bae4292dd4d1e6959e0c832da
|
[connection] rework some log messages
|
<26>:<del> self._logger.debug(
<27>:<del> "Network path %s sending challenge", network_path.addr
<28>:<del> )
<29>:<add> challenge = os.urandom(8)
<del> network_path.local_challenge = os.urandom(8)
<31>:<add> buf.push_bytes(challenge)
<del> buf.push_bytes(network_path.local_challenge)
<32>:<add> network_path.local_challenge = challenge
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
<0> crypto_stream: Optional[QuicStream] = None
<1> if self._cryptos[tls.Epoch.ONE_RTT].send.is_valid():
<2> crypto = self._cryptos[tls.Epoch.ONE_RTT]
<3> crypto_stream = self._crypto_streams[tls.Epoch.ONE_RTT]
<4> packet_type = PACKET_TYPE_ONE_RTT
<5> elif self._cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
<6> crypto = self._cryptos[tls.Epoch.ZERO_RTT]
<7> packet_type = PACKET_TYPE_ZERO_RTT
<8> else:
<9> return
<10> space = self._spaces[tls.Epoch.ONE_RTT]
<11>
<12> while True:
<13> # write header
<14> builder.start_packet(packet_type, crypto)
<15>
<16> if self._handshake_complete:
<17> # ACK
<18> if space.ack_at is not None and space.ack_at <= now:
<19> self._write_ack_frame(builder=builder, space=space)
<20>
<21> # PATH CHALLENGE
<22> if (
<23> not network_path.is_validated
<24> and network_path.local_challenge is None
<25> ):
<26> self._logger.debug(
<27> "Network path %s sending challenge", network_path.addr
<28> )
<29> network_path.local_challenge = os.urandom(8)
<30> buf = builder.start_frame(QuicFrameType.PATH_CHALLENGE)
<31> buf.push_bytes(network_path.local_challenge)
<32>
<33> # log frame
<34> if self._quic_logger is not None:
<35> builder.quic_logger_frames.append(
<36> self._quic_logger.encode_path_challenge_frame(
</s>
|
===========below chunk 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
# offset: 1
)
)
# PATH RESPONSE
if network_path.remote_challenge is not None:
challenge = network_path.remote_challenge
buf = builder.start_frame(QuicFrameType.PATH_RESPONSE)
buf.push_bytes(challenge)
network_path.remote_challenge = None
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_path_response_frame(data=challenge)
)
# NEW_CONNECTION_ID
for connection_id in self._host_cids:
if not connection_id.was_sent:
self._write_new_connection_id_frame(
builder=builder, connection_id=connection_id
)
# RETIRE_CONNECTION_ID
while self._retire_connection_ids:
sequence_number = self._retire_connection_ids.pop(0)
self._write_retire_connection_id_frame(
builder=builder, sequence_number=sequence_number
)
# STREAMS_BLOCKED
if self._streams_blocked_pending:
if self._streams_blocked_bidi:
self._write_streams_blocked_frame(
builder=builder,
frame_type=QuicFrameType.STREAMS_BLOCKED_BIDI,
limit=self._remote_max_streams_bidi,
)
if self._streams_blocked_uni:
self._write_streams_blocked_frame(
builder=builder,
frame_type=QuicFrameType.STREAMS_BLOCKED_UNI,
limit=self._remote_max_streams_uni,
)
self._streams_blocked_pending = False
# connection-level limits
self._write_connection</s>
===========below chunk 1===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
# offset: 2
<s>,
)
self._streams_blocked_pending = False
# connection-level limits
self._write_connection_limits(builder=builder, space=space)
# stream-level limits
for stream in self._streams.values():
self._write_stream_limits(builder=builder, space=space, stream=stream)
# PING (user-request)
if self._ping_pending:
self._logger.info("Sending PING in packet %d", builder.packet_number)
self._write_ping_frame(builder, self._ping_pending)
self._ping_pending.clear()
# PING (probe)
if self._probe_pending:
self._logger.info(
"Sending PING (probe) in packet %d", builder.packet_number
)
self._write_ping_frame(builder)
self._probe_pending = False
# CRYPTO
if crypto_stream is not None and not crypto_stream.send_buffer_is_empty:
self._write_crypto_frame(
builder=builder, space=space, stream=crypto_stream
)
# DATAGRAM
while self._datagrams_pending:
if self._write_datagram_frame(
builder=builder,
data=self._datagrams_pending[0],
frame_type=QuicFrameType.DATAGRAM_WITH_LENGTH,
):
self._datagrams_pending.popleft()
else:
break
for stream in self._streams.values():
# STREAM
if not stream.is_blocked and not stream.send_buffer_is_empty:
self._remote_max_</s>
===========below chunk 2===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
# offset: 3
<s>used += self._write_stream_frame(
builder=builder,
space=space,
stream=stream,
max_offset=min(
stream._send_highest
+ self._remote_max_data
- self._remote_max_data_used,
stream.max_stream_data_remote,
),
)
if builder.packet_is_empty:
break
===========unchanged ref 0===========
at: aioquic.quic.connection
QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, is_validated: bool=False, local_challenge: Optional[bytes]=None, remote_challenge: Optional[bytes]=None)
at: aioquic.quic.connection.QuicConnection
_write_ack_frame(self, builder: QuicPacketBuilder, space: QuicPacketSpace)
_write_ack_frame(builder: QuicPacketBuilder, space: QuicPacketSpace)
_write_connection_limits(builder: QuicPacketBuilder, space: QuicPacketSpace) -> None
_write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> bool
_write_datagram_frame(builder: QuicPacketBuilder, data: bytes, frame_type: QuicFrameType) -> bool
_write_new_connection_id_frame(builder: QuicPacketBuilder, connection_id: QuicConnectionId) -> None
_write_ping_frame(builder: QuicPacketBuilder, uids: List[int]=[])
_write_retire_connection_id_frame(builder: QuicPacketBuilder, sequence_number: int) -> None
_write_retire_connection_id_frame(self, builder: QuicPacketBuilder, sequence_number: int) -> None
_write_stream_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream, max_offset: int) -> int
_write_stream_limits(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
_write_streams_blocked_frame(builder: QuicPacketBuilder, frame_type: QuicFrameType, limit: int) -> None
at: aioquic.quic.connection.QuicConnection.__init__
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
|
aioquic.quic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
25719c59916bd85bae4292dd4d1e6959e0c832da
|
[connection] rework some log messages
|
<27>:<del> self._logger.info(
<28>:<del> "Sending PING (probe) in packet %d", builder.packet_number
<29>:<del> )
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
<0> crypto = self._cryptos[epoch]
<1> if not crypto.send.is_valid():
<2> return
<3>
<4> crypto_stream = self._crypto_streams[epoch]
<5> space = self._spaces[epoch]
<6>
<7> while True:
<8> if epoch == tls.Epoch.INITIAL:
<9> packet_type = PACKET_TYPE_INITIAL
<10> else:
<11> packet_type = PACKET_TYPE_HANDSHAKE
<12> builder.start_packet(packet_type, crypto)
<13>
<14> # ACK
<15> if space.ack_at is not None:
<16> self._write_ack_frame(builder=builder, space=space)
<17>
<18> # CRYPTO
<19> if not crypto_stream.send_buffer_is_empty:
<20> if self._write_crypto_frame(
<21> builder=builder, space=space, stream=crypto_stream
<22> ):
<23> self._probe_pending = False
<24>
<25> # PING (probe)
<26> if self._probe_pending and epoch == tls.Epoch.HANDSHAKE:
<27> self._logger.info(
<28> "Sending PING (probe) in packet %d", builder.packet_number
<29> )
<30> self._write_ping_frame(builder)
<31> self._probe_pending = False
<32>
<33> if builder.packet_is_empty:
<34> break
<35>
|
===========unchanged ref 0===========
at: aioquic.quic.connection.QuicConnection
_on_ack_delivery(delivery: QuicDeliveryState, space: QuicPacketSpace, highest_acked: int) -> None
_write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> bool
_write_ping_frame(builder: QuicPacketBuilder, uids: List[int]=[])
at: aioquic.quic.connection.QuicConnection.__init__
self._spaces: Dict[tls.Epoch, QuicPacketSpace] = {}
self._probe_pending = False
at: aioquic.quic.connection.QuicConnection._initialize
self._spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.quic.connection.QuicConnection._send_probe
self._probe_pending = True
at: aioquic.quic.connection.QuicConnection._write_application
self._probe_pending = False
at: aioquic.quic.connection.QuicConnection._write_handshake
crypto = self._cryptos[epoch]
crypto_stream = self._crypto_streams[epoch]
===========changed ref 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _on_ping_delivery(
self, delivery: QuicDeliveryState, uids: Sequence[int]
) -> None:
"""
Callback when a PING frame is acknowledged or lost.
"""
if delivery == QuicDeliveryState.ACKED:
+ self._logger.debug("Received PING%s response", "" if uids else " (probe)")
- self._logger.info("Received PING response")
for uid in uids:
self._events.append(events.PingAcknowledged(uid=uid))
else:
self._ping_pending.extend(uids)
===========changed ref 1===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
crypto_stream: Optional[QuicStream] = None
if self._cryptos[tls.Epoch.ONE_RTT].send.is_valid():
crypto = self._cryptos[tls.Epoch.ONE_RTT]
crypto_stream = self._crypto_streams[tls.Epoch.ONE_RTT]
packet_type = PACKET_TYPE_ONE_RTT
elif self._cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
crypto = self._cryptos[tls.Epoch.ZERO_RTT]
packet_type = PACKET_TYPE_ZERO_RTT
else:
return
space = self._spaces[tls.Epoch.ONE_RTT]
while True:
# write header
builder.start_packet(packet_type, crypto)
if self._handshake_complete:
# ACK
if space.ack_at is not None and space.ack_at <= now:
self._write_ack_frame(builder=builder, space=space)
# PATH CHALLENGE
if (
not network_path.is_validated
and network_path.local_challenge is None
):
- self._logger.debug(
- "Network path %s sending challenge", network_path.addr
- )
+ challenge = os.urandom(8)
- network_path.local_challenge = os.urandom(8)
buf = builder.start_frame(QuicFrameType.PATH_CHALLENGE)
+ buf.push_bytes(challenge)
- buf.push_bytes(network_path.local_challenge)
+ network_path.local_challenge = challenge
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_path_challenge_</s>
===========changed ref 2===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
# offset: 1
<s> None:
builder.quic_logger_frames.append(
self._quic_logger.encode_path_challenge_frame(
+ data=challenge
- data=network_path.local_challenge
)
)
# PATH RESPONSE
if network_path.remote_challenge is not None:
challenge = network_path.remote_challenge
buf = builder.start_frame(QuicFrameType.PATH_RESPONSE)
buf.push_bytes(challenge)
network_path.remote_challenge = None
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_path_response_frame(data=challenge)
)
# NEW_CONNECTION_ID
for connection_id in self._host_cids:
if not connection_id.was_sent:
self._write_new_connection_id_frame(
builder=builder, connection_id=connection_id
)
# RETIRE_CONNECTION_ID
while self._retire_connection_ids:
sequence_number = self._retire_connection_ids.pop(0)
self._write_retire_connection_id_frame(
builder=builder, sequence_number=sequence_number
)
# STREAMS_BLOCKED
if self._streams_blocked_pending:
if self._streams_blocked_bidi:
self._write_streams_blocked_frame(
builder=builder,
frame_type=QuicFrameType.STREAMS_BLOCKED_BIDI,
limit=self._remote_max_streams_bidi,
)
if self._streams_blocked_</s>
===========changed ref 3===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
# offset: 2
<s>:
self._write_streams_blocked_frame(
builder=builder,
frame_type=QuicFrameType.STREAMS_BLOCKED_UNI,
limit=self._remote_max_streams_uni,
)
self._streams_blocked_pending = False
# connection-level limits
self._write_connection_limits(builder=builder, space=space)
# stream-level limits
for stream in self._streams.values():
self._write_stream_limits(builder=builder, space=space, stream=stream)
# PING (user-request)
if self._ping_pending:
- self._logger.info("Sending PING in packet %d", builder.packet_number)
self._write_ping_frame(builder, self._ping_pending)
self._ping_pending.clear()
# PING (probe)
if self._probe_pending:
- self._logger.info(
- "Sending PING (probe) in packet %d", builder.packet_number
- )
self._write_ping_frame(builder)
self._probe_pending = False
# CRYPTO
if crypto_stream is not None and not crypto_stream.send_buffer_is_empty:
self._write_crypto_frame(
builder=builder, space=space, stream=crypto_stream
)
# DATAGRAM
while self._datagrams_pending:
if self._write_datagram_frame(
builder=builder,
data=self._datagrams_pending[0],
frame_type=QuicFrameType.DATAGRAM_WITH_LENGTH,
):
self._datagrams_pending</s>
|
aioquic.quic.connection/QuicConnection._write_ping_frame
|
Modified
|
aiortc~aioquic
|
25719c59916bd85bae4292dd4d1e6959e0c832da
|
[connection] rework some log messages
|
<1>:<add> self._logger.debug(
<add> "Sending PING%s in packet %d",
<add> "" if uids else " (probe)",
<add> builder.packet_number,
<add> )
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_ping_frame(self, builder: QuicPacketBuilder, uids: List[int] = []):
<0> builder.start_frame(QuicFrameType.PING, self._on_ping_delivery, (tuple(uids),))
<1>
<2> # log frame
<3> if self._quic_logger is not None:
<4> builder.quic_logger_frames.append(self._quic_logger.encode_ping_frame())
<5>
|
===========unchanged ref 0===========
at: aioquic.quic.connection.QuicConnection.__init__
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
===========changed ref 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
crypto = self._cryptos[epoch]
if not crypto.send.is_valid():
return
crypto_stream = self._crypto_streams[epoch]
space = self._spaces[epoch]
while True:
if epoch == tls.Epoch.INITIAL:
packet_type = PACKET_TYPE_INITIAL
else:
packet_type = PACKET_TYPE_HANDSHAKE
builder.start_packet(packet_type, crypto)
# ACK
if space.ack_at is not None:
self._write_ack_frame(builder=builder, space=space)
# CRYPTO
if not crypto_stream.send_buffer_is_empty:
if self._write_crypto_frame(
builder=builder, space=space, stream=crypto_stream
):
self._probe_pending = False
# PING (probe)
if self._probe_pending and epoch == tls.Epoch.HANDSHAKE:
- self._logger.info(
- "Sending PING (probe) in packet %d", builder.packet_number
- )
self._write_ping_frame(builder)
self._probe_pending = False
if builder.packet_is_empty:
break
===========changed ref 1===========
# module: aioquic.quic.connection
class QuicConnection:
def _on_ping_delivery(
self, delivery: QuicDeliveryState, uids: Sequence[int]
) -> None:
"""
Callback when a PING frame is acknowledged or lost.
"""
if delivery == QuicDeliveryState.ACKED:
+ self._logger.debug("Received PING%s response", "" if uids else " (probe)")
- self._logger.info("Received PING response")
for uid in uids:
self._events.append(events.PingAcknowledged(uid=uid))
else:
self._ping_pending.extend(uids)
===========changed ref 2===========
# module: aioquic.quic.connection
class QuicConnection:
def _get_or_create_stream(self, frame_type: int, stream_id: int) -> QuicStream:
"""
Get or create a stream in response to a received frame.
"""
stream = self._streams.get(stream_id, None)
if stream is None:
# check initiator
if stream_is_client_initiated(stream_id) == self._is_client:
raise QuicConnectionError(
error_code=QuicErrorCode.STREAM_STATE_ERROR,
frame_type=frame_type,
reason_phrase="Wrong stream initiator",
)
# determine limits
if stream_is_unidirectional(stream_id):
max_stream_data_local = self._local_max_stream_data_uni
max_stream_data_remote = 0
max_streams = self._local_max_streams_uni
else:
max_stream_data_local = self._local_max_stream_data_bidi_remote
max_stream_data_remote = self._remote_max_stream_data_bidi_local
max_streams = self._local_max_streams_bidi
# check max streams
if stream_id // 4 >= max_streams:
raise QuicConnectionError(
error_code=QuicErrorCode.STREAM_LIMIT_ERROR,
frame_type=frame_type,
reason_phrase="Too many streams open",
)
# create stream
+ self._logger.debug("Stream %d created by peer" % stream_id)
- self._logger.info("Stream %d created by peer" % stream_id)
stream = self._streams[stream_id] = QuicStream(
stream_id=stream_id,
max_stream_data_local=max_stream_data_local,
max_stream_data_remote=max_stream_data_remote,
)
return stream
===========changed ref 3===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
crypto_stream: Optional[QuicStream] = None
if self._cryptos[tls.Epoch.ONE_RTT].send.is_valid():
crypto = self._cryptos[tls.Epoch.ONE_RTT]
crypto_stream = self._crypto_streams[tls.Epoch.ONE_RTT]
packet_type = PACKET_TYPE_ONE_RTT
elif self._cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
crypto = self._cryptos[tls.Epoch.ZERO_RTT]
packet_type = PACKET_TYPE_ZERO_RTT
else:
return
space = self._spaces[tls.Epoch.ONE_RTT]
while True:
# write header
builder.start_packet(packet_type, crypto)
if self._handshake_complete:
# ACK
if space.ack_at is not None and space.ack_at <= now:
self._write_ack_frame(builder=builder, space=space)
# PATH CHALLENGE
if (
not network_path.is_validated
and network_path.local_challenge is None
):
- self._logger.debug(
- "Network path %s sending challenge", network_path.addr
- )
+ challenge = os.urandom(8)
- network_path.local_challenge = os.urandom(8)
buf = builder.start_frame(QuicFrameType.PATH_CHALLENGE)
+ buf.push_bytes(challenge)
- buf.push_bytes(network_path.local_challenge)
+ network_path.local_challenge = challenge
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_path_challenge_</s>
|
aioquic.quic.connection/QuicConnection._handle_new_token_frame
|
Modified
|
aiortc~aioquic
|
5889cef66e581057abe9f4098f03657fdeb4c455
|
[packet] inline NEW_TOKEN parsing
|
<3>:<add> length = buf.pull_uint_var()
<add> token = buf.pull_bytes(length)
<del> token = pull_new_token_frame(buf)
|
# module: aioquic.quic.connection
class QuicConnection:
def _handle_new_token_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a NEW_TOKEN frame.
<2> """
<3> token = pull_new_token_frame(buf)
<4>
<5> if not self._is_client:
<6> raise QuicConnectionError(
<7> error_code=QuicErrorCode.PROTOCOL_VIOLATION,
<8> frame_type=frame_type,
<9> reason_phrase="Clients must not send NEW_TOKEN frames",
<10> )
<11>
<12> # log frame
<13> if self._quic_logger is not None:
<14> context.quic_logger_frames.append(
<15> self._quic_logger.encode_new_token_frame(token=token)
<16> )
<17>
|
===========unchanged ref 0===========
at: aioquic.quic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath, quic_logger_frames: Optional[List[Any]], time: float)
at: aioquic.quic.connection.QuicConnection.__init__
self._is_client = configuration.is_client
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
at: aioquic.quic.connection.QuicReceiveContext
epoch: tls.Epoch
host_cid: bytes
network_path: QuicNetworkPath
quic_logger_frames: Optional[List[Any]]
time: float
===========changed ref 0===========
# module: aioquic.quic.packet
- def pull_new_token_frame(buf: Buffer) -> bytes:
- length = buf.pull_uint_var()
- return buf.pull_bytes(length)
-
===========changed ref 1===========
# module: aioquic.quic.packet
- def push_new_token_frame(buf: Buffer, token: bytes) -> None:
- buf.push_uint_var(len(token))
- buf.push_bytes(token)
-
===========changed ref 2===========
# module: tests.test_packet
class FrameTest(TestCase):
- def test_new_token(self):
- data = binascii.unhexlify("080102030405060708")
-
- # parse
- buf = Buffer(data=data)
- token = packet.pull_new_token_frame(buf)
- self.assertEqual(token, binascii.unhexlify("0102030405060708"))
-
- # serialize
- buf = Buffer(capacity=len(data))
- packet.push_new_token_frame(buf, token)
- self.assertEqual(buf.data, data)
-
|
tests.test_connection/QuicConnectionTest.test_handle_connection_close_frame
|
Modified
|
aiortc~aioquic
|
05d918ea90db9ee08b08a3242e4f43514c62266e
|
[packet] inline CONNECTION_CLOSE parsing
|
<2>:<add> error_code=QuicErrorCode.PROTOCOL_VIOLATION,
<add> frame_type=QuicFrameType.ACK,
<add> reason_phrase="illegal ACK frame",
<del> error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
<0> with client_and_server() as (client, server):
<1> server.close(
<2> error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
<3> )
<4> roundtrip(server, client)
<5>
|
===========unchanged ref 0===========
at: tests.test_connection
client_and_server(client_kwargs={}, client_options={}, client_patch=lambda x: None, handshake=True, server_kwargs={}, server_certfile=SERVER_CERTFILE, server_keyfile=SERVER_KEYFILE, server_options={}, server_patch=lambda x: None, transport_options={})
roundtrip(sender, receiver)
===========changed ref 0===========
# module: aioquic.quic.packet
- def decode_reason_phrase(reason_bytes: bytes) -> str:
- try:
- return reason_bytes.decode("utf8")
- except UnicodeDecodeError:
- return ""
-
===========changed ref 1===========
# module: aioquic.quic.packet
- def pull_application_close_frame(buf: Buffer) -> Tuple[int, str]:
- error_code = buf.pull_uint_var()
- reason_length = buf.pull_uint_var()
- reason_phrase = decode_reason_phrase(buf.pull_bytes(reason_length))
- return (error_code, reason_phrase)
-
===========changed ref 2===========
# module: aioquic.quic.packet
- def pull_transport_close_frame(buf: Buffer) -> Tuple[int, int, str]:
- error_code = buf.pull_uint_var()
- frame_type = buf.pull_uint_var()
- reason_length = buf.pull_uint_var()
- reason_phrase = decode_reason_phrase(buf.pull_bytes(reason_length))
- return (error_code, frame_type, reason_phrase)
-
|
tests.test_connection/QuicConnectionTest.test_handle_connection_close_frame_app
|
Modified
|
aiortc~aioquic
|
05d918ea90db9ee08b08a3242e4f43514c62266e
|
[packet] inline CONNECTION_CLOSE parsing
|
<1>:<add> server.close(error_code=QuicErrorCode.NO_ERROR, reason_phrase="goodbye")
<del> server.close(error_code=QuicErrorCode.NO_ERROR)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
<0> with client_and_server() as (client, server):
<1> server.close(error_code=QuicErrorCode.NO_ERROR)
<2> roundtrip(server, client)
<3>
|
===========unchanged ref 0===========
at: tests.test_connection
client_and_server(client_kwargs={}, client_options={}, client_patch=lambda x: None, handshake=True, server_kwargs={}, server_certfile=SERVER_CERTFILE, server_keyfile=SERVER_KEYFILE, server_options={}, server_patch=lambda x: None, transport_options={})
roundtrip(sender, receiver)
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
with client_and_server() as (client, server):
server.close(
+ error_code=QuicErrorCode.PROTOCOL_VIOLATION,
+ frame_type=QuicFrameType.ACK,
+ reason_phrase="illegal ACK frame",
- error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
)
roundtrip(server, client)
===========changed ref 1===========
# module: aioquic.quic.packet
- def decode_reason_phrase(reason_bytes: bytes) -> str:
- try:
- return reason_bytes.decode("utf8")
- except UnicodeDecodeError:
- return ""
-
===========changed ref 2===========
# module: aioquic.quic.packet
- def pull_application_close_frame(buf: Buffer) -> Tuple[int, str]:
- error_code = buf.pull_uint_var()
- reason_length = buf.pull_uint_var()
- reason_phrase = decode_reason_phrase(buf.pull_bytes(reason_length))
- return (error_code, reason_phrase)
-
===========changed ref 3===========
# module: aioquic.quic.packet
- def pull_transport_close_frame(buf: Buffer) -> Tuple[int, int, str]:
- error_code = buf.pull_uint_var()
- frame_type = buf.pull_uint_var()
- reason_length = buf.pull_uint_var()
- reason_phrase = decode_reason_phrase(buf.pull_bytes(reason_length))
- return (error_code, frame_type, reason_phrase)
-
|
aioquic.quic.connection/QuicConnection._handle_connection_close_frame
|
Modified
|
aiortc~aioquic
|
05d918ea90db9ee08b08a3242e4f43514c62266e
|
[packet] inline CONNECTION_CLOSE parsing
|
<3>:<add> error_code = buf.pull_uint_var()
<4>:<add> frame_type = buf.pull_uint_var()
<del> error_code, frame_type, reason_phrase = pull_transport_close_frame(buf)
<6>:<del> error_code, reason_phrase = pull_application_close_frame(buf)
<8>:<add> reason_length = buf.pull_uint_var()
<add> try:
<add> reason_phrase = buf.pull_bytes(reason_length).decode("utf8")
<add> except UnicodeDecodeError:
<add> reason_phrase = ""
|
# module: aioquic.quic.connection
class QuicConnection:
def _handle_connection_close_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a CONNECTION_CLOSE frame.
<2> """
<3> if frame_type == QuicFrameType.TRANSPORT_CLOSE:
<4> error_code, frame_type, reason_phrase = pull_transport_close_frame(buf)
<5> else:
<6> error_code, reason_phrase = pull_application_close_frame(buf)
<7> frame_type = None
<8>
<9> # log frame
<10> if self._quic_logger is not None:
<11> context.quic_logger_frames.append(
<12> self._quic_logger.encode_connection_close_frame(
<13> error_code=error_code,
<14> frame_type=frame_type,
<15> reason_phrase=reason_phrase,
<16> )
<17> )
<18>
<19> self._logger.info(
<20> "Connection close code 0x%X, reason %s", error_code, reason_phrase
<21> )
<22> self._close_event = events.ConnectionTerminated(
<23> error_code=error_code, frame_type=frame_type, reason_phrase=reason_phrase
<24> )
<25> self._close_begin(is_initiator=False, now=context.time)
<26>
|
===========unchanged ref 0===========
at: aioquic.quic.connection.QuicConnection.__init__
self._close_event: Optional[events.ConnectionTerminated] = None
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
self._logger = QuicConnectionAdapter(
logger, {"id": dump_cid(logger_connection_id)}
)
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
at: aioquic.quic.connection.QuicConnection.close
self._close_event = events.ConnectionTerminated(
error_code=error_code,
frame_type=frame_type,
reason_phrase=reason_phrase,
)
at: aioquic.quic.connection.QuicConnection.handle_timer
self._close_event = events.ConnectionTerminated(
error_code=QuicErrorCode.INTERNAL_ERROR,
frame_type=None,
reason_phrase="Idle timeout",
)
at: aioquic.quic.connection.QuicConnection.receive_datagram
self._close_event = events.ConnectionTerminated(
error_code=QuicErrorCode.INTERNAL_ERROR,
frame_type=None,
reason_phrase="Could not find a common protocol version",
)
at: aioquic.quic.connection.QuicReceiveContext
epoch: tls.Epoch
host_cid: bytes
network_path: QuicNetworkPath
quic_logger_frames: Optional[List[Any]]
time: float
at: logging.LoggerAdapter
logger: Logger
extra: Mapping[str, Any]
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.quic.packet
- def decode_reason_phrase(reason_bytes: bytes) -> str:
- try:
- return reason_bytes.decode("utf8")
- except UnicodeDecodeError:
- return ""
-
===========changed ref 1===========
# module: aioquic.quic.packet
- def pull_application_close_frame(buf: Buffer) -> Tuple[int, str]:
- error_code = buf.pull_uint_var()
- reason_length = buf.pull_uint_var()
- reason_phrase = decode_reason_phrase(buf.pull_bytes(reason_length))
- return (error_code, reason_phrase)
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
with client_and_server() as (client, server):
+ server.close(error_code=QuicErrorCode.NO_ERROR, reason_phrase="goodbye")
- server.close(error_code=QuicErrorCode.NO_ERROR)
roundtrip(server, client)
===========changed ref 3===========
# module: tests.test_packet
class FrameTest(TestCase):
- def test_application_close_not_utf8(self):
- data = binascii.unhexlify("0008676f6f6462798200")
-
- # parse
- buf = Buffer(data=data)
- frame = packet.pull_application_close_frame(buf)
- self.assertEqual(frame, (0, ""))
-
===========changed ref 4===========
# module: tests.test_packet
class FrameTest(TestCase):
- def test_application_close(self):
- data = binascii.unhexlify("0008676f6f6462796500")
-
- # parse
- buf = Buffer(data=data)
- frame = packet.pull_application_close_frame(buf)
- self.assertEqual(frame, (0, "goodbye\x00"))
-
===========changed ref 5===========
# module: aioquic.quic.packet
- def pull_transport_close_frame(buf: Buffer) -> Tuple[int, int, str]:
- error_code = buf.pull_uint_var()
- frame_type = buf.pull_uint_var()
- reason_length = buf.pull_uint_var()
- reason_phrase = decode_reason_phrase(buf.pull_bytes(reason_length))
- return (error_code, frame_type, reason_phrase)
-
===========changed ref 6===========
# module: tests.test_packet
class FrameTest(TestCase):
- def test_transport_close(self):
- data = binascii.unhexlify("0a0212696c6c6567616c2041434b206672616d6500")
-
- # parse
- buf = Buffer(data=data)
- frame = packet.pull_transport_close_frame(buf)
- self.assertEqual(frame, (10, 2, "illegal ACK frame\x00"))
-
===========changed ref 7===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
with client_and_server() as (client, server):
server.close(
+ error_code=QuicErrorCode.PROTOCOL_VIOLATION,
+ frame_type=QuicFrameType.ACK,
+ reason_phrase="illegal ACK frame",
- error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
)
roundtrip(server, client)
===========changed ref 8===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_handle_connection_close_frame_app_not_utf8(self):
+ client = create_standalone_client(self)
+
+ client._handle_connection_close_frame(
+ client_receive_context(client),
+ QuicFrameType.APPLICATION_CLOSE,
+ Buffer(data=binascii.unhexlify("0008676f6f6462798200")),
+ )
+
+ self.assertEqual(
+ client._close_event,
+ events.ConnectionTerminated(
+ error_code=QuicErrorCode.NO_ERROR, frame_type=None, reason_phrase="",
+ ),
+ )
+
|
aioquic.quic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
0cc37a0853062497ba6b3d72668d88dfe2d064f0
|
[connection] add helper methods for path challenge / response
|
<27>:<add> self._write_path_challenge_frame(
<add> builder=builder, challenge=challenge
<add> )
<del> buf = builder.start_frame(QuicFrameType.PATH_CHALLENGE)
<28>:<del> buf.push_bytes(challenge)
<30>:<del>
<31>:<del> # log frame
<32>:<del> if self._quic_logger is not None:
<33>:<del> builder.quic_logger_frames.append(
<34>:<del> self._quic_logger.encode_path_challenge_frame(
<35>:<del> data=challenge
<36>:<del> )
<37>:<del> )
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
<0> crypto_stream: Optional[QuicStream] = None
<1> if self._cryptos[tls.Epoch.ONE_RTT].send.is_valid():
<2> crypto = self._cryptos[tls.Epoch.ONE_RTT]
<3> crypto_stream = self._crypto_streams[tls.Epoch.ONE_RTT]
<4> packet_type = PACKET_TYPE_ONE_RTT
<5> elif self._cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
<6> crypto = self._cryptos[tls.Epoch.ZERO_RTT]
<7> packet_type = PACKET_TYPE_ZERO_RTT
<8> else:
<9> return
<10> space = self._spaces[tls.Epoch.ONE_RTT]
<11>
<12> while True:
<13> # write header
<14> builder.start_packet(packet_type, crypto)
<15>
<16> if self._handshake_complete:
<17> # ACK
<18> if space.ack_at is not None and space.ack_at <= now:
<19> self._write_ack_frame(builder=builder, space=space)
<20>
<21> # PATH CHALLENGE
<22> if (
<23> not network_path.is_validated
<24> and network_path.local_challenge is None
<25> ):
<26> challenge = os.urandom(8)
<27> buf = builder.start_frame(QuicFrameType.PATH_CHALLENGE)
<28> buf.push_bytes(challenge)
<29> network_path.local_challenge = challenge
<30>
<31> # log frame
<32> if self._quic_logger is not None:
<33> builder.quic_logger_frames.append(
<34> self._quic_logger.encode_path_challenge_frame(
<35> data=challenge
<36> )
<37> )
<38>
<39> # PATH RESPONSE
<40> if network_path.</s>
|
===========below chunk 0===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
# offset: 1
challenge = network_path.remote_challenge
buf = builder.start_frame(QuicFrameType.PATH_RESPONSE)
buf.push_bytes(challenge)
network_path.remote_challenge = None
# log frame
if self._quic_logger is not None:
builder.quic_logger_frames.append(
self._quic_logger.encode_path_response_frame(data=challenge)
)
# NEW_CONNECTION_ID
for connection_id in self._host_cids:
if not connection_id.was_sent:
self._write_new_connection_id_frame(
builder=builder, connection_id=connection_id
)
# RETIRE_CONNECTION_ID
while self._retire_connection_ids:
sequence_number = self._retire_connection_ids.pop(0)
self._write_retire_connection_id_frame(
builder=builder, sequence_number=sequence_number
)
# STREAMS_BLOCKED
if self._streams_blocked_pending:
if self._streams_blocked_bidi:
self._write_streams_blocked_frame(
builder=builder,
frame_type=QuicFrameType.STREAMS_BLOCKED_BIDI,
limit=self._remote_max_streams_bidi,
)
if self._streams_blocked_uni:
self._write_streams_blocked_frame(
builder=builder,
frame_type=QuicFrameType.STREAMS_BLOCKED_UNI,
limit=self._remote_max_streams_uni,
)
self._streams_blocked_pending = False
# connection-level limits
self._write_connection_limits(builder=builder, space=space)
# stream-level limits
for stream in self._</s>
===========below chunk 1===========
# module: aioquic.quic.connection
class QuicConnection:
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
# offset: 2
<s>._write_connection_limits(builder=builder, space=space)
# stream-level limits
for stream in self._streams.values():
self._write_stream_limits(builder=builder, space=space, stream=stream)
# PING (user-request)
if self._ping_pending:
self._write_ping_frame(builder, self._ping_pending)
self._ping_pending.clear()
# PING (probe)
if self._probe_pending:
self._write_ping_frame(builder)
self._probe_pending = False
# CRYPTO
if crypto_stream is not None and not crypto_stream.send_buffer_is_empty:
self._write_crypto_frame(
builder=builder, space=space, stream=crypto_stream
)
# DATAGRAM
while self._datagrams_pending:
if self._write_datagram_frame(
builder=builder,
data=self._datagrams_pending[0],
frame_type=QuicFrameType.DATAGRAM_WITH_LENGTH,
):
self._datagrams_pending.popleft()
else:
break
for stream in self._streams.values():
# STREAM
if not stream.is_blocked and not stream.send_buffer_is_empty:
self._remote_max_data_used += self._write_stream_frame(
builder=builder,
space=space,
stream=stream,
max_offset=min(
stream._send_highest
+ self._remote_max_data
- self._remote_max_data_used,
stream.max_stream_data_
===========unchanged ref 0===========
at: aioquic.quic.connection
QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, is_validated: bool=False, local_challenge: Optional[bytes]=None, remote_challenge: Optional[bytes]=None)
at: aioquic.quic.connection.QuicConnection
_write_ack_frame(builder: QuicPacketBuilder, space: QuicPacketSpace)
_write_connection_limits(builder: QuicPacketBuilder, space: QuicPacketSpace) -> None
_write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> bool
_write_datagram_frame(builder: QuicPacketBuilder, data: bytes, frame_type: QuicFrameType) -> bool
_write_new_connection_id_frame(builder: QuicPacketBuilder, connection_id: QuicConnectionId) -> None
_write_path_challenge_frame(builder: QuicPacketBuilder, challenge: bytes) -> None
_write_path_response_frame(builder: QuicPacketBuilder, challenge: bytes) -> None
_write_ping_frame(builder: QuicPacketBuilder, uids: List[int]=[])
_write_retire_connection_id_frame(builder: QuicPacketBuilder, sequence_number: int) -> None
_write_stream_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream, max_offset: int) -> int
_write_stream_limits(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
_write_streams_blocked_frame(builder: QuicPacketBuilder, frame_type: QuicFrameType, limit: int) -> None
at: aioquic.quic.connection.QuicConnection.__init__
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
self._handshake_complete = False
===========unchanged ref 1===========
self._host_cids = [
QuicConnectionId(
cid=os.urandom(configuration.connection_id_length),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._spaces: Dict[tls.Epoch, QuicPacketSpace] = {}
self._streams: Dict[int, QuicStream] = {}
self._streams_blocked_bidi: List[QuicStream] = []
self._streams_blocked_uni: List[QuicStream] = []
self._datagrams_pending: Deque[bytes] = deque()
self._ping_pending: List[int] = []
self._probe_pending = False
self._retire_connection_ids: List[int] = []
self._streams_blocked_pending = False
at: aioquic.quic.connection.QuicConnection._create_stream
self._streams_blocked_pending = True
at: aioquic.quic.connection.QuicConnection._handle_crypto_frame
self._handshake_complete = True
at: aioquic.quic.connection.QuicConnection._handle_max_data_frame
self._remote_max_data = max_data
at: aioquic.quic.connection.QuicConnection._handle_max_streams_bidi_frame
self._remote_max_streams_bidi = max_streams
at: aioquic.quic.connection.QuicConnection._handle_max_streams_uni_frame
self._remote_max_streams_uni = max_streams
|
aioquic.quic.connection/QuicConnection.datagrams_to_send
|
Modified
|
aiortc~aioquic
|
59959d8409c505af6b18d3286202cc66d75381af
|
[connection] cosmetic changes to comments
|
<31>:<add> self._write_connection_close_frame(
<del> self._write_close_frame(
|
# module: aioquic.quic.connection
class QuicConnection:
def datagrams_to_send(self, now: float) -> List[Tuple[bytes, NetworkAddress]]:
<0> """
<1> Return a list of `(data, addr)` tuples of datagrams which need to be
<2> sent, and the network address to which they need to be sent.
<3>
<4> :param now: The current time.
<5> """
<6> network_path = self._network_paths[0]
<7>
<8> if self._state in END_STATES:
<9> return []
<10>
<11> # build datagrams
<12> builder = QuicPacketBuilder(
<13> host_cid=self.host_cid,
<14> is_client=self._is_client,
<15> packet_number=self._packet_number,
<16> peer_cid=self._peer_cid,
<17> peer_token=self._peer_token,
<18> quic_logger=self._quic_logger,
<19> spin_bit=self._spin_bit,
<20> version=self._version,
<21> )
<22> if self._close_pending:
<23> for epoch, packet_type in (
<24> (tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
<25> (tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
<26> (tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
<27> ):
<28> crypto = self._cryptos[epoch]
<29> if crypto.send.is_valid():
<30> builder.start_packet(packet_type, crypto)
<31> self._write_close_frame(
<32> builder=builder,
<33> error_code=self._close_event.error_code,
<34> frame_type=self._close_event.frame_type,
<35> reason_phrase=self._close_event.reason_phrase,
<36> )
<37> self._close_pending = False
<38> break
<39> self._close_begin(is_initiator=True, now=now)
<40> else:
<41> # congestion</s>
|
===========below chunk 0===========
# module: aioquic.quic.connection
class QuicConnection:
def datagrams_to_send(self, now: float) -> List[Tuple[bytes, NetworkAddress]]:
# offset: 1
builder.max_flight_bytes = (
self._loss.congestion_window - self._loss.bytes_in_flight
)
if self._probe_pending and builder.max_flight_bytes < PACKET_MAX_SIZE:
builder.max_flight_bytes = PACKET_MAX_SIZE
# limit data on un-validated network paths
if not network_path.is_validated:
builder.max_total_bytes = (
network_path.bytes_received * 3 - network_path.bytes_sent
)
try:
if not self._handshake_confirmed:
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch)
self._write_application(builder, network_path, now)
except QuicPacketBuilderStop:
pass
datagrams, packets = builder.flush()
if datagrams:
self._packet_number = builder.packet_number
# register packets
sent_handshake = False
for packet in packets:
packet.sent_time = now
self._loss.on_packet_sent(
packet=packet, space=self._spaces[packet.epoch]
)
if packet.epoch == tls.Epoch.HANDSHAKE:
sent_handshake = True
# log packet
if self._quic_logger is not None:
self._quic_logger.log_event(
category="transport",
event="packet_sent",
data={
"packet_type": self._quic_logger.packet_type(
packet.packet_type
),
"header": {
"packet_number": str(packet.packet_number),
"packet_size": packet.sent_bytes,
"scid": dump_cid(self.host_cid)
if</s>
===========below chunk 1===========
# module: aioquic.quic.connection
class QuicConnection:
def datagrams_to_send(self, now: float) -> List[Tuple[bytes, NetworkAddress]]:
# offset: 2
<s> "packet_size": packet.sent_bytes,
"scid": dump_cid(self.host_cid)
if is_long_header(packet.packet_type)
else "",
"dcid": dump_cid(self._peer_cid),
},
"frames": packet.quic_logger_frames,
},
)
# check if we can discard initial keys
if sent_handshake and self._is_client:
self._discard_epoch(tls.Epoch.INITIAL)
# return datagrams to send and the destination network address
ret = []
for datagram in datagrams:
byte_length = len(datagram)
network_path.bytes_sent += byte_length
ret.append((datagram, network_path.addr))
if self._quic_logger is not None:
self._quic_logger.log_event(
category="transport",
event="datagrams_sent",
data={"byte_length": byte_length, "count": 1},
)
return ret
===========unchanged ref 0===========
at: aioquic.quic.connection
NetworkAddress = Any
dump_cid(cid: bytes) -> str
END_STATES = frozenset(
[
QuicConnectionState.CLOSING,
QuicConnectionState.DRAINING,
QuicConnectionState.TERMINATED,
]
)
at: aioquic.quic.connection.QuicConnection
_close_begin(is_initiator: bool, now: float) -> None
_discard_epoch(epoch: tls.Epoch) -> None
_write_application(builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float) -> None
_write_handshake(builder: QuicPacketBuilder, epoch: tls.Epoch) -> None
_write_connection_close_frame(builder: QuicPacketBuilder, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None
at: aioquic.quic.connection.QuicConnection.__init__
self._is_client = configuration.is_client
self._close_event: Optional[events.ConnectionTerminated] = None
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._handshake_confirmed = False
self.host_cid = self._host_cids[0].cid
self._network_paths: List[QuicNetworkPath] = []
self._packet_number = 0
self._peer_cid = os.urandom(configuration.connection_id_length)
self._peer_token = b""
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
self._spaces: Dict[tls.Epoch, QuicPacketSpace] = {}
self._spin_bit = False
self._state = QuicConnectionState.FIRSTFLIGHT
self._version: Optional[int] = None
===========unchanged ref 1===========
self._loss = QuicPacketRecovery(
is_client_without_1rtt=self._is_client,
quic_logger=self._quic_logger,
send_probe=self._send_probe,
)
self._close_pending = False
self._probe_pending = False
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
at: aioquic.quic.connection.QuicConnection._handle_ack_frame
self._handshake_confirmed = True
at: aioquic.quic.connection.QuicConnection._handle_connection_close_frame
self._close_event = events.ConnectionTerminated(
error_code=error_code, frame_type=frame_type, reason_phrase=reason_phrase
)
at: aioquic.quic.connection.QuicConnection._initialize
self._cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self._spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
self._packet_number = 0
at: aioquic.quic.connection.QuicConnection._send_probe
self._probe_pending = True
at: aioquic.quic.connection.QuicConnection._set_state
self._state = state
at: aioquic.quic.connection.QuicConnection._write_application
self._probe_pending = False
at: aioquic.quic.connection.QuicConnection._write_handshake
self._probe_pending = False
at: aioquic.quic.connection.QuicConnection.change_connection_id
self._peer_cid = connection_id.cid
|
aioquic.quic.logger/QuicLoggerTrace.encode_crypto_frame
|
Modified
|
aiortc~aioquic
|
370b6982f59c8b39bc0c4736b3d4ac5b223def76
|
[packet] inline NEW_CONNECTION_ID parsing / serialization
|
<3>:<add> "length": len(frame.data),
<del> "length": str(len(frame.data)),
|
# module: aioquic.quic.logger
class QuicLoggerTrace:
def encode_crypto_frame(self, frame: QuicStreamFrame) -> Dict:
<0> return {
<1> "fin": frame.fin,
<2> "frame_type": "crypto",
<3> "length": str(len(frame.data)),
<4> "offset": str(frame.offset),
<5> }
<6>
| |
aioquic.quic.logger/QuicLoggerTrace.encode_new_connection_id_frame
|
Modified
|
aiortc~aioquic
|
370b6982f59c8b39bc0c4736b3d4ac5b223def76
|
[packet] inline NEW_CONNECTION_ID parsing / serialization
|
<1>:<add> "connection_id": hexdump(connection_id),
<del> "connection_id": hexdump(frame.connection_id),
<3>:<add> "length": len(connection_id),
<del> "length": len(str(frame.connection_id)),
<4>:<add> "reset_token": hexdump(stateless_reset_token),
<del> "reset_token": hexdump(frame.stateless_reset_token),
<5>:<add> "retire_prior_to": str(retire_prior_to),
<del> "retire_prior_to": str(frame.retire_prior_to),
<6>:<add> "sequence_number": str(sequence_number),
<del> "sequence_number": str(frame.sequence_number),
|
# module: aioquic.quic.logger
class QuicLoggerTrace:
+ def encode_new_connection_id_frame(
+ self,
+ connection_id: bytes,
+ retire_prior_to: int,
+ sequence_number: int,
+ stateless_reset_token: bytes,
+ ) -> Dict:
- def encode_new_connection_id_frame(self, frame: QuicNewConnectionIdFrame) -> Dict:
<0> return {
<1> "connection_id": hexdump(frame.connection_id),
<2> "frame_type": "new_connection_id",
<3> "length": len(str(frame.connection_id)),
<4> "reset_token": hexdump(frame.stateless_reset_token),
<5> "retire_prior_to": str(frame.retire_prior_to),
<6> "sequence_number": str(frame.sequence_number),
<7> }
<8>
|
===========unchanged ref 0===========
at: aioquic.quic.logger
hexdump(data: bytes) -> str
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: aioquic.quic.logger
class QuicLoggerTrace:
def encode_crypto_frame(self, frame: QuicStreamFrame) -> Dict:
return {
"fin": frame.fin,
"frame_type": "crypto",
+ "length": len(frame.data),
- "length": str(len(frame.data)),
"offset": str(frame.offset),
}
|
aioquic.quic.logger/QuicLoggerTrace.encode_new_token_frame
|
Modified
|
aiortc~aioquic
|
370b6982f59c8b39bc0c4736b3d4ac5b223def76
|
[packet] inline NEW_CONNECTION_ID parsing / serialization
|
<2>:<add> "length": len(token),
<del> "length": str(len(token)),
|
# module: aioquic.quic.logger
class QuicLoggerTrace:
def encode_new_token_frame(self, token: bytes) -> Dict:
<0> return {
<1> "frame_type": "new_token",
<2> "length": str(len(token)),
<3> "token": hexdump(token),
<4> }
<5>
|
===========unchanged ref 0===========
at: aioquic.quic.logger
hexdump(data: bytes) -> str
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: aioquic.quic.logger
class QuicLoggerTrace:
def encode_crypto_frame(self, frame: QuicStreamFrame) -> Dict:
return {
"fin": frame.fin,
"frame_type": "crypto",
+ "length": len(frame.data),
- "length": str(len(frame.data)),
"offset": str(frame.offset),
}
===========changed ref 1===========
# module: aioquic.quic.logger
class QuicLoggerTrace:
+ def encode_new_connection_id_frame(
+ self,
+ connection_id: bytes,
+ retire_prior_to: int,
+ sequence_number: int,
+ stateless_reset_token: bytes,
+ ) -> Dict:
- def encode_new_connection_id_frame(self, frame: QuicNewConnectionIdFrame) -> Dict:
return {
+ "connection_id": hexdump(connection_id),
- "connection_id": hexdump(frame.connection_id),
"frame_type": "new_connection_id",
+ "length": len(connection_id),
- "length": len(str(frame.connection_id)),
+ "reset_token": hexdump(stateless_reset_token),
- "reset_token": hexdump(frame.stateless_reset_token),
+ "retire_prior_to": str(retire_prior_to),
- "retire_prior_to": str(frame.retire_prior_to),
+ "sequence_number": str(sequence_number),
- "sequence_number": str(frame.sequence_number),
}
|
aioquic.quic.logger/QuicLoggerTrace.encode_stream_frame
|
Modified
|
aiortc~aioquic
|
370b6982f59c8b39bc0c4736b3d4ac5b223def76
|
[packet] inline NEW_CONNECTION_ID parsing / serialization
|
<3>:<add> "length": len(frame.data),
<del> "length": str(len(frame.data)),
|
# module: aioquic.quic.logger
class QuicLoggerTrace:
def encode_stream_frame(self, frame: QuicStreamFrame, stream_id: int) -> Dict:
<0> return {
<1> "fin": frame.fin,
<2> "frame_type": "stream",
<3> "length": str(len(frame.data)),
<4> "offset": str(frame.offset),
<5> "stream_id": str(stream_id),
<6> }
<7>
|
===========unchanged ref 0===========
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: aioquic.quic.logger
class QuicLoggerTrace:
def encode_new_token_frame(self, token: bytes) -> Dict:
return {
"frame_type": "new_token",
+ "length": len(token),
- "length": str(len(token)),
"token": hexdump(token),
}
===========changed ref 1===========
# module: aioquic.quic.logger
class QuicLoggerTrace:
def encode_crypto_frame(self, frame: QuicStreamFrame) -> Dict:
return {
"fin": frame.fin,
"frame_type": "crypto",
+ "length": len(frame.data),
- "length": str(len(frame.data)),
"offset": str(frame.offset),
}
===========changed ref 2===========
# module: aioquic.quic.logger
class QuicLoggerTrace:
+ def encode_new_connection_id_frame(
+ self,
+ connection_id: bytes,
+ retire_prior_to: int,
+ sequence_number: int,
+ stateless_reset_token: bytes,
+ ) -> Dict:
- def encode_new_connection_id_frame(self, frame: QuicNewConnectionIdFrame) -> Dict:
return {
+ "connection_id": hexdump(connection_id),
- "connection_id": hexdump(frame.connection_id),
"frame_type": "new_connection_id",
+ "length": len(connection_id),
- "length": len(str(frame.connection_id)),
+ "reset_token": hexdump(stateless_reset_token),
- "reset_token": hexdump(frame.stateless_reset_token),
+ "retire_prior_to": str(retire_prior_to),
- "retire_prior_to": str(frame.retire_prior_to),
+ "sequence_number": str(sequence_number),
- "sequence_number": str(frame.sequence_number),
}
|
aioquic.quic.connection/QuicConnection._handle_new_connection_id_frame
|
Modified
|
aiortc~aioquic
|
370b6982f59c8b39bc0c4736b3d4ac5b223def76
|
[packet] inline NEW_CONNECTION_ID parsing / serialization
|
<3>:<add> sequence_number = buf.pull_uint_var()
<add> retire_prior_to = buf.pull_uint_var()
<add> length = buf.pull_uint8()
<add> connection_id = buf.pull_bytes(length)
<add> stateless_reset_token = buf.pull_bytes(16)
<del> frame = pull_new_connection_id_frame(buf)
<8>:<add> self._quic_logger.encode_new_connection_id_frame(
<del> self._quic_logger.encode_new_connection_id_frame(frame)
<9>:<add> connection_id=connection_id,
<add> retire_prior_to=retire_prior_to,
<add> sequence_number=sequence_number,
<add> stateless_reset_token=stateless_reset_token,
<add> )
<13>:<add> cid=connection_id,
<del> cid=frame.connection_id,
<14>:<add> sequence_number=sequence_number,
<del> sequence_number=frame.sequence_number,
<15>:<add> stateless_reset_token=stateless_reset_token,
<del> stateless_reset_token=frame.stateless_reset_token,
|
# module: aioquic.quic.connection
class QuicConnection:
def _handle_new_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a NEW_CONNECTION_ID frame.
<2> """
<3> frame = pull_new_connection_id_frame(buf)
<4>
<5> # log frame
<6> if self._quic_logger is not None:
<7> context.quic_logger_frames.append(
<8> self._quic_logger.encode_new_connection_id_frame(frame)
<9> )
<10>
<11> self._peer_cid_available.append(
<12> QuicConnectionId(
<13> cid=frame.connection_id,
<14> sequence_number=frame.sequence_number,
<15> stateless_reset_token=frame.stateless_reset_token,
<16> )
<17> )
<18>
|
===========unchanged ref 0===========
at: aioquic.quic.connection
QuicConnectionId(cid: bytes, sequence_number: int, stateless_reset_token: bytes=b"", was_sent: bool=False)
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath, quic_logger_frames: Optional[List[Any]], time: float)
at: aioquic.quic.connection.QuicConnection.__init__
self._peer_cid_available: List[QuicConnectionId] = []
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
at: aioquic.quic.connection.QuicConnectionId
cid: bytes
sequence_number: int
stateless_reset_token: bytes = b""
was_sent: bool = False
at: aioquic.quic.connection.QuicReceiveContext
epoch: tls.Epoch
host_cid: bytes
network_path: QuicNetworkPath
quic_logger_frames: Optional[List[Any]]
time: float
===========changed ref 0===========
# module: aioquic.quic.packet
- @dataclass
- class QuicNewConnectionIdFrame:
- sequence_number: int
- retire_prior_to: int
- connection_id: bytes
- stateless_reset_token: bytes
-
===========changed ref 1===========
# module: aioquic.quic.logger
class QuicLoggerTrace:
def encode_new_token_frame(self, token: bytes) -> Dict:
return {
"frame_type": "new_token",
+ "length": len(token),
- "length": str(len(token)),
"token": hexdump(token),
}
===========changed ref 2===========
# module: aioquic.quic.logger
class QuicLoggerTrace:
def encode_crypto_frame(self, frame: QuicStreamFrame) -> Dict:
return {
"fin": frame.fin,
"frame_type": "crypto",
+ "length": len(frame.data),
- "length": str(len(frame.data)),
"offset": str(frame.offset),
}
===========changed ref 3===========
# module: aioquic.quic.logger
class QuicLoggerTrace:
def encode_stream_frame(self, frame: QuicStreamFrame, stream_id: int) -> Dict:
return {
"fin": frame.fin,
"frame_type": "stream",
+ "length": len(frame.data),
- "length": str(len(frame.data)),
"offset": str(frame.offset),
"stream_id": str(stream_id),
}
===========changed ref 4===========
# module: aioquic.quic.packet
- def push_new_connection_id_frame(buf: Buffer, frame: QuicNewConnectionIdFrame) -> None:
- assert len(frame.stateless_reset_token) == 16
- buf.push_uint_var(frame.sequence_number)
- buf.push_uint_var(frame.retire_prior_to)
- buf.push_uint8(len(frame.connection_id))
- buf.push_bytes(frame.connection_id)
- buf.push_bytes(frame.stateless_reset_token)
-
===========changed ref 5===========
# module: aioquic.quic.packet
- def pull_new_connection_id_frame(buf: Buffer) -> QuicNewConnectionIdFrame:
- sequence_number = buf.pull_uint_var()
- retire_prior_to = buf.pull_uint_var()
- length = buf.pull_uint8()
- connection_id = buf.pull_bytes(length)
- stateless_reset_token = buf.pull_bytes(16)
- return QuicNewConnectionIdFrame(
- sequence_number=sequence_number,
- retire_prior_to=retire_prior_to,
- connection_id=connection_id,
- stateless_reset_token=stateless_reset_token,
- )
-
===========changed ref 6===========
# module: aioquic.quic.logger
class QuicLoggerTrace:
+ def encode_new_connection_id_frame(
+ self,
+ connection_id: bytes,
+ retire_prior_to: int,
+ sequence_number: int,
+ stateless_reset_token: bytes,
+ ) -> Dict:
- def encode_new_connection_id_frame(self, frame: QuicNewConnectionIdFrame) -> Dict:
return {
+ "connection_id": hexdump(connection_id),
- "connection_id": hexdump(frame.connection_id),
"frame_type": "new_connection_id",
+ "length": len(connection_id),
- "length": len(str(frame.connection_id)),
+ "reset_token": hexdump(stateless_reset_token),
- "reset_token": hexdump(frame.stateless_reset_token),
+ "retire_prior_to": str(retire_prior_to),
- "retire_prior_to": str(frame.retire_prior_to),
+ "sequence_number": str(sequence_number),
- "sequence_number": str(frame.sequence_number),
}
===========changed ref 7===========
# module: tests.test_packet
class FrameTest(TestCase):
- def test_new_connection_id(self):
- data = binascii.unhexlify(
- "0200117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8"
- )
-
- # parse
- buf = Buffer(data=data)
- frame = packet.pull_new_connection_id_frame(buf)
- self.assertEqual(
- frame,
- QuicNewConnectionIdFrame(
- sequence_number=2,
- retire_prior_to=0,
- connection_id=binascii.unhexlify("7813f3d9e45e0cacbb491b4b66b039f204"),
- stateless_reset_token=binascii.unhexlify(
- "06f68fede38ec4c31aba8ab1245244e8"
- ),
- ),
- )
-
- # serialize
- buf = Buffer(capacity=len(data))
- packet.push_new_connection_id_frame(buf, frame)
- self.assertEqual(buf.data, data)
-
|
aioquic.quic.connection/QuicConnection._write_new_connection_id_frame
|
Modified
|
aiortc~aioquic
|
370b6982f59c8b39bc0c4736b3d4ac5b223def76
|
[packet] inline NEW_CONNECTION_ID parsing / serialization
|
<0>:<add> retire_prior_to = 0 # FIXME
<add>
<5>:<del> frame = QuicNewConnectionIdFrame(
<6>:<del> sequence_number=connection_id.sequence_number,
<7>:<del> retire_prior_to=0, # FIXME
<8>:<del> connection_id=connection_id.cid,
<9>:<del> stateless_reset_token=connection_id.stateless_reset_token,
<10>:<del> )
<11>:<del> push_new_connection_id_frame(buf, frame)
<12>:<add> buf.push_uint_var(connection_id.sequence_number)
<add> buf.push_uint_var(retire_prior_to)
<add> buf.push_uint8(len(connection_id.cid))
<add> buf.push_bytes(connection_id.cid)
<add> buf.push_bytes(connection_id.stateless_reset_token)
<add>
<18>:<add> self._quic_logger.encode_new_connection_id_frame(
<del> self._quic_logger.encode_new_connection_id_frame(frame)
<19>:<add> connection_id=connection_id.cid,
<add> retire_prior_to=retire_prior_to,
<add> sequence_number=connection_id.sequence_number,
<add> stateless_reset_token=connection_id.stateless_reset_token,
<add> )
|
# module: aioquic.quic.connection
class QuicConnection:
def _write_new_connection_id_frame(
self, builder: QuicPacketBuilder, connection_id: QuicConnectionId
) -> None:
<0> buf = builder.start_frame(
<1> QuicFrameType.NEW_CONNECTION_ID,
<2> self._on_new_connection_id_delivery,
<3> (connection_id,),
<4> )
<5> frame = QuicNewConnectionIdFrame(
<6> sequence_number=connection_id.sequence_number,
<7> retire_prior_to=0, # FIXME
<8> connection_id=connection_id.cid,
<9> stateless_reset_token=connection_id.stateless_reset_token,
<10> )
<11> push_new_connection_id_frame(buf, frame)
<12> connection_id.was_sent = True
<13> self._events.append(events.ConnectionIdIssued(connection_id=connection_id.cid))
<14>
<15> # log frame
<16> if self._quic_logger is not None:
<17> builder.quic_logger_frames.append(
<18> self._quic_logger.encode_new_connection_id_frame(frame)
<19> )
<20>
|
===========unchanged ref 0===========
at: aioquic.quic.connection
QuicConnectionId(cid: bytes, sequence_number: int, stateless_reset_token: bytes=b"", was_sent: bool=False)
at: aioquic.quic.connection.QuicConnection
_on_new_connection_id_delivery(delivery: QuicDeliveryState, connection_id: QuicConnectionId) -> None
at: aioquic.quic.connection.QuicConnection.__init__
self._events: Deque[events.QuicEvent] = deque()
self._quic_logger: Optional[QuicLoggerTrace] = None
self._quic_logger = configuration.quic_logger.start_trace(
is_client=configuration.is_client, odcid=logger_connection_id
)
at: aioquic.quic.connection.QuicConnection._close_end
self._quic_logger = None
at: aioquic.quic.connection.QuicConnectionId
cid: bytes
sequence_number: int
stateless_reset_token: bytes = b""
was_sent: bool = False
at: collections.deque
append(x: _T) -> None
===========changed ref 0===========
# module: aioquic.quic.packet
- @dataclass
- class QuicNewConnectionIdFrame:
- sequence_number: int
- retire_prior_to: int
- connection_id: bytes
- stateless_reset_token: bytes
-
===========changed ref 1===========
# module: aioquic.quic.logger
class QuicLoggerTrace:
def encode_new_token_frame(self, token: bytes) -> Dict:
return {
"frame_type": "new_token",
+ "length": len(token),
- "length": str(len(token)),
"token": hexdump(token),
}
===========changed ref 2===========
# module: aioquic.quic.logger
class QuicLoggerTrace:
def encode_crypto_frame(self, frame: QuicStreamFrame) -> Dict:
return {
"fin": frame.fin,
"frame_type": "crypto",
+ "length": len(frame.data),
- "length": str(len(frame.data)),
"offset": str(frame.offset),
}
===========changed ref 3===========
# module: aioquic.quic.logger
class QuicLoggerTrace:
def encode_stream_frame(self, frame: QuicStreamFrame, stream_id: int) -> Dict:
return {
"fin": frame.fin,
"frame_type": "stream",
+ "length": len(frame.data),
- "length": str(len(frame.data)),
"offset": str(frame.offset),
"stream_id": str(stream_id),
}
===========changed ref 4===========
# module: aioquic.quic.packet
- def push_new_connection_id_frame(buf: Buffer, frame: QuicNewConnectionIdFrame) -> None:
- assert len(frame.stateless_reset_token) == 16
- buf.push_uint_var(frame.sequence_number)
- buf.push_uint_var(frame.retire_prior_to)
- buf.push_uint8(len(frame.connection_id))
- buf.push_bytes(frame.connection_id)
- buf.push_bytes(frame.stateless_reset_token)
-
===========changed ref 5===========
# module: aioquic.quic.packet
- def pull_new_connection_id_frame(buf: Buffer) -> QuicNewConnectionIdFrame:
- sequence_number = buf.pull_uint_var()
- retire_prior_to = buf.pull_uint_var()
- length = buf.pull_uint8()
- connection_id = buf.pull_bytes(length)
- stateless_reset_token = buf.pull_bytes(16)
- return QuicNewConnectionIdFrame(
- sequence_number=sequence_number,
- retire_prior_to=retire_prior_to,
- connection_id=connection_id,
- stateless_reset_token=stateless_reset_token,
- )
-
===========changed ref 6===========
# module: aioquic.quic.connection
class QuicConnection:
def _handle_new_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a NEW_CONNECTION_ID frame.
"""
+ sequence_number = buf.pull_uint_var()
+ retire_prior_to = buf.pull_uint_var()
+ length = buf.pull_uint8()
+ connection_id = buf.pull_bytes(length)
+ stateless_reset_token = buf.pull_bytes(16)
- frame = pull_new_connection_id_frame(buf)
# log frame
if self._quic_logger is not None:
context.quic_logger_frames.append(
+ self._quic_logger.encode_new_connection_id_frame(
- self._quic_logger.encode_new_connection_id_frame(frame)
+ connection_id=connection_id,
+ retire_prior_to=retire_prior_to,
+ sequence_number=sequence_number,
+ stateless_reset_token=stateless_reset_token,
+ )
)
self._peer_cid_available.append(
QuicConnectionId(
+ cid=connection_id,
- cid=frame.connection_id,
+ sequence_number=sequence_number,
- sequence_number=frame.sequence_number,
+ stateless_reset_token=stateless_reset_token,
- stateless_reset_token=frame.stateless_reset_token,
)
)
===========changed ref 7===========
# module: aioquic.quic.logger
class QuicLoggerTrace:
+ def encode_new_connection_id_frame(
+ self,
+ connection_id: bytes,
+ retire_prior_to: int,
+ sequence_number: int,
+ stateless_reset_token: bytes,
+ ) -> Dict:
- def encode_new_connection_id_frame(self, frame: QuicNewConnectionIdFrame) -> Dict:
return {
+ "connection_id": hexdump(connection_id),
- "connection_id": hexdump(frame.connection_id),
"frame_type": "new_connection_id",
+ "length": len(connection_id),
- "length": len(str(frame.connection_id)),
+ "reset_token": hexdump(stateless_reset_token),
- "reset_token": hexdump(frame.stateless_reset_token),
+ "retire_prior_to": str(retire_prior_to),
- "retire_prior_to": str(frame.retire_prior_to),
+ "sequence_number": str(sequence_number),
- "sequence_number": str(frame.sequence_number),
}
|
tests.test_asyncio/HighLevelTest.test_connect_and_serve_with_packet_loss
|
Modified
|
aiortc~aioquic
|
99eba3fabec092be4f71128517950ca17d4d5aeb
|
[tests] don't touch idle timeout for packet loss test
|
<7>:<add> is_client=False, quic_logger=QuicLogger()
<del> idle_timeout=300.0, is_client=False, quic_logger=QuicLogger()
<16>:<add> is_client=True, quic_logger=QuicLogger()
<del> is_client=True, idle_timeout=300.0, quic_logger=QuicLogger()
|
# module: tests.test_asyncio
class HighLevelTest(TestCase):
@patch("socket.socket.sendto", new_callable=lambda: sendto_with_loss)
def test_connect_and_serve_with_packet_loss(self, mock_sendto):
<0> """
<1> This test ensures handshake success and stream data is successfully sent
<2> and received in the presence of packet loss (randomized 25% in each direction).
<3> """
<4> data = b"Z" * 65536
<5>
<6> server_configuration = QuicConfiguration(
<7> idle_timeout=300.0, is_client=False, quic_logger=QuicLogger()
<8> )
<9> server_configuration.load_cert_chain(SERVER_CERTFILE, SERVER_KEYFILE)
<10> run(self.run_server(configuration=server_configuration))
<11>
<12> response = run(
<13> self.run_client(
<14> "127.0.0.1",
<15> configuration=QuicConfiguration(
<16> is_client=True, idle_timeout=300.0, quic_logger=QuicLogger()
<17> ),
<18> request=data,
<19> )
<20> )
<21> self.assertEqual(response, data)
<22>
|
===========unchanged ref 0===========
at: tests.test_asyncio
sendto_with_loss(self, data, addr=None)
at: tests.test_asyncio.HighLevelTest
run_client(host, port=4433, cadata=None, cafile=SERVER_CACERTFILE, configuration=None, request=b"ping", **kwargs)
run_server(configuration=None, **kwargs)
at: tests.utils
run(coro)
SERVER_CERTFILE = os.path.join(os.path.dirname(__file__), "ssl_cert.pem")
SERVER_KEYFILE = os.path.join(os.path.dirname(__file__), "ssl_key.pem")
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
at: unittest.mock
_patcher(target: Any, new: _T, spec: Optional[Any]=..., create: bool=..., spec_set: Optional[Any]=..., autospec: Optional[Any]=..., new_callable: Optional[Any]=..., **kwargs: Any) -> _patch[_T]
_patcher(target: Any, *, spec: Optional[Any]=..., create: bool=..., spec_set: Optional[Any]=..., autospec: Optional[Any]=..., new_callable: Optional[Any]=..., **kwargs: Any) -> _patch[Union[MagicMock, AsyncMock]]
|
aioquic.quic.recovery/QuicPacketSpace.__init__
|
Modified
|
aiortc~aioquic
|
d5db4f58df738f25b0f4fa7575829c4b6ca77f3a
|
[recovery] send ack_delay
|
<3>:<add> self.largest_received_packet = -1
<del> self.largest_received_packet = 0
<4>:<add> self.largest_received_time: Optional[float] = None
|
# module: aioquic.quic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
<0> self.ack_at: Optional[float] = None
<1> self.ack_queue = RangeSet()
<2> self.expected_packet_number = 0
<3> self.largest_received_packet = 0
<4>
<5> # sent packets and loss
<6> self.ack_eliciting_in_flight = 0
<7> self.largest_acked_packet = 0
<8> self.loss_time: Optional[float] = None
<9> self.sent_packets: Dict[int, QuicSentPacket] = {}
<10>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.