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.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
8dcf957d462fde5bd7480b49e6643d7180986582
|
[connection] rework packet writing
|
<2>:<del> send_ack = space.ack_queue if self.send_ack[epoch] else None
<8>:<add> while True:
<add> # write header
<del> # write header
<9>:<add> push_uint8(buf, PACKET_FIXED_BIT | (SEND_PN_SIZE - 1))
<del> push_uint8(buf, PACKET_FIXED_BIT | (SEND_PN_SIZE - 1))
<10>:<add> push_bytes(buf, self.peer_cid)
<del> push_bytes(buf, self.peer_cid)
<11>:<add> push_uint16(buf, self.packet_number)
<del> push_uint16(buf, self.packet_number)
<12>:<add> header_size = buf.tell()
<del> header_size = buf.tell()
<14>:<add> # ACK
<del> # ACK
<15>:<add> if self.send_ack[epoch] and space.ack_queue:
<del> if send_ack:
<16>:<add> push_uint_var(buf, QuicFrameType.ACK)
<del> push_uint_var(buf, QuicFrameType.ACK)
<17>:<add> packet.push_ack_frame(buf, space.ack_queue, 0)
<del> packet.push_ack_frame(buf, send_ack, 0)
<18>:<add> self.send_ack[epoch] = False
<del> self.send_ack[epoch] = False
<20>:<add> # CLOSE
<del> # CLOSE
<21>:<add> if self.__close and self.__epoch == epoch:
<del> if self.__close and self.__epoch == epoch:
<22>:<add> push_close(buf, **self.__close)
<del> push_close(buf, **self.__close)
<23>:<add> self.__close = None
<del> self.__close = None
<25>:<add> # STREAM
<del> # STREAM
<26>:<add> for stream_id, stream in self
|
# module: aioquic.connection
class QuicConnection:
def _write_application(self) -> Iterator[bytes]:
<0> epoch = tls.Epoch.ONE_RTT
<1> space = self.spaces[epoch]
<2> send_ack = space.ack_queue if self.send_ack[epoch] else None
<3> if not space.crypto.send.is_valid():
<4> return
<5>
<6> buf = Buffer(capacity=PACKET_MAX_SIZE)
<7>
<8> # write header
<9> push_uint8(buf, PACKET_FIXED_BIT | (SEND_PN_SIZE - 1))
<10> push_bytes(buf, self.peer_cid)
<11> push_uint16(buf, self.packet_number)
<12> header_size = buf.tell()
<13>
<14> # ACK
<15> if send_ack:
<16> push_uint_var(buf, QuicFrameType.ACK)
<17> packet.push_ack_frame(buf, send_ack, 0)
<18> self.send_ack[epoch] = False
<19>
<20> # CLOSE
<21> if self.__close and self.__epoch == epoch:
<22> push_close(buf, **self.__close)
<23> self.__close = None
<24>
<25> # STREAM
<26> for stream_id, stream in self.streams.items():
<27> if isinstance(stream_id, int) and stream.has_data_to_send():
<28> frame = stream.get_frame(
<29> PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6
<30> )
<31> flags = QuicStreamFlag.OFF | QuicStreamFlag.LEN
<32> if frame.fin:
<33> flags |= QuicStreamFlag.FIN
<34> push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)
<35> with push_stream_frame(buf, 0, frame.offset):
<36> push_bytes(buf, frame.data)
<37>
<38> # encrypt
<39> packet_size = buf.tell()
<40> if packet_size > header_size:
<41> </s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _write_application(self) -> Iterator[bytes]:
# offset: 1
yield space.crypto.encrypt_packet(
data[0:header_size], data[header_size:packet_size]
)
self.packet_number += 1
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
push_bytes(buf: Buffer, v: bytes) -> None
push_uint8(buf: Buffer, v: int) -> None
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.connection
PACKET_MAX_SIZE = 1280
SEND_PN_SIZE = 2
push_close(buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: bytes) -> None
at: aioquic.connection.PacketSpace.__init__
self.ack_queue = RangeSet()
self.crypto = CryptoPair()
at: aioquic.connection.QuicConnection.__init__
self.peer_cid = os.urandom(8)
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__close: Optional[Dict] = None
self.__epoch = tls.Epoch.INITIAL
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self.__logger)
self.send_ack = {
tls.Epoch.INITIAL: False,
tls.Epoch.HANDSHAKE: False,
tls.Epoch.ONE_RTT: False,
}
self.spaces = {
tls.Epoch.INITIAL: PacketSpace(),
tls.Epoch.HANDSHAKE: PacketSpace(),
tls.Epoch.ONE_RTT: PacketSpace(),
}
self.packet_number = 0
at: aioquic.connection.QuicConnection._payload_received
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._update_traffic_key
crypto = self.spaces[epoch].crypto
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._write_application
self.packet_number += 1
at: aioquic.connection.QuicConnection._write_handshake
self.__close = None
self.packet_number += 1
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.datagram_received
self.peer_cid = header.source_cid
at: aioquic.crypto.CryptoContext
is_valid() -> bool
setup(cipher_suite: CipherSuite, secret: bytes) -> None
at: aioquic.crypto.CryptoPair.__init__
self.aead_tag_size = 16
self.recv = CryptoContext()
self.send = CryptoContext()
at: aioquic.packet
PACKET_FIXED_BIT = 0x40
push_uint_var(buf: Buffer, value: int) -> None
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
push_ack_frame(buf: Buffer, rangeset: RangeSet, delay: int) -> None
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
push_stream_frame(buf: Buffer, stream_id: int, offset: int) -> Generator
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.stream.QuicStream
get_frame(size: int) -> QuicStreamFrame
has_data_to_send() -> bool
===========unchanged ref 2===========
at: aioquic.tls
Direction()
Epoch()
at: aioquic.tls.Context.__init__
self.key_schedule: Optional[KeySchedule] = None
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
at: aioquic.tls.Context._server_handle_hello
self.key_schedule = KeySchedule(cipher_suite)
at: aioquic.tls.KeySchedule.__init__
self.cipher_suite = cipher_suite
at: typing
Iterator = _alias(collections.abc.Iterator, 1)
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def datagram_received(self, data: bytes, addr: Any) -> None:
"""
Handle an incoming datagram.
"""
buf = Buffer(data=data)
while not buf.eof():
start_off = buf.tell()
header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:
# version negotiation
versions = []
while not buf.eof():
versions.append(pull_uint32(buf))
common = set(self.supported_versions).intersection(versions)
if not common:
self.__logger.error("Could not find a common protocol version")
return
self.version = QuicProtocolVersion(max(common))
self.__logger.info("Retrying with %s" % self.version)
self.connection_made(self.__transport)
return
elif self.is_client and header.packet_type == PACKET_TYPE_RETRY:
# stateless retry
if (
header.destination_cid == self.host_cid
and header.original_destination_cid == self.peer_cid
):
self.__logger.info("Performing stateless retry")
self.peer_cid = header.source_cid
self.peer_token = header.token
self.connection_made(self.__transport)
return
encrypted_off = buf.tell() - start_off
end_off = buf.tell() + header.rest_length
pull_bytes(buf, header.rest_length)
if not self.is_client and not self.__initialized:
self._initialize(header.destination_cid)
epoch = get_epoch(header.packet_type)
space = self.spaces[epoch]
try:
plain_header, plain_payload, packet_number = space.crypto.decrypt_packet(
data[start_off:end_off], encrypted_</s>
|
aioquic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
8dcf957d462fde5bd7480b49e6643d7180986582
|
[connection] rework packet writing
|
<1>:<del> stream = self.streams[epoch]
<2>:<del> send_ack = space.ack_queue if self.send_ack[epoch] else None
<3>:<del> self.send_ack[epoch] = False
<4>:<add> if not space.crypto.send.is_valid():
<add> return
<7>:<add> while True:
<del> while space.crypto.send.is_valid() and (send_ack or stream.has_data_to_send()):
<27>:<add> if self.send_ack[epoch] and space.ack_queue:
<del> if send_ack is not None:
<29>:<add> packet.push_ack_frame(buf, space.ack_queue, 0)
<del> packet.push_ack_frame(buf, send_ack, 0)
<30>:<add> self.send_ack[epoch] = False
<del> send_ack = None
<37>:<add> stream = self.streams[epoch]
|
# module: aioquic.connection
class QuicConnection:
def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]:
<0> space = self.spaces[epoch]
<1> stream = self.streams[epoch]
<2> send_ack = space.ack_queue if self.send_ack[epoch] else None
<3> self.send_ack[epoch] = False
<4>
<5> buf = Buffer(capacity=PACKET_MAX_SIZE)
<6>
<7> while space.crypto.send.is_valid() and (send_ack or stream.has_data_to_send()):
<8> if epoch == tls.Epoch.INITIAL:
<9> packet_type = PACKET_TYPE_INITIAL
<10> else:
<11> packet_type = PACKET_TYPE_HANDSHAKE
<12>
<13> # write header
<14> push_quic_header(
<15> buf,
<16> QuicHeader(
<17> version=self.version,
<18> packet_type=packet_type | (SEND_PN_SIZE - 1),
<19> destination_cid=self.peer_cid,
<20> source_cid=self.host_cid,
<21> token=self.peer_token,
<22> ),
<23> )
<24> header_size = buf.tell()
<25>
<26> # ACK
<27> if send_ack is not None:
<28> push_uint_var(buf, QuicFrameType.ACK)
<29> packet.push_ack_frame(buf, send_ack, 0)
<30> send_ack = None
<31>
<32> # CLOSE
<33> if self.__close and self.__epoch == epoch:
<34> push_close(buf, **self.__close)
<35> self.__close = None
<36>
<37> if stream.has_data_to_send():
<38> # CRYPTO
<39> frame = stream.get_frame(
<40> PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 4
<41> )
<42> push_uint_var(buf, QuicFrameType.CRYPTO)
<43> with packet.push_crypto_frame(buf,</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]:
# offset: 1
push_bytes(buf, frame.data)
# PADDING
if epoch == tls.Epoch.INITIAL and self.is_client:
push_bytes(
buf,
bytes(
PACKET_MAX_SIZE - space.crypto.aead_tag_size - buf.tell()
),
)
# finalize length
packet_size = buf.tell()
buf.seek(header_size - SEND_PN_SIZE - 2)
length = packet_size - header_size + 2 + space.crypto.aead_tag_size
push_uint16(buf, length | 0x4000)
push_uint16(buf, self.packet_number)
buf.seek(packet_size)
# encrypt
data = buf.data
yield space.crypto.encrypt_packet(
data[0:header_size], data[header_size:packet_size]
)
self.packet_number += 1
buf.seek(0)
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
push_bytes(buf: Buffer, v: bytes) -> None
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
seek(pos: int) -> None
tell() -> int
at: aioquic.connection
PACKET_MAX_SIZE = 1280
SEND_PN_SIZE = 2
push_close(buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: bytes) -> None
at: aioquic.connection.PacketSpace.__init__
self.ack_queue = RangeSet()
self.crypto = CryptoPair()
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_token = b""
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.version = QuicProtocolVersion.DRAFT_20
self.__close: Optional[Dict] = None
self.__epoch = tls.Epoch.INITIAL
at: aioquic.connection.QuicConnection._initialize
self.send_ack = {
tls.Epoch.INITIAL: False,
tls.Epoch.HANDSHAKE: False,
tls.Epoch.ONE_RTT: False,
}
self.spaces = {
tls.Epoch.INITIAL: PacketSpace(),
tls.Epoch.HANDSHAKE: PacketSpace(),
tls.Epoch.ONE_RTT: PacketSpace(),
}
self.packet_number = 0
at: aioquic.connection.QuicConnection._payload_received
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._write_application
buf = Buffer(capacity=PACKET_MAX_SIZE)
header_size = buf.tell()
self.__close = None
packet_size = buf.tell()
data = buf.data
at: aioquic.connection.QuicConnection._write_handshake
self.packet_number += 1
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair.__init__
self.aead_tag_size = 16
self.send = CryptoContext()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
QuicHeader(version: int, packet_type: int, destination_cid: bytes, source_cid: bytes, original_destination_cid: bytes=b"", token: bytes=b"", rest_length: int=0)
push_uint_var(buf: Buffer, value: int) -> None
push_quic_header(buf: Buffer, header: QuicHeader) -> None
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
push_ack_frame(buf: Buffer, rangeset: RangeSet, delay: int) -> None
===========unchanged ref 2===========
push_crypto_frame(buf: Buffer, offset: int=0) -> Generator
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
offset: int = 0
at: aioquic.stream.QuicStream
get_frame(size: int) -> QuicStreamFrame
has_data_to_send() -> bool
at: aioquic.tls
Epoch()
at: typing
Iterator = _alias(collections.abc.Iterator, 1)
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def datagram_received(self, data: bytes, addr: Any) -> None:
"""
Handle an incoming datagram.
"""
buf = Buffer(data=data)
while not buf.eof():
start_off = buf.tell()
header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:
# version negotiation
versions = []
while not buf.eof():
versions.append(pull_uint32(buf))
common = set(self.supported_versions).intersection(versions)
if not common:
self.__logger.error("Could not find a common protocol version")
return
self.version = QuicProtocolVersion(max(common))
self.__logger.info("Retrying with %s" % self.version)
self.connection_made(self.__transport)
return
elif self.is_client and header.packet_type == PACKET_TYPE_RETRY:
# stateless retry
if (
header.destination_cid == self.host_cid
and header.original_destination_cid == self.peer_cid
):
self.__logger.info("Performing stateless retry")
self.peer_cid = header.source_cid
self.peer_token = header.token
self.connection_made(self.__transport)
return
encrypted_off = buf.tell() - start_off
end_off = buf.tell() + header.rest_length
pull_bytes(buf, header.rest_length)
if not self.is_client and not self.__initialized:
self._initialize(header.destination_cid)
epoch = get_epoch(header.packet_type)
space = self.spaces[epoch]
try:
plain_header, plain_payload, packet_number = space.crypto.decrypt_packet(
data[start_off:end_off], encrypted_</s>
|
aioquic.packet/push_stream_frame
|
Modified
|
aiortc~aioquic
|
6c879f057b21ac99a89b6b0da534f976350060a1
|
[packets] only encode offset if necessary
|
<1>:<add> if offset:
<add> push_uint_var(buf, offset)
<del> push_uint_var(buf, offset)
|
# module: aioquic.packet
@contextmanager
def push_stream_frame(buf: Buffer, stream_id: int, offset: int) -> Generator:
<0> push_uint_var(buf, stream_id)
<1> push_uint_var(buf, offset)
<2> push_uint16(buf, 0)
<3> start = buf.tell()
<4> yield
<5> end = buf.tell()
<6> buf.seek(start - 2)
<7> push_uint16(buf, (end - start) | 0x4000)
<8> buf.seek(end)
<9>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
seek(pos: int) -> None
tell() -> int
at: aioquic.packet
push_uint_var(buf: Buffer, value: int) -> None
at: contextlib
contextmanager(func: Callable[..., Iterator[_T]]) -> Callable[..., _GeneratorContextManager[_T]]
at: typing
Generator = _alias(collections.abc.Generator, 3)
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
6c879f057b21ac99a89b6b0da534f976350060a1
|
[packets] only encode offset if necessary
|
<31>:<add> flags = QuicStreamFlag.LEN
<del> flags = QuicStreamFlag.OFF | QuicStreamFlag.LEN
<32>:<add> if frame.offset:
<add> flags |= QuicStreamFlag.OFF
|
# module: aioquic.connection
class QuicConnection:
def _write_application(self) -> Iterator[bytes]:
<0> epoch = tls.Epoch.ONE_RTT
<1> space = self.spaces[epoch]
<2> if not space.crypto.send.is_valid():
<3> return
<4>
<5> buf = Buffer(capacity=PACKET_MAX_SIZE)
<6>
<7> while True:
<8> # write header
<9> push_uint8(buf, PACKET_FIXED_BIT | (SEND_PN_SIZE - 1))
<10> push_bytes(buf, self.peer_cid)
<11> push_uint16(buf, self.packet_number)
<12> header_size = buf.tell()
<13>
<14> # ACK
<15> if self.send_ack[epoch] and space.ack_queue:
<16> push_uint_var(buf, QuicFrameType.ACK)
<17> packet.push_ack_frame(buf, space.ack_queue, 0)
<18> self.send_ack[epoch] = False
<19>
<20> # CLOSE
<21> if self.__close and self.__epoch == epoch:
<22> push_close(buf, **self.__close)
<23> self.__close = None
<24>
<25> # STREAM
<26> for stream_id, stream in self.streams.items():
<27> if isinstance(stream_id, int) and stream.has_data_to_send():
<28> frame = stream.get_frame(
<29> PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6
<30> )
<31> flags = QuicStreamFlag.OFF | QuicStreamFlag.LEN
<32> if frame.fin:
<33> flags |= QuicStreamFlag.FIN
<34> push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)
<35> with push_stream_frame(buf, 0, frame.offset):
<36> push_bytes(buf, frame.data)
<37>
<38> packet_size = buf.tell()
<39> if packet_size > header_size:
<40> # encrypt
<41> data = buf.</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _write_application(self) -> Iterator[bytes]:
# offset: 1
yield space.crypto.encrypt_packet(
data[0:header_size], data[header_size:packet_size]
)
self.packet_number += 1
buf.seek(0)
else:
break
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
push_bytes(buf: Buffer, v: bytes) -> None
push_uint8(buf: Buffer, v: int) -> None
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
seek(pos: int) -> None
tell() -> int
at: aioquic.connection
PACKET_MAX_SIZE = 1280
SEND_PN_SIZE = 2
push_close(buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: bytes) -> None
at: aioquic.connection.PacketSpace.__init__
self.ack_queue = RangeSet()
self.crypto = CryptoPair()
at: aioquic.connection.QuicConnection.__init__
self.peer_cid = os.urandom(8)
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__close: Optional[Dict] = None
self.__epoch = tls.Epoch.INITIAL
at: aioquic.connection.QuicConnection._initialize
self.send_ack = {
tls.Epoch.INITIAL: False,
tls.Epoch.HANDSHAKE: False,
tls.Epoch.ONE_RTT: False,
}
self.spaces = {
tls.Epoch.INITIAL: PacketSpace(),
tls.Epoch.HANDSHAKE: PacketSpace(),
tls.Epoch.ONE_RTT: PacketSpace(),
}
self.packet_number = 0
at: aioquic.connection.QuicConnection._payload_received
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._write_handshake
self.__close = None
self.packet_number += 1
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.datagram_received
self.peer_cid = header.source_cid
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair
encrypt_packet(plain_header: bytes, plain_payload: bytes) -> bytes
at: aioquic.crypto.CryptoPair.__init__
self.aead_tag_size = 16
self.send = CryptoContext()
at: aioquic.packet
PACKET_FIXED_BIT = 0x40
push_uint_var(buf: Buffer, value: int) -> None
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
push_ack_frame(buf: Buffer, rangeset: RangeSet, delay: int) -> None
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
push_stream_frame(buf: Buffer, stream_id: int, offset: int) -> Generator
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.stream.QuicStream
get_frame(size: int) -> QuicStreamFrame
has_data_to_send() -> bool
at: aioquic.tls
Epoch()
at: typing
Iterator = _alias(collections.abc.Iterator, 1)
===========changed ref 0===========
# module: aioquic.packet
@contextmanager
def push_stream_frame(buf: Buffer, stream_id: int, offset: int) -> Generator:
push_uint_var(buf, stream_id)
+ if offset:
+ push_uint_var(buf, offset)
- push_uint_var(buf, offset)
push_uint16(buf, 0)
start = buf.tell()
yield
end = buf.tell()
buf.seek(start - 2)
push_uint16(buf, (end - start) | 0x4000)
buf.seek(end)
|
tests.test_connection/QuicConnectionTest._test_connect_with_version
|
Modified
|
aiortc~aioquic
|
6c879f057b21ac99a89b6b0da534f976350060a1
|
[packets] only encode offset if necessary
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
<0> client = QuicConnection(is_client=True)
<1> client.supported_versions = client_versions
<2> client.version = max(client_versions)
<3>
<4> server = QuicConnection(
<5> is_client=False,
<6> certificate=SERVER_CERTIFICATE,
<7> private_key=SERVER_PRIVATE_KEY,
<8> )
<9> server.supported_versions = server_versions
<10> server.version = max(server_versions)
<11>
<12> # perform handshake
<13> client_transport, server_transport = create_transport(client, server)
<14> self.assertEqual(client_transport.sent, 4)
<15> self.assertEqual(server_transport.sent, 4)
<16> run(client.connect())
<17>
<18> # send data over stream
<19> client_reader, client_writer = client.create_stream()
<20> client_writer.write(b"ping")
<21> self.assertEqual(client_transport.sent, 5)
<22> self.assertEqual(server_transport.sent, 5)
<23>
<24> # FIXME: needs an API
<25> server_reader, server_writer = (
<26> server.streams[0].reader,
<27> server.streams[0].writer,
<28> )
<29> self.assertEqual(run(server_reader.read(1024)), b"ping")
<30> server_writer.write(b"pong")
<31> self.assertEqual(client_transport.sent, 6)
<32> self.assertEqual(server_transport.sent, 6)
<33>
<34> # client receives pong
<35> self.assertEqual(run(client_reader.read(1024)), b"pong")
<36>
<37> # client writes EOF
<38> client_writer.write_eof()
<39> self.assertEqual(client_transport.sent, 7)
<40> self.assertEqual(server_transport.sent, 7)
<41>
<42> # server receives EOF
<43> self.</s>
|
===========below chunk 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 1
return client, server
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
connect() -> None
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
at: aioquic.stream.QuicStream.__init__
self.reader = asyncio.StreamReader()
self.reader = None
self.writer = None
self.writer = asyncio.StreamWriter(self, None, self.reader, None)
at: asyncio.streams.StreamReader
_source_traceback = None
read(n: int=...) -> bytes
at: asyncio.streams.StreamWriter
write(data: bytes) -> None
write_eof() -> None
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
create_transport(client, server)
at: tests.test_connection.FakeTransport.sendto
self.sent += 1
===========unchanged ref 1===========
at: tests.utils
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: aioquic.packet
@contextmanager
def push_stream_frame(buf: Buffer, stream_id: int, offset: int) -> Generator:
push_uint_var(buf, stream_id)
+ if offset:
+ push_uint_var(buf, offset)
- push_uint_var(buf, offset)
push_uint16(buf, 0)
start = buf.tell()
yield
end = buf.tell()
buf.seek(start - 2)
push_uint16(buf, (end - start) | 0x4000)
buf.seek(end)
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def _write_application(self) -> Iterator[bytes]:
epoch = tls.Epoch.ONE_RTT
space = self.spaces[epoch]
if not space.crypto.send.is_valid():
return
buf = Buffer(capacity=PACKET_MAX_SIZE)
while True:
# write header
push_uint8(buf, PACKET_FIXED_BIT | (SEND_PN_SIZE - 1))
push_bytes(buf, self.peer_cid)
push_uint16(buf, self.packet_number)
header_size = buf.tell()
# ACK
if self.send_ack[epoch] and space.ack_queue:
push_uint_var(buf, QuicFrameType.ACK)
packet.push_ack_frame(buf, space.ack_queue, 0)
self.send_ack[epoch] = False
# CLOSE
if self.__close and self.__epoch == epoch:
push_close(buf, **self.__close)
self.__close = None
# STREAM
for stream_id, stream in self.streams.items():
if isinstance(stream_id, int) and stream.has_data_to_send():
frame = stream.get_frame(
PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6
)
+ flags = QuicStreamFlag.LEN
- flags = QuicStreamFlag.OFF | QuicStreamFlag.LEN
+ if frame.offset:
+ flags |= QuicStreamFlag.OFF
if frame.fin:
flags |= QuicStreamFlag.FIN
push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)
with push_stream_frame(buf, 0, frame.offset):
push_bytes(buf, frame.data)
packet_size = buf.tell()
if packet_size > header_size:
# encrypt
data = buf.data
yield space.crypto.encrypt_packet</s>
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def _write_application(self) -> Iterator[bytes]:
# offset: 1
<s> if packet_size > header_size:
# encrypt
data = buf.data
yield space.crypto.encrypt_packet(
data[0:header_size], data[header_size:packet_size]
)
self.packet_number += 1
buf.seek(0)
else:
break
|
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
2d63ddf4c0023fbc7b8e3d35000f1144d82b69f7
|
[connection] defer construction of QuicTransportParameters
|
<25>:<del> self.quic_transport_parameters = QuicTransportParameters(
<26>:<del> idle_timeout=600,
<27>:<del> initial_max_data=16777216,
<28>:<del> initial_max_stream_data_bidi_local=1048576,
<29>:<del> initial_max_stream_data_bidi_remote=1048576,
<30>:<del> initial_max_stream_data_uni=1048576,
<31>:<del> initial_max_streams_bidi=100,
<32>:<del> ack_delay_exponent=10,
<33>:<del>
|
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
<0> if not is_client:
<1> assert certificate is not None, "SSL certificate is required"
<2> assert private_key is not None, "SSL private key is required"
<3>
<4> self.alpn_protocols = alpn_protocols
<5> self.certificate = certificate
<6> self.is_client = is_client
<7> self.host_cid = os.urandom(8)
<8> self.peer_cid = os.urandom(8)
<9> self.peer_cid_set = False
<10> self.peer_token = b""
<11> self.private_key = private_key
<12> self.secrets_log_file = secrets_log_file
<13> self.server_name = server_name
<14> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<15>
<16> # protocol versions
<17> self.supported_versions = [
<18> QuicProtocolVersion.DRAFT_17,
<19> QuicProtocolVersion.DRAFT_18,
<20> QuicProtocolVersion.DRAFT_19,
<21> QuicProtocolVersion.DRAFT_20,
<22> ]
<23> self.version = QuicProtocolVersion.DRAFT_20
<24>
<25> self.quic_transport_parameters = QuicTransportParameters(
<26> idle_timeout=600,
<27> initial_max_data=16777216,
<28> initial_max_stream_data_bidi_local=1048576,
<29> initial_max_stream_data_bidi_remote=1048576,
<30> initial_max_stream_data_uni=1048576,
<31> initial_max_streams_bidi=100,
<32> ack_delay_exponent=10,
<33> </s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__logger = logger
self.__transport: Optional[asyncio.DatagramTransport] = None
===========unchanged ref 0===========
at: aioquic.connection
logger = logging.getLogger("quic")
at: aioquic.connection.QuicConnection._initialize
self.__initialized = True
at: aioquic.connection.QuicConnection._payload_received
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._write_application
self.__close = None
at: aioquic.connection.QuicConnection._write_handshake
self.__close = None
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.connection_made
self.__transport = transport
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
self.peer_cid_set = True
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None)
at: aioquic.tls
Epoch()
at: asyncio.locks
Event(*, loop: Optional[AbstractEventLoop]=...)
at: asyncio.transports
DatagramTransport(extra: Optional[Mapping[Any, Any]]=...)
at: os
urandom(size: int, /) -> bytes
at: typing
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
TextIO()
|
aioquic.connection/QuicConnection._initialize
|
Modified
|
aiortc~aioquic
|
2d63ddf4c0023fbc7b8e3d35000f1144d82b69f7
|
[connection] defer construction of QuicTransportParameters
|
<0>:<add> # build transport parameters
<del> # transport parameters
<1>:<add> quic_transport_parameters = QuicTransportParameters(
<add> initial_max_data=16777216,
<add> initial_max_stream_data_bidi_local=1048576,
<add> initial_max_stream_data_bidi_remote=1048576,
<add> initial_max_stream_data_uni=1048576,
<add> initial_max_streams_bidi=self.__local_max_streams_bidi,
<add> initial_max_streams_uni=self.__local_max_streams_uni,
<add> ack_delay_exponent=10,
<add> )
<2>:<add> quic_transport_parameters.idle_timeout = 600000
<del> self.quic_transport_parameters.idle_timeout = 600000
<4>:<add> quic_transport_parameters.idle_timeout = 600
<del> self.quic_transport_parameters.idle_timeout = 600
<6>:<add> quic_transport_parameters.initial_version = self.version
<del> self.quic_transport_parameters.initial_version = self.version
<8>:<add> quic_transport_parameters.negotiated_version = self.version
<del> self.quic_transport_parameters.negotiated_version = self.version
<9>:<add> quic_transport_parameters.supported_versions = self.supported_versions
|
# module: aioquic.connection
class QuicConnection:
def _initialize(self, peer_cid: bytes) -> None:
<0> # transport parameters
<1> if self.version >= QuicProtocolVersion.DRAFT_19:
<2> self.quic_transport_parameters.idle_timeout = 600000
<3> else:
<4> self.quic_transport_parameters.idle_timeout = 600
<5> if self.is_client:
<6> self.quic_transport_parameters.initial_version = self.version
<7> else:
<8> self.quic_transport_parameters.negotiated_version = self.version
<9> self.quic_transport_parameters.supported_versions = (
<10> self.supported_versions
<11> )
<12> self.quic_transport_parameters.stateless_reset_token = bytes(16)
<13>
<14> # TLS
<15> self.tls = tls.Context(is_client=self.is_client, logger=self.__logger)
<16> self.tls.alpn_protocols = self.alpn_protocols
<17> self.tls.certificate = self.certificate
<18> self.tls.certificate_private_key = self.private_key
<19> self.tls.handshake_extensions = [
<20> (tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS, self._serialize_parameters())
<21> ]
<22> self.tls.server_name = self.server_name
<23> self.tls.update_traffic_key_cb = self._update_traffic_key
<24>
<25> # packet spaces
<26> self.send_ack = {
<27> tls.Epoch.INITIAL: False,
<28> tls.Epoch.HANDSHAKE: False,
<29> tls.Epoch.ONE_RTT: False,
<30> }
<31> self.send_buffer = {
<32> tls.Epoch.INITIAL: Buffer(capacity=4096),
<33> tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
<34> tls.Epoch.ONE_RTT: Buffer(capacity=4096),
<35> }
<36> self.spaces = {
<37> tls.Epoch.INITIAL: PacketSpace(),</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _initialize(self, peer_cid: bytes) -> None:
# offset: 1
tls.Epoch.ONE_RTT: PacketSpace(),
}
self.streams[tls.Epoch.INITIAL] = QuicStream()
self.streams[tls.Epoch.HANDSHAKE] = QuicStream()
self.streams[tls.Epoch.ONE_RTT] = QuicStream()
self.spaces[tls.Epoch.INITIAL].crypto.setup_initial(
cid=peer_cid, is_client=self.is_client
)
self.__initialized = True
self.packet_number = 0
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
PacketSpace()
at: aioquic.connection.PacketSpace.__init__
self.crypto = CryptoPair()
at: aioquic.connection.QuicConnection
_serialize_parameters(self, quic_transport_parameters: QuicTransportParameters) -> bytes
_serialize_parameters(quic_transport_parameters: QuicTransportParameters) -> bytes
_update_traffic_key(direction: tls.Direction, epoch: tls.Epoch, secret: bytes) -> None
at: aioquic.connection.QuicConnection.__init__
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.private_key = private_key
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
self.__local_max_streams_uni = 0
self.__logger = logger
at: aioquic.connection.QuicConnection._initialize
quic_transport_parameters = QuicTransportParameters(
initial_max_data=16777216,
initial_max_stream_data_bidi_local=1048576,
initial_max_stream_data_bidi_remote=1048576,
initial_max_stream_data_uni=1048576,
initial_max_streams_bidi=self.__local_max_streams_bidi,
initial_max_streams_uni=self.__local_max_streams_uni,
ack_delay_exponent=10,
)
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.packet.QuicTransportParameters
initial_version: Optional[QuicProtocolVersion] = None
negotiated_version: Optional[QuicProtocolVersion] = None
supported_versions: List[QuicProtocolVersion] = field(default_factory=list)
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_migration: Optional[bool] = False
preferred_address: Optional[bytes] = None
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None)
at: aioquic.tls
Epoch()
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
===========unchanged ref 2===========
Context(is_client: bool, logger: logging.Logger=None)
at: aioquic.tls.Context.__init__
self.alpn_protocols: Optional[List[str]] = None
self.certificate: Optional[x509.Certificate] = None
self.certificate_private_key: Optional[
Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
] = None
self.handshake_extensions: List[Extension] = []
self.server_name: Optional[str] = None
self.update_traffic_key_cb: Callable[
[Direction, Epoch, bytes], None
] = lambda d, e, s: None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# protocol versions
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
- self.quic_transport_parameters = QuicTransportParameters(
- idle_timeout=600,
- initial_max_data=16777216,
- initial_max_stream_data_bidi_local=1048576,
- initial_max_stream_data_bidi_remote=1048576,
- initial_max_stream_data_uni=1048576,
- initial_max_streams_bidi=100,
- ack_delay_exponent=10,
- )
-
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()</s>
|
aioquic.connection/QuicConnection._serialize_parameters
|
Modified
|
aiortc~aioquic
|
2d63ddf4c0023fbc7b8e3d35000f1144d82b69f7
|
[connection] defer construction of QuicTransportParameters
|
<6>:<add> buf, quic_transport_parameters, is_client=is_client
<del> buf, self.quic_transport_parameters, is_client=is_client
|
# module: aioquic.connection
class QuicConnection:
+ def _serialize_parameters(
- def _serialize_parameters(self) -> bytes:
+ self, quic_transport_parameters: QuicTransportParameters
+ ) -> bytes:
<0> buf = Buffer(capacity=512)
<1> if self.version >= QuicProtocolVersion.DRAFT_19:
<2> is_client = None
<3> else:
<4> is_client = self.is_client
<5> push_quic_transport_parameters(
<6> buf, self.quic_transport_parameters, is_client=is_client
<7> )
<8> return buf.data
<9>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.version = QuicProtocolVersion.DRAFT_20
self.__transport: Optional[asyncio.DatagramTransport] = None
at: aioquic.connection.QuicConnection.connection_made
self.__transport = transport
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicTransportParameters(initial_version: Optional[QuicProtocolVersion]=None, negotiated_version: Optional[QuicProtocolVersion]=None, supported_versions: List[QuicProtocolVersion]=field(default_factory=list), 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_migration: Optional[bool]=False, preferred_address: Optional[bytes]=None)
at: asyncio.transports.DatagramTransport
__slots__ = ()
sendto(data: Any, addr: Optional[_Address]=...) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# protocol versions
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
- self.quic_transport_parameters = QuicTransportParameters(
- idle_timeout=600,
- initial_max_data=16777216,
- initial_max_stream_data_bidi_local=1048576,
- initial_max_stream_data_bidi_remote=1048576,
- initial_max_stream_data_uni=1048576,
- initial_max_streams_bidi=100,
- ack_delay_exponent=10,
- )
-
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()</s>
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
<s>10,
- )
-
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
+ self.__local_max_streams_bidi = 100
+ self.__local_max_streams_uni = 0
self.__logger = logger
self.__transport: Optional[asyncio.DatagramTransport] = None
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def _initialize(self, peer_cid: bytes) -> None:
+ # build transport parameters
- # transport parameters
+ quic_transport_parameters = QuicTransportParameters(
+ initial_max_data=16777216,
+ initial_max_stream_data_bidi_local=1048576,
+ initial_max_stream_data_bidi_remote=1048576,
+ initial_max_stream_data_uni=1048576,
+ initial_max_streams_bidi=self.__local_max_streams_bidi,
+ initial_max_streams_uni=self.__local_max_streams_uni,
+ ack_delay_exponent=10,
+ )
if self.version >= QuicProtocolVersion.DRAFT_19:
+ quic_transport_parameters.idle_timeout = 600000
- self.quic_transport_parameters.idle_timeout = 600000
else:
+ quic_transport_parameters.idle_timeout = 600
- self.quic_transport_parameters.idle_timeout = 600
if self.is_client:
+ quic_transport_parameters.initial_version = self.version
- self.quic_transport_parameters.initial_version = self.version
else:
+ quic_transport_parameters.negotiated_version = self.version
- self.quic_transport_parameters.negotiated_version = self.version
+ quic_transport_parameters.supported_versions = self.supported_versions
- self.quic_transport_parameters.supported_versions = (
- self.supported_versions
- )
+ quic_transport_parameters.stateless_reset_token = bytes(16)
- self.quic_transport_parameters.stateless_reset_token = bytes(16)
# TLS
self.tls = tls.Context(is_client=self.is_client, logger=self.__logger)
self.tls.alpn_protocols = self.alpn_protocols
self.</s>
|
aioquic.connection/push_close
|
Modified
|
aiortc~aioquic
|
b0595e0d935a0666b797835d517146a39357b46f
|
[connection] rework error handling
|
<0>:<add> reason_phrase_bytes = reason_phrase.encode("utf8")
<2>:<add> packet.push_application_close_frame(buf, error_code, reason_phrase_bytes)
<del> packet.push_application_close_frame(buf, error_code, reason_phrase)
<5>:<add> packet.push_transport_close_frame(
<add> buf, error_code, frame_type, reason_phrase_bytes
<add> )
<del> packet.push_transport_close_frame(buf, error_code, frame_type, reason_phrase)
|
# module: aioquic.connection
def push_close(
+ buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str
- buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: bytes
) -> None:
<0> if frame_type is None:
<1> push_uint_var(buf, QuicFrameType.APPLICATION_CLOSE)
<2> packet.push_application_close_frame(buf, error_code, reason_phrase)
<3> else:
<4> push_uint_var(buf, QuicFrameType.TRANSPORT_CLOSE)
<5> packet.push_transport_close_frame(buf, error_code, frame_type, reason_phrase)
<6>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.packet
push_uint_var(buf: Buffer, value: int) -> None
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
push_application_close_frame(buf: Buffer, error_code: int, reason_phrase: bytes) -> None
|
aioquic.connection/QuicConnection.datagram_received
|
Modified
|
aiortc~aioquic
|
b0595e0d935a0666b797835d517146a39357b46f
|
[connection] rework error handling
|
# module: aioquic.connection
class QuicConnection:
def datagram_received(self, data: bytes, addr: Any) -> None:
<0> """
<1> Handle an incoming datagram.
<2> """
<3> buf = Buffer(data=data)
<4>
<5> while not buf.eof():
<6> start_off = buf.tell()
<7> header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
<8>
<9> if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:
<10> # version negotiation
<11> versions = []
<12> while not buf.eof():
<13> versions.append(pull_uint32(buf))
<14> common = set(self.supported_versions).intersection(versions)
<15> if not common:
<16> self.__logger.error("Could not find a common protocol version")
<17> return
<18> self.version = QuicProtocolVersion(max(common))
<19> self.__logger.info("Retrying with %s" % self.version)
<20> self.connection_made(self.__transport)
<21> return
<22> elif self.is_client and header.packet_type == PACKET_TYPE_RETRY:
<23> # stateless retry
<24> if (
<25> header.destination_cid == self.host_cid
<26> and header.original_destination_cid == self.peer_cid
<27> ):
<28> self.__logger.info("Performing stateless retry")
<29> self.peer_cid = header.source_cid
<30> self.peer_token = header.token
<31> self.connection_made(self.__transport)
<32> return
<33>
<34> encrypted_off = buf.tell() - start_off
<35> end_off = buf.tell() + header.rest_length
<36> pull_bytes(buf, header.rest_length)
<37>
<38> if not self.is_client and not self.__initialized:
<39> self._initialize(header.destination_cid)
<40>
<41> epoch = get_epoch(header.packet_type)
<42> space = self.spaces</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def datagram_received(self, data: bytes, addr: Any) -> None:
# offset: 1
try:
plain_header, plain_payload, packet_number = space.crypto.decrypt_packet(
data[start_off:end_off], encrypted_off
)
except CryptoError as exc:
self.__logger.warning(exc)
return
if not self.peer_cid_set:
self.peer_cid = header.source_cid
self.peer_cid_set = True
# handle payload
try:
is_ack_only = self._payload_received(epoch, plain_payload)
except tls.Alert:
return
# record packet as received
space.ack_queue.add(packet_number)
if not is_ack_only:
self.send_ack[epoch] = True
self._send_pending()
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
pull_uint32(buf: Buffer) -> int
at: aioquic.buffer.Buffer
eof() -> bool
tell() -> int
at: aioquic.connection
get_epoch(packet_type: int) -> tls.Epoch
at: aioquic.connection.PacketSpace.__init__
self.crypto = CryptoPair()
at: aioquic.connection.QuicConnection
connection_made(transport: asyncio.DatagramTransport) -> None
_initialize(peer_cid: bytes) -> None
_push_crypto_data() -> None
_send_pending() -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
self.__initialized = False
self.__logger = logger
self.__transport: Optional[asyncio.DatagramTransport] = None
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self.__logger)
self.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
===========unchanged ref 1===========
self.spaces = {
tls.Epoch.INITIAL: PacketSpace(),
tls.Epoch.HANDSHAKE: PacketSpace(),
tls.Epoch.ONE_RTT: PacketSpace(),
}
self.__initialized = True
at: aioquic.crypto
CryptoError(*args: object)
at: aioquic.crypto.CryptoPair
decrypt_packet(packet: bytes, encrypted_offset: int) -> Tuple[bytes, bytes, int]
at: aioquic.packet
PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader
at: aioquic.packet.QuicHeader
version: int
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
at: aioquic.tls.Context
handle_message(input_data: bytes, output_buf: Dict[Epoch, Buffer]) -> None
at: logging.Logger
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
warning(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
error(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
+ class QuicConnectionError(Exception):
+ def __str__(self):
+ return "Error: %d, reason: %s" % (self.error_code, self.reason_phrase)
+
===========changed ref 1===========
# module: aioquic.connection
+ class QuicConnectionError(Exception):
+ def __init__(self, error_code: int, frame_type: int, reason_phrase: str):
+ self.error_code = error_code
+ self.frame_type = frame_type
+ self.reason_phrase = reason_phrase
+
===========changed ref 2===========
# module: aioquic.connection
def push_close(
+ buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str
- buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: bytes
) -> None:
+ reason_phrase_bytes = reason_phrase.encode("utf8")
if frame_type is None:
push_uint_var(buf, QuicFrameType.APPLICATION_CLOSE)
+ packet.push_application_close_frame(buf, error_code, reason_phrase_bytes)
- packet.push_application_close_frame(buf, error_code, reason_phrase)
else:
push_uint_var(buf, QuicFrameType.TRANSPORT_CLOSE)
+ packet.push_transport_close_frame(
+ buf, error_code, frame_type, reason_phrase_bytes
+ )
- packet.push_transport_close_frame(buf, error_code, frame_type, reason_phrase)
|
|
aioquic.connection/QuicConnection._payload_received
|
Modified
|
aiortc~aioquic
|
b0595e0d935a0666b797835d517146a39357b46f
|
[connection] rework error handling
|
<17>:<add> # pass data to TLS layer
<20>:<add> raise QuicConnectionError(
<add> error_code=QuicErrorCode.CRYPTO_ERROR
<del> self.__logger.warning("TLS error: %s" % exc)
<21>:<del> self.close(
<22>:<add> + int(exc.description),
<del> QuicErrorCode.CRYPTO_ERROR + int(exc.description),
<23>:<add> frame_type=frame_type,
<del> frame_type,
<24>:<add> reason_phrase=str(exc),
<del> str(exc).encode("ascii"),
<26>:<del> raise
<38>:<del>
|
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
<0> buf = Buffer(data=plain)
<1>
<2> is_ack_only = True
<3> while not buf.eof():
<4> frame_type = pull_uint_var(buf)
<5> if frame_type != QuicFrameType.ACK:
<6> is_ack_only = False
<7>
<8> if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
<9> pass
<10> elif frame_type == QuicFrameType.ACK:
<11> packet.pull_ack_frame(buf)
<12> elif frame_type == QuicFrameType.CRYPTO:
<13> stream = self.streams[epoch]
<14> stream.add_frame(packet.pull_crypto_frame(buf))
<15> data = stream.pull_data()
<16> if data:
<17> try:
<18> self.tls.handle_message(data, self.send_buffer)
<19> except tls.Alert as exc:
<20> self.__logger.warning("TLS error: %s" % exc)
<21> self.close(
<22> QuicErrorCode.CRYPTO_ERROR + int(exc.description),
<23> frame_type,
<24> str(exc).encode("ascii"),
<25> )
<26> raise
<27>
<28> # update current epoch
<29> if self.tls.state in [
<30> tls.State.CLIENT_POST_HANDSHAKE,
<31> tls.State.SERVER_POST_HANDSHAKE,
<32> ]:
<33> if not self.__connected.is_set():
<34> self.__connected.set()
<35> self.__epoch = tls.Epoch.ONE_RTT
<36> else:
<37> self.__epoch = tls.Epoch.HANDSHAKE
<38>
<39> elif frame_type == QuicFrameType.NEW_TOKEN:
<40> packet.pull_new_token_frame(buf)
<41> elif (frame_type & ~STREAM_FLAGS) == QuicFrameType.STREAM_BASE:
<42> flags = frame_type</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
# offset: 1
stream_id = pull_uint_var(buf)
if flags & QuicStreamFlag.OFF:
offset = pull_uint_var(buf)
else:
offset = 0
if flags & QuicStreamFlag.LEN:
length = pull_uint_var(buf)
else:
length = buf.capacity - buf.tell()
frame = QuicStreamFrame(
offset=offset,
data=pull_bytes(buf, length),
fin=bool(flags & QuicStreamFlag.FIN),
)
stream = self._get_or_create_stream(stream_id)
stream.add_frame(frame)
elif frame_type == QuicFrameType.MAX_DATA:
pull_uint_var(buf)
elif frame_type in [
QuicFrameType.MAX_STREAMS_BIDI,
QuicFrameType.MAX_STREAMS_UNI,
]:
pull_uint_var(buf)
elif frame_type == QuicFrameType.NEW_CONNECTION_ID:
packet.pull_new_connection_id_frame(buf)
elif frame_type == QuicFrameType.TRANSPORT_CLOSE:
error_code, frame_type, reason_phrase = packet.pull_transport_close_frame(
buf
)
self.__logger.info(
"Transport close code 0x%X, reason %s" % (error_code, reason_phrase)
)
self.connection_lost(None)
elif frame_type == QuicFrameType.APPLICATION_CLOSE:
error_code, reason_phrase = packet.pull_application_close_frame(buf)
self.__logger.info(
"Application close code 0x%X, reason %s"
% (error_code, reason_phrase)
)
self.connection_lost(None)
else:
self.__logger.warning("unhandled frame type</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
# offset: 2
<s>
)
self.connection_lost(None)
else:
self.__logger.warning("unhandled frame type %d", frame_type)
break
self._push_crypto_data()
return is_ack_only
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
at: aioquic.buffer.Buffer
eof() -> bool
tell() -> int
at: aioquic.connection
STREAM_FLAGS = 0x07
PacketSpace()
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
at: aioquic.connection.PacketSpace.__init__
self.crypto = CryptoPair()
at: aioquic.connection.QuicConnection
_get_or_create_stream(stream_id: int) -> QuicStream
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__logger = logger
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self.__logger)
self.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
at: aioquic.connection.QuicConnection._write_application
self.packet_number += 1
at: aioquic.connection.QuicConnection._write_handshake
self.packet_number += 1
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
===========unchanged ref 1===========
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
pull_uint_var(buf: Buffer) -> int
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_ack_frame(buf: Buffer) -> Tuple[RangeSet, int]
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
pull_crypto_frame(buf: Buffer) -> QuicStreamFrame
pull_new_token_frame(buf: Buffer) -> bytes
pull_new_connection_id_frame(buf: Buffer) -> Tuple[int, bytes, bytes]
pull_transport_close_frame(buf: Buffer) -> Tuple[int, int, bytes]
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None)
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
pull_data() -> bytes
at: aioquic.tls
Alert(*args: object)
Epoch()
State()
at: aioquic.tls.Alert
description: AlertDescription
at: aioquic.tls.Context
handle_message(input_data: bytes, output_buf: Dict[Epoch, Buffer]) -> None
===========unchanged ref 2===========
at: aioquic.tls.Context.__init__
self.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: aioquic.tls.Context._set_state
self.state = state
at: asyncio.locks.Event
is_set() -> bool
set() -> None
at: logging.Logger
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
+ class QuicConnectionError(Exception):
+ def __str__(self):
+ return "Error: %d, reason: %s" % (self.error_code, self.reason_phrase)
+
===========changed ref 1===========
# module: aioquic.connection
+ class QuicConnectionError(Exception):
+ def __init__(self, error_code: int, frame_type: int, reason_phrase: str):
+ self.error_code = error_code
+ self.frame_type = frame_type
+ self.reason_phrase = reason_phrase
+
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
c710b9f451502a04ce16b5dfda5f3f69f3e90e8d
|
[connection] regroup transport parameters serialization
|
<29>:<add> self.__local_idle_timeout = 60.0 # seconds
|
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
<0> if not is_client:
<1> assert certificate is not None, "SSL certificate is required"
<2> assert private_key is not None, "SSL private key is required"
<3>
<4> self.alpn_protocols = alpn_protocols
<5> self.certificate = certificate
<6> self.is_client = is_client
<7> self.host_cid = os.urandom(8)
<8> self.peer_cid = os.urandom(8)
<9> self.peer_cid_set = False
<10> self.peer_token = b""
<11> self.private_key = private_key
<12> self.secrets_log_file = secrets_log_file
<13> self.server_name = server_name
<14> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<15>
<16> # protocol versions
<17> self.supported_versions = [
<18> QuicProtocolVersion.DRAFT_17,
<19> QuicProtocolVersion.DRAFT_18,
<20> QuicProtocolVersion.DRAFT_19,
<21> QuicProtocolVersion.DRAFT_20,
<22> ]
<23> self.version = QuicProtocolVersion.DRAFT_20
<24>
<25> self.__close: Optional[Dict] = None
<26> self.__connected = asyncio.Event()
<27> self.__epoch = tls.Epoch.INITIAL
<28> self.__initialized = False
<29> self.__local_max_streams_bidi = 100
<30> self.__local_max_streams_uni = 0
<31> self.__logger = logger
<32> self.__transport: Optional[asyncio.DatagramTransport] = None
<33>
|
===========unchanged ref 0===========
at: aioquic.connection
logger = logging.getLogger("quic")
at: aioquic.connection.QuicConnection._initialize
self.__initialized = True
at: aioquic.connection.QuicConnection._payload_received
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._write_application
self.__close = None
at: aioquic.connection.QuicConnection._write_handshake
self.__close = None
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
self.peer_cid_set = True
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None)
at: aioquic.tls
Epoch()
at: asyncio.locks
Event(*, loop: Optional[AbstractEventLoop]=...)
at: os
urandom(size: int, /) -> bytes
at: typing
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
TextIO()
|
aioquic.connection/QuicConnection._initialize
|
Modified
|
aiortc~aioquic
|
c710b9f451502a04ce16b5dfda5f3f69f3e90e8d
|
[connection] regroup transport parameters serialization
|
<0>:<del> # build transport parameters
<1>:<del> quic_transport_parameters = QuicTransportParameters(
<2>:<del> initial_max_data=16777216,
<3>:<del> initial_max_stream_data_bidi_local=1048576,
<4>:<del> initial_max_stream_data_bidi_remote=1048576,
<5>:<del> initial_max_stream_data_uni=1048576,
<6>:<del> initial_max_streams_bidi=self.__local_max_streams_bidi,
<7>:<del> initial_max_streams_uni=self.__local_max_streams_uni,
<8>:<del> ack_delay_exponent=10,
<9>:<del> )
<10>:<del> if self.version >= QuicProtocolVersion.DRAFT_19:
<11>:<del> quic_transport_parameters.idle_timeout = 600000
<12>:<del> else:
<13>:<del> quic_transport_parameters.idle_timeout = 600
<14>:<del> if self.is_client:
<15>:<del> quic_transport_parameters.initial_version = self.version
<16>:<del> else:
<17>:<del> quic_transport_parameters.negotiated_version = self.version
<18>:<del> quic_transport_parameters.supported_versions = self.supported_versions
<19>:<del> quic_transport_parameters.stateless_reset_token = bytes(16)
<20>:<del>
<29>:<add> self._serialize_parameters(),
<del> self._serialize_parameters(quic_transport_parameters),
|
# module: aioquic.connection
class QuicConnection:
def _initialize(self, peer_cid: bytes) -> None:
<0> # build transport parameters
<1> quic_transport_parameters = QuicTransportParameters(
<2> initial_max_data=16777216,
<3> initial_max_stream_data_bidi_local=1048576,
<4> initial_max_stream_data_bidi_remote=1048576,
<5> initial_max_stream_data_uni=1048576,
<6> initial_max_streams_bidi=self.__local_max_streams_bidi,
<7> initial_max_streams_uni=self.__local_max_streams_uni,
<8> ack_delay_exponent=10,
<9> )
<10> if self.version >= QuicProtocolVersion.DRAFT_19:
<11> quic_transport_parameters.idle_timeout = 600000
<12> else:
<13> quic_transport_parameters.idle_timeout = 600
<14> if self.is_client:
<15> quic_transport_parameters.initial_version = self.version
<16> else:
<17> quic_transport_parameters.negotiated_version = self.version
<18> quic_transport_parameters.supported_versions = self.supported_versions
<19> quic_transport_parameters.stateless_reset_token = bytes(16)
<20>
<21> # TLS
<22> self.tls = tls.Context(is_client=self.is_client, logger=self.__logger)
<23> self.tls.alpn_protocols = self.alpn_protocols
<24> self.tls.certificate = self.certificate
<25> self.tls.certificate_private_key = self.private_key
<26> self.tls.handshake_extensions = [
<27> (
<28> tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS,
<29> self._serialize_parameters(quic_transport_parameters),
<30> )
<31> ]
<32> self.tls.server_name = self.server_name
<33> self.tls.update_traffic_key_cb = self._update_traffic_key
<34>
<35> </s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _initialize(self, peer_cid: bytes) -> None:
# offset: 1
self.send_ack = {
tls.Epoch.INITIAL: False,
tls.Epoch.HANDSHAKE: False,
tls.Epoch.ONE_RTT: False,
}
self.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
self.spaces = {
tls.Epoch.INITIAL: PacketSpace(),
tls.Epoch.HANDSHAKE: PacketSpace(),
tls.Epoch.ONE_RTT: PacketSpace(),
}
self.streams[tls.Epoch.INITIAL] = QuicStream()
self.streams[tls.Epoch.HANDSHAKE] = QuicStream()
self.streams[tls.Epoch.ONE_RTT] = QuicStream()
self.spaces[tls.Epoch.INITIAL].crypto.setup_initial(
cid=peer_cid, is_client=self.is_client
)
self.__initialized = True
self.packet_number = 0
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.buffer.Buffer
eof() -> bool
at: aioquic.connection
PacketSpace()
at: aioquic.connection.PacketSpace.__init__
self.crypto = CryptoPair()
at: aioquic.connection.QuicConnection
_serialize_parameters() -> bytes
_update_traffic_key(direction: tls.Direction, epoch: tls.Epoch, secret: bytes) -> None
_update_traffic_key(self, direction: tls.Direction, epoch: tls.Epoch, secret: bytes) -> None
at: aioquic.connection.QuicConnection.__init__
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.private_key = private_key
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__initialized = False
self.__logger = logger
at: aioquic.connection.QuicConnection._write_application
self.packet_number += 1
at: aioquic.connection.QuicConnection._write_handshake
self.packet_number += 1
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_ack_frame(buf: Buffer) -> Tuple[RangeSet, int]
pull_crypto_frame(buf: Buffer) -> QuicStreamFrame
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None)
===========unchanged ref 1===========
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
pull_data() -> bytes
at: aioquic.tls
Epoch()
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
Context(is_client: bool, logger: logging.Logger=None)
at: aioquic.tls.Context.__init__
self.alpn_protocols: Optional[List[str]] = None
self.certificate: Optional[x509.Certificate] = None
self.certificate_private_key: Optional[
Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
] = None
self.handshake_extensions: List[Extension] = []
self.server_name: Optional[str] = None
self.update_traffic_key_cb: Callable[
[Direction, Epoch, bytes], None
] = lambda d, e, s: None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# protocol versions
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
+ self.__local_idle_timeout = 60.0 # seconds
self.__local_max_streams_bidi = 100
self.__local_max_streams_uni = 0
self.__logger = logger
self.__transport: Optional[asyncio.DatagramTransport] = None
|
aioquic.connection/QuicConnection._serialize_parameters
|
Modified
|
aiortc~aioquic
|
c710b9f451502a04ce16b5dfda5f3f69f3e90e8d
|
[connection] regroup transport parameters serialization
|
<0>:<add> quic_transport_parameters = QuicTransportParameters(
<add> initial_max_data=16777216,
<add> initial_max_stream_data_bidi_local=1048576,
<add> initial_max_stream_data_bidi_remote=1048576,
<add> initial_max_stream_data_uni=1048576,
<add> initial_max_streams_bidi=self.__local_max_streams_bidi,
<add> initial_max_streams_uni=self.__local_max_streams_uni,
<add> ack_delay_exponent=10,
<add> )
<del> buf = Buffer(capacity=512)
<3>:<add> quic_transport_parameters.idle_timeout = int(
<add> self.__local_idle_timeout * 1000
<add> )
<5>:<add> quic_transport_parameters.idle_timeout = int(self.__local_idle_timeout)
<add> if self.is_client:
<add> quic_transport_parameters.initial_version = self.version
<add> else:
<add> quic_transport_parameters.negotiated_
|
# module: aioquic.connection
class QuicConnection:
+ def _serialize_parameters(self) -> bytes:
- def _serialize_parameters(
- self, quic_transport_parameters: QuicTransportParameters
- ) -> bytes:
<0> buf = Buffer(capacity=512)
<1> if self.version >= QuicProtocolVersion.DRAFT_19:
<2> is_client = None
<3> else:
<4> is_client = self.is_client
<5> push_quic_transport_parameters(
<6> buf, quic_transport_parameters, is_client=is_client
<7> )
<8> return buf.data
<9>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection.QuicConnection.__init__
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
at: aioquic.connection.QuicConnection._serialize_parameters
quic_transport_parameters = QuicTransportParameters(
initial_max_data=16777216,
initial_max_stream_data_bidi_local=1048576,
initial_max_stream_data_bidi_remote=1048576,
initial_max_stream_data_uni=1048576,
initial_max_streams_bidi=self.__local_max_streams_bidi,
initial_max_streams_uni=self.__local_max_streams_uni,
ack_delay_exponent=10,
)
is_client = None
is_client = self.is_client
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
at: aioquic.packet
push_quic_transport_parameters(buf: Buffer, params: QuicTransportParameters, is_client: Optional[bool]=None) -> None
at: aioquic.packet.QuicTransportParameters
initial_version: Optional[QuicProtocolVersion] = None
negotiated_version: Optional[QuicProtocolVersion] = None
supported_versions: List[QuicProtocolVersion] = field(default_factory=list)
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
===========unchanged ref 1===========
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_migration: Optional[bool] = False
preferred_address: Optional[bytes] = None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# protocol versions
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
+ self.__local_idle_timeout = 60.0 # seconds
self.__local_max_streams_bidi = 100
self.__local_max_streams_uni = 0
self.__logger = logger
self.__transport: Optional[asyncio.DatagramTransport] = None
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def _initialize(self, peer_cid: bytes) -> None:
- # build transport parameters
- quic_transport_parameters = QuicTransportParameters(
- initial_max_data=16777216,
- initial_max_stream_data_bidi_local=1048576,
- initial_max_stream_data_bidi_remote=1048576,
- initial_max_stream_data_uni=1048576,
- initial_max_streams_bidi=self.__local_max_streams_bidi,
- initial_max_streams_uni=self.__local_max_streams_uni,
- ack_delay_exponent=10,
- )
- if self.version >= QuicProtocolVersion.DRAFT_19:
- quic_transport_parameters.idle_timeout = 600000
- else:
- quic_transport_parameters.idle_timeout = 600
- if self.is_client:
- quic_transport_parameters.initial_version = self.version
- else:
- quic_transport_parameters.negotiated_version = self.version
- quic_transport_parameters.supported_versions = self.supported_versions
- quic_transport_parameters.stateless_reset_token = bytes(16)
-
# TLS
self.tls = tls.Context(is_client=self.is_client, logger=self.__logger)
self.tls.alpn_protocols = self.alpn_protocols
self.tls.certificate = self.certificate
self.tls.certificate_private_key = self.private_key
self.tls.handshake_extensions = [
(
tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS,
+ self._serialize_parameters(),
- self._serialize_parameters(quic_transport_parameters),
)
]
self.tls.server_name = self.server_name
self.tls.update_traffic_key_cb = self._update_traffic_key
# packet spaces
</s>
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def _initialize(self, peer_cid: bytes) -> None:
# offset: 1
<s>_name
self.tls.update_traffic_key_cb = self._update_traffic_key
# packet spaces
self.send_ack = {
tls.Epoch.INITIAL: False,
tls.Epoch.HANDSHAKE: False,
tls.Epoch.ONE_RTT: False,
}
self.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
self.spaces = {
tls.Epoch.INITIAL: PacketSpace(),
tls.Epoch.HANDSHAKE: PacketSpace(),
tls.Epoch.ONE_RTT: PacketSpace(),
}
self.streams[tls.Epoch.INITIAL] = QuicStream()
self.streams[tls.Epoch.HANDSHAKE] = QuicStream()
self.streams[tls.Epoch.ONE_RTT] = QuicStream()
self.spaces[tls.Epoch.INITIAL].crypto.setup_initial(
cid=peer_cid, is_client=self.is_client
)
self.__initialized = True
self.packet_number = 0
|
aioquic.tls/Context.__init__
|
Modified
|
aiortc~aioquic
|
9189593fb82052db3448a0ad80efcc271992113b
|
[connection] parse received transport parameters
|
<8>:<add> self.received_extensions: List[Extension] = []
|
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = None):
<0> self.alpn_protocols: Optional[List[str]] = None
<1> self.certificate: Optional[x509.Certificate] = None
<2> self.certificate_private_key: Optional[
<3> Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
<4> ] = None
<5> self.handshake_extensions: List[Extension] = []
<6> self.is_client = is_client
<7> self.key_schedule: Optional[KeySchedule] = None
<8> self.server_name: Optional[str] = None
<9> self.update_traffic_key_cb: Callable[
<10> [Direction, Epoch, bytes], None
<11> ] = lambda d, e, s: None
<12>
<13> self._cipher_suites = [
<14> CipherSuite.AES_256_GCM_SHA384,
<15> CipherSuite.AES_128_GCM_SHA256,
<16> CipherSuite.CHACHA20_POLY1305_SHA256,
<17> ]
<18> self._compression_methods = [CompressionMethod.NULL]
<19> self._key_exchange_modes = [KeyExchangeMode.PSK_DHE_KE]
<20> self._signature_algorithms = [
<21> SignatureAlgorithm.RSA_PSS_RSAE_SHA256,
<22> SignatureAlgorithm.RSA_PKCS1_SHA256,
<23> SignatureAlgorithm.RSA_PKCS1_SHA1,
<24> ]
<25> self._supported_versions = [TLS_VERSION_1_3]
<26>
<27> self._key_schedule_proxy: Optional[KeyScheduleProxy] = None
<28> self._peer_certificate: Optional[x509.Certificate] = None
<29> self._receive_buffer = b""
<30> self._enc_key: Optional[bytes] = None
<31> self._dec_key: Optional[bytes] = None
<32> self.__logger = logger
<33>
<34> if is_client:
<35> self.client_random = os.urandom(32)</s>
|
===========below chunk 0===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = None):
# offset: 1
self.private_key = ec.generate_private_key(
ec.SECP256R1(), default_backend()
)
self.state = State.CLIENT_HANDSHAKE_START
else:
self.client_random = None
self.session_id = None
self.private_key = None
self.state = State.SERVER_EXPECT_CLIENT_HELLO
===========unchanged ref 0===========
at: aioquic.tls
TLS_VERSION_1_3 = 0x0304
Direction()
Epoch()
State()
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
CompressionMethod(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
CompressionMethod(x: Union[str, bytes, bytearray], base: int)
KeyExchangeMode(x: Union[str, bytes, bytearray], base: int)
KeyExchangeMode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
SignatureAlgorithm(x: Union[str, bytes, bytearray], base: int)
SignatureAlgorithm(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
Extension = Tuple[int, bytes]
KeySchedule(cipher_suite: CipherSuite)
KeyScheduleProxy(cipher_suites: List[CipherSuite])
at: aioquic.tls.Context._client_handle_certificate
self._peer_certificate = x509.load_der_x509_certificate(
certificate.certificates[0][0], backend=default_backend()
)
at: aioquic.tls.Context._client_handle_encrypted_extensions
self.received_extensions = encrypted_extensions.other_extensions
at: aioquic.tls.Context._client_handle_finished
self._enc_key = next_enc_key
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
at: aioquic.tls.Context._client_send_hello
self._key_schedule_proxy = KeyScheduleProxy(hello.cipher_suites)
at: aioquic.tls.Context._server_handle_finished
self._dec_key = self._next_dec_key
===========unchanged ref 1===========
at: aioquic.tls.Context._server_handle_hello
self.client_random = peer_hello.random
self.session_id = peer_hello.session_id
self.private_key = ec.generate_private_key(ec.SECP256R1(), default_backend())
self.received_extensions = peer_hello.other_extensions
self.key_schedule = KeySchedule(cipher_suite)
at: aioquic.tls.Context._set_state
self.state = state
at: aioquic.tls.Context._setup_traffic_protection
self._enc_key = key
self._dec_key = key
at: aioquic.tls.Context.handle_message
self._receive_buffer += input_data
self._receive_buffer = self._receive_buffer[message_length:]
at: logging
Logger(name: str, level: _Level=...)
at: os
urandom(size: int, /) -> bytes
at: typing
Callable = _CallableType(collections.abc.Callable, 2)
List = _alias(list, 1, inst=False, name='List')
|
aioquic.tls/Context._client_handle_encrypted_extensions
|
Modified
|
aiortc~aioquic
|
9189593fb82052db3448a0ad80efcc271992113b
|
[connection] parse received transport parameters
|
<0>:<add> encrypted_extensions = pull_encrypted_extensions(input_buf)
<del> pull_encrypted_extensions(input_buf)
<1>:<add> self.received_extensions = encrypted_extensions.other_extensions
|
# module: aioquic.tls
class Context:
def _client_handle_encrypted_extensions(self, input_buf: Buffer) -> None:
<0> pull_encrypted_extensions(input_buf)
<1>
<2> self._setup_traffic_protection(
<3> Direction.ENCRYPT, Epoch.HANDSHAKE, b"c hs traffic"
<4> )
<5> self.key_schedule.update_hash(input_buf.data)
<6>
<7> self._set_state(State.CLIENT_EXPECT_CERTIFICATE_REQUEST_OR_CERTIFICATE)
<8>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.tls
Direction()
Epoch()
pull_encrypted_extensions(buf: Buffer) -> EncryptedExtensions
at: aioquic.tls.Context
_setup_traffic_protection(direction: Direction, epoch: Epoch, label: bytes) -> None
at: aioquic.tls.Context.__init__
self.key_schedule: Optional[KeySchedule] = None
self.received_extensions: List[Extension] = []
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
at: aioquic.tls.Context._server_handle_hello
self.received_extensions = peer_hello.other_extensions
self.key_schedule = KeySchedule(cipher_suite)
at: aioquic.tls.EncryptedExtensions
other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
at: aioquic.tls.KeySchedule
update_hash(data: bytes) -> None
===========changed ref 0===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = None):
self.alpn_protocols: Optional[List[str]] = None
self.certificate: Optional[x509.Certificate] = None
self.certificate_private_key: Optional[
Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
] = None
self.handshake_extensions: List[Extension] = []
self.is_client = is_client
self.key_schedule: Optional[KeySchedule] = None
+ self.received_extensions: List[Extension] = []
self.server_name: Optional[str] = None
self.update_traffic_key_cb: Callable[
[Direction, Epoch, bytes], None
] = lambda d, e, s: None
self._cipher_suites = [
CipherSuite.AES_256_GCM_SHA384,
CipherSuite.AES_128_GCM_SHA256,
CipherSuite.CHACHA20_POLY1305_SHA256,
]
self._compression_methods = [CompressionMethod.NULL]
self._key_exchange_modes = [KeyExchangeMode.PSK_DHE_KE]
self._signature_algorithms = [
SignatureAlgorithm.RSA_PSS_RSAE_SHA256,
SignatureAlgorithm.RSA_PKCS1_SHA256,
SignatureAlgorithm.RSA_PKCS1_SHA1,
]
self._supported_versions = [TLS_VERSION_1_3]
self._key_schedule_proxy: Optional[KeyScheduleProxy] = None
self._peer_certificate: Optional[x509.Certificate] = None
self._receive_buffer = b""
self._enc_key: Optional[bytes] = None
self._dec_key: Optional[bytes] = None
self.__logger = logger
if is_client:
self.client_random = os.urandom(32)
self.session_id = os.urandom(32)
self.private_</s>
===========changed ref 1===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = None):
# offset: 1
<s>random = os.urandom(32)
self.session_id = os.urandom(32)
self.private_key = ec.generate_private_key(
ec.SECP256R1(), default_backend()
)
self.state = State.CLIENT_HANDSHAKE_START
else:
self.client_random = None
self.session_id = None
self.private_key = None
self.state = State.SERVER_EXPECT_CLIENT_HELLO
|
aioquic.tls/Context._server_handle_hello
|
Modified
|
aiortc~aioquic
|
9189593fb82052db3448a0ad80efcc271992113b
|
[connection] parse received transport parameters
|
<33>:<add> self.received_extensions = peer_hello.other_extensions
|
# module: aioquic.tls
class Context:
def _server_handle_hello(
self, input_buf: Buffer, initial_buf: Buffer, output_buf: Buffer
) -> None:
<0> peer_hello = pull_client_hello(input_buf)
<1>
<2> # negotiate parameters
<3> cipher_suite = negotiate(
<4> self._cipher_suites,
<5> peer_hello.cipher_suites,
<6> AlertHandshakeFailure("No supported cipher suite"),
<7> )
<8> compression_method = negotiate(
<9> self._compression_methods,
<10> peer_hello.compression_methods,
<11> AlertHandshakeFailure("No supported compression method"),
<12> )
<13> negotiate(
<14> self._key_exchange_modes,
<15> peer_hello.key_exchange_modes,
<16> AlertHandshakeFailure("No supported key exchange mode"),
<17> )
<18> signature_algorithm = negotiate(
<19> self._signature_algorithms,
<20> peer_hello.signature_algorithms,
<21> AlertHandshakeFailure("No supported signature algorithm"),
<22> )
<23> supported_version = negotiate(
<24> self._supported_versions,
<25> peer_hello.supported_versions,
<26> AlertProtocolVersion("No supported protocol version"),
<27> )
<28>
<29> self.client_random = peer_hello.random
<30> self.server_random = os.urandom(32)
<31> self.session_id = peer_hello.session_id
<32> self.private_key = ec.generate_private_key(ec.SECP256R1(), default_backend())
<33>
<34> self.key_schedule = KeySchedule(cipher_suite)
<35> self.key_schedule.extract(None)
<36> self.key_schedule.update_hash(input_buf.data)
<37>
<38> peer_public_key = decode_public_key(peer_hello.key_share[0])
<39> shared_key = self.private_key.exchange(ec.ECDH(), peer_public_key)
<40>
<41> # send hello
<42> hello = ServerHello(
</s>
|
===========below chunk 0===========
# module: aioquic.tls
class Context:
def _server_handle_hello(
self, input_buf: Buffer, initial_buf: Buffer, output_buf: Buffer
) -> None:
# offset: 1
session_id=self.session_id,
cipher_suite=cipher_suite,
compression_method=compression_method,
key_share=encode_public_key(self.private_key.public_key()),
supported_version=supported_version,
)
with push_message(self.key_schedule, initial_buf):
push_server_hello(initial_buf, hello)
self.key_schedule.extract(shared_key)
self._setup_traffic_protection(
Direction.ENCRYPT, Epoch.HANDSHAKE, b"s hs traffic"
)
self._setup_traffic_protection(
Direction.DECRYPT, Epoch.HANDSHAKE, b"c hs traffic"
)
# send encrypted extensions
with push_message(self.key_schedule, output_buf):
push_encrypted_extensions(
output_buf,
EncryptedExtensions(other_extensions=self.handshake_extensions),
)
# send certificate
with push_message(self.key_schedule, output_buf):
push_certificate(
output_buf,
Certificate(
request_context=b"",
certificates=[(self.certificate.public_bytes(Encoding.DER), b"")],
),
)
# send certificate verify
signature = self.certificate_private_key.sign(
self.key_schedule.certificate_verify_data(
b"TLS 1.3, server CertificateVerify"
),
*signature_algorithm_params(signature_algorithm),
)
with push_message(self.key_schedule, output_buf):
push_certificate_verify(
output_buf,
CertificateVerify(algorithm=signature_algorithm, signature=signature),
)
# send finished
with push_message(self.key_schedule, output_buf):
</s>
===========below chunk 1===========
# module: aioquic.tls
class Context:
def _server_handle_hello(
self, input_buf: Buffer, initial_buf: Buffer, output_buf: Buffer
) -> None:
# offset: 2
<s>signature),
)
# send finished
with push_message(self.key_schedule, output_buf):
push_finished(
output_buf,
Finished(
verify_data=self.key_schedule.finished_verify_data(self._enc_key)
),
)
# prepare traffic keys
assert self.key_schedule.generation == 2
self.key_schedule.extract(None)
self._setup_traffic_protection(
Direction.ENCRYPT, Epoch.ONE_RTT, b"s ap traffic"
)
self._next_dec_key = self.key_schedule.derive_secret(b"c ap traffic")
self._set_state(State.SERVER_EXPECT_FINISHED)
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.tls
AlertHandshakeFailure(*args: object)
AlertProtocolVersion(*args: object)
Direction()
Epoch()
pull_client_hello(buf: Buffer) -> ClientHello
ServerHello(random: bytes, session_id: bytes, cipher_suite: CipherSuite, compression_method: CompressionMethod, key_share: Optional[KeyShareEntry]=None, supported_version: Optional[int]=None)
push_server_hello(buf: Buffer, hello: ServerHello) -> None
pull_new_session_ticket(buf: Buffer) -> NewSessionTicket
EncryptedExtensions(other_extensions: List[Tuple[int, bytes]]=field(default_factory=list))
push_encrypted_extensions(buf: Buffer, extensions: EncryptedExtensions) -> None
Certificate(request_context: bytes=b"", certificates: List[CertificateEntry]=field(default_factory=list))
push_certificate(buf: Buffer, certificate: Certificate) -> None
CertificateVerify(algorithm: SignatureAlgorithm, signature: bytes)
push_certificate_verify(buf: Buffer, verify: CertificateVerify) -> None
Finished(verify_data: bytes=b"")
push_finished(buf: Buffer, finished: Finished) -> None
KeySchedule(cipher_suite: CipherSuite)
decode_public_key(key_share: KeyShareEntry) -> ec.EllipticCurvePublicKey
encode_public_key(public_key: ec.EllipticCurvePublicKey) -> KeyShareEntry
negotiate(supported: List[T], offered: List[T], exc: Alert) -> T
signature_algorithm_params(signature_algorithm: SignatureAlgorithm) -> Tuple[padding.AsymmetricPadding, hashes.HashAlgorithm]
push_message(key_schedule: Union[KeySchedule, KeyScheduleProxy], buf: Buffer) -> Generator
at: aioquic.tls.Certificate
request_context: bytes = b""
===========unchanged ref 1===========
certificates: List[CertificateEntry] = field(default_factory=list)
at: aioquic.tls.CertificateVerify
algorithm: SignatureAlgorithm
signature: bytes
at: aioquic.tls.ClientHello
random: bytes
session_id: bytes
cipher_suites: List[CipherSuite]
compression_methods: List[CompressionMethod]
alpn_protocols: Optional[List[str]] = None
key_exchange_modes: Optional[List[KeyExchangeMode]] = None
key_share: Optional[List[KeyShareEntry]] = None
server_name: Optional[str] = None
signature_algorithms: Optional[List[SignatureAlgorithm]] = None
supported_groups: Optional[List[Group]] = None
supported_versions: Optional[List[int]] = None
other_extensions: List[Extension] = field(default_factory=list)
at: aioquic.tls.Context
_setup_traffic_protection(direction: Direction, epoch: Epoch, label: bytes) -> None
at: aioquic.tls.Context.__init__
self.certificate: Optional[x509.Certificate] = None
self.certificate_private_key: Optional[
Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
] = None
self.handshake_extensions: List[Extension] = []
self.key_schedule: Optional[KeySchedule] = None
self.received_extensions: List[Extension] = []
self._cipher_suites = [
CipherSuite.AES_256_GCM_SHA384,
CipherSuite.AES_128_GCM_SHA256,
CipherSuite.CHACHA20_POLY1305_SHA256,
]
self._compression_methods = [CompressionMethod.NULL]
self._key_exchange_modes = [KeyExchangeMode.PSK_DHE_KE]
|
aioquic.packet/pull_quic_transport_parameters
|
Modified
|
aiortc~aioquic
|
9189593fb82052db3448a0ad80efcc271992113b
|
[connection] parse received transport parameters
|
<2>:<add> # version < DRAFT_19
<del> # version < DRAFT_17
<15>:<add> if param_id < len(PARAMS):
<add> # parse known parameter
<add> param_name, param_type = PARAMS[param_id]
<del> param_name, param_type = PARAMS[param_id]
<16>:<add> if param_type == int:
<del> if param_type == int:
<17>:<add> setattr(params, param_name, pull_uint_var(buf))
<del> setattr(params, param_name, pull_uint_var(buf))
<18>:<add> elif param_type == bytes:
<del> elif param_type == bytes:
<19>:<add> setattr(params, param_name, pull_bytes(buf, param_len))
<del> setattr(params, param_name, pull_bytes(buf, param_len))
<20>:<add> else:
<add> setattr(params, param_name, True)
<21>:<add> # skip unknown parameter
<add> pull_bytes(buf, param_len)
<del> setattr(params, param_name, True)
|
# module: aioquic.packet
def pull_quic_transport_parameters(
buf: Buffer, is_client: Optional[bool] = None
) -> QuicTransportParameters:
<0> params = QuicTransportParameters()
<1>
<2> # version < DRAFT_17
<3> if is_client:
<4> params.initial_version = pull_protocol_version(buf)
<5> elif is_client is False:
<6> params.negotiated_version = pull_protocol_version(buf)
<7> params.supported_versions = pull_list(buf, 1, pull_protocol_version)
<8>
<9> with pull_block(buf, 2) as length:
<10> end = buf.tell() + length
<11> while buf.tell() < end:
<12> param_id = pull_uint16(buf)
<13> param_len = pull_uint16(buf)
<14> param_start = buf.tell()
<15> param_name, param_type = PARAMS[param_id]
<16> if param_type == int:
<17> setattr(params, param_name, pull_uint_var(buf))
<18> elif param_type == bytes:
<19> setattr(params, param_name, pull_bytes(buf, param_len))
<20> else:
<21> setattr(params, param_name, True)
<22> assert buf.tell() == param_start + param_len
<23>
<24> return params
<25>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
pull_uint16(buf: Buffer) -> int
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.packet
pull_protocol_version(buf: Buffer) -> QuicProtocolVersion
pull_uint_var(buf: Buffer) -> int
QuicTransportParameters(initial_version: Optional[QuicProtocolVersion]=None, negotiated_version: Optional[QuicProtocolVersion]=None, supported_versions: List[QuicProtocolVersion]=field(default_factory=list), 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_migration: Optional[bool]=False, preferred_address: Optional[bytes]=None)
===========unchanged ref 1===========
PARAMS = [
("original_connection_id", bytes),
("idle_timeout", int),
("stateless_reset_token", bytes),
("max_packet_size", int),
("initial_max_data", int),
("initial_max_stream_data_bidi_local", int),
("initial_max_stream_data_bidi_remote", int),
("initial_max_stream_data_uni", int),
("initial_max_streams_bidi", int),
("initial_max_streams_uni", int),
("ack_delay_exponent", int),
("max_ack_delay", int),
("disable_migration", bool),
("preferred_address", bytes),
]
at: aioquic.packet.QuicTransportParameters
initial_version: Optional[QuicProtocolVersion] = None
negotiated_version: Optional[QuicProtocolVersion] = None
supported_versions: List[QuicProtocolVersion] = field(default_factory=list)
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_migration: Optional[bool] = False
preferred_address: Optional[bytes] = None
at: aioquic.tls
pull_block(buf: Buffer, capacity: int) -> Generator
===========unchanged ref 2===========
pull_list(buf: Buffer, capacity: int, func: Callable[[Buffer], T]) -> List[T]
===========changed ref 0===========
# module: aioquic.tls
class Context:
def _client_handle_encrypted_extensions(self, input_buf: Buffer) -> None:
+ encrypted_extensions = pull_encrypted_extensions(input_buf)
- pull_encrypted_extensions(input_buf)
+ self.received_extensions = encrypted_extensions.other_extensions
self._setup_traffic_protection(
Direction.ENCRYPT, Epoch.HANDSHAKE, b"c hs traffic"
)
self.key_schedule.update_hash(input_buf.data)
self._set_state(State.CLIENT_EXPECT_CERTIFICATE_REQUEST_OR_CERTIFICATE)
===========changed ref 1===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = None):
self.alpn_protocols: Optional[List[str]] = None
self.certificate: Optional[x509.Certificate] = None
self.certificate_private_key: Optional[
Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
] = None
self.handshake_extensions: List[Extension] = []
self.is_client = is_client
self.key_schedule: Optional[KeySchedule] = None
+ self.received_extensions: List[Extension] = []
self.server_name: Optional[str] = None
self.update_traffic_key_cb: Callable[
[Direction, Epoch, bytes], None
] = lambda d, e, s: None
self._cipher_suites = [
CipherSuite.AES_256_GCM_SHA384,
CipherSuite.AES_128_GCM_SHA256,
CipherSuite.CHACHA20_POLY1305_SHA256,
]
self._compression_methods = [CompressionMethod.NULL]
self._key_exchange_modes = [KeyExchangeMode.PSK_DHE_KE]
self._signature_algorithms = [
SignatureAlgorithm.RSA_PSS_RSAE_SHA256,
SignatureAlgorithm.RSA_PKCS1_SHA256,
SignatureAlgorithm.RSA_PKCS1_SHA1,
]
self._supported_versions = [TLS_VERSION_1_3]
self._key_schedule_proxy: Optional[KeyScheduleProxy] = None
self._peer_certificate: Optional[x509.Certificate] = None
self._receive_buffer = b""
self._enc_key: Optional[bytes] = None
self._dec_key: Optional[bytes] = None
self.__logger = logger
if is_client:
self.client_random = os.urandom(32)
self.session_id = os.urandom(32)
self.private_</s>
===========changed ref 2===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = None):
# offset: 1
<s>random = os.urandom(32)
self.session_id = os.urandom(32)
self.private_key = ec.generate_private_key(
ec.SECP256R1(), default_backend()
)
self.state = State.CLIENT_HANDSHAKE_START
else:
self.client_random = None
self.session_id = None
self.private_key = None
self.state = State.SERVER_EXPECT_CLIENT_HELLO
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
9189593fb82052db3448a0ad80efcc271992113b
|
[connection] parse received transport parameters
|
<33>:<add> self._pending_flow_control: List[bytes] = []
<add> self._remote_idle_timeout = 0.0
<add> self._remote_max_streams_bidi = 0
<add> self._remote_max_streams_uni = 0
|
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
<0> if not is_client:
<1> assert certificate is not None, "SSL certificate is required"
<2> assert private_key is not None, "SSL private key is required"
<3>
<4> self.alpn_protocols = alpn_protocols
<5> self.certificate = certificate
<6> self.is_client = is_client
<7> self.host_cid = os.urandom(8)
<8> self.peer_cid = os.urandom(8)
<9> self.peer_cid_set = False
<10> self.peer_token = b""
<11> self.private_key = private_key
<12> self.secrets_log_file = secrets_log_file
<13> self.server_name = server_name
<14> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<15>
<16> # protocol versions
<17> self.supported_versions = [
<18> QuicProtocolVersion.DRAFT_17,
<19> QuicProtocolVersion.DRAFT_18,
<20> QuicProtocolVersion.DRAFT_19,
<21> QuicProtocolVersion.DRAFT_20,
<22> ]
<23> self.version = QuicProtocolVersion.DRAFT_20
<24>
<25> self.__close: Optional[Dict] = None
<26> self.__connected = asyncio.Event()
<27> self.__epoch = tls.Epoch.INITIAL
<28> self.__initialized = False
<29> self.__local_idle_timeout = 60.0 # seconds
<30> self.__local_max_streams_bidi = 100
<31> self.__local_max_streams_uni = 0
<32> self.__logger = logger
<33> self.__transport: Optional[asyncio.DatagramTransport] = None
<34>
|
===========unchanged ref 0===========
at: aioquic.connection
logger = logging.getLogger("quic")
at: aioquic.connection.QuicConnection._crypto_data_received
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._initialize
self.__initialized = True
at: aioquic.connection.QuicConnection._write_application
self.__close = None
at: aioquic.connection.QuicConnection._write_handshake
self.__close = None
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
self.peer_cid_set = True
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None)
at: aioquic.tls
Epoch()
at: asyncio.locks
Event(*, loop: Optional[AbstractEventLoop]=...)
at: os
urandom(size: int, /) -> bytes
at: typing
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
TextIO()
===========changed ref 0===========
# module: aioquic.tls
class Context:
def _client_handle_encrypted_extensions(self, input_buf: Buffer) -> None:
+ encrypted_extensions = pull_encrypted_extensions(input_buf)
- pull_encrypted_extensions(input_buf)
+ self.received_extensions = encrypted_extensions.other_extensions
self._setup_traffic_protection(
Direction.ENCRYPT, Epoch.HANDSHAKE, b"c hs traffic"
)
self.key_schedule.update_hash(input_buf.data)
self._set_state(State.CLIENT_EXPECT_CERTIFICATE_REQUEST_OR_CERTIFICATE)
===========changed ref 1===========
# module: aioquic.packet
def pull_quic_transport_parameters(
buf: Buffer, is_client: Optional[bool] = None
) -> QuicTransportParameters:
params = QuicTransportParameters()
+ # version < DRAFT_19
- # version < DRAFT_17
if is_client:
params.initial_version = pull_protocol_version(buf)
elif is_client is False:
params.negotiated_version = pull_protocol_version(buf)
params.supported_versions = pull_list(buf, 1, pull_protocol_version)
with pull_block(buf, 2) as length:
end = buf.tell() + length
while buf.tell() < end:
param_id = pull_uint16(buf)
param_len = pull_uint16(buf)
param_start = buf.tell()
+ if param_id < len(PARAMS):
+ # parse known parameter
+ param_name, param_type = PARAMS[param_id]
- param_name, param_type = PARAMS[param_id]
+ if param_type == int:
- if param_type == int:
+ setattr(params, param_name, pull_uint_var(buf))
- setattr(params, param_name, pull_uint_var(buf))
+ elif param_type == bytes:
- elif param_type == bytes:
+ setattr(params, param_name, pull_bytes(buf, param_len))
- setattr(params, param_name, pull_bytes(buf, param_len))
+ else:
+ setattr(params, param_name, True)
else:
+ # skip unknown parameter
+ pull_bytes(buf, param_len)
- setattr(params, param_name, True)
assert buf.tell() == param_start + param_len
return params
===========changed ref 2===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = None):
self.alpn_protocols: Optional[List[str]] = None
self.certificate: Optional[x509.Certificate] = None
self.certificate_private_key: Optional[
Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
] = None
self.handshake_extensions: List[Extension] = []
self.is_client = is_client
self.key_schedule: Optional[KeySchedule] = None
+ self.received_extensions: List[Extension] = []
self.server_name: Optional[str] = None
self.update_traffic_key_cb: Callable[
[Direction, Epoch, bytes], None
] = lambda d, e, s: None
self._cipher_suites = [
CipherSuite.AES_256_GCM_SHA384,
CipherSuite.AES_128_GCM_SHA256,
CipherSuite.CHACHA20_POLY1305_SHA256,
]
self._compression_methods = [CompressionMethod.NULL]
self._key_exchange_modes = [KeyExchangeMode.PSK_DHE_KE]
self._signature_algorithms = [
SignatureAlgorithm.RSA_PSS_RSAE_SHA256,
SignatureAlgorithm.RSA_PKCS1_SHA256,
SignatureAlgorithm.RSA_PKCS1_SHA1,
]
self._supported_versions = [TLS_VERSION_1_3]
self._key_schedule_proxy: Optional[KeyScheduleProxy] = None
self._peer_certificate: Optional[x509.Certificate] = None
self._receive_buffer = b""
self._enc_key: Optional[bytes] = None
self._dec_key: Optional[bytes] = None
self.__logger = logger
if is_client:
self.client_random = os.urandom(32)
self.session_id = os.urandom(32)
self.private_</s>
===========changed ref 3===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = None):
# offset: 1
<s>random = os.urandom(32)
self.session_id = os.urandom(32)
self.private_key = ec.generate_private_key(
ec.SECP256R1(), default_backend()
)
self.state = State.CLIENT_HANDSHAKE_START
else:
self.client_random = None
self.session_id = None
self.private_key = None
self.state = State.SERVER_EXPECT_CLIENT_HELLO
|
aioquic.connection/QuicConnection._initialize
|
Modified
|
aiortc~aioquic
|
9189593fb82052db3448a0ad80efcc271992113b
|
[connection] parse received transport parameters
|
<8>:<add> self._serialize_transport_parameters(),
<del> self._serialize_parameters(),
|
# module: aioquic.connection
class QuicConnection:
def _initialize(self, peer_cid: bytes) -> None:
<0> # TLS
<1> self.tls = tls.Context(is_client=self.is_client, logger=self.__logger)
<2> self.tls.alpn_protocols = self.alpn_protocols
<3> self.tls.certificate = self.certificate
<4> self.tls.certificate_private_key = self.private_key
<5> self.tls.handshake_extensions = [
<6> (
<7> tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS,
<8> self._serialize_parameters(),
<9> )
<10> ]
<11> self.tls.server_name = self.server_name
<12> self.tls.update_traffic_key_cb = self._update_traffic_key
<13>
<14> # packet spaces
<15> self.send_ack = {
<16> tls.Epoch.INITIAL: False,
<17> tls.Epoch.HANDSHAKE: False,
<18> tls.Epoch.ONE_RTT: False,
<19> }
<20> self.send_buffer = {
<21> tls.Epoch.INITIAL: Buffer(capacity=4096),
<22> tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
<23> tls.Epoch.ONE_RTT: Buffer(capacity=4096),
<24> }
<25> self.spaces = {
<26> tls.Epoch.INITIAL: PacketSpace(),
<27> tls.Epoch.HANDSHAKE: PacketSpace(),
<28> tls.Epoch.ONE_RTT: PacketSpace(),
<29> }
<30> self.streams[tls.Epoch.INITIAL] = QuicStream()
<31> self.streams[tls.Epoch.HANDSHAKE] = QuicStream()
<32> self.streams[tls.Epoch.ONE_RTT] = QuicStream()
<33>
<34> self.spaces[tls.Epoch.INITIAL].crypto.setup_initial(
<35> cid=peer_cid, is_client=self.is_client
<36> )
<37>
<38> self.__initialized = True
<39> self.packet_number = 0
<40>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
PacketSpace()
at: aioquic.connection.PacketSpace.__init__
self.crypto = CryptoPair()
at: aioquic.connection.QuicConnection
_serialize_transport_parameters() -> bytes
_update_traffic_key(direction: tls.Direction, epoch: tls.Epoch, secret: bytes) -> None
_update_traffic_key(self, direction: tls.Direction, epoch: tls.Epoch, secret: bytes) -> None
at: aioquic.connection.QuicConnection.__init__
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.private_key = private_key
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__logger = logger
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None)
at: aioquic.tls
Epoch()
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
Context(is_client: bool, logger: logging.Logger=None)
at: aioquic.tls.Context.__init__
self.alpn_protocols: Optional[List[str]] = None
self.certificate: Optional[x509.Certificate] = None
self.certificate_private_key: Optional[
Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
] = None
self.handshake_extensions: List[Extension] = []
===========unchanged ref 1===========
self.server_name: Optional[str] = None
self.update_traffic_key_cb: Callable[
[Direction, Epoch, bytes], None
] = lambda d, e, s: None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# protocol versions
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__local_idle_timeout = 60.0 # seconds
self.__local_max_streams_bidi = 100
self.__local_max_streams_uni = 0
self.__logger = logger
+ self._pending_flow_control: List[bytes] = []
+ self._remote_idle_timeout = 0.0
+ self._remote_max_streams_bidi = 0
+ self._remote_max_streams_uni =</s>
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
<s>0
+ self._remote_max_streams_bidi = 0
+ self._remote_max_streams_uni = 0
self.__transport: Optional[asyncio.DatagramTransport] = None
===========changed ref 2===========
# module: aioquic.tls
class Context:
def _client_handle_encrypted_extensions(self, input_buf: Buffer) -> None:
+ encrypted_extensions = pull_encrypted_extensions(input_buf)
- pull_encrypted_extensions(input_buf)
+ self.received_extensions = encrypted_extensions.other_extensions
self._setup_traffic_protection(
Direction.ENCRYPT, Epoch.HANDSHAKE, b"c hs traffic"
)
self.key_schedule.update_hash(input_buf.data)
self._set_state(State.CLIENT_EXPECT_CERTIFICATE_REQUEST_OR_CERTIFICATE)
===========changed ref 3===========
# module: aioquic.packet
def pull_quic_transport_parameters(
buf: Buffer, is_client: Optional[bool] = None
) -> QuicTransportParameters:
params = QuicTransportParameters()
+ # version < DRAFT_19
- # version < DRAFT_17
if is_client:
params.initial_version = pull_protocol_version(buf)
elif is_client is False:
params.negotiated_version = pull_protocol_version(buf)
params.supported_versions = pull_list(buf, 1, pull_protocol_version)
with pull_block(buf, 2) as length:
end = buf.tell() + length
while buf.tell() < end:
param_id = pull_uint16(buf)
param_len = pull_uint16(buf)
param_start = buf.tell()
+ if param_id < len(PARAMS):
+ # parse known parameter
+ param_name, param_type = PARAMS[param_id]
- param_name, param_type = PARAMS[param_id]
+ if param_type == int:
- if param_type == int:
+ setattr(params, param_name, pull_uint_var(buf))
- setattr(params, param_name, pull_uint_var(buf))
+ elif param_type == bytes:
- elif param_type == bytes:
+ setattr(params, param_name, pull_bytes(buf, param_len))
- setattr(params, param_name, pull_bytes(buf, param_len))
+ else:
+ setattr(params, param_name, True)
else:
+ # skip unknown parameter
+ pull_bytes(buf, param_len)
- setattr(params, param_name, True)
assert buf.tell() == param_start + param_len
return params
|
aioquic.connection/QuicConnection._payload_received
|
Modified
|
aiortc~aioquic
|
9189593fb82052db3448a0ad80efcc271992113b
|
[connection] parse received transport parameters
|
<17>:<del> # pass data to TLS layer
<18>:<del> try:
<19>:<del> self.tls.handle_message(data, self.send_buffer)
<20>:<del> except tls.Alert as exc:
<21>:<del> raise QuicConnectionError(
<22>:<del> error_code=QuicErrorCode.CRYPTO_ERROR
<23>:<del> + int(exc.description),
<24>:<del> frame_type=frame_type,
<25>:<del> reason_phrase=str(exc),
<26>:<del> )
<27>:<del>
<28>:<del> # update current epoch
<29>:<del> if self.tls.state in [
<30>:<del> tls.State.CLIENT_POST_HANDSHAKE,
<31>:<del> tls.State.SERVER_POST_HANDSHAKE,
<32>:<del> ]:
<33>:<del> if not self.__connected.is_set():
<34>:<del> self.__connected.set()
<35>:<del> self.__epoch = tls.Epoch.ONE_RTT
<36>:<del> else:
<37>:<del> self.__epoch = tls.Epoch.HANDSHAKE
<38>:<add> self._crypto_data_received(data)
|
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
<0> buf = Buffer(data=plain)
<1>
<2> is_ack_only = True
<3> while not buf.eof():
<4> frame_type = pull_uint_var(buf)
<5> if frame_type != QuicFrameType.ACK:
<6> is_ack_only = False
<7>
<8> if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
<9> pass
<10> elif frame_type == QuicFrameType.ACK:
<11> packet.pull_ack_frame(buf)
<12> elif frame_type == QuicFrameType.CRYPTO:
<13> stream = self.streams[epoch]
<14> stream.add_frame(packet.pull_crypto_frame(buf))
<15> data = stream.pull_data()
<16> if data:
<17> # pass data to TLS layer
<18> try:
<19> self.tls.handle_message(data, self.send_buffer)
<20> except tls.Alert as exc:
<21> raise QuicConnectionError(
<22> error_code=QuicErrorCode.CRYPTO_ERROR
<23> + int(exc.description),
<24> frame_type=frame_type,
<25> reason_phrase=str(exc),
<26> )
<27>
<28> # update current epoch
<29> if self.tls.state in [
<30> tls.State.CLIENT_POST_HANDSHAKE,
<31> tls.State.SERVER_POST_HANDSHAKE,
<32> ]:
<33> if not self.__connected.is_set():
<34> self.__connected.set()
<35> self.__epoch = tls.Epoch.ONE_RTT
<36> else:
<37> self.__epoch = tls.Epoch.HANDSHAKE
<38> elif frame_type == QuicFrameType.NEW_TOKEN:
<39> packet.pull_new_token_frame(buf)
<40> elif (frame_type & ~STREAM_FLAGS) == QuicFrameType.STREAM_BASE:
<41> flags = frame_type & STREAM_FLAGS</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
# offset: 1
if flags & QuicStreamFlag.OFF:
offset = pull_uint_var(buf)
else:
offset = 0
if flags & QuicStreamFlag.LEN:
length = pull_uint_var(buf)
else:
length = buf.capacity - buf.tell()
frame = QuicStreamFrame(
offset=offset,
data=pull_bytes(buf, length),
fin=bool(flags & QuicStreamFlag.FIN),
)
stream = self._get_or_create_stream(stream_id)
stream.add_frame(frame)
elif frame_type == QuicFrameType.MAX_DATA:
pull_uint_var(buf)
elif frame_type in [
QuicFrameType.MAX_STREAMS_BIDI,
QuicFrameType.MAX_STREAMS_UNI,
]:
pull_uint_var(buf)
elif frame_type == QuicFrameType.NEW_CONNECTION_ID:
packet.pull_new_connection_id_frame(buf)
elif frame_type == QuicFrameType.TRANSPORT_CLOSE:
error_code, frame_type, reason_phrase = packet.pull_transport_close_frame(
buf
)
self.__logger.info(
"Transport close code 0x%X, reason %s" % (error_code, reason_phrase)
)
self.connection_lost(None)
elif frame_type == QuicFrameType.APPLICATION_CLOSE:
error_code, reason_phrase = packet.pull_application_close_frame(buf)
self.__logger.info(
"Application close code 0x%X, reason %s"
% (error_code, reason_phrase)
)
self.connection_lost(None)
else:
self.__logger.warning("unhandled frame type %d", frame_type)
break
self</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
# offset: 2
<s>
else:
self.__logger.warning("unhandled frame type %d", frame_type)
break
self._push_crypto_data()
return is_ack_only
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
at: aioquic.buffer.Buffer
eof() -> bool
tell() -> int
at: aioquic.connection
STREAM_FLAGS = 0x07
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
at: aioquic.connection.QuicConnection
connection_lost(exc: Exception) -> None
_get_or_create_stream(self, stream_id: int) -> QuicStream
_get_or_create_stream(stream_id: int) -> QuicStream
_parse_transport_parameters(data: bytes) -> None
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__logger = logger
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self.__logger)
self.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
at: aioquic.connection.QuicConnection._parse_transport_parameters
self._remote_max_streams_bidi = (
quic_transport_parameters.initial_max_streams_bidi
)
self._remote_max_streams_uni = (
quic_transport_parameters.initial_max_streams_uni
)
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._write_application
self.packet_number += 1
at: aioquic.connection.QuicConnection._write_handshake
self.packet_number += 1
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
pull_uint_var(buf: Buffer) -> int
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_ack_frame(buf: Buffer) -> Tuple[RangeSet, int]
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
pull_crypto_frame(buf: Buffer) -> QuicStreamFrame
pull_new_token_frame(buf: Buffer) -> bytes
pull_new_connection_id_frame(buf: Buffer) -> Tuple[int, bytes, bytes]
pull_transport_close_frame(buf: Buffer) -> Tuple[int, int, bytes]
pull_application_close_frame(buf: Buffer) -> Tuple[int, bytes]
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
pull_data() -> bytes
at: aioquic.tls
Alert(*args: object)
Epoch()
State()
===========unchanged ref 2===========
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls.Alert
description: AlertDescription
at: aioquic.tls.Context
handle_message(input_data: bytes, output_buf: Dict[Epoch, Buffer]) -> None
at: aioquic.tls.Context.__init__
self.received_extensions: List[Extension] = []
self.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: aioquic.tls.Context._client_handle_encrypted_extensions
self.received_extensions = encrypted_extensions.other_extensions
at: aioquic.tls.Context._server_handle_hello
self.received_extensions = peer_hello.other_extensions
at: aioquic.tls.Context._set_state
self.state = state
at: asyncio.locks.Event
is_set() -> bool
set() -> None
at: logging.Logger
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
9189593fb82052db3448a0ad80efcc271992113b
|
[connection] parse received transport parameters
|
<19>:<add>
<add> # FLOW CONTROL
<add> for control_frame in self._pending_flow_control:
<add> push_bytes(buf, control_frame)
<add> self._pending_flow_control = []
|
# module: aioquic.connection
class QuicConnection:
def _write_application(self) -> Iterator[bytes]:
<0> epoch = tls.Epoch.ONE_RTT
<1> space = self.spaces[epoch]
<2> if not space.crypto.send.is_valid():
<3> return
<4>
<5> buf = Buffer(capacity=PACKET_MAX_SIZE)
<6>
<7> while True:
<8> # write header
<9> push_uint8(buf, PACKET_FIXED_BIT | (SEND_PN_SIZE - 1))
<10> push_bytes(buf, self.peer_cid)
<11> push_uint16(buf, self.packet_number)
<12> header_size = buf.tell()
<13>
<14> # ACK
<15> if self.send_ack[epoch] and space.ack_queue:
<16> push_uint_var(buf, QuicFrameType.ACK)
<17> packet.push_ack_frame(buf, space.ack_queue, 0)
<18> self.send_ack[epoch] = False
<19>
<20> # CLOSE
<21> if self.__close and self.__epoch == epoch:
<22> push_close(buf, **self.__close)
<23> self.__close = None
<24>
<25> # STREAM
<26> for stream_id, stream in self.streams.items():
<27> if isinstance(stream_id, int) and stream.has_data_to_send():
<28> frame = stream.get_frame(
<29> PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6
<30> )
<31> flags = QuicStreamFlag.LEN
<32> if frame.offset:
<33> flags |= QuicStreamFlag.OFF
<34> if frame.fin:
<35> flags |= QuicStreamFlag.FIN
<36> push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)
<37> with push_stream_frame(buf, 0, frame.offset):
<38> push_bytes(buf, frame.data)
<39>
<40> packet_size = buf.tell()
<41> if packet_size > header_size:</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _write_application(self) -> Iterator[bytes]:
# offset: 1
data = buf.data
yield space.crypto.encrypt_packet(
data[0:header_size], data[header_size:packet_size]
)
self.packet_number += 1
buf.seek(0)
else:
break
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
push_bytes(buf: Buffer, v: bytes) -> None
push_uint8(buf: Buffer, v: int) -> None
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.connection
PACKET_MAX_SIZE = 1280
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",
],
]
SEND_PN_SIZE = 2
at: aioquic.connection.PacketSpace.__init__
self.ack_queue = RangeSet()
self.crypto = CryptoPair()
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.peer_cid = os.urandom(8)
self.secrets_log_file = secrets_log_file
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
self.__local_idle_timeout = 60.0 # seconds
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self.__logger)
===========unchanged ref 1===========
self.send_ack = {
tls.Epoch.INITIAL: False,
tls.Epoch.HANDSHAKE: False,
tls.Epoch.ONE_RTT: False,
}
self.spaces = {
tls.Epoch.INITIAL: PacketSpace(),
tls.Epoch.HANDSHAKE: PacketSpace(),
tls.Epoch.ONE_RTT: PacketSpace(),
}
self.packet_number = 0
at: aioquic.connection.QuicConnection._serialize_transport_parameters
quic_transport_parameters = QuicTransportParameters(
initial_max_data=16777216,
initial_max_stream_data_bidi_local=1048576,
initial_max_stream_data_bidi_remote=1048576,
initial_max_stream_data_uni=1048576,
initial_max_streams_bidi=self.__local_max_streams_bidi,
initial_max_streams_uni=self.__local_max_streams_uni,
ack_delay_exponent=10,
)
at: aioquic.connection.QuicConnection._write_application
self.packet_number += 1
at: aioquic.connection.QuicConnection._write_handshake
self.packet_number += 1
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
at: aioquic.crypto.CryptoContext
is_valid() -> bool
setup(cipher_suite: CipherSuite, secret: bytes) -> None
at: aioquic.crypto.CryptoPair.__init__
self.recv = CryptoContext()
self.send = CryptoContext()
at: aioquic.packet
PACKET_FIXED_BIT = 0x40
push_uint_var(buf: Buffer, value: int) -> None
push_quic_transport_parameters(buf: Buffer, params: QuicTransportParameters, is_client: Optional[bool]=None) -> None
===========unchanged ref 2===========
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.packet.QuicTransportParameters
initial_version: Optional[QuicProtocolVersion] = None
negotiated_version: Optional[QuicProtocolVersion] = None
supported_versions: List[QuicProtocolVersion] = field(default_factory=list)
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_migration: Optional[bool] = False
preferred_address: Optional[bytes] = None
at: aioquic.tls
Direction()
Epoch()
at: aioquic.tls.Context.__init__
self.key_schedule: Optional[KeySchedule] = None
self.client_random = None
self.client_random = os.urandom(32)
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
at: aioquic.tls.Context._server_handle_hello
self.client_random = peer_hello.random
self.key_schedule = KeySchedule(cipher_suite)
===========unchanged ref 3===========
at: aioquic.tls.KeySchedule.__init__
self.cipher_suite = cipher_suite
at: enum.Enum
name: str
value: Any
_name_: str
_value_: Any
_member_names_: List[str] # undocumented
_member_map_: Dict[str, Enum] # undocumented
_value2member_map_: Dict[int, Enum] # undocumented
_ignore_: Union[str, List[str]]
_order_: str
__order__: str
at: typing
Iterator = _alias(collections.abc.Iterator, 1)
at: typing.IO
__slots__ = ()
flush() -> None
write(s: AnyStr) -> int
|
aioquic.packet/pull_quic_header
|
Modified
|
aiortc~aioquic
|
45ef09d0c7fd0baa0c49cadee56e5e55e1063df0
|
[packet] add helper to encode version negotiation packet
|
<6>:<add> version = pull_uint32(buf)
<del> version = pull_protocol_version(buf)
|
# module: aioquic.packet
def pull_quic_header(buf: Buffer, host_cid_length: Optional[int] = None) -> QuicHeader:
<0> first_byte = pull_uint8(buf)
<1>
<2> original_destination_cid = b""
<3> token = b""
<4> if is_long_header(first_byte):
<5> # long header packet
<6> version = pull_protocol_version(buf)
<7> cid_lengths = pull_uint8(buf)
<8>
<9> destination_cid_length = decode_cid_length(cid_lengths // 16)
<10> destination_cid = pull_bytes(buf, destination_cid_length)
<11>
<12> source_cid_length = decode_cid_length(cid_lengths % 16)
<13> source_cid = pull_bytes(buf, source_cid_length)
<14>
<15> if version == QuicProtocolVersion.NEGOTIATION:
<16> # version negotiation
<17> packet_type = None
<18> rest_length = buf.capacity - buf.tell()
<19> else:
<20> if version and not (first_byte & PACKET_FIXED_BIT):
<21> raise ValueError("Packet fixed bit is zero")
<22>
<23> packet_type = first_byte & PACKET_TYPE_MASK
<24> if packet_type == PACKET_TYPE_INITIAL:
<25> token_length = pull_uint_var(buf)
<26> token = pull_bytes(buf, token_length)
<27> rest_length = pull_uint_var(buf)
<28> elif packet_type == PACKET_TYPE_RETRY:
<29> original_destination_cid_length = decode_cid_length(first_byte & 0xF)
<30> original_destination_cid = pull_bytes(
<31> buf, original_destination_cid_length
<32> )
<33> token = pull_bytes(buf, buf.capacity - buf.tell())
<34> rest_length = 0
<35> else:
<36> rest_length = pull_uint_var(buf)
<37>
<38> return QuicHeader(
<39> version=version,
<40> packet_type=packet_</s>
|
===========below chunk 0===========
# module: aioquic.packet
def pull_quic_header(buf: Buffer, host_cid_length: Optional[int] = None) -> QuicHeader:
# offset: 1
destination_cid=destination_cid,
source_cid=source_cid,
original_destination_cid=original_destination_cid,
token=token,
rest_length=rest_length,
)
else:
# short header packet
if not (first_byte & PACKET_FIXED_BIT):
raise ValueError("Packet fixed bit is zero")
packet_type = first_byte & PACKET_TYPE_MASK
destination_cid = pull_bytes(buf, host_cid_length)
return QuicHeader(
version=None,
packet_type=packet_type,
destination_cid=destination_cid,
source_cid=b"",
token=b"",
rest_length=buf.capacity - buf.tell(),
)
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
pull_uint8(buf: Buffer) -> int
pull_uint32(buf: Buffer) -> int
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.packet
PACKET_FIXED_BIT = 0x40
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30
PACKET_TYPE_MASK = 0xF0
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicHeader(version: Optional[int], packet_type: int, destination_cid: bytes, source_cid: bytes, original_destination_cid: bytes=b"", token: bytes=b"", rest_length: int=0)
decode_cid_length(length: int) -> int
is_long_header(first_byte: int) -> bool
pull_uint_var(buf: Buffer) -> int
at: aioquic.packet.QuicHeader
version: Optional[int]
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
===========changed ref 0===========
# module: aioquic.packet
@dataclass
class QuicHeader:
+ version: Optional[int]
- version: int
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
19e64aaece808f26cad1ecebe70c2d485636f5dd
|
[examples] implement version negotiation in server example
|
<17>:<del> self.supported_versions = [
<18>:<del> QuicProtocolVersion.DRAFT_17,
<19>:<del> QuicProtocolVersion.DRAFT_18,
<20>:<del> QuicProtocolVersion.DRAFT_19,
<21>:<del> QuicProtocolVersion.DRAFT_20,
<22>:<del> ]
<23>:<del> self.version = QuicProtocolVersion.DRAFT_20
<24>:<add> self.version = max(self.supported_versions)
|
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
<0> if not is_client:
<1> assert certificate is not None, "SSL certificate is required"
<2> assert private_key is not None, "SSL private key is required"
<3>
<4> self.alpn_protocols = alpn_protocols
<5> self.certificate = certificate
<6> self.is_client = is_client
<7> self.host_cid = os.urandom(8)
<8> self.peer_cid = os.urandom(8)
<9> self.peer_cid_set = False
<10> self.peer_token = b""
<11> self.private_key = private_key
<12> self.secrets_log_file = secrets_log_file
<13> self.server_name = server_name
<14> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<15>
<16> # protocol versions
<17> self.supported_versions = [
<18> QuicProtocolVersion.DRAFT_17,
<19> QuicProtocolVersion.DRAFT_18,
<20> QuicProtocolVersion.DRAFT_19,
<21> QuicProtocolVersion.DRAFT_20,
<22> ]
<23> self.version = QuicProtocolVersion.DRAFT_20
<24>
<25> self.__close: Optional[Dict] = None
<26> self.__connected = asyncio.Event()
<27> self.__epoch = tls.Epoch.INITIAL
<28> self.__initialized = False
<29> self.__local_idle_timeout = 60.0 # seconds
<30> self.__local_max_streams_bidi = 100
<31> self.__local_max_streams_uni = 0
<32> self.__logger = logger
<33> self._pending_flow_control: List[bytes] = []
<34> self._remote_idle_timeout</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self.__transport: Optional[asyncio.DatagramTransport] = None
===========unchanged ref 0===========
at: aioquic.connection
logger = logging.getLogger("quic")
at: aioquic.connection.QuicConnection._crypto_data_received
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._initialize
self.__initialized = True
at: aioquic.connection.QuicConnection._parse_transport_parameters
self._remote_idle_timeout = quic_transport_parameters.idle_timeout
self._remote_idle_timeout = (
quic_transport_parameters.idle_timeout / 1000
)
self._remote_max_streams_bidi = (
quic_transport_parameters.initial_max_streams_bidi
)
self._remote_max_streams_uni = (
quic_transport_parameters.initial_max_streams_uni
)
at: aioquic.connection.QuicConnection._payload_received
self._remote_max_streams_bidi = pull_uint_var(buf)
self._remote_max_streams_uni = pull_uint_var(buf)
at: aioquic.connection.QuicConnection._write_application
self._pending_flow_control = []
self.__close = None
at: aioquic.connection.QuicConnection._write_handshake
self.__close = None
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
self.peer_cid_set = True
===========unchanged ref 1===========
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None)
at: aioquic.tls
Epoch()
at: asyncio.locks
Event(*, loop: Optional[AbstractEventLoop]=...)
at: os
urandom(size: int, /) -> bytes
at: typing
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
TextIO()
|
examples.server/QuicServerProtocol.datagram_received
|
Modified
|
aiortc~aioquic
|
19e64aaece808f26cad1ecebe70c2d485636f5dd
|
[examples] implement version negotiation in server example
|
<2>:<add>
<add> # version negotiation
<add> if (
<add> header.version is not None
<add> and header.version not in QuicConnection.supported_versions
<add> ):
<add> self._transport.sendto(
<add> encode_quic_version_negotiation(
<add> source_cid=header.destination_cid,
<add> destination_cid=header.source_cid,
<add> supported_versions=QuicConnection.supported_versions,
<add> ),
<add> addr,
<add> )
<add> return
<add>
|
# module: examples.server
class QuicServerProtocol(asyncio.DatagramProtocol):
def datagram_received(self, datagram, addr):
<0> buf = Buffer(data=datagram)
<1> header = pull_quic_header(buf, host_cid_length=8)
<2> connection = self._connections.get(header.destination_cid, None)
<3> if connection is None:
<4> connection = QuicConnection(is_client=False, **self._kwargs)
<5> connection.connection_made(QuicConnectionTransport(self, addr))
<6> self._connections[connection.host_cid] = connection
<7> connection.datagram_received(datagram, addr)
<8>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
at: aioquic.packet
pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader
at: aioquic.packet.QuicHeader
version: Optional[int]
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
at: asyncio.protocols.DatagramProtocol
__slots__ = ()
datagram_received(self, data: bytes, addr: Tuple[str, int]) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# protocol versions
- self.supported_versions = [
- QuicProtocolVersion.DRAFT_17,
- QuicProtocolVersion.DRAFT_18,
- QuicProtocolVersion.DRAFT_19,
- QuicProtocolVersion.DRAFT_20,
- ]
- self.version = QuicProtocolVersion.DRAFT_20
+ self.version = max(self.supported_versions)
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__local_idle_timeout = 60.0 # seconds
self.__local_max_streams_bidi = 100
self.__local_max_streams_uni = 0
self.__logger = logger
self._pending_flow_control: List[bytes] = []
self._remote_idle_timeout = 0.0
self._remote_max_streams</s>
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
<s>control: List[bytes] = []
self._remote_idle_timeout = 0.0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self.__transport: Optional[asyncio.DatagramTransport] = None
|
tests.test_packet/PacketTest.test_pull_initial_client
|
Modified
|
aiortc~aioquic
|
bf5f9fc502c95961d9cff6f7712340505ed2cf3f
|
[examples] drop packets for unknown CID
|
<2>:<add> self.assertTrue(header.is_long_header)
|
# module: tests.test_packet
class PacketTest(TestCase):
def test_pull_initial_client(self):
<0> buf = Buffer(data=load("initial_client.bin"))
<1> header = pull_quic_header(buf, host_cid_length=8)
<2> self.assertEqual(header.version, QuicProtocolVersion.DRAFT_17)
<3> self.assertEqual(header.packet_type, PACKET_TYPE_INITIAL)
<4> self.assertEqual(header.destination_cid, binascii.unhexlify("90ed1e1c7b04b5d3"))
<5> self.assertEqual(header.source_cid, b"")
<6> self.assertEqual(header.original_destination_cid, b"")
<7> self.assertEqual(header.token, b"")
<8> self.assertEqual(header.rest_length, 1263)
<9> self.assertEqual(buf.tell(), 17)
<10>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader
at: aioquic.packet.QuicHeader
version: Optional[int]
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.utils
load(name)
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.packet
@dataclass
class QuicHeader:
+ @property
+ def is_long_header(self) -> bool:
+ return self.packet_type is None or is_long_header(self.packet_type)
+
|
tests.test_packet/PacketTest.test_pull_initial_server
|
Modified
|
aiortc~aioquic
|
bf5f9fc502c95961d9cff6f7712340505ed2cf3f
|
[examples] drop packets for unknown CID
|
<2>:<add> self.assertTrue(header.is_long_header)
|
# module: tests.test_packet
class PacketTest(TestCase):
def test_pull_initial_server(self):
<0> buf = Buffer(data=load("initial_server.bin"))
<1> header = pull_quic_header(buf, host_cid_length=8)
<2> self.assertEqual(header.version, QuicProtocolVersion.DRAFT_17)
<3> self.assertEqual(header.packet_type, PACKET_TYPE_INITIAL)
<4> self.assertEqual(header.destination_cid, b"")
<5> self.assertEqual(header.source_cid, binascii.unhexlify("0fcee9852fde8780"))
<6> self.assertEqual(header.original_destination_cid, b"")
<7> self.assertEqual(header.token, b"")
<8> self.assertEqual(header.rest_length, 182)
<9> self.assertEqual(buf.tell(), 17)
<10>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.utils
load(name)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_packet
class PacketTest(TestCase):
def test_pull_initial_client(self):
buf = Buffer(data=load("initial_client.bin"))
header = pull_quic_header(buf, host_cid_length=8)
+ self.assertTrue(header.is_long_header)
self.assertEqual(header.version, QuicProtocolVersion.DRAFT_17)
self.assertEqual(header.packet_type, PACKET_TYPE_INITIAL)
self.assertEqual(header.destination_cid, binascii.unhexlify("90ed1e1c7b04b5d3"))
self.assertEqual(header.source_cid, b"")
self.assertEqual(header.original_destination_cid, b"")
self.assertEqual(header.token, b"")
self.assertEqual(header.rest_length, 1263)
self.assertEqual(buf.tell(), 17)
===========changed ref 1===========
# module: aioquic.packet
@dataclass
class QuicHeader:
+ @property
+ def is_long_header(self) -> bool:
+ return self.packet_type is None or is_long_header(self.packet_type)
+
|
tests.test_packet/PacketTest.test_pull_retry
|
Modified
|
aiortc~aioquic
|
bf5f9fc502c95961d9cff6f7712340505ed2cf3f
|
[examples] drop packets for unknown CID
|
<2>:<add> self.assertTrue(header.is_long_header)
|
# module: tests.test_packet
class PacketTest(TestCase):
def test_pull_retry(self):
<0> buf = Buffer(data=load("retry.bin"))
<1> header = pull_quic_header(buf, host_cid_length=8)
<2> self.assertEqual(header.version, QuicProtocolVersion.DRAFT_19)
<3> self.assertEqual(header.packet_type, PACKET_TYPE_RETRY)
<4> self.assertEqual(header.destination_cid, binascii.unhexlify("c98343fe8f5f0ff4"))
<5> self.assertEqual(
<6> header.source_cid,
<7> binascii.unhexlify("c17f7c0473e635351b85a17e9f3296d7246c"),
<8> )
<9> self.assertEqual(
<10> header.original_destination_cid, binascii.unhexlify("85abb547bf28be97")
<11> )
<12> self.assertEqual(
<13> header.token,
<14> binascii.unhexlify(
<15> "01652d68d17c8e9f968d4fb4b70c9e526c4f837dbd85abb547bf28be97"
<16> ),
<17> )
<18> self.assertEqual(header.rest_length, 0)
<19> self.assertEqual(buf.tell(), 69)
<20>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.packet
PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_packet.PacketTest.test_pull_initial_server
buf = Buffer(data=load("initial_server.bin"))
at: tests.utils
load(name)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_packet
class PacketTest(TestCase):
def test_pull_initial_server(self):
buf = Buffer(data=load("initial_server.bin"))
header = pull_quic_header(buf, host_cid_length=8)
+ self.assertTrue(header.is_long_header)
self.assertEqual(header.version, QuicProtocolVersion.DRAFT_17)
self.assertEqual(header.packet_type, PACKET_TYPE_INITIAL)
self.assertEqual(header.destination_cid, b"")
self.assertEqual(header.source_cid, binascii.unhexlify("0fcee9852fde8780"))
self.assertEqual(header.original_destination_cid, b"")
self.assertEqual(header.token, b"")
self.assertEqual(header.rest_length, 182)
self.assertEqual(buf.tell(), 17)
===========changed ref 1===========
# module: tests.test_packet
class PacketTest(TestCase):
def test_pull_initial_client(self):
buf = Buffer(data=load("initial_client.bin"))
header = pull_quic_header(buf, host_cid_length=8)
+ self.assertTrue(header.is_long_header)
self.assertEqual(header.version, QuicProtocolVersion.DRAFT_17)
self.assertEqual(header.packet_type, PACKET_TYPE_INITIAL)
self.assertEqual(header.destination_cid, binascii.unhexlify("90ed1e1c7b04b5d3"))
self.assertEqual(header.source_cid, b"")
self.assertEqual(header.original_destination_cid, b"")
self.assertEqual(header.token, b"")
self.assertEqual(header.rest_length, 1263)
self.assertEqual(buf.tell(), 17)
===========changed ref 2===========
# module: aioquic.packet
@dataclass
class QuicHeader:
+ @property
+ def is_long_header(self) -> bool:
+ return self.packet_type is None or is_long_header(self.packet_type)
+
|
tests.test_packet/PacketTest.test_pull_version_negotiation
|
Modified
|
aiortc~aioquic
|
bf5f9fc502c95961d9cff6f7712340505ed2cf3f
|
[examples] drop packets for unknown CID
|
<2>:<add> self.assertTrue(header.is_long_header)
|
# module: tests.test_packet
class PacketTest(TestCase):
def test_pull_version_negotiation(self):
<0> buf = Buffer(data=load("version_negotiation.bin"))
<1> header = pull_quic_header(buf, host_cid_length=8)
<2> self.assertEqual(header.version, QuicProtocolVersion.NEGOTIATION)
<3> self.assertEqual(header.packet_type, None)
<4> self.assertEqual(header.destination_cid, binascii.unhexlify("dae1889b81a91c26"))
<5> self.assertEqual(header.source_cid, binascii.unhexlify("f49243784f9bf3be"))
<6> self.assertEqual(header.original_destination_cid, b"")
<7> self.assertEqual(header.token, b"")
<8> self.assertEqual(header.rest_length, 8)
<9> self.assertEqual(buf.tell(), 22)
<10>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_packet.PacketTest.test_pull_retry
buf = Buffer(data=load("retry.bin"))
header = pull_quic_header(buf, host_cid_length=8)
at: tests.utils
load(name)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_packet
class PacketTest(TestCase):
def test_pull_initial_server(self):
buf = Buffer(data=load("initial_server.bin"))
header = pull_quic_header(buf, host_cid_length=8)
+ self.assertTrue(header.is_long_header)
self.assertEqual(header.version, QuicProtocolVersion.DRAFT_17)
self.assertEqual(header.packet_type, PACKET_TYPE_INITIAL)
self.assertEqual(header.destination_cid, b"")
self.assertEqual(header.source_cid, binascii.unhexlify("0fcee9852fde8780"))
self.assertEqual(header.original_destination_cid, b"")
self.assertEqual(header.token, b"")
self.assertEqual(header.rest_length, 182)
self.assertEqual(buf.tell(), 17)
===========changed ref 1===========
# module: tests.test_packet
class PacketTest(TestCase):
def test_pull_initial_client(self):
buf = Buffer(data=load("initial_client.bin"))
header = pull_quic_header(buf, host_cid_length=8)
+ self.assertTrue(header.is_long_header)
self.assertEqual(header.version, QuicProtocolVersion.DRAFT_17)
self.assertEqual(header.packet_type, PACKET_TYPE_INITIAL)
self.assertEqual(header.destination_cid, binascii.unhexlify("90ed1e1c7b04b5d3"))
self.assertEqual(header.source_cid, b"")
self.assertEqual(header.original_destination_cid, b"")
self.assertEqual(header.token, b"")
self.assertEqual(header.rest_length, 1263)
self.assertEqual(buf.tell(), 17)
===========changed ref 2===========
# module: tests.test_packet
class PacketTest(TestCase):
def test_pull_retry(self):
buf = Buffer(data=load("retry.bin"))
header = pull_quic_header(buf, host_cid_length=8)
+ self.assertTrue(header.is_long_header)
self.assertEqual(header.version, QuicProtocolVersion.DRAFT_19)
self.assertEqual(header.packet_type, PACKET_TYPE_RETRY)
self.assertEqual(header.destination_cid, binascii.unhexlify("c98343fe8f5f0ff4"))
self.assertEqual(
header.source_cid,
binascii.unhexlify("c17f7c0473e635351b85a17e9f3296d7246c"),
)
self.assertEqual(
header.original_destination_cid, binascii.unhexlify("85abb547bf28be97")
)
self.assertEqual(
header.token,
binascii.unhexlify(
"01652d68d17c8e9f968d4fb4b70c9e526c4f837dbd85abb547bf28be97"
),
)
self.assertEqual(header.rest_length, 0)
self.assertEqual(buf.tell(), 69)
===========changed ref 3===========
# module: aioquic.packet
@dataclass
class QuicHeader:
+ @property
+ def is_long_header(self) -> bool:
+ return self.packet_type is None or is_long_header(self.packet_type)
+
|
tests.test_packet/PacketTest.test_pull_short_header
|
Modified
|
aiortc~aioquic
|
bf5f9fc502c95961d9cff6f7712340505ed2cf3f
|
[examples] drop packets for unknown CID
|
<2>:<add> self.assertFalse(header.is_long_header)
|
# module: tests.test_packet
class PacketTest(TestCase):
def test_pull_short_header(self):
<0> buf = Buffer(data=load("short_header.bin"))
<1> header = pull_quic_header(buf, host_cid_length=8)
<2> self.assertEqual(header.version, None)
<3> self.assertEqual(header.packet_type, 0x50)
<4> self.assertEqual(header.destination_cid, binascii.unhexlify("f45aa7b59c0e1ad6"))
<5> self.assertEqual(header.source_cid, b"")
<6> self.assertEqual(header.original_destination_cid, b"")
<7> self.assertEqual(header.token, b"")
<8> self.assertEqual(header.rest_length, 12)
<9> self.assertEqual(buf.tell(), 9)
<10>
|
===========unchanged ref 0===========
at: aioquic.buffer
BufferReadError(*args: object)
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.packet
pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.utils
load(name)
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
class PacketTest(TestCase):
def test_pull_version_negotiation(self):
buf = Buffer(data=load("version_negotiation.bin"))
header = pull_quic_header(buf, host_cid_length=8)
+ self.assertTrue(header.is_long_header)
self.assertEqual(header.version, QuicProtocolVersion.NEGOTIATION)
self.assertEqual(header.packet_type, None)
self.assertEqual(header.destination_cid, binascii.unhexlify("dae1889b81a91c26"))
self.assertEqual(header.source_cid, binascii.unhexlify("f49243784f9bf3be"))
self.assertEqual(header.original_destination_cid, b"")
self.assertEqual(header.token, b"")
self.assertEqual(header.rest_length, 8)
self.assertEqual(buf.tell(), 22)
===========changed ref 1===========
# module: tests.test_packet
class PacketTest(TestCase):
def test_pull_initial_server(self):
buf = Buffer(data=load("initial_server.bin"))
header = pull_quic_header(buf, host_cid_length=8)
+ self.assertTrue(header.is_long_header)
self.assertEqual(header.version, QuicProtocolVersion.DRAFT_17)
self.assertEqual(header.packet_type, PACKET_TYPE_INITIAL)
self.assertEqual(header.destination_cid, b"")
self.assertEqual(header.source_cid, binascii.unhexlify("0fcee9852fde8780"))
self.assertEqual(header.original_destination_cid, b"")
self.assertEqual(header.token, b"")
self.assertEqual(header.rest_length, 182)
self.assertEqual(buf.tell(), 17)
===========changed ref 2===========
# module: tests.test_packet
class PacketTest(TestCase):
def test_pull_initial_client(self):
buf = Buffer(data=load("initial_client.bin"))
header = pull_quic_header(buf, host_cid_length=8)
+ self.assertTrue(header.is_long_header)
self.assertEqual(header.version, QuicProtocolVersion.DRAFT_17)
self.assertEqual(header.packet_type, PACKET_TYPE_INITIAL)
self.assertEqual(header.destination_cid, binascii.unhexlify("90ed1e1c7b04b5d3"))
self.assertEqual(header.source_cid, b"")
self.assertEqual(header.original_destination_cid, b"")
self.assertEqual(header.token, b"")
self.assertEqual(header.rest_length, 1263)
self.assertEqual(buf.tell(), 17)
===========changed ref 3===========
# module: tests.test_packet
class PacketTest(TestCase):
def test_pull_retry(self):
buf = Buffer(data=load("retry.bin"))
header = pull_quic_header(buf, host_cid_length=8)
+ self.assertTrue(header.is_long_header)
self.assertEqual(header.version, QuicProtocolVersion.DRAFT_19)
self.assertEqual(header.packet_type, PACKET_TYPE_RETRY)
self.assertEqual(header.destination_cid, binascii.unhexlify("c98343fe8f5f0ff4"))
self.assertEqual(
header.source_cid,
binascii.unhexlify("c17f7c0473e635351b85a17e9f3296d7246c"),
)
self.assertEqual(
header.original_destination_cid, binascii.unhexlify("85abb547bf28be97")
)
self.assertEqual(
header.token,
binascii.unhexlify(
"01652d68d17c8e9f968d4fb4b70c9e526c4f837dbd85abb547bf28be97"
),
)
self.assertEqual(header.rest_length, 0)
self.assertEqual(buf.tell(), 69)
===========changed ref 4===========
# module: aioquic.packet
@dataclass
class QuicHeader:
+ @property
+ def is_long_header(self) -> bool:
+ return self.packet_type is None or is_long_header(self.packet_type)
+
|
examples.server/QuicServerProtocol.datagram_received
|
Modified
|
aiortc~aioquic
|
bf5f9fc502c95961d9cff6f7712340505ed2cf3f
|
[examples] drop packets for unknown CID
|
<19>:<add> if connection is None and header.is_long_header:
<add> # create new connection
<del> if connection is None:
<23>:<del> connection.datagram_received(datagram, addr)
|
# module: examples.server
class QuicServerProtocol(asyncio.DatagramProtocol):
def datagram_received(self, datagram, addr):
<0> buf = Buffer(data=datagram)
<1> header = pull_quic_header(buf, host_cid_length=8)
<2>
<3> # version negotiation
<4> if (
<5> header.version is not None
<6> and header.version not in QuicConnection.supported_versions
<7> ):
<8> self._transport.sendto(
<9> encode_quic_version_negotiation(
<10> source_cid=header.destination_cid,
<11> destination_cid=header.source_cid,
<12> supported_versions=QuicConnection.supported_versions,
<13> ),
<14> addr,
<15> )
<16> return
<17>
<18> connection = self._connections.get(header.destination_cid, None)
<19> if connection is None:
<20> connection = QuicConnection(is_client=False, **self._kwargs)
<21> connection.connection_made(QuicConnectionTransport(self, addr))
<22> self._connections[connection.host_cid] = connection
<23> connection.datagram_received(datagram, addr)
<24>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
connection_made(transport: asyncio.DatagramTransport) -> None
at: aioquic.connection.QuicConnection.__init__
self.host_cid = os.urandom(8)
at: aioquic.packet
pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader
encode_quic_version_negotiation(source_cid: bytes, destination_cid: bytes, supported_versions: List[QuicProtocolVersion]) -> bytes
at: aioquic.packet.QuicHeader
version: Optional[int]
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
at: asyncio.protocols.DatagramProtocol
__slots__ = ()
datagram_received(self, data: bytes, addr: Tuple[str, int]) -> None
at: examples.server
QuicConnectionTransport(protocol, addr)
at: examples.server.QuicServerProtocol.__init__
self._connections = {}
self._kwargs = kwargs
self._transport = None
at: examples.server.QuicServerProtocol.connection_made
self._transport = transport
===========unchanged ref 1===========
at: typing.Mapping
get(key: _KT, default: Union[_VT_co, _T]) -> Union[_VT_co, _T]
get(key: _KT) -> Optional[_VT_co]
===========changed ref 0===========
# module: aioquic.packet
@dataclass
class QuicHeader:
+ @property
+ def is_long_header(self) -> bool:
+ return self.packet_type is None or is_long_header(self.packet_type)
+
===========changed ref 1===========
# module: tests.test_packet
class PacketTest(TestCase):
def test_pull_short_header(self):
buf = Buffer(data=load("short_header.bin"))
header = pull_quic_header(buf, host_cid_length=8)
+ self.assertFalse(header.is_long_header)
self.assertEqual(header.version, None)
self.assertEqual(header.packet_type, 0x50)
self.assertEqual(header.destination_cid, binascii.unhexlify("f45aa7b59c0e1ad6"))
self.assertEqual(header.source_cid, b"")
self.assertEqual(header.original_destination_cid, b"")
self.assertEqual(header.token, b"")
self.assertEqual(header.rest_length, 12)
self.assertEqual(buf.tell(), 9)
===========changed ref 2===========
# module: tests.test_packet
class PacketTest(TestCase):
def test_pull_initial_server(self):
buf = Buffer(data=load("initial_server.bin"))
header = pull_quic_header(buf, host_cid_length=8)
+ self.assertTrue(header.is_long_header)
self.assertEqual(header.version, QuicProtocolVersion.DRAFT_17)
self.assertEqual(header.packet_type, PACKET_TYPE_INITIAL)
self.assertEqual(header.destination_cid, b"")
self.assertEqual(header.source_cid, binascii.unhexlify("0fcee9852fde8780"))
self.assertEqual(header.original_destination_cid, b"")
self.assertEqual(header.token, b"")
self.assertEqual(header.rest_length, 182)
self.assertEqual(buf.tell(), 17)
===========changed ref 3===========
# module: tests.test_packet
class PacketTest(TestCase):
def test_pull_initial_client(self):
buf = Buffer(data=load("initial_client.bin"))
header = pull_quic_header(buf, host_cid_length=8)
+ self.assertTrue(header.is_long_header)
self.assertEqual(header.version, QuicProtocolVersion.DRAFT_17)
self.assertEqual(header.packet_type, PACKET_TYPE_INITIAL)
self.assertEqual(header.destination_cid, binascii.unhexlify("90ed1e1c7b04b5d3"))
self.assertEqual(header.source_cid, b"")
self.assertEqual(header.original_destination_cid, b"")
self.assertEqual(header.token, b"")
self.assertEqual(header.rest_length, 1263)
self.assertEqual(buf.tell(), 17)
===========changed ref 4===========
# module: tests.test_packet
class PacketTest(TestCase):
def test_pull_version_negotiation(self):
buf = Buffer(data=load("version_negotiation.bin"))
header = pull_quic_header(buf, host_cid_length=8)
+ self.assertTrue(header.is_long_header)
self.assertEqual(header.version, QuicProtocolVersion.NEGOTIATION)
self.assertEqual(header.packet_type, None)
self.assertEqual(header.destination_cid, binascii.unhexlify("dae1889b81a91c26"))
self.assertEqual(header.source_cid, binascii.unhexlify("f49243784f9bf3be"))
self.assertEqual(header.original_destination_cid, b"")
self.assertEqual(header.token, b"")
self.assertEqual(header.rest_length, 8)
self.assertEqual(buf.tell(), 22)
===========changed ref 5===========
# module: tests.test_packet
class PacketTest(TestCase):
def test_pull_retry(self):
buf = Buffer(data=load("retry.bin"))
header = pull_quic_header(buf, host_cid_length=8)
+ self.assertTrue(header.is_long_header)
self.assertEqual(header.version, QuicProtocolVersion.DRAFT_19)
self.assertEqual(header.packet_type, PACKET_TYPE_RETRY)
self.assertEqual(header.destination_cid, binascii.unhexlify("c98343fe8f5f0ff4"))
self.assertEqual(
header.source_cid,
binascii.unhexlify("c17f7c0473e635351b85a17e9f3296d7246c"),
)
self.assertEqual(
header.original_destination_cid, binascii.unhexlify("85abb547bf28be97")
)
self.assertEqual(
header.token,
binascii.unhexlify(
"01652d68d17c8e9f968d4fb4b70c9e526c4f837dbd85abb547bf28be97"
),
)
self.assertEqual(header.rest_length, 0)
self.assertEqual(buf.tell(), 69)
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
7a3fa5df5902c93068bd30371f6b9b9918910c0e
|
[examples] make server respond to HTTP/0.9
|
<15>:<add>
<add> # callbacks
<add> self.stream_created_cb: Callable[
<add> [asyncio.StreamReader, asyncio.StreamWriter], None
<add> ] = lambda r, w: None
|
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
<0> if not is_client:
<1> assert certificate is not None, "SSL certificate is required"
<2> assert private_key is not None, "SSL private key is required"
<3>
<4> self.alpn_protocols = alpn_protocols
<5> self.certificate = certificate
<6> self.is_client = is_client
<7> self.host_cid = os.urandom(8)
<8> self.peer_cid = os.urandom(8)
<9> self.peer_cid_set = False
<10> self.peer_token = b""
<11> self.private_key = private_key
<12> self.secrets_log_file = secrets_log_file
<13> self.server_name = server_name
<14> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<15>
<16> # protocol versions
<17> self.version = max(self.supported_versions)
<18>
<19> self.__close: Optional[Dict] = None
<20> self.__connected = asyncio.Event()
<21> self.__epoch = tls.Epoch.INITIAL
<22> self.__initialized = False
<23> self.__local_idle_timeout = 60.0 # seconds
<24> self.__local_max_streams_bidi = 100
<25> self.__local_max_streams_uni = 0
<26> self.__logger = logger
<27> self._pending_flow_control: List[bytes] = []
<28> self._remote_idle_timeout = 0.0
<29> self._remote_max_streams_bidi = 0
<30> self._remote_max_streams_uni = 0
<31> self.__transport: Optional[asyncio.DatagramTransport] = None
<32>
|
===========unchanged ref 0===========
at: aioquic.connection
logger = logging.getLogger("quic")
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
at: aioquic.connection.QuicConnection._crypto_data_received
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._initialize
self.__initialized = True
at: aioquic.connection.QuicConnection._write_application
self.__close = None
at: aioquic.connection.QuicConnection._write_handshake
self.__close = None
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
self.peer_cid_set = True
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None)
at: aioquic.tls
Epoch()
at: asyncio.locks
Event(*, loop: Optional[AbstractEventLoop]=...)
at: asyncio.streams
StreamWriter(transport: transports.BaseTransport, protocol: protocols.BaseProtocol, reader: Optional[StreamReader], loop: events.AbstractEventLoop)
StreamReader(limit: int=..., loop: Optional[events.AbstractEventLoop]=...)
at: os
urandom(size: int, /) -> bytes
at: typing
Callable = _CallableType(collections.abc.Callable, 2)
===========unchanged ref 1===========
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
TextIO()
|
aioquic.connection/QuicConnection._get_or_create_stream
|
Modified
|
aiortc~aioquic
|
7a3fa5df5902c93068bd30371f6b9b9918910c0e
|
[examples] make server respond to HTTP/0.9
|
<2>:<add> self.stream_created_cb(
<add> self.streams[stream_id].reader, self.streams[stream_id].writer
<add> )
|
# module: aioquic.connection
class QuicConnection:
# Private
def _get_or_create_stream(self, stream_id: int) -> QuicStream:
<0> if stream_id not in self.streams:
<1> self.streams[stream_id] = QuicStream(connection=self, stream_id=stream_id)
<2> return self.streams[stream_id]
<3>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
_send_pending() -> None
at: aioquic.connection.QuicConnection.__init__
self.__logger = logger
at: logging.Logger
warning(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
+
+ # callbacks
+ self.stream_created_cb: Callable[
+ [asyncio.StreamReader, asyncio.StreamWriter], None
+ ] = lambda r, w: None
# protocol versions
self.version = max(self.supported_versions)
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__local_idle_timeout = 60.0 # seconds
self.__local_max_streams_bidi = 100
self.__local_max_streams_uni = 0
self.__logger = logger
self._pending_flow_control: List[bytes] = []
self._remote_idle_timeout = 0.0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self.__transport: Optional[asyncio.DatagramTransport</s>
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
<s> = 0
self._remote_max_streams_uni = 0
self.__transport: Optional[asyncio.DatagramTransport] = None
|
examples.server/QuicServerProtocol.datagram_received
|
Modified
|
aiortc~aioquic
|
7a3fa5df5902c93068bd30371f6b9b9918910c0e
|
[examples] make server respond to HTTP/0.9
|
<23>:<add> connection.stream_created_cb = self.stream_created
|
# module: examples.server
class QuicServerProtocol(asyncio.DatagramProtocol):
def datagram_received(self, datagram, addr):
<0> buf = Buffer(data=datagram)
<1> header = pull_quic_header(buf, host_cid_length=8)
<2>
<3> # version negotiation
<4> if (
<5> header.version is not None
<6> and header.version not in QuicConnection.supported_versions
<7> ):
<8> self._transport.sendto(
<9> encode_quic_version_negotiation(
<10> source_cid=header.destination_cid,
<11> destination_cid=header.source_cid,
<12> supported_versions=QuicConnection.supported_versions,
<13> ),
<14> addr,
<15> )
<16> return
<17>
<18> connection = self._connections.get(header.destination_cid, None)
<19> if connection is None and header.is_long_header:
<20> # create new connection
<21> connection = QuicConnection(is_client=False, **self._kwargs)
<22> connection.connection_made(QuicConnectionTransport(self, addr))
<23> self._connections[connection.host_cid] = connection
<24>
<25> if connection is not None:
<26> connection.datagram_received(datagram, addr)
<27>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
at: aioquic.packet
pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader
encode_quic_version_negotiation(source_cid: bytes, destination_cid: bytes, supported_versions: List[QuicProtocolVersion]) -> bytes
at: aioquic.packet.QuicHeader
version: Optional[int]
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
at: asyncio.protocols
DatagramProtocol()
at: asyncio.protocols.BaseProtocol
__slots__ = ()
connection_made(self, transport: transports.BaseTransport) -> None
at: asyncio.protocols.DatagramProtocol
__slots__ = ()
datagram_received(self, data: bytes, addr: Tuple[str, int]) -> None
at: examples.server.QuicConnectionTransport.__init__
self.__addr = addr
self.__protocol = protocol
===========changed ref 0===========
# module: examples.server
+ def serve_http_request(reader, writer):
+ """
+ Serve an HTTP/0.9 request.
+ """
+ request = await reader.read()
+
+ if request == b"GET /\r\n":
+ writer.write(b"It works!\r\n")
+ else:
+ writer.write(b"Not found\r\n")
+
+ writer.write_eof()
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
# Private
def _get_or_create_stream(self, stream_id: int) -> QuicStream:
if stream_id not in self.streams:
self.streams[stream_id] = QuicStream(connection=self, stream_id=stream_id)
+ self.stream_created_cb(
+ self.streams[stream_id].reader, self.streams[stream_id].writer
+ )
return self.streams[stream_id]
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
+
+ # callbacks
+ self.stream_created_cb: Callable[
+ [asyncio.StreamReader, asyncio.StreamWriter], None
+ ] = lambda r, w: None
# protocol versions
self.version = max(self.supported_versions)
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__local_idle_timeout = 60.0 # seconds
self.__local_max_streams_bidi = 100
self.__local_max_streams_uni = 0
self.__logger = logger
self._pending_flow_control: List[bytes] = []
self._remote_idle_timeout = 0.0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self.__transport: Optional[asyncio.DatagramTransport</s>
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
<s> = 0
self._remote_max_streams_uni = 0
self.__transport: Optional[asyncio.DatagramTransport] = None
|
aioquic.stream/QuicStream.get_extra_info
|
Modified
|
aiortc~aioquic
|
efcd51b2204ad8a4dd8248b348bb46425420f165
|
[examples] improve logging
|
<3>:<add> if name == "connection":
<add> return self._connection
<add> elif name == "stream_id":
<del> if name == "stream_id":
|
# module: aioquic.stream
class QuicStream:
# asyncio.Transport
def get_extra_info(self, name: str, default: Any = None) -> Any:
<0> """
<1> Returns information about the underlying QUIC stream.
<2> """
<3> if name == "stream_id":
<4> return self.stream_id
<5>
|
===========unchanged ref 0===========
at: aioquic.stream.QuicStream.__init__
self._connection = connection
|
tests.test_connection/QuicConnectionTest.test_create_stream
|
Modified
|
aiortc~aioquic
|
efcd51b2204ad8a4dd8248b348bb46425420f165
|
[examples] improve logging
|
<13>:<add> self.assertIsNotNone(writer.get_extra_info("connection"))
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream(self):
<0> client = QuicConnection(is_client=True)
<1> client._initialize(b"")
<2>
<3> server = QuicConnection(
<4> is_client=False,
<5> certificate=SERVER_CERTIFICATE,
<6> private_key=SERVER_PRIVATE_KEY,
<7> )
<8> server._initialize(b"")
<9>
<10> # client
<11> reader, writer = client.create_stream()
<12> self.assertEqual(writer.get_extra_info("stream_id"), 0)
<13>
<14> reader, writer = client.create_stream()
<15> self.assertEqual(writer.get_extra_info("stream_id"), 4)
<16>
<17> reader, writer = client.create_stream(is_unidirectional=True)
<18> self.assertEqual(writer.get_extra_info("stream_id"), 2)
<19>
<20> reader, writer = client.create_stream(is_unidirectional=True)
<21> self.assertEqual(writer.get_extra_info("stream_id"), 6)
<22>
<23> # server
<24> reader, writer = server.create_stream()
<25> self.assertEqual(writer.get_extra_info("stream_id"), 1)
<26>
<27> reader, writer = server.create_stream()
<28> self.assertEqual(writer.get_extra_info("stream_id"), 5)
<29>
<30> reader, writer = server.create_stream(is_unidirectional=True)
<31> self.assertEqual(writer.get_extra_info("stream_id"), 3)
<32>
<33> reader, writer = server.create_stream(is_unidirectional=True)
<34> self.assertEqual(writer.get_extra_info("stream_id"), 7)
<35>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
_initialize(peer_cid: bytes) -> None
at: asyncio.streams.StreamWriter
get_extra_info(name: str, default: Any=...) -> Any
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertIsNotNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.stream
class QuicStream:
# asyncio.Transport
def get_extra_info(self, name: str, default: Any = None) -> Any:
"""
Returns information about the underlying QUIC stream.
"""
+ if name == "connection":
+ return self._connection
+ elif name == "stream_id":
- if name == "stream_id":
return self.stream_id
|
examples.server/QuicServerProtocol.datagram_received
|
Modified
|
aiortc~aioquic
|
efcd51b2204ad8a4dd8248b348bb46425420f165
|
[examples] improve logging
|
<25>:<add> logger.info("%s New connection from %s" % (connection_id(connection), addr))
|
# module: examples.server
class QuicServerProtocol(asyncio.DatagramProtocol):
def datagram_received(self, datagram, addr):
<0> buf = Buffer(data=datagram)
<1> header = pull_quic_header(buf, host_cid_length=8)
<2>
<3> # version negotiation
<4> if (
<5> header.version is not None
<6> and header.version not in QuicConnection.supported_versions
<7> ):
<8> self._transport.sendto(
<9> encode_quic_version_negotiation(
<10> source_cid=header.destination_cid,
<11> destination_cid=header.source_cid,
<12> supported_versions=QuicConnection.supported_versions,
<13> ),
<14> addr,
<15> )
<16> return
<17>
<18> connection = self._connections.get(header.destination_cid, None)
<19> if connection is None and header.is_long_header:
<20> # create new connection
<21> connection = QuicConnection(is_client=False, **self._kwargs)
<22> connection.connection_made(QuicConnectionTransport(self, addr))
<23> connection.stream_created_cb = self.stream_created
<24> self._connections[connection.host_cid] = connection
<25>
<26> if connection is not None:
<27> connection.datagram_received(datagram, addr)
<28>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
at: aioquic.packet
pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader
encode_quic_version_negotiation(source_cid: bytes, destination_cid: bytes, supported_versions: List[QuicProtocolVersion]) -> bytes
at: aioquic.packet.QuicHeader
version: Optional[int]
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
at: asyncio.protocols.BaseProtocol
__slots__ = ()
connection_made(self, transport: transports.BaseTransport) -> None
at: asyncio.protocols.DatagramProtocol
__slots__ = ()
datagram_received(self, data: bytes, addr: Tuple[str, int]) -> None
at: typing.Mapping
get(key: _KT, default: Union[_VT_co, _T]) -> Union[_VT_co, _T]
get(key: _KT) -> Optional[_VT_co]
===========changed ref 0===========
# module: examples.server
+ def connection_id(connection):
+ return "Connection %s" % binascii.hexlify(connection.host_cid).decode("ascii")
+
===========changed ref 1===========
# module: aioquic.stream
class QuicStream:
# asyncio.Transport
def get_extra_info(self, name: str, default: Any = None) -> Any:
"""
Returns information about the underlying QUIC stream.
"""
+ if name == "connection":
+ return self._connection
+ elif name == "stream_id":
- if name == "stream_id":
return self.stream_id
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream(self):
client = QuicConnection(is_client=True)
client._initialize(b"")
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
server._initialize(b"")
# client
reader, writer = client.create_stream()
self.assertEqual(writer.get_extra_info("stream_id"), 0)
+ self.assertIsNotNone(writer.get_extra_info("connection"))
reader, writer = client.create_stream()
self.assertEqual(writer.get_extra_info("stream_id"), 4)
reader, writer = client.create_stream(is_unidirectional=True)
self.assertEqual(writer.get_extra_info("stream_id"), 2)
reader, writer = client.create_stream(is_unidirectional=True)
self.assertEqual(writer.get_extra_info("stream_id"), 6)
# server
reader, writer = server.create_stream()
self.assertEqual(writer.get_extra_info("stream_id"), 1)
reader, writer = server.create_stream()
self.assertEqual(writer.get_extra_info("stream_id"), 5)
reader, writer = server.create_stream(is_unidirectional=True)
self.assertEqual(writer.get_extra_info("stream_id"), 3)
reader, writer = server.create_stream(is_unidirectional=True)
self.assertEqual(writer.get_extra_info("stream_id"), 7)
|
examples.server/QuicServerProtocol.stream_created
|
Modified
|
aiortc~aioquic
|
efcd51b2204ad8a4dd8248b348bb46425420f165
|
[examples] improve logging
|
<0>:<add> connection = writer.get_extra_info("connection")
<1>:<add> logger.info(
<add> "%s Stream %d created by remote party"
<add> % (connection_id(connection), stream_id)
<add> )
|
# module: examples.server
class QuicServerProtocol(asyncio.DatagramProtocol):
def stream_created(self, reader, writer):
<0> stream_id = writer.get_extra_info("stream_id")
<1> if stream_id == 0:
<2> asyncio.ensure_future(serve_http_request(reader, writer))
<3>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
connection_made(transport: asyncio.DatagramTransport) -> None
at: aioquic.connection.QuicConnection.__init__
self.host_cid = os.urandom(8)
self.stream_created_cb: Callable[
[asyncio.StreamReader, asyncio.StreamWriter], None
] = lambda r, w: None
at: examples.server
logger = logging.getLogger("server")
connection_id(connection)
QuicConnectionTransport(protocol, addr)
at: examples.server.QuicServerProtocol
stream_created(reader, writer)
at: examples.server.QuicServerProtocol.__init__
self._connections = {}
at: examples.server.QuicServerProtocol.datagram_received
connection = self._connections.get(header.destination_cid, None)
connection = QuicConnection(is_client=False, **self._kwargs)
at: logging.Logger
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: examples.server
+ def connection_id(connection):
+ return "Connection %s" % binascii.hexlify(connection.host_cid).decode("ascii")
+
===========changed ref 1===========
# module: examples.server
class QuicServerProtocol(asyncio.DatagramProtocol):
def datagram_received(self, datagram, addr):
buf = Buffer(data=datagram)
header = pull_quic_header(buf, host_cid_length=8)
# version negotiation
if (
header.version is not None
and header.version not in QuicConnection.supported_versions
):
self._transport.sendto(
encode_quic_version_negotiation(
source_cid=header.destination_cid,
destination_cid=header.source_cid,
supported_versions=QuicConnection.supported_versions,
),
addr,
)
return
connection = self._connections.get(header.destination_cid, None)
if connection is None and header.is_long_header:
# create new connection
connection = QuicConnection(is_client=False, **self._kwargs)
connection.connection_made(QuicConnectionTransport(self, addr))
connection.stream_created_cb = self.stream_created
self._connections[connection.host_cid] = connection
+ logger.info("%s New connection from %s" % (connection_id(connection), addr))
if connection is not None:
connection.datagram_received(datagram, addr)
===========changed ref 2===========
# module: aioquic.stream
class QuicStream:
# asyncio.Transport
def get_extra_info(self, name: str, default: Any = None) -> Any:
"""
Returns information about the underlying QUIC stream.
"""
+ if name == "connection":
+ return self._connection
+ elif name == "stream_id":
- if name == "stream_id":
return self.stream_id
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream(self):
client = QuicConnection(is_client=True)
client._initialize(b"")
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
server._initialize(b"")
# client
reader, writer = client.create_stream()
self.assertEqual(writer.get_extra_info("stream_id"), 0)
+ self.assertIsNotNone(writer.get_extra_info("connection"))
reader, writer = client.create_stream()
self.assertEqual(writer.get_extra_info("stream_id"), 4)
reader, writer = client.create_stream(is_unidirectional=True)
self.assertEqual(writer.get_extra_info("stream_id"), 2)
reader, writer = client.create_stream(is_unidirectional=True)
self.assertEqual(writer.get_extra_info("stream_id"), 6)
# server
reader, writer = server.create_stream()
self.assertEqual(writer.get_extra_info("stream_id"), 1)
reader, writer = server.create_stream()
self.assertEqual(writer.get_extra_info("stream_id"), 5)
reader, writer = server.create_stream(is_unidirectional=True)
self.assertEqual(writer.get_extra_info("stream_id"), 3)
reader, writer = server.create_stream(is_unidirectional=True)
self.assertEqual(writer.get_extra_info("stream_id"), 7)
|
aioquic.connection/QuicConnection._payload_received
|
Modified
|
aiortc~aioquic
|
b97a0f8e5edb7966f5110ac3f33e0da910153341
|
[connection] don't send ACK for ACK with ECN or PADDING
|
<5>:<add> if frame_type not in [
<add> QuicFrameType.ACK,
<del> if frame_type != QuicFrameType.ACK:
<6>:<add> QuicFrameType.ACK_ECN,
<add> QuicFrameType.PADDING,
<add> ]:
|
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
<0> buf = Buffer(data=plain)
<1>
<2> is_ack_only = True
<3> while not buf.eof():
<4> frame_type = pull_uint_var(buf)
<5> if frame_type != QuicFrameType.ACK:
<6> is_ack_only = False
<7>
<8> if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
<9> pass
<10> elif frame_type == QuicFrameType.ACK:
<11> packet.pull_ack_frame(buf)
<12> elif frame_type == QuicFrameType.CRYPTO:
<13> stream = self.streams[epoch]
<14> stream.add_frame(packet.pull_crypto_frame(buf))
<15> data = stream.pull_data()
<16> if data:
<17> self._crypto_data_received(data)
<18> elif frame_type == QuicFrameType.NEW_TOKEN:
<19> packet.pull_new_token_frame(buf)
<20> elif (frame_type & ~STREAM_FLAGS) == QuicFrameType.STREAM_BASE:
<21> flags = frame_type & STREAM_FLAGS
<22> stream_id = pull_uint_var(buf)
<23> if flags & QuicStreamFlag.OFF:
<24> offset = pull_uint_var(buf)
<25> else:
<26> offset = 0
<27> if flags & QuicStreamFlag.LEN:
<28> length = pull_uint_var(buf)
<29> else:
<30> length = buf.capacity - buf.tell()
<31> frame = QuicStreamFrame(
<32> offset=offset,
<33> data=pull_bytes(buf, length),
<34> fin=bool(flags & QuicStreamFlag.FIN),
<35> )
<36> stream = self._get_or_create_stream(stream_id)
<37> stream.add_frame(frame)
<38> elif frame_type == QuicFrameType.MAX_DATA:
<39> pull_uint</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
# offset: 1
elif frame_type == QuicFrameType.MAX_STREAMS_BIDI:
self._remote_max_streams_bidi = pull_uint_var(buf)
elif frame_type == QuicFrameType.MAX_STREAMS_UNI:
self._remote_max_streams_uni = pull_uint_var(buf)
elif frame_type == QuicFrameType.NEW_CONNECTION_ID:
packet.pull_new_connection_id_frame(buf)
elif frame_type == QuicFrameType.TRANSPORT_CLOSE:
error_code, frame_type, reason_phrase = packet.pull_transport_close_frame(
buf
)
self.__logger.info(
"Transport close code 0x%X, reason %s" % (error_code, reason_phrase)
)
self.connection_lost(None)
elif frame_type == QuicFrameType.APPLICATION_CLOSE:
error_code, reason_phrase = packet.pull_application_close_frame(buf)
self.__logger.info(
"Application close code 0x%X, reason %s"
% (error_code, reason_phrase)
)
self.connection_lost(None)
else:
self.__logger.warning("unhandled frame type %d", frame_type)
break
self._push_crypto_data()
return is_ack_only
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
at: aioquic.buffer.Buffer
eof() -> bool
tell() -> int
at: aioquic.connection
STREAM_FLAGS = 0x07
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
connection_lost(exc: Exception) -> None
_get_or_create_stream(stream_id: int) -> QuicStream
_crypto_data_received(data: bytes) -> None
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__logger = logger
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
at: aioquic.connection.QuicConnection._parse_transport_parameters
self._remote_max_streams_bidi = (
quic_transport_parameters.initial_max_streams_bidi
)
self._remote_max_streams_uni = (
quic_transport_parameters.initial_max_streams_uni
)
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_ack_frame(buf: Buffer) -> Tuple[RangeSet, int]
===========unchanged ref 1===========
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
pull_crypto_frame(buf: Buffer) -> QuicStreamFrame
pull_new_token_frame(buf: Buffer) -> bytes
pull_new_connection_id_frame(buf: Buffer) -> Tuple[int, bytes, bytes]
pull_transport_close_frame(buf: Buffer) -> Tuple[int, int, bytes]
pull_application_close_frame(buf: Buffer) -> Tuple[int, bytes]
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
pull_data() -> bytes
at: aioquic.tls
Epoch()
at: logging.Logger
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
warning(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
|
aioquic.connection/QuicConnection._payload_received
|
Modified
|
aiortc~aioquic
|
93ee761616335c76ef7f090c4c538ff58ce4b2cc
|
[connection] skip MAX_STREAM_DATA
|
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
<0> buf = Buffer(data=plain)
<1>
<2> is_ack_only = True
<3> while not buf.eof():
<4> frame_type = pull_uint_var(buf)
<5> if frame_type not in [
<6> QuicFrameType.ACK,
<7> QuicFrameType.ACK_ECN,
<8> QuicFrameType.PADDING,
<9> ]:
<10> is_ack_only = False
<11>
<12> if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
<13> pass
<14> elif frame_type == QuicFrameType.ACK:
<15> packet.pull_ack_frame(buf)
<16> elif frame_type == QuicFrameType.CRYPTO:
<17> stream = self.streams[epoch]
<18> stream.add_frame(packet.pull_crypto_frame(buf))
<19> data = stream.pull_data()
<20> if data:
<21> self._crypto_data_received(data)
<22> elif frame_type == QuicFrameType.NEW_TOKEN:
<23> packet.pull_new_token_frame(buf)
<24> elif (frame_type & ~STREAM_FLAGS) == QuicFrameType.STREAM_BASE:
<25> flags = frame_type & STREAM_FLAGS
<26> stream_id = pull_uint_var(buf)
<27> if flags & QuicStreamFlag.OFF:
<28> offset = pull_uint_var(buf)
<29> else:
<30> offset = 0
<31> if flags & QuicStreamFlag.LEN:
<32> length = pull_uint_var(buf)
<33> else:
<34> length = buf.capacity - buf.tell()
<35> frame = QuicStreamFrame(
<36> offset=offset,
<37> data=pull_bytes(buf, length),
<38> fin=bool(flags & QuicStreamFlag.FIN),
<39> )
<40> stream = self._get_or_create_stream(stream_id)</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
# offset: 1
elif frame_type == QuicFrameType.MAX_DATA:
pull_uint_var(buf)
elif frame_type == QuicFrameType.MAX_STREAMS_BIDI:
self._remote_max_streams_bidi = pull_uint_var(buf)
elif frame_type == QuicFrameType.MAX_STREAMS_UNI:
self._remote_max_streams_uni = pull_uint_var(buf)
elif frame_type == QuicFrameType.NEW_CONNECTION_ID:
packet.pull_new_connection_id_frame(buf)
elif frame_type == QuicFrameType.TRANSPORT_CLOSE:
error_code, frame_type, reason_phrase = packet.pull_transport_close_frame(
buf
)
self.__logger.info(
"Transport close code 0x%X, reason %s" % (error_code, reason_phrase)
)
self.connection_lost(None)
elif frame_type == QuicFrameType.APPLICATION_CLOSE:
error_code, reason_phrase = packet.pull_application_close_frame(buf)
self.__logger.info(
"Application close code 0x%X, reason %s"
% (error_code, reason_phrase)
)
self.connection_lost(None)
else:
self.__logger.warning("unhandled frame type %d", frame_type)
break
self._push_crypto_data()
return is_ack_only
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
at: aioquic.buffer.Buffer
eof() -> bool
tell() -> int
at: aioquic.connection
STREAM_FLAGS = 0x07
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
connection_lost(exc: Exception) -> None
_get_or_create_stream(stream_id: int) -> QuicStream
_crypto_data_received(data: bytes) -> None
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__logger = logger
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
at: aioquic.connection.QuicConnection._parse_transport_parameters
self._remote_max_streams_bidi = (
quic_transport_parameters.initial_max_streams_bidi
)
self._remote_max_streams_uni = (
quic_transport_parameters.initial_max_streams_uni
)
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_ack_frame(buf: Buffer) -> Tuple[RangeSet, int]
===========unchanged ref 1===========
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
pull_crypto_frame(buf: Buffer) -> QuicStreamFrame
pull_new_token_frame(buf: Buffer) -> bytes
pull_new_connection_id_frame(buf: Buffer) -> Tuple[int, bytes, bytes]
pull_transport_close_frame(buf: Buffer) -> Tuple[int, int, bytes]
pull_application_close_frame(buf: Buffer) -> Tuple[int, bytes]
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
pull_data() -> bytes
at: aioquic.tls
Epoch()
at: logging.Logger
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
warning(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
|
|
aioquic.connection/QuicConnection._payload_received
|
Modified
|
aiortc~aioquic
|
a2b98a92c30ff98add6e94af71db8be387e49cee
|
[connection] only allow raising max_streams
|
<15>:<add> self._handle_ack_frame(frame_type, buf)
<del> packet.pull_ack_frame(buf)
<25>:<del> flags = frame_type & STREAM_FLAGS
<26>:<del> stream_id = pull_uint_var(buf)
<27>:<del> if flags & QuicStreamFlag.OFF:
<28>:<del> offset = pull_uint_var(buf)
<29>:<del> else:
<30>:<del> offset = 0
<31>:<del> if flags & QuicStreamFlag.LEN:
<32>:<del> length = pull_uint_var(buf)
<33>:<del> else:
<34>:<del> length = buf.capacity - buf.tell()
<35>:<del> frame = QuicStreamFrame(
<36>:<del> offset=offset,
<37>:<del> data=pull_bytes(buf, length),
<38>:<del> fin=bool(flags & QuicStreamFlag.FIN),
<39>:<del> )
<40>:<del> stream = self._get_or_create_stream(stream_id)
|
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
<0> buf = Buffer(data=plain)
<1>
<2> is_ack_only = True
<3> while not buf.eof():
<4> frame_type = pull_uint_var(buf)
<5> if frame_type not in [
<6> QuicFrameType.ACK,
<7> QuicFrameType.ACK_ECN,
<8> QuicFrameType.PADDING,
<9> ]:
<10> is_ack_only = False
<11>
<12> if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
<13> pass
<14> elif frame_type == QuicFrameType.ACK:
<15> packet.pull_ack_frame(buf)
<16> elif frame_type == QuicFrameType.CRYPTO:
<17> stream = self.streams[epoch]
<18> stream.add_frame(packet.pull_crypto_frame(buf))
<19> data = stream.pull_data()
<20> if data:
<21> self._crypto_data_received(data)
<22> elif frame_type == QuicFrameType.NEW_TOKEN:
<23> packet.pull_new_token_frame(buf)
<24> elif (frame_type & ~STREAM_FLAGS) == QuicFrameType.STREAM_BASE:
<25> flags = frame_type & STREAM_FLAGS
<26> stream_id = pull_uint_var(buf)
<27> if flags & QuicStreamFlag.OFF:
<28> offset = pull_uint_var(buf)
<29> else:
<30> offset = 0
<31> if flags & QuicStreamFlag.LEN:
<32> length = pull_uint_var(buf)
<33> else:
<34> length = buf.capacity - buf.tell()
<35> frame = QuicStreamFrame(
<36> offset=offset,
<37> data=pull_bytes(buf, length),
<38> fin=bool(flags & QuicStreamFlag.FIN),
<39> )
<40> stream = self._get_or_create_stream(stream_id)</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
# offset: 1
elif frame_type == QuicFrameType.MAX_DATA:
pull_uint_var(buf)
elif frame_type == QuicFrameType.MAX_STREAM_DATA:
pull_uint_var(buf)
pull_uint_var(buf)
elif frame_type == QuicFrameType.MAX_STREAMS_BIDI:
self._remote_max_streams_bidi = pull_uint_var(buf)
elif frame_type == QuicFrameType.MAX_STREAMS_UNI:
self._remote_max_streams_uni = pull_uint_var(buf)
elif frame_type == QuicFrameType.NEW_CONNECTION_ID:
packet.pull_new_connection_id_frame(buf)
elif frame_type == QuicFrameType.TRANSPORT_CLOSE:
error_code, frame_type, reason_phrase = packet.pull_transport_close_frame(
buf
)
self.__logger.info(
"Transport close code 0x%X, reason %s" % (error_code, reason_phrase)
)
self.connection_lost(None)
elif frame_type == QuicFrameType.APPLICATION_CLOSE:
error_code, reason_phrase = packet.pull_application_close_frame(buf)
self.__logger.info(
"Application close code 0x%X, reason %s"
% (error_code, reason_phrase)
)
self.connection_lost(None)
else:
self.__logger.warning("unhandled frame type %d", frame_type)
break
self._push_crypto_data()
return is_ack_only
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.connection
STREAM_FLAGS = 0x07
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
connection_lost(exc: Exception) -> None
at: aioquic.connection.QuicConnection.__init__
self.__logger = logger
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
at: aioquic.connection.QuicConnection._parse_transport_parameters
self._remote_max_streams_bidi = (
quic_transport_parameters.initial_max_streams_bidi
)
self._remote_max_streams_uni = (
quic_transport_parameters.initial_max_streams_uni
)
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_ack_frame(buf: Buffer) -> Tuple[RangeSet, int]
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
pull_transport_close_frame(buf: Buffer) -> Tuple[int, int, bytes]
===========unchanged ref 1===========
pull_application_close_frame(buf: Buffer) -> Tuple[int, bytes]
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: logging.Logger
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
+ def _handle_ack_frame(self, frame_type: int, buf: Buffer) -> None:
+ """
+ Handle an ACK frame.
+ """
+ packet.pull_ack_frame(buf)
+
|
aioquic.connection/QuicConnection._payload_received
|
Modified
|
aiortc~aioquic
|
488c9dc69d954792afead7fc077f0734898dc42f
|
[connection] add test for NEW_CONNECTION_ID and NEW_TOKEN frames
|
<23>:<add> self._handle_new_token_frame(frame_type, buf)
<del> packet.pull_new_token_frame(buf)
|
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
<0> buf = Buffer(data=plain)
<1>
<2> is_ack_only = True
<3> while not buf.eof():
<4> frame_type = pull_uint_var(buf)
<5> if frame_type not in [
<6> QuicFrameType.ACK,
<7> QuicFrameType.ACK_ECN,
<8> QuicFrameType.PADDING,
<9> ]:
<10> is_ack_only = False
<11>
<12> if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
<13> pass
<14> elif frame_type == QuicFrameType.ACK:
<15> self._handle_ack_frame(frame_type, buf)
<16> elif frame_type == QuicFrameType.CRYPTO:
<17> stream = self.streams[epoch]
<18> stream.add_frame(packet.pull_crypto_frame(buf))
<19> data = stream.pull_data()
<20> if data:
<21> self._crypto_data_received(data)
<22> elif frame_type == QuicFrameType.NEW_TOKEN:
<23> packet.pull_new_token_frame(buf)
<24> elif (frame_type & ~STREAM_FLAGS) == QuicFrameType.STREAM_BASE:
<25> self._handle_stream_frame(frame_type, buf)
<26> elif frame_type == QuicFrameType.MAX_DATA:
<27> self._handle_max_data_frame(frame_type, buf)
<28> elif frame_type == QuicFrameType.MAX_STREAM_DATA:
<29> self._handle_max_stream_data_frame(frame_type, buf)
<30> elif frame_type == QuicFrameType.MAX_STREAMS_BIDI:
<31> self._handle_max_streams_bidi_frame(frame_type, buf)
<32> elif frame_type == QuicFrameType.MAX_STREAMS_UNI:
<33> self._handle_max_streams_uni_frame(frame_</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
# offset: 1
elif frame_type == QuicFrameType.NEW_CONNECTION_ID:
packet.pull_new_connection_id_frame(buf)
elif frame_type in [
QuicFrameType.TRANSPORT_CLOSE,
QuicFrameType.APPLICATION_CLOSE,
]:
self._handle_connection_close_frame(frame_type, buf)
else:
self.__logger.warning("unhandled frame type %d", frame_type)
break
self._push_crypto_data()
return is_ack_only
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
at: aioquic.buffer.Buffer
eof() -> bool
tell() -> int
at: aioquic.connection
STREAM_FLAGS = 0x07
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
_get_or_create_stream(stream_id: int) -> QuicStream
_crypto_data_received(data: bytes) -> None
_handle_ack_frame(frame_type: int, buf: Buffer) -> None
_handle_max_data_frame(frame_type: int, buf: Buffer) -> None
_handle_max_stream_data_frame(frame_type: int, buf: Buffer) -> None
_handle_max_streams_bidi_frame(frame_type: int, buf: Buffer) -> None
_handle_max_streams_uni_frame(frame_type: int, buf: Buffer) -> None
_handle_new_connection_id_frame(frame_type: int, buf: Buffer) -> None
_handle_new_token_frame(frame_type: int, buf: Buffer) -> None
_handle_stream_frame(frame_type: int, buf: Buffer) -> None
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
at: aioquic.connection.QuicConnection._handle_stream_frame
flags = frame_type & STREAM_FLAGS
stream_id = pull_uint_var(buf)
offset = 0
offset = pull_uint_var(buf)
===========unchanged ref 1===========
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
pull_crypto_frame(buf: Buffer) -> QuicStreamFrame
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
pull_data() -> bytes
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
+ def _handle_new_token_frame(self, frame_type: int, buf: Buffer) -> None:
+ """
+ Handle a NEW_TOKEN frame.
+ """
+ packet.pull_new_token_frame(buf)
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
+ def _handle_new_connection_id_frame(self, frame_type: int, buf: Buffer) -> None:
+ """
+ Handle a NEW_CONNECTION_ID frame.
+ """
+ packet.pull_new_connection_id_frame(buf)
+
|
aioquic.connection/QuicConnection._payload_received
|
Modified
|
aiortc~aioquic
|
92957cfa450fb5f3049cf9e046d0649520d6645c
|
[connection] add stubs for more frame types
|
<16>:<add> elif frame_type == QuicFrameType.RESET_STREAM:
<add> self._handle_reset_stream_frame(frame_type, buf)
<add> elif frame_type == QuicFrameType.STOP_SENDING:
<add> self._handle_stop_sending_frame(frame_type, buf)
|
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
<0> buf = Buffer(data=plain)
<1>
<2> is_ack_only = True
<3> while not buf.eof():
<4> frame_type = pull_uint_var(buf)
<5> if frame_type not in [
<6> QuicFrameType.ACK,
<7> QuicFrameType.ACK_ECN,
<8> QuicFrameType.PADDING,
<9> ]:
<10> is_ack_only = False
<11>
<12> if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
<13> pass
<14> elif frame_type == QuicFrameType.ACK:
<15> self._handle_ack_frame(frame_type, buf)
<16> elif frame_type == QuicFrameType.CRYPTO:
<17> stream = self.streams[epoch]
<18> stream.add_frame(packet.pull_crypto_frame(buf))
<19> data = stream.pull_data()
<20> if data:
<21> self._crypto_data_received(data)
<22> elif frame_type == QuicFrameType.NEW_TOKEN:
<23> self._handle_new_token_frame(frame_type, buf)
<24> elif (frame_type & ~STREAM_FLAGS) == QuicFrameType.STREAM_BASE:
<25> self._handle_stream_frame(frame_type, buf)
<26> elif frame_type == QuicFrameType.MAX_DATA:
<27> self._handle_max_data_frame(frame_type, buf)
<28> elif frame_type == QuicFrameType.MAX_STREAM_DATA:
<29> self._handle_max_stream_data_frame(frame_type, buf)
<30> elif frame_type == QuicFrameType.MAX_STREAMS_BIDI:
<31> self._handle_max_streams_bidi_frame(frame_type, buf)
<32> elif frame_type == QuicFrameType.MAX_STREAMS_UNI:
<33> self._handle_max_streams_uni_</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
# offset: 1
elif frame_type == QuicFrameType.NEW_CONNECTION_ID:
self._handle_new_connection_id_frame(frame_type, buf)
elif frame_type in [
QuicFrameType.TRANSPORT_CLOSE,
QuicFrameType.APPLICATION_CLOSE,
]:
self._handle_connection_close_frame(frame_type, buf)
else:
self.__logger.warning("unhandled frame type %d", frame_type)
break
self._push_crypto_data()
return is_ack_only
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
pull_uint16(buf: Buffer) -> int
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.connection
STREAM_FLAGS = 0x07
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
_get_or_create_stream(stream_id: int) -> QuicStream
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
+ def _handle_retire_connection_id_frame(self, frame_type: int, buf: Buffer) -> None:
+ """
+ Handle a RETIRE_CONNECTION_ID frame.
+ """
+ pull_uint_var(buf) # sequence number
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
+ def _handle_reset_stream_frame(self, frame_type: int, buf: Buffer) -> None:
+ """
+ Handle a RESET_STREAM frame.
+ """
+ pull_uint_var(buf) # stream id
+ pull_uint16(buf) # application error code
+ pull_uint16(buf) # unused
+ pull_uint_var(buf) # final size
+
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
+ def _handle_data_blocked_frame(self, frame_type: int, buf: Buffer) -> None:
+ """
+ Handle a DATA_BLOCKED frame.
+ """
+ pull_uint_var(buf) # limit
+
|
aioquic.connection/QuicConnection._payload_received
|
Modified
|
aiortc~aioquic
|
1c05008925484b02720486314c4021bf43e1f593
|
[connection] raise exception for unknown frame type
|
<21>:<del> stream = self.streams[epoch]
<22>:<del> stream.add_frame(packet.pull_crypto_frame(buf))
<23>:<del> data = stream.pull_data()
<24>:<del> if data:
<25>:<del> self._crypto_data_received(data)
<26>:<add> self._handle_crypto_frame(epoch, frame_type, buf)
|
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
<0> buf = Buffer(data=plain)
<1>
<2> is_ack_only = True
<3> while not buf.eof():
<4> frame_type = pull_uint_var(buf)
<5> if frame_type not in [
<6> QuicFrameType.ACK,
<7> QuicFrameType.ACK_ECN,
<8> QuicFrameType.PADDING,
<9> ]:
<10> is_ack_only = False
<11>
<12> if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
<13> pass
<14> elif frame_type == QuicFrameType.ACK:
<15> self._handle_ack_frame(frame_type, buf)
<16> elif frame_type == QuicFrameType.RESET_STREAM:
<17> self._handle_reset_stream_frame(frame_type, buf)
<18> elif frame_type == QuicFrameType.STOP_SENDING:
<19> self._handle_stop_sending_frame(frame_type, buf)
<20> elif frame_type == QuicFrameType.CRYPTO:
<21> stream = self.streams[epoch]
<22> stream.add_frame(packet.pull_crypto_frame(buf))
<23> data = stream.pull_data()
<24> if data:
<25> self._crypto_data_received(data)
<26> elif frame_type == QuicFrameType.NEW_TOKEN:
<27> self._handle_new_token_frame(frame_type, buf)
<28> elif (frame_type & ~STREAM_FLAGS) == QuicFrameType.STREAM_BASE:
<29> self._handle_stream_frame(frame_type, buf)
<30> elif frame_type == QuicFrameType.MAX_DATA:
<31> self._handle_max_data_frame(frame_type, buf)
<32> elif frame_type == QuicFrameType.MAX_STREAM_DATA:
<33> self._handle_max_stream_data_frame(frame_type, buf)
<34> </s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
# offset: 1
self._handle_max_streams_bidi_frame(frame_type, buf)
elif frame_type == QuicFrameType.MAX_STREAMS_UNI:
self._handle_max_streams_uni_frame(frame_type, buf)
elif frame_type == QuicFrameType.DATA_BLOCKED:
self._handle_data_blocked_frame(frame_type, buf)
elif frame_type == QuicFrameType.STREAM_DATA_BLOCKED:
self._handle_stream_data_blocked_frame(frame_type, buf)
elif frame_type in [
QuicFrameType.STREAMS_BLOCKED_BIDI,
QuicFrameType.STREAMS_BLOCKED_UNI,
]:
self._handle_streams_blocked_frame(frame_type, buf)
elif frame_type == QuicFrameType.NEW_CONNECTION_ID:
self._handle_new_connection_id_frame(frame_type, buf)
elif frame_type == QuicFrameType.RETIRE_CONNECTION_ID:
self._handle_retire_connection_id_frame(frame_type, buf)
elif frame_type in [
QuicFrameType.TRANSPORT_CLOSE,
QuicFrameType.APPLICATION_CLOSE,
]:
self._handle_connection_close_frame(frame_type, buf)
else:
self.__logger.warning("unhandled frame type %d", frame_type)
break
self._push_crypto_data()
return is_ack_only
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.buffer.Buffer
eof() -> bool
at: aioquic.connection
STREAM_FLAGS = 0x07
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
_handle_ack_frame(frame_type: int, buf: Buffer) -> None
_handle_connection_close_frame(frame_type: int, buf: Buffer) -> None
_handle_crypto_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_data_blocked_frame(frame_type: int, buf: Buffer) -> None
_handle_max_data_frame(frame_type: int, buf: Buffer) -> None
_handle_max_stream_data_frame(frame_type: int, buf: Buffer) -> None
_handle_max_streams_bidi_frame(frame_type: int, buf: Buffer) -> None
_handle_max_streams_uni_frame(frame_type: int, buf: Buffer) -> None
_handle_new_connection_id_frame(frame_type: int, buf: Buffer) -> None
_handle_new_token_frame(frame_type: int, buf: Buffer) -> None
_handle_reset_stream_frame(frame_type: int, buf: Buffer) -> None
_handle_retire_connection_id_frame(frame_type: int, buf: Buffer) -> None
_handle_stop_sending_frame(frame_type: int, buf: Buffer) -> None
_handle_stream_frame(frame_type: int, buf: Buffer) -> None
===========unchanged ref 1===========
_handle_stream_data_blocked_frame(frame_type: int, buf: Buffer) -> None
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
+ def _handle_crypto_frame(
+ self, epoch: tls.Epoch, frame_type: int, buf: Buffer
+ ) -> None:
+ """
+ Handle a CRYPTO frame.
+ """
+ stream = self.streams[epoch]
+ stream.add_frame(packet.pull_crypto_frame(buf))
+ data = stream.pull_data()
+ if data:
+ # pass data to TLS layer
+ try:
+ self.tls.handle_message(data, self.send_buffer)
+ except tls.Alert as exc:
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),
+ frame_type=QuicFrameType.CRYPTO,
+ reason_phrase=str(exc),
+ )
+
+ # update current epoch
+ if self.tls.state in [
+ tls.State.CLIENT_POST_HANDSHAKE,
+ tls.State.SERVER_POST_HANDSHAKE,
+ ]:
+ if not self.__connected.is_set():
+ # parse transport parameters
+ for ext_type, ext_data in self.tls.received_extensions:
+ if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
+ self._parse_transport_parameters(ext_data)
+ break
+ self.__connected.set()
+ self.__epoch = tls.Epoch.ONE_RTT
+ else:
+ self.__epoch = tls.Epoch.HANDSHAKE
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
- def _crypto_data_received(self, data: bytes) -> None:
- # pass data to TLS layer
- try:
- self.tls.handle_message(data, self.send_buffer)
- except tls.Alert as exc:
- raise QuicConnectionError(
- error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),
- frame_type=QuicFrameType.CRYPTO,
- reason_phrase=str(exc),
- )
-
- # update current epoch
- if self.tls.state in [
- tls.State.CLIENT_POST_HANDSHAKE,
- tls.State.SERVER_POST_HANDSHAKE,
- ]:
- if not self.__connected.is_set():
- # parse transport parameters
- for ext_type, ext_data in self.tls.received_extensions:
- if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
- self._parse_transport_parameters(ext_data)
- break
- self.__connected.set()
- self.__epoch = tls.Epoch.ONE_RTT
- else:
- self.__epoch = tls.Epoch.HANDSHAKE
-
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
7c6ba4e0187ec7f961e7af0a2b9d26d84a797be9
|
[connection] add handlers for all frame types
|
<32>:<add> self.__path_challenge = None
|
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
<0> if not is_client:
<1> assert certificate is not None, "SSL certificate is required"
<2> assert private_key is not None, "SSL private key is required"
<3>
<4> self.alpn_protocols = alpn_protocols
<5> self.certificate = certificate
<6> self.is_client = is_client
<7> self.host_cid = os.urandom(8)
<8> self.peer_cid = os.urandom(8)
<9> self.peer_cid_set = False
<10> self.peer_token = b""
<11> self.private_key = private_key
<12> self.secrets_log_file = secrets_log_file
<13> self.server_name = server_name
<14> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<15>
<16> # callbacks
<17> self.stream_created_cb: Callable[
<18> [asyncio.StreamReader, asyncio.StreamWriter], None
<19> ] = lambda r, w: None
<20>
<21> # protocol versions
<22> self.version = max(self.supported_versions)
<23>
<24> self.__close: Optional[Dict] = None
<25> self.__connected = asyncio.Event()
<26> self.__epoch = tls.Epoch.INITIAL
<27> self.__initialized = False
<28> self.__local_idle_timeout = 60.0 # seconds
<29> self.__local_max_streams_bidi = 100
<30> self.__local_max_streams_uni = 0
<31> self.__logger = logger
<32> self._pending_flow_control: List[bytes] = []
<33> self._remote_idle_timeout = 0.0
<34> self._remote_max_streams_bidi</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
self._remote_max_streams_uni = 0
self.__transport: Optional[asyncio.DatagramTransport] = None
===========unchanged ref 0===========
at: aioquic.connection
logger = logging.getLogger("quic")
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._handle_max_streams_bidi_frame
self._remote_max_streams_bidi = max_streams
at: aioquic.connection.QuicConnection._handle_max_streams_uni_frame
self._remote_max_streams_uni = max_streams
at: aioquic.connection.QuicConnection._initialize
self.__initialized = True
at: aioquic.connection.QuicConnection._parse_transport_parameters
self._remote_idle_timeout = quic_transport_parameters.idle_timeout
self._remote_idle_timeout = (
quic_transport_parameters.idle_timeout / 1000
)
self._remote_max_streams_bidi = (
quic_transport_parameters.initial_max_streams_bidi
)
self._remote_max_streams_uni = (
quic_transport_parameters.initial_max_streams_uni
)
at: aioquic.connection.QuicConnection._send_path_challenge
self.__path_challenge = os.urandom(8)
at: aioquic.connection.QuicConnection._write_application
self._pending_flow_control = []
self.__close = None
at: aioquic.connection.QuicConnection._write_handshake
self.__close = None
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
self.peer_cid_set = True
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None)
at: aioquic.tls
Epoch()
at: asyncio.locks
Event(*, loop: Optional[AbstractEventLoop]=...)
at: asyncio.streams
StreamWriter(transport: transports.BaseTransport, protocol: protocols.BaseProtocol, reader: Optional[StreamReader], loop: events.AbstractEventLoop)
StreamReader(limit: int=..., loop: Optional[events.AbstractEventLoop]=...)
at: os
urandom(size: int, /) -> bytes
at: typing
Callable = _CallableType(collections.abc.Callable, 2)
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
TextIO()
|
aioquic.connection/QuicConnection._handle_ack_frame
|
Modified
|
aiortc~aioquic
|
7c6ba4e0187ec7f961e7af0a2b9d26d84a797be9
|
[connection] add handlers for all frame types
|
<4>:<add> if frame_type == QuicFrameType.ACK_ECN:
<add> pull_uint_var(buf)
<add> pull_uint_var(buf)
<add> pull_uint_var(buf)
|
# module: aioquic.connection
class QuicConnection:
+ def _handle_ack_frame(self, epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None:
- def _handle_ack_frame(self, frame_type: int, buf: Buffer) -> None:
<0> """
<1> Handle an ACK frame.
<2> """
<3> packet.pull_ack_frame(buf)
<4>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
_serialize_transport_parameters() -> bytes
at: aioquic.tls
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# callbacks
self.stream_created_cb: Callable[
[asyncio.StreamReader, asyncio.StreamWriter], None
] = lambda r, w: None
# protocol versions
self.version = max(self.supported_versions)
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__local_idle_timeout = 60.0 # seconds
self.__local_max_streams_bidi = 100
self.__local_max_streams_uni = 0
self.__logger = logger
+ self.__path_challenge = None
self._pending_flow_control: List[bytes] = []
self._remote_idle_timeout = 0.0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self.__transport: Optional[async</s>
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
<s>_streams_bidi = 0
self._remote_max_streams_uni = 0
self.__transport: Optional[asyncio.DatagramTransport] = None
|
aioquic.connection/QuicConnection._payload_received
|
Modified
|
aiortc~aioquic
|
7c6ba4e0187ec7f961e7af0a2b9d26d84a797be9
|
[connection] add handlers for all frame types
|
<12>:<del> if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
<13>:<del> pass
<14>:<del> elif frame_type == QuicFrameType.ACK:
<15>:<del> self._handle_ack_frame(frame_type, buf)
<16>:<del> elif frame_type == QuicFrameType.RESET_STREAM:
<17>:<del> self._handle_reset_stream_frame(frame_type, buf)
<18>:<del> elif frame_type == QuicFrameType.STOP_SENDING:
<19>:<del> self._handle_stop_sending_frame(frame_type, buf)
<20>:<del> elif frame_type == QuicFrameType.CRYPTO:
<21>:<add> if frame_type < len(self.__frame_handlers):
<add> self.__frame_handlers[frame_type](epoch, frame_type, buf)
<del> self._handle_crypto_frame(epoch, frame_type, buf)
<22>:<del> elif frame_type == QuicFrameType.NEW_TOKEN:
<23>:<del> self._handle_new_token_frame(frame_type, buf)
<24>:<del> elif (frame_type & ~STREAM_FLAGS) == QuicFrameType.STREAM_BASE:
<25>:<del> self._handle_stream_frame(frame_type, buf)
<26>:<del> elif frame_type == QuicFrameType.MAX_DATA:
<27>:<del> self._handle_max_data_frame(frame_type, buf)
<28>:<del> elif frame_type == QuicFrameType.MAX_STREAM_DATA:
<29>:<del> self._handle_max_stream_data_frame(frame_type, buf)
<30>:<del> elif frame_type == QuicFrameType.MAX_STREAMS_BIDI:
<31>:<del> self._handle_max_streams_bidi_frame(frame_type, buf)
|
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
<0> buf = Buffer(data=plain)
<1>
<2> is_ack_only = True
<3> while not buf.eof():
<4> frame_type = pull_uint_var(buf)
<5> if frame_type not in [
<6> QuicFrameType.ACK,
<7> QuicFrameType.ACK_ECN,
<8> QuicFrameType.PADDING,
<9> ]:
<10> is_ack_only = False
<11>
<12> if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
<13> pass
<14> elif frame_type == QuicFrameType.ACK:
<15> self._handle_ack_frame(frame_type, buf)
<16> elif frame_type == QuicFrameType.RESET_STREAM:
<17> self._handle_reset_stream_frame(frame_type, buf)
<18> elif frame_type == QuicFrameType.STOP_SENDING:
<19> self._handle_stop_sending_frame(frame_type, buf)
<20> elif frame_type == QuicFrameType.CRYPTO:
<21> self._handle_crypto_frame(epoch, frame_type, buf)
<22> elif frame_type == QuicFrameType.NEW_TOKEN:
<23> self._handle_new_token_frame(frame_type, buf)
<24> elif (frame_type & ~STREAM_FLAGS) == QuicFrameType.STREAM_BASE:
<25> self._handle_stream_frame(frame_type, buf)
<26> elif frame_type == QuicFrameType.MAX_DATA:
<27> self._handle_max_data_frame(frame_type, buf)
<28> elif frame_type == QuicFrameType.MAX_STREAM_DATA:
<29> self._handle_max_stream_data_frame(frame_type, buf)
<30> elif frame_type == QuicFrameType.MAX_STREAMS_BIDI:
<31> self._handle_max_streams_bidi_frame(frame_type, buf)
</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
# offset: 1
self._handle_max_streams_uni_frame(frame_type, buf)
elif frame_type == QuicFrameType.DATA_BLOCKED:
self._handle_data_blocked_frame(frame_type, buf)
elif frame_type == QuicFrameType.STREAM_DATA_BLOCKED:
self._handle_stream_data_blocked_frame(frame_type, buf)
elif frame_type in [
QuicFrameType.STREAMS_BLOCKED_BIDI,
QuicFrameType.STREAMS_BLOCKED_UNI,
]:
self._handle_streams_blocked_frame(frame_type, buf)
elif frame_type == QuicFrameType.NEW_CONNECTION_ID:
self._handle_new_connection_id_frame(frame_type, buf)
elif frame_type == QuicFrameType.RETIRE_CONNECTION_ID:
self._handle_retire_connection_id_frame(frame_type, buf)
elif frame_type in [
QuicFrameType.TRANSPORT_CLOSE,
QuicFrameType.APPLICATION_CLOSE,
]:
self._handle_connection_close_frame(frame_type, buf)
else:
raise QuicConnectionError(
error_code=QuicErrorCode.PROTOCOL_VIOLATION,
frame_type=frame_type,
reason_phrase="Unexpected frame type",
)
self._push_crypto_data()
return is_ack_only
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
pull_uint16(buf: Buffer) -> int
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
at: aioquic.connection.QuicConnection.__init__
self.__path_challenge = None
self._pending_flow_control: List[bytes] = []
at: aioquic.connection.QuicConnection._send_path_challenge
self.__path_challenge = os.urandom(8)
at: aioquic.connection.QuicConnection._write_application
self._pending_flow_control = []
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
pull_uint_var(buf: Buffer) -> int
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
+ def _handle_padding_frame(
+ self, epoch: tls.Epoch, frame_type: int, buf: Buffer
+ ) -> None:
+ """
+ Handle a PADDING or PING frame.
+ """
+ pass
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
+ def _handle_ack_frame(self, epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None:
- def _handle_ack_frame(self, frame_type: int, buf: Buffer) -> None:
"""
Handle an ACK frame.
"""
packet.pull_ack_frame(buf)
+ if frame_type == QuicFrameType.ACK_ECN:
+ pull_uint_var(buf)
+ pull_uint_var(buf)
+ pull_uint_var(buf)
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# callbacks
self.stream_created_cb: Callable[
[asyncio.StreamReader, asyncio.StreamWriter], None
] = lambda r, w: None
# protocol versions
self.version = max(self.supported_versions)
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__local_idle_timeout = 60.0 # seconds
self.__local_max_streams_bidi = 100
self.__local_max_streams_uni = 0
self.__logger = logger
+ self.__path_challenge = None
self._pending_flow_control: List[bytes] = []
self._remote_idle_timeout = 0.0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self.__transport: Optional[async</s>
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
<s>_streams_bidi = 0
self._remote_max_streams_uni = 0
self.__transport: Optional[asyncio.DatagramTransport] = None
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
1a0fe6d41c01ac96370583606608ca078d252e14
|
[connection] do not allow data on unidirectional stream
|
<15>:<del>
<16>:<del> # callbacks
<17>:<del> self.stream_created_cb: Callable[
<18>:<del> [asyncio.StreamReader, asyncio.StreamWriter], None
<19>:<del> ] = lambda r, w: None
|
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
<0> if not is_client:
<1> assert certificate is not None, "SSL certificate is required"
<2> assert private_key is not None, "SSL private key is required"
<3>
<4> self.alpn_protocols = alpn_protocols
<5> self.certificate = certificate
<6> self.is_client = is_client
<7> self.host_cid = os.urandom(8)
<8> self.peer_cid = os.urandom(8)
<9> self.peer_cid_set = False
<10> self.peer_token = b""
<11> self.private_key = private_key
<12> self.secrets_log_file = secrets_log_file
<13> self.server_name = server_name
<14> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<15>
<16> # callbacks
<17> self.stream_created_cb: Callable[
<18> [asyncio.StreamReader, asyncio.StreamWriter], None
<19> ] = lambda r, w: None
<20>
<21> # protocol versions
<22> self.version = max(self.supported_versions)
<23>
<24> self.__close: Optional[Dict] = None
<25> self.__connected = asyncio.Event()
<26> self.__epoch = tls.Epoch.INITIAL
<27> self.__initialized = False
<28> self.__local_idle_timeout = 60.0 # seconds
<29> self.__local_max_streams_bidi = 100
<30> self.__local_max_streams_uni = 0
<31> self.__logger = logger
<32> self.__path_challenge = None
<33> self._pending_flow_control: List[bytes] = []
<34> self._remote_idle_timeout = 0.0
<35> </s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
self._remote_max_streams_uni = 0
self.__transport: Optional[asyncio.DatagramTransport] = None
# frame handlers
self.__frame_handlers = [
self._handle_padding_frame,
self._handle_padding_frame,
self._handle_ack_frame,
self._handle_ack_frame,
self._handle_reset_stream_frame,
self._handle_stop_sending_frame,
self._handle_crypto_frame,
self._handle_new_token_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_max_data_frame,
self._handle_max_stream_data_frame,
self._handle_max_streams_bidi_frame,
self._handle_max_streams_uni_frame,
self._handle_data_blocked_frame,
self._handle_stream_data_blocked_frame,
self._handle_streams_blocked_frame,
self._handle_streams_blocked_frame,
self._handle_new_connection_id_frame,
self._handle_retire_connection_id_frame,
self._handle_path_challenge_frame,
self._handle_path_response_frame,
self._handle_connection_close_frame,
self._handle_connection_close_frame,
]
===========unchanged ref 0===========
at: aioquic.connection
logger = logging.getLogger("quic")
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
_handle_ack_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_connection_close_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_crypto_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_data_blocked_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_max_data_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_max_stream_data_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_max_streams_bidi_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_max_streams_uni_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_new_connection_id_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_new_token_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_padding_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_path_challenge_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_path_response_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_reset_stream_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
===========unchanged ref 1===========
_handle_retire_connection_id_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_stop_sending_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_stream_frame(self, epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_stream_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_stream_data_blocked_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_streams_blocked_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._handle_max_streams_bidi_frame
self._remote_max_streams_bidi = max_streams
at: aioquic.connection.QuicConnection._handle_max_streams_uni_frame
self._remote_max_streams_uni = max_streams
at: aioquic.connection.QuicConnection._initialize
self.__initialized = True
at: aioquic.connection.QuicConnection._parse_transport_parameters
self._remote_idle_timeout = quic_transport_parameters.idle_timeout
self._remote_idle_timeout = (
quic_transport_parameters.idle_timeout / 1000
)
self._remote_max_streams_bidi = (
quic_transport_parameters.initial_max_streams_bidi
)
self._remote_max_streams_uni = (
quic_transport_parameters.initial_max_streams_uni
)
at: aioquic.connection.QuicConnection._send_path_challenge
self.__path_challenge = os.urandom(8)
===========unchanged ref 2===========
at: aioquic.connection.QuicConnection._write_application
self._pending_flow_control = []
self.__close = None
at: aioquic.connection.QuicConnection._write_handshake
self.__close = None
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.connection_made
self.__transport = transport
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
self.peer_cid_set = True
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None)
at: aioquic.tls
Epoch()
at: asyncio.locks
Event(*, loop: Optional[AbstractEventLoop]=...)
at: asyncio.streams
StreamWriter(transport: transports.BaseTransport, protocol: protocols.BaseProtocol, reader: Optional[StreamReader], loop: events.AbstractEventLoop)
StreamReader(limit: int=..., loop: Optional[events.AbstractEventLoop]=...)
at: asyncio.transports
DatagramTransport(extra: Optional[Mapping[Any, Any]]=...)
at: os
urandom(size: int, /) -> bytes
at: typing
Callable = _CallableType(collections.abc.Callable, 2)
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
TextIO()
|
aioquic.connection/QuicConnection._handle_stream_frame
|
Modified
|
aiortc~aioquic
|
1a0fe6d41c01ac96370583606608ca078d252e14
|
[connection] do not allow data on unidirectional stream
|
<18>:<add>
<add> # check stream is allowed to receive data
<add> if not self._stream_can_receive(stream_id):
<add> raise QuicConnectionError(
<add> error_code=QuicErrorCode.STREAM_STATE_ERROR,
<add> frame_type=frame_type,
<add> reason_phrase="Cannot receive data on unidirectional stream",
<add> )
<add>
|
# module: aioquic.connection
class QuicConnection:
def _handle_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a STREAM frame.
<2> """
<3> flags = frame_type & STREAM_FLAGS
<4> stream_id = pull_uint_var(buf)
<5> if flags & QuicStreamFlag.OFF:
<6> offset = pull_uint_var(buf)
<7> else:
<8> offset = 0
<9> if flags & QuicStreamFlag.LEN:
<10> length = pull_uint_var(buf)
<11> else:
<12> length = buf.capacity - buf.tell()
<13> frame = QuicStreamFrame(
<14> offset=offset,
<15> data=pull_bytes(buf, length),
<16> fin=bool(flags & QuicStreamFlag.FIN),
<17> )
<18> stream = self._get_or_create_stream(stream_id)
<19> stream.add_frame(frame)
<20>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.connection
STREAM_FLAGS = 0x07
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
-
- # callbacks
- self.stream_created_cb: Callable[
- [asyncio.StreamReader, asyncio.StreamWriter], None
- ] = lambda r, w: None
# protocol versions
self.version = max(self.supported_versions)
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__local_idle_timeout = 60.0 # seconds
self.__local_max_streams_bidi = 100
self.__local_max_streams_uni = 0
self.__logger = logger
self.__path_challenge = None
self._pending_flow_control: List[bytes] = []
self._remote_idle_timeout = 0.0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self.__transport</s>
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
<s>._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self.__transport: Optional[asyncio.DatagramTransport] = None
+
+ # callbacks
+ self.stream_created_cb: Callable[
+ [asyncio.StreamReader, asyncio.StreamWriter], None
+ ] = lambda r, w: None
# frame handlers
self.__frame_handlers = [
self._handle_padding_frame,
self._handle_padding_frame,
self._handle_ack_frame,
self._handle_ack_frame,
self._handle_reset_stream_frame,
self._handle_stop_sending_frame,
self._handle_crypto_frame,
self._handle_new_token_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_max_data_frame,
self._handle_max_stream_data_frame,
self._handle_max_streams_bidi_frame,
self._handle_max_streams_uni_frame,
self._handle_data_blocked_frame,
self._handle_stream_data_blocked_frame,
self._handle_streams_blocked_frame,
self._handle_streams_</s>
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 2
<s>frame,
self._handle_new_connection_id_frame,
self._handle_retire_connection_id_frame,
self._handle_path_challenge_frame,
self._handle_path_response_frame,
self._handle_connection_close_frame,
self._handle_connection_close_frame,
]
|
tests.test_connection/QuicConnectionTest.test_handle_path_response_frame_bad
|
Modified
|
aiortc~aioquic
|
1a0fe6d41c01ac96370583606608ca078d252e14
|
[connection] do not allow data on unidirectional stream
|
<14>:<add> # server receives unsollicited PATH_RESPONSE
<del> # client sends unsollicited PATH_RESPONSE
<15>:<add> with self.assertRaises(QuicConnectionError) as cm:
<add> server._handle_path_response_frame(
<add> tls.Epoch.ONE_RTT,
<add> QuicFrameType.PATH_RESPONSE,
<add> Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"),
<add> )
<add> self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
<add> self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)
<del> client._pending_flow_control.append(binascii.unhexlify("1b1122334455667788"))
<16>:<del> client._send_pending()
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_path_response_frame_bad(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10> self.assertEqual(client_transport.sent, 4)
<11> self.assertEqual(server_transport.sent, 4)
<12> self.assertEqual(client._remote_max_streams_bidi, 100)
<13>
<14> # client sends unsollicited PATH_RESPONSE
<15> client._pending_flow_control.append(binascii.unhexlify("1b1122334455667788"))
<16> client._send_pending()
<17>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection.__init__
self._remote_max_streams_bidi = 0
at: aioquic.connection.QuicConnection._handle_max_streams_bidi_frame
self._remote_max_streams_bidi = max_streams
at: aioquic.connection.QuicConnection._parse_transport_parameters
self._remote_max_streams_bidi = (
quic_transport_parameters.initial_max_streams_bidi
)
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
create_transport(client, server)
at: tests.test_connection.FakeTransport.sendto
self.sent += 1
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
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: aioquic.connection
class QuicConnection:
+ def _stream_can_send(self, stream_id):
+ is_local = bool(stream_id & 1) == (not self.is_client)
+ is_unidirectional = bool(stream_id & 2)
+ return is_local or not is_unidirectional
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
+ def _stream_can_receive(self, stream_id):
+ is_local = bool(stream_id & 1) == (not self.is_client)
+ is_unidirectional = bool(stream_id & 2)
+ return not is_local or not is_unidirectional
+
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def _handle_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STREAM frame.
"""
flags = frame_type & STREAM_FLAGS
stream_id = pull_uint_var(buf)
if flags & QuicStreamFlag.OFF:
offset = pull_uint_var(buf)
else:
offset = 0
if flags & QuicStreamFlag.LEN:
length = pull_uint_var(buf)
else:
length = buf.capacity - buf.tell()
frame = QuicStreamFrame(
offset=offset,
data=pull_bytes(buf, length),
fin=bool(flags & QuicStreamFlag.FIN),
)
+
+ # check stream is allowed to receive data
+ if not self._stream_can_receive(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Cannot receive data on unidirectional stream",
+ )
+
stream = self._get_or_create_stream(stream_id)
stream.add_frame(frame)
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
-
- # callbacks
- self.stream_created_cb: Callable[
- [asyncio.StreamReader, asyncio.StreamWriter], None
- ] = lambda r, w: None
# protocol versions
self.version = max(self.supported_versions)
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__local_idle_timeout = 60.0 # seconds
self.__local_max_streams_bidi = 100
self.__local_max_streams_uni = 0
self.__logger = logger
self.__path_challenge = None
self._pending_flow_control: List[bytes] = []
self._remote_idle_timeout = 0.0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self.__transport</s>
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<27>:<add> self.__path_challenge: Optional[bytes] = None
<del> self.__path_challenge = None
|
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
<0> if not is_client:
<1> assert certificate is not None, "SSL certificate is required"
<2> assert private_key is not None, "SSL private key is required"
<3>
<4> self.alpn_protocols = alpn_protocols
<5> self.certificate = certificate
<6> self.is_client = is_client
<7> self.host_cid = os.urandom(8)
<8> self.peer_cid = os.urandom(8)
<9> self.peer_cid_set = False
<10> self.peer_token = b""
<11> self.private_key = private_key
<12> self.secrets_log_file = secrets_log_file
<13> self.server_name = server_name
<14> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<15>
<16> # protocol versions
<17> self.version = max(self.supported_versions)
<18>
<19> self.__close: Optional[Dict] = None
<20> self.__connected = asyncio.Event()
<21> self.__epoch = tls.Epoch.INITIAL
<22> self.__initialized = False
<23> self.__local_idle_timeout = 60.0 # seconds
<24> self.__local_max_streams_bidi = 100
<25> self.__local_max_streams_uni = 0
<26> self.__logger = logger
<27> self.__path_challenge = None
<28> self._pending_flow_control: List[bytes] = []
<29> self._remote_idle_timeout = 0.0
<30> self._remote_max_streams_bidi = 0
<31> self._remote_max_streams_uni = 0
<32> self.__transport: Optional[asyncio.DatagramTransport] = None</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
# callbacks
self.stream_created_cb: Callable[
[asyncio.StreamReader, asyncio.StreamWriter], None
] = lambda r, w: None
# frame handlers
self.__frame_handlers = [
self._handle_padding_frame,
self._handle_padding_frame,
self._handle_ack_frame,
self._handle_ack_frame,
self._handle_reset_stream_frame,
self._handle_stop_sending_frame,
self._handle_crypto_frame,
self._handle_new_token_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_max_data_frame,
self._handle_max_stream_data_frame,
self._handle_max_streams_bidi_frame,
self._handle_max_streams_uni_frame,
self._handle_data_blocked_frame,
self._handle_stream_data_blocked_frame,
self._handle_streams_blocked_frame,
self._handle_streams_blocked_frame,
self._handle_new_connection_id_frame,
self._handle_retire_connection_id_frame,
self._handle_path_challenge_frame,
self._handle_path_response_frame,
self._handle_connection_close_frame,
self._handle_connection_close_frame,
</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 2
<s>_response_frame,
self._handle_connection_close_frame,
self._handle_connection_close_frame,
]
===========unchanged ref 0===========
at: aioquic.connection
logger = logging.getLogger("quic")
at: aioquic.connection.QuicConnection
_handle_ack_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_crypto_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_max_data_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_new_token_frame(self, epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_new_token_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_padding_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_reset_stream_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_reset_stream_frame(self, epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_stop_sending_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_stop_sending_frame(self, epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_stream_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._handle_max_streams_bidi_frame
self._remote_max_streams_bidi = max_streams
at: aioquic.connection.QuicConnection._handle_max_streams_uni_frame
self._remote_max_streams_uni = max_streams
at: aioquic.connection.QuicConnection._initialize
self.__initialized = True
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._parse_transport_parameters
self._remote_idle_timeout = quic_transport_parameters.idle_timeout
self._remote_idle_timeout = (
quic_transport_parameters.idle_timeout / 1000
)
self._remote_max_streams_bidi = (
quic_transport_parameters.initial_max_streams_bidi
)
self._remote_max_streams_uni = (
quic_transport_parameters.initial_max_streams_uni
)
at: aioquic.connection.QuicConnection._send_path_challenge
self.__path_challenge = os.urandom(8)
at: aioquic.connection.QuicConnection._write_application
self._pending_flow_control = []
self.__close = None
at: aioquic.connection.QuicConnection._write_handshake
self.__close = None
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.connection_made
self.__transport = transport
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
self.peer_cid_set = True
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None)
at: aioquic.tls
Epoch()
at: asyncio.locks
Event(*, loop: Optional[AbstractEventLoop]=...)
===========unchanged ref 2===========
at: asyncio.streams
StreamWriter(transport: transports.BaseTransport, protocol: protocols.BaseProtocol, reader: Optional[StreamReader], loop: events.AbstractEventLoop)
StreamReader(limit: int=..., loop: Optional[events.AbstractEventLoop]=...)
at: asyncio.transports
DatagramTransport(extra: Optional[Mapping[Any, Any]]=...)
at: os
urandom(size: int, /) -> bytes
at: typing
Callable = _CallableType(collections.abc.Callable, 2)
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
TextIO()
===========changed ref 0===========
# module: aioquic.connection
+ def stream_is_unidirectional(stream_id: int) -> bool:
+ """
+ Returns True if the stream is unidirectional.
+ """
+ return bool(stream_id & 2)
+
===========changed ref 1===========
# module: aioquic.connection
+ def stream_is_client_initiated(stream_id: int) -> bool:
+ """
+ Returns True if the stream is client initiated.
+ """
+ return not (stream_id & 1)
+
|
aioquic.connection/QuicConnection._handle_max_stream_data_frame
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<5>:<add> stream_id = pull_uint_var(buf)
<del> pull_uint_var(buf) # stream id
|
# module: aioquic.connection
class QuicConnection:
def _handle_max_stream_data_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a MAX_STREAM_DATA frame.
<2>
<3> This adjusts the amount of data we can send on a specific stream.
<4> """
<5> pull_uint_var(buf) # stream id
<6> pull_uint_var(buf) # limit
<7>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection.__init__
self.__connected = asyncio.Event()
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self.__logger)
at: aioquic.tls
State()
at: aioquic.tls.Context.__init__
self.received_extensions: List[Extension] = []
self.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: aioquic.tls.Context._client_handle_encrypted_extensions
self.received_extensions = encrypted_extensions.other_extensions
at: aioquic.tls.Context._server_handle_hello
self.received_extensions = peer_hello.other_extensions
at: aioquic.tls.Context._set_state
self.state = state
at: asyncio.locks.Event
is_set() -> bool
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
+ def _assert_stream_can_send(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can send data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_send(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is receive-only",
+ )
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
+ # Private
+
+ def _assert_stream_can_receive(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can receive data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_receive(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is send-only",
+ )
+
===========changed ref 2===========
# module: aioquic.connection
+ def stream_is_unidirectional(stream_id: int) -> bool:
+ """
+ Returns True if the stream is unidirectional.
+ """
+ return bool(stream_id & 2)
+
===========changed ref 3===========
# module: aioquic.connection
+ def stream_is_client_initiated(stream_id: int) -> bool:
+ """
+ Returns True if the stream is client initiated.
+ """
+ return not (stream_id & 1)
+
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# protocol versions
self.version = max(self.supported_versions)
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__local_idle_timeout = 60.0 # seconds
self.__local_max_streams_bidi = 100
self.__local_max_streams_uni = 0
self.__logger = logger
+ self.__path_challenge: Optional[bytes] = None
- self.__path_challenge = None
self._pending_flow_control: List[bytes] = []
self._remote_idle_timeout = 0.0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self.__transport: Optional[asyncio.DatagramTransport] = None
# callbacks
self.stream_created_cb: Callable[</s>
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
<s>transport: Optional[asyncio.DatagramTransport] = None
# callbacks
self.stream_created_cb: Callable[
[asyncio.StreamReader, asyncio.StreamWriter], None
] = lambda r, w: None
# frame handlers
self.__frame_handlers = [
self._handle_padding_frame,
self._handle_padding_frame,
self._handle_ack_frame,
self._handle_ack_frame,
self._handle_reset_stream_frame,
self._handle_stop_sending_frame,
self._handle_crypto_frame,
self._handle_new_token_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_max_data_frame,
self._handle_max_stream_data_frame,
self._handle_max_streams_bidi_frame,
self._handle_max_streams_uni_frame,
self._handle_data_blocked_frame,
self._handle_stream_data_blocked_frame,
self._handle_streams_blocked_frame,
self._handle_streams_blocked_frame,
self._handle_new_connection_id_frame,
self._handle_retire_connection_id_frame,
</s>
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 2
<s>._handle_path_challenge_frame,
self._handle_path_response_frame,
self._handle_connection_close_frame,
self._handle_connection_close_frame,
]
|
aioquic.connection/QuicConnection._handle_reset_stream_frame
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<3>:<add> stream_id = pull_uint_var(buf)
<del> pull_uint_var(buf) # stream id
|
# module: aioquic.connection
class QuicConnection:
def _handle_reset_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a RESET_STREAM frame.
<2> """
<3> pull_uint_var(buf) # stream id
<4> pull_uint16(buf) # application error code
<5> pull_uint16(buf) # unused
<6> pull_uint_var(buf) # final size
<7>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.packet
pull_new_token_frame(buf: Buffer) -> bytes
pull_new_connection_id_frame(buf: Buffer) -> Tuple[int, bytes, bytes]
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def _handle_max_stream_data_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAM_DATA frame.
This adjusts the amount of data we can send on a specific stream.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint_var(buf) # limit
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
+ def _assert_stream_can_send(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can send data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_send(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is receive-only",
+ )
+
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
+ # Private
+
+ def _assert_stream_can_receive(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can receive data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_receive(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is send-only",
+ )
+
===========changed ref 3===========
# module: aioquic.connection
+ def stream_is_unidirectional(stream_id: int) -> bool:
+ """
+ Returns True if the stream is unidirectional.
+ """
+ return bool(stream_id & 2)
+
===========changed ref 4===========
# module: aioquic.connection
+ def stream_is_client_initiated(stream_id: int) -> bool:
+ """
+ Returns True if the stream is client initiated.
+ """
+ return not (stream_id & 1)
+
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# protocol versions
self.version = max(self.supported_versions)
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__local_idle_timeout = 60.0 # seconds
self.__local_max_streams_bidi = 100
self.__local_max_streams_uni = 0
self.__logger = logger
+ self.__path_challenge: Optional[bytes] = None
- self.__path_challenge = None
self._pending_flow_control: List[bytes] = []
self._remote_idle_timeout = 0.0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self.__transport: Optional[asyncio.DatagramTransport] = None
# callbacks
self.stream_created_cb: Callable[</s>
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
<s>transport: Optional[asyncio.DatagramTransport] = None
# callbacks
self.stream_created_cb: Callable[
[asyncio.StreamReader, asyncio.StreamWriter], None
] = lambda r, w: None
# frame handlers
self.__frame_handlers = [
self._handle_padding_frame,
self._handle_padding_frame,
self._handle_ack_frame,
self._handle_ack_frame,
self._handle_reset_stream_frame,
self._handle_stop_sending_frame,
self._handle_crypto_frame,
self._handle_new_token_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_max_data_frame,
self._handle_max_stream_data_frame,
self._handle_max_streams_bidi_frame,
self._handle_max_streams_uni_frame,
self._handle_data_blocked_frame,
self._handle_stream_data_blocked_frame,
self._handle_streams_blocked_frame,
self._handle_streams_blocked_frame,
self._handle_new_connection_id_frame,
self._handle_retire_connection_id_frame,
</s>
===========changed ref 7===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 2
<s>._handle_path_challenge_frame,
self._handle_path_response_frame,
self._handle_connection_close_frame,
self._handle_connection_close_frame,
]
|
aioquic.connection/QuicConnection._handle_stop_sending_frame
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<3>:<add> stream_id = pull_uint_var(buf)
<del> pull_uint_var(buf) # stream id
|
# module: aioquic.connection
class QuicConnection:
def _handle_stop_sending_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a STOP_SENDING frame.
<2> """
<3> pull_uint_var(buf) # stream id
<4> pull_uint16(buf) # application error code
<5>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
at: aioquic.connection.QuicConnection.__init__
self._pending_flow_control: List[bytes] = []
at: aioquic.connection.QuicConnection._write_application
self._pending_flow_control = []
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def _handle_reset_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RESET_STREAM frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint16(buf) # application error code
pull_uint16(buf) # unused
pull_uint_var(buf) # final size
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def _handle_max_stream_data_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAM_DATA frame.
This adjusts the amount of data we can send on a specific stream.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint_var(buf) # limit
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
+ def _assert_stream_can_send(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can send data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_send(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is receive-only",
+ )
+
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
+ # Private
+
+ def _assert_stream_can_receive(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can receive data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_receive(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is send-only",
+ )
+
===========changed ref 4===========
# module: aioquic.connection
+ def stream_is_unidirectional(stream_id: int) -> bool:
+ """
+ Returns True if the stream is unidirectional.
+ """
+ return bool(stream_id & 2)
+
===========changed ref 5===========
# module: aioquic.connection
+ def stream_is_client_initiated(stream_id: int) -> bool:
+ """
+ Returns True if the stream is client initiated.
+ """
+ return not (stream_id & 1)
+
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# protocol versions
self.version = max(self.supported_versions)
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__local_idle_timeout = 60.0 # seconds
self.__local_max_streams_bidi = 100
self.__local_max_streams_uni = 0
self.__logger = logger
+ self.__path_challenge: Optional[bytes] = None
- self.__path_challenge = None
self._pending_flow_control: List[bytes] = []
self._remote_idle_timeout = 0.0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self.__transport: Optional[asyncio.DatagramTransport] = None
# callbacks
self.stream_created_cb: Callable[</s>
===========changed ref 7===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
<s>transport: Optional[asyncio.DatagramTransport] = None
# callbacks
self.stream_created_cb: Callable[
[asyncio.StreamReader, asyncio.StreamWriter], None
] = lambda r, w: None
# frame handlers
self.__frame_handlers = [
self._handle_padding_frame,
self._handle_padding_frame,
self._handle_ack_frame,
self._handle_ack_frame,
self._handle_reset_stream_frame,
self._handle_stop_sending_frame,
self._handle_crypto_frame,
self._handle_new_token_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_max_data_frame,
self._handle_max_stream_data_frame,
self._handle_max_streams_bidi_frame,
self._handle_max_streams_uni_frame,
self._handle_data_blocked_frame,
self._handle_stream_data_blocked_frame,
self._handle_streams_blocked_frame,
self._handle_streams_blocked_frame,
self._handle_new_connection_id_frame,
self._handle_retire_connection_id_frame,
</s>
|
aioquic.connection/QuicConnection._handle_stream_frame
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<19>:<add> # check stream direction
<del> # check stream is allowed to receive data
<20>:<add> self._assert_stream_can_receive(frame_type, stream_id)
<del> if not self._stream_can_receive(stream_id):
<21>:<del> raise QuicConnectionError(
<22>:<del> error_code=QuicErrorCode.STREAM_STATE_ERROR,
<23>:<del> frame_type=frame_type,
<24>:<del> reason_phrase="Cannot receive data on unidirectional stream",
<25>:<del> )
|
# module: aioquic.connection
class QuicConnection:
def _handle_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a STREAM frame.
<2> """
<3> flags = frame_type & STREAM_FLAGS
<4> stream_id = pull_uint_var(buf)
<5> if flags & QuicStreamFlag.OFF:
<6> offset = pull_uint_var(buf)
<7> else:
<8> offset = 0
<9> if flags & QuicStreamFlag.LEN:
<10> length = pull_uint_var(buf)
<11> else:
<12> length = buf.capacity - buf.tell()
<13> frame = QuicStreamFrame(
<14> offset=offset,
<15> data=pull_bytes(buf, length),
<16> fin=bool(flags & QuicStreamFlag.FIN),
<17> )
<18>
<19> # check stream is allowed to receive data
<20> if not self._stream_can_receive(stream_id):
<21> raise QuicConnectionError(
<22> error_code=QuicErrorCode.STREAM_STATE_ERROR,
<23> frame_type=frame_type,
<24> reason_phrase="Cannot receive data on unidirectional stream",
<25> )
<26>
<27> stream = self._get_or_create_stream(stream_id)
<28> stream.add_frame(frame)
<29>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
pull_uint16(buf: Buffer) -> int
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
at: aioquic.connection.QuicConnection
_assert_stream_can_receive(frame_type: int, stream_id: int) -> None
_get_or_create_stream(stream_id: int) -> QuicStream
at: aioquic.connection.QuicConnection.__init__
self.__path_challenge: Optional[bytes] = None
at: aioquic.connection.QuicConnection._send_path_challenge
self.__path_challenge = os.urandom(8)
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
pull_uint_var(buf: Buffer) -> int
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
+ # Private
+
+ def _assert_stream_can_receive(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can receive data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_receive(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is send-only",
+ )
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def _handle_stop_sending_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STOP_SENDING frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint16(buf) # application error code
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def _handle_reset_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RESET_STREAM frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint16(buf) # application error code
pull_uint16(buf) # unused
pull_uint_var(buf) # final size
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
def _handle_max_stream_data_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAM_DATA frame.
This adjusts the amount of data we can send on a specific stream.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint_var(buf) # limit
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection:
+ def _assert_stream_can_send(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can send data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_send(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is receive-only",
+ )
+
===========changed ref 5===========
# module: aioquic.connection
+ def stream_is_unidirectional(stream_id: int) -> bool:
+ """
+ Returns True if the stream is unidirectional.
+ """
+ return bool(stream_id & 2)
+
===========changed ref 6===========
# module: aioquic.connection
+ def stream_is_client_initiated(stream_id: int) -> bool:
+ """
+ Returns True if the stream is client initiated.
+ """
+ return not (stream_id & 1)
+
===========changed ref 7===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# protocol versions
self.version = max(self.supported_versions)
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__local_idle_timeout = 60.0 # seconds
self.__local_max_streams_bidi = 100
self.__local_max_streams_uni = 0
self.__logger = logger
+ self.__path_challenge: Optional[bytes] = None
- self.__path_challenge = None
self._pending_flow_control: List[bytes] = []
self._remote_idle_timeout = 0.0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self.__transport: Optional[asyncio.DatagramTransport] = None
# callbacks
self.stream_created_cb: Callable[</s>
|
aioquic.connection/QuicConnection._handle_stream_data_blocked_frame
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<3>:<add> stream_id = pull_uint_var(buf)
<del> pull_uint_var(buf) # stream id
|
# module: aioquic.connection
class QuicConnection:
def _handle_stream_data_blocked_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a STREAM_DATA_BLOCKED frame.
<2> """
<3> pull_uint_var(buf) # stream id
<4> pull_uint_var(buf) # limit
<5>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def _handle_stop_sending_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STOP_SENDING frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint16(buf) # application error code
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def _handle_reset_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RESET_STREAM frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint16(buf) # application error code
pull_uint16(buf) # unused
pull_uint_var(buf) # final size
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def _handle_max_stream_data_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAM_DATA frame.
This adjusts the amount of data we can send on a specific stream.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint_var(buf) # limit
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
def _handle_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STREAM frame.
"""
flags = frame_type & STREAM_FLAGS
stream_id = pull_uint_var(buf)
if flags & QuicStreamFlag.OFF:
offset = pull_uint_var(buf)
else:
offset = 0
if flags & QuicStreamFlag.LEN:
length = pull_uint_var(buf)
else:
length = buf.capacity - buf.tell()
frame = QuicStreamFrame(
offset=offset,
data=pull_bytes(buf, length),
fin=bool(flags & QuicStreamFlag.FIN),
)
+ # check stream direction
- # check stream is allowed to receive data
+ self._assert_stream_can_receive(frame_type, stream_id)
- if not self._stream_can_receive(stream_id):
- raise QuicConnectionError(
- error_code=QuicErrorCode.STREAM_STATE_ERROR,
- frame_type=frame_type,
- reason_phrase="Cannot receive data on unidirectional stream",
- )
stream = self._get_or_create_stream(stream_id)
stream.add_frame(frame)
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection:
+ def _assert_stream_can_send(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can send data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_send(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is receive-only",
+ )
+
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection:
+ # Private
+
+ def _assert_stream_can_receive(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can receive data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_receive(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is send-only",
+ )
+
===========changed ref 6===========
# module: aioquic.connection
+ def stream_is_unidirectional(stream_id: int) -> bool:
+ """
+ Returns True if the stream is unidirectional.
+ """
+ return bool(stream_id & 2)
+
===========changed ref 7===========
# module: aioquic.connection
+ def stream_is_client_initiated(stream_id: int) -> bool:
+ """
+ Returns True if the stream is client initiated.
+ """
+ return not (stream_id & 1)
+
===========changed ref 8===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# protocol versions
self.version = max(self.supported_versions)
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__local_idle_timeout = 60.0 # seconds
self.__local_max_streams_bidi = 100
self.__local_max_streams_uni = 0
self.__logger = logger
+ self.__path_challenge: Optional[bytes] = None
- self.__path_challenge = None
self._pending_flow_control: List[bytes] = []
self._remote_idle_timeout = 0.0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self.__transport: Optional[asyncio.DatagramTransport] = None
# callbacks
self.stream_created_cb: Callable[</s>
|
aioquic.connection/QuicConnection._stream_can_receive
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<0>:<add> return stream_is_client_initiated(
<add> stream_id
<add> ) != self.is_client or not stream_is_unidirectional(stream_id)
<del> is_local = bool(stream_id & 1) == (not self.is_client)
<1>:<del> is_unidirectional = bool(stream_id & 2)
<2>:<del> return not is_local or not is_unidirectional
|
# module: aioquic.connection
class QuicConnection:
+ def _stream_can_receive(self, stream_id: int) -> bool:
- def _stream_can_receive(self, stream_id):
<0> is_local = bool(stream_id & 1) == (not self.is_client)
<1> is_unidirectional = bool(stream_id & 2)
<2> return not is_local or not is_unidirectional
<3>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
at: aioquic.packet
pull_quic_transport_parameters(buf: Buffer, is_client: Optional[bool]=None) -> QuicTransportParameters
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def _handle_stream_data_blocked_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STREAM_DATA_BLOCKED frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint_var(buf) # limit
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def _handle_stop_sending_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STOP_SENDING frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint16(buf) # application error code
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def _handle_reset_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RESET_STREAM frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint16(buf) # application error code
pull_uint16(buf) # unused
pull_uint_var(buf) # final size
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
def _handle_max_stream_data_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAM_DATA frame.
This adjusts the amount of data we can send on a specific stream.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint_var(buf) # limit
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection:
def _handle_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STREAM frame.
"""
flags = frame_type & STREAM_FLAGS
stream_id = pull_uint_var(buf)
if flags & QuicStreamFlag.OFF:
offset = pull_uint_var(buf)
else:
offset = 0
if flags & QuicStreamFlag.LEN:
length = pull_uint_var(buf)
else:
length = buf.capacity - buf.tell()
frame = QuicStreamFrame(
offset=offset,
data=pull_bytes(buf, length),
fin=bool(flags & QuicStreamFlag.FIN),
)
+ # check stream direction
- # check stream is allowed to receive data
+ self._assert_stream_can_receive(frame_type, stream_id)
- if not self._stream_can_receive(stream_id):
- raise QuicConnectionError(
- error_code=QuicErrorCode.STREAM_STATE_ERROR,
- frame_type=frame_type,
- reason_phrase="Cannot receive data on unidirectional stream",
- )
stream = self._get_or_create_stream(stream_id)
stream.add_frame(frame)
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection:
+ def _assert_stream_can_send(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can send data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_send(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is receive-only",
+ )
+
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection:
+ # Private
+
+ def _assert_stream_can_receive(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can receive data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_receive(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is send-only",
+ )
+
===========changed ref 7===========
# module: aioquic.connection
+ def stream_is_unidirectional(stream_id: int) -> bool:
+ """
+ Returns True if the stream is unidirectional.
+ """
+ return bool(stream_id & 2)
+
===========changed ref 8===========
# module: aioquic.connection
+ def stream_is_client_initiated(stream_id: int) -> bool:
+ """
+ Returns True if the stream is client initiated.
+ """
+ return not (stream_id & 1)
+
===========changed ref 9===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# protocol versions
self.version = max(self.supported_versions)
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__local_idle_timeout = 60.0 # seconds
self.__local_max_streams_bidi = 100
self.__local_max_streams_uni = 0
self.__logger = logger
+ self.__path_challenge: Optional[bytes] = None
- self.__path_challenge = None
self._pending_flow_control: List[bytes] = []
self._remote_idle_timeout = 0.0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self.__transport: Optional[asyncio.DatagramTransport] = None
# callbacks
self.stream_created_cb: Callable[</s>
|
aioquic.connection/QuicConnection._stream_can_send
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<0>:<add> return stream_is_client_initiated(
<add> stream_id
<add> ) == self.is_client or not stream_is_unidirectional(stream_id)
<del> is_local = bool(stream_id & 1) == (not self.is_client)
<1>:<del> is_unidirectional = bool(stream_id & 2)
<2>:<del> return is_local or not is_unidirectional
|
# module: aioquic.connection
class QuicConnection:
+ def _stream_can_send(self, stream_id: int) -> bool:
- def _stream_can_send(self, stream_id):
<0> is_local = bool(stream_id & 1) == (not self.is_client)
<1> is_unidirectional = bool(stream_id & 2)
<2> return is_local or not is_unidirectional
<3>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection.__init__
self.version = max(self.supported_versions)
self._remote_idle_timeout = 0.0
at: aioquic.connection.QuicConnection._parse_transport_parameters
quic_transport_parameters = pull_quic_transport_parameters(
Buffer(data=data), is_client=is_client
)
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.packet.QuicTransportParameters
initial_version: Optional[QuicProtocolVersion] = None
negotiated_version: Optional[QuicProtocolVersion] = None
supported_versions: List[QuicProtocolVersion] = field(default_factory=list)
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_migration: Optional[bool] = False
preferred_address: Optional[bytes] = None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
+ def _stream_can_receive(self, stream_id: int) -> bool:
- def _stream_can_receive(self, stream_id):
+ return stream_is_client_initiated(
+ stream_id
+ ) != self.is_client or not stream_is_unidirectional(stream_id)
- is_local = bool(stream_id & 1) == (not self.is_client)
- is_unidirectional = bool(stream_id & 2)
- return not is_local or not is_unidirectional
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def _handle_stream_data_blocked_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STREAM_DATA_BLOCKED frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint_var(buf) # limit
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def _handle_stop_sending_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STOP_SENDING frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint16(buf) # application error code
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
def _handle_reset_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RESET_STREAM frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint16(buf) # application error code
pull_uint16(buf) # unused
pull_uint_var(buf) # final size
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection:
def _handle_max_stream_data_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAM_DATA frame.
This adjusts the amount of data we can send on a specific stream.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint_var(buf) # limit
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection:
def _handle_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STREAM frame.
"""
flags = frame_type & STREAM_FLAGS
stream_id = pull_uint_var(buf)
if flags & QuicStreamFlag.OFF:
offset = pull_uint_var(buf)
else:
offset = 0
if flags & QuicStreamFlag.LEN:
length = pull_uint_var(buf)
else:
length = buf.capacity - buf.tell()
frame = QuicStreamFrame(
offset=offset,
data=pull_bytes(buf, length),
fin=bool(flags & QuicStreamFlag.FIN),
)
+ # check stream direction
- # check stream is allowed to receive data
+ self._assert_stream_can_receive(frame_type, stream_id)
- if not self._stream_can_receive(stream_id):
- raise QuicConnectionError(
- error_code=QuicErrorCode.STREAM_STATE_ERROR,
- frame_type=frame_type,
- reason_phrase="Cannot receive data on unidirectional stream",
- )
stream = self._get_or_create_stream(stream_id)
stream.add_frame(frame)
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection:
+ def _assert_stream_can_send(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can send data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_send(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is receive-only",
+ )
+
===========changed ref 7===========
# module: aioquic.connection
class QuicConnection:
+ # Private
+
+ def _assert_stream_can_receive(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can receive data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_receive(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is send-only",
+ )
+
===========changed ref 8===========
# module: aioquic.connection
+ def stream_is_unidirectional(stream_id: int) -> bool:
+ """
+ Returns True if the stream is unidirectional.
+ """
+ return bool(stream_id & 2)
+
===========changed ref 9===========
# module: aioquic.connection
+ def stream_is_client_initiated(stream_id: int) -> bool:
+ """
+ Returns True if the stream is client initiated.
+ """
+ return not (stream_id & 1)
+
|
tests.test_connection/QuicConnectionTest.test_handle_data_blocked_frame
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<1>:<del>
<10>:<del> self.assertEqual(client_transport.sent, 4)
<11>:<del> self.assertEqual(server_transport.sent, 4)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_data_blocked_frame(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10> self.assertEqual(client_transport.sent, 4)
<11> self.assertEqual(server_transport.sent, 4)
<12>
<13> # server sends DATA_BLOCKED: 12345
<14> server._pending_flow_control.append(b"\x14\x70\x39")
<15> server._send_pending()
<16>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
_send_pending() -> None
at: aioquic.connection.QuicConnection.__init__
self._pending_flow_control: List[bytes] = []
at: aioquic.connection.QuicConnection._write_application
self._pending_flow_control = []
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
create_transport(client, server)
at: tests.test_connection.QuicConnectionTest.test_handle_data_blocked_frame
client = QuicConnection(is_client=True)
===========changed ref 0===========
# module: aioquic.connection
+ def stream_is_client_initiated(stream_id: int) -> bool:
+ """
+ Returns True if the stream is client initiated.
+ """
+ return not (stream_id & 1)
+
===========changed ref 1===========
# module: aioquic.connection
+ def stream_is_unidirectional(stream_id: int) -> bool:
+ """
+ Returns True if the stream is unidirectional.
+ """
+ return bool(stream_id & 2)
+
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def _handle_stop_sending_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STOP_SENDING frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint16(buf) # application error code
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
def _handle_stream_data_blocked_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STREAM_DATA_BLOCKED frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint_var(buf) # limit
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection:
def _handle_max_stream_data_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAM_DATA frame.
This adjusts the amount of data we can send on a specific stream.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint_var(buf) # limit
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection:
def _handle_reset_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RESET_STREAM frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint16(buf) # application error code
pull_uint16(buf) # unused
pull_uint_var(buf) # final size
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection:
+ def _assert_stream_can_send(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can send data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_send(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is receive-only",
+ )
+
===========changed ref 7===========
# module: aioquic.connection
class QuicConnection:
+ # Private
+
+ def _assert_stream_can_receive(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can receive data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_receive(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is send-only",
+ )
+
===========changed ref 8===========
# module: aioquic.connection
class QuicConnection:
+ def _stream_can_send(self, stream_id: int) -> bool:
- def _stream_can_send(self, stream_id):
+ return stream_is_client_initiated(
+ stream_id
+ ) == self.is_client or not stream_is_unidirectional(stream_id)
- is_local = bool(stream_id & 1) == (not self.is_client)
- is_unidirectional = bool(stream_id & 2)
- return is_local or not is_unidirectional
===========changed ref 9===========
# module: aioquic.connection
class QuicConnection:
+ def _stream_can_receive(self, stream_id: int) -> bool:
- def _stream_can_receive(self, stream_id):
+ return stream_is_client_initiated(
+ stream_id
+ ) != self.is_client or not stream_is_unidirectional(stream_id)
- is_local = bool(stream_id & 1) == (not self.is_client)
- is_unidirectional = bool(stream_id & 2)
- return not is_local or not is_unidirectional
===========changed ref 10===========
# module: aioquic.connection
class QuicConnection:
def _handle_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STREAM frame.
"""
flags = frame_type & STREAM_FLAGS
stream_id = pull_uint_var(buf)
if flags & QuicStreamFlag.OFF:
offset = pull_uint_var(buf)
else:
offset = 0
if flags & QuicStreamFlag.LEN:
length = pull_uint_var(buf)
else:
length = buf.capacity - buf.tell()
frame = QuicStreamFrame(
offset=offset,
data=pull_bytes(buf, length),
fin=bool(flags & QuicStreamFlag.FIN),
)
+ # check stream direction
- # check stream is allowed to receive data
+ self._assert_stream_can_receive(frame_type, stream_id)
- if not self._stream_can_receive(stream_id):
- raise QuicConnectionError(
- error_code=QuicErrorCode.STREAM_STATE_ERROR,
- frame_type=frame_type,
- reason_phrase="Cannot receive data on unidirectional stream",
- )
stream = self._get_or_create_stream(stream_id)
stream.add_frame(frame)
|
tests.test_connection/QuicConnectionTest.test_handle_max_data_frame
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<1>:<del>
<10>:<del> self.assertEqual(client_transport.sent, 4)
<11>:<del> self.assertEqual(server_transport.sent, 4)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_data_frame(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10> self.assertEqual(client_transport.sent, 4)
<11> self.assertEqual(server_transport.sent, 4)
<12>
<13> # server sends MAX_DATA: 12345
<14> server._pending_flow_control.append(b"\x10\x70\x39")
<15> server._send_pending()
<16>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
_send_pending() -> None
at: aioquic.connection.QuicConnection.__init__
self._pending_flow_control: List[bytes] = []
at: aioquic.connection.QuicConnection._write_application
self._pending_flow_control = []
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
create_transport(client, server)
at: tests.test_connection.QuicConnectionTest.test_handle_max_data_frame
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_data_blocked_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends DATA_BLOCKED: 12345
server._pending_flow_control.append(b"\x14\x70\x39")
server._send_pending()
===========changed ref 1===========
# module: aioquic.connection
+ def stream_is_client_initiated(stream_id: int) -> bool:
+ """
+ Returns True if the stream is client initiated.
+ """
+ return not (stream_id & 1)
+
===========changed ref 2===========
# module: aioquic.connection
+ def stream_is_unidirectional(stream_id: int) -> bool:
+ """
+ Returns True if the stream is unidirectional.
+ """
+ return bool(stream_id & 2)
+
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
def _handle_stop_sending_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STOP_SENDING frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint16(buf) # application error code
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection:
def _handle_stream_data_blocked_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STREAM_DATA_BLOCKED frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint_var(buf) # limit
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection:
def _handle_max_stream_data_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAM_DATA frame.
This adjusts the amount of data we can send on a specific stream.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint_var(buf) # limit
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection:
def _handle_reset_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RESET_STREAM frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint16(buf) # application error code
pull_uint16(buf) # unused
pull_uint_var(buf) # final size
===========changed ref 7===========
# module: aioquic.connection
class QuicConnection:
+ def _assert_stream_can_send(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can send data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_send(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is receive-only",
+ )
+
===========changed ref 8===========
# module: aioquic.connection
class QuicConnection:
+ # Private
+
+ def _assert_stream_can_receive(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can receive data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_receive(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is send-only",
+ )
+
===========changed ref 9===========
# module: aioquic.connection
class QuicConnection:
+ def _stream_can_send(self, stream_id: int) -> bool:
- def _stream_can_send(self, stream_id):
+ return stream_is_client_initiated(
+ stream_id
+ ) == self.is_client or not stream_is_unidirectional(stream_id)
- is_local = bool(stream_id & 1) == (not self.is_client)
- is_unidirectional = bool(stream_id & 2)
- return is_local or not is_unidirectional
===========changed ref 10===========
# module: aioquic.connection
class QuicConnection:
+ def _stream_can_receive(self, stream_id: int) -> bool:
- def _stream_can_receive(self, stream_id):
+ return stream_is_client_initiated(
+ stream_id
+ ) != self.is_client or not stream_is_unidirectional(stream_id)
- is_local = bool(stream_id & 1) == (not self.is_client)
- is_unidirectional = bool(stream_id & 2)
- return not is_local or not is_unidirectional
|
tests.test_connection/QuicConnectionTest.test_handle_max_stream_data_frame
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<1>:<del>
<10>:<del> self.assertEqual(client_transport.sent, 4)
<11>:<del> self.assertEqual(server_transport.sent, 4)
<13>:<del> # server sends MAX_STREAM_DATA: 0, 1
<14>:<del> server._pending_flow_control.append(b"\x11\x00\x01")
<15>:<del> server._send_pending()
<16>:<add> # client creates bidirectional stream 0
<add> client.create_stream()
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_stream_data_frame(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10> self.assertEqual(client_transport.sent, 4)
<11> self.assertEqual(server_transport.sent, 4)
<12>
<13> # server sends MAX_STREAM_DATA: 0, 1
<14> server._pending_flow_control.append(b"\x11\x00\x01")
<15> server._send_pending()
<16>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
_handle_max_stream_data_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.tls
Epoch()
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
create_transport(client, server)
at: tests.test_connection.QuicConnectionTest.test_handle_max_stream_data_frame
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def _handle_max_stream_data_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAM_DATA frame.
This adjusts the amount of data we can send on a specific stream.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint_var(buf) # limit
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_data_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends MAX_DATA: 12345
server._pending_flow_control.append(b"\x10\x70\x39")
server._send_pending()
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_data_blocked_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends DATA_BLOCKED: 12345
server._pending_flow_control.append(b"\x14\x70\x39")
server._send_pending()
===========changed ref 3===========
# module: aioquic.connection
+ def stream_is_client_initiated(stream_id: int) -> bool:
+ """
+ Returns True if the stream is client initiated.
+ """
+ return not (stream_id & 1)
+
===========changed ref 4===========
# module: aioquic.connection
+ def stream_is_unidirectional(stream_id: int) -> bool:
+ """
+ Returns True if the stream is unidirectional.
+ """
+ return bool(stream_id & 2)
+
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection:
def _handle_stop_sending_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STOP_SENDING frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint16(buf) # application error code
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection:
def _handle_stream_data_blocked_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STREAM_DATA_BLOCKED frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint_var(buf) # limit
===========changed ref 7===========
# module: aioquic.connection
class QuicConnection:
def _handle_reset_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RESET_STREAM frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint16(buf) # application error code
pull_uint16(buf) # unused
pull_uint_var(buf) # final size
===========changed ref 8===========
# module: aioquic.connection
class QuicConnection:
+ def _assert_stream_can_send(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can send data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_send(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is receive-only",
+ )
+
===========changed ref 9===========
# module: aioquic.connection
class QuicConnection:
+ # Private
+
+ def _assert_stream_can_receive(self, frame_type: int, stream_id: int) -> None:
+ """
+ Check the specified stream can receive data or raises a QuicConnectionError.
+ """
+ if not self._stream_can_receive(stream_id):
+ raise QuicConnectionError(
+ error_code=QuicErrorCode.STREAM_STATE_ERROR,
+ frame_type=frame_type,
+ reason_phrase="Stream is send-only",
+ )
+
===========changed ref 10===========
# module: aioquic.connection
class QuicConnection:
+ def _stream_can_send(self, stream_id: int) -> bool:
- def _stream_can_send(self, stream_id):
+ return stream_is_client_initiated(
+ stream_id
+ ) == self.is_client or not stream_is_unidirectional(stream_id)
- is_local = bool(stream_id & 1) == (not self.is_client)
- is_unidirectional = bool(stream_id & 2)
- return is_local or not is_unidirectional
|
tests.test_connection/QuicConnectionTest.test_handle_max_streams_bidi_frame
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<1>:<del>
<10>:<del> self.assertEqual(client_transport.sent, 4)
<11>:<del> self.assertEqual(server_transport.sent, 4)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_streams_bidi_frame(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10> self.assertEqual(client_transport.sent, 4)
<11> self.assertEqual(server_transport.sent, 4)
<12> self.assertEqual(client._remote_max_streams_bidi, 100)
<13>
<14> # server sends MAX_STREAMS_BIDI: 101
<15> server._pending_flow_control.append(b"\x12\x40\x65")
<16> server._send_pending()
<17> self.assertEqual(client._remote_max_streams_bidi, 101)
<18>
<19> # server sends MAX_STREAMS_BIDI: 99 -> discarded
<20> server._pending_flow_control.append(b"\x12\x40\x63")
<21> server._send_pending()
<22> self.assertEqual(client._remote_max_streams_bidi, 101)
<23>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
_handle_max_stream_data_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.tls
Epoch()
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
create_transport(client, server)
at: tests.test_connection.QuicConnectionTest.test_handle_max_stream_data_frame_receive_only
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
===========unchanged ref 1===========
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
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
at: unittest.case._AssertRaisesContext.__exit__
self.exception = exc_value.with_traceback(None)
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def _handle_max_stream_data_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAM_DATA frame.
This adjusts the amount of data we can send on a specific stream.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint_var(buf) # limit
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_data_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends MAX_DATA: 12345
server._pending_flow_control.append(b"\x10\x70\x39")
server._send_pending()
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_stream_data_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- # server sends MAX_STREAM_DATA: 0, 1
- server._pending_flow_control.append(b"\x11\x00\x01")
- server._send_pending()
+ # client creates bidirectional stream 0
+ client.create_stream()
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_data_blocked_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends DATA_BLOCKED: 12345
server._pending_flow_control.append(b"\x14\x70\x39")
server._send_pending()
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_handle_max_stream_data_frame_receive_only(self):
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False,
+ certificate=SERVER_CERTIFICATE,
+ private_key=SERVER_PRIVATE_KEY,
+ )
+
+ # perform handshake
+ client_transport, server_transport = create_transport(client, server)
+
+ # server creates unidirectional stream 3
+ server.create_stream(is_unidirectional=True)
+
+ # client receives MAX_STREAM_DATA: 3, 1
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_max_stream_data_frame(
+ tls.Epoch.ONE_RTT,
+ QuicFrameType.MAX_STREAM_DATA,
+ Buffer(data=b"\x03\x01"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA)
+ self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only")
+
===========changed ref 5===========
# module: aioquic.connection
+ def stream_is_client_initiated(stream_id: int) -> bool:
+ """
+ Returns True if the stream is client initiated.
+ """
+ return not (stream_id & 1)
+
===========changed ref 6===========
# module: aioquic.connection
+ def stream_is_unidirectional(stream_id: int) -> bool:
+ """
+ Returns True if the stream is unidirectional.
+ """
+ return bool(stream_id & 2)
+
|
tests.test_connection/QuicConnectionTest.test_handle_max_streams_uni_frame
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<1>:<del>
<10>:<del> self.assertEqual(client_transport.sent, 4)
<11>:<del> self.assertEqual(server_transport.sent, 4)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_streams_uni_frame(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10> self.assertEqual(client_transport.sent, 4)
<11> self.assertEqual(server_transport.sent, 4)
<12> self.assertEqual(client._remote_max_streams_uni, 0)
<13>
<14> # server sends MAX_STREAMS_UNI: 1
<15> server._pending_flow_control.append(b"\x13\x01")
<16> server._send_pending()
<17> self.assertEqual(client._remote_max_streams_uni, 1)
<18>
<19> # server sends MAX_STREAMS_UNI: 0 -> discarded
<20> server._pending_flow_control.append(b"\x13\x00")
<21> server._send_pending()
<22> self.assertEqual(client._remote_max_streams_uni, 1)
<23>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
_send_pending() -> None
at: aioquic.connection.QuicConnection.__init__
self._pending_flow_control: List[bytes] = []
self._remote_max_streams_bidi = 0
at: aioquic.connection.QuicConnection._handle_max_streams_bidi_frame
self._remote_max_streams_bidi = max_streams
at: aioquic.connection.QuicConnection._parse_transport_parameters
self._remote_max_streams_bidi = (
quic_transport_parameters.initial_max_streams_bidi
)
at: aioquic.connection.QuicConnection._write_application
self._pending_flow_control = []
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
create_transport(client, server)
at: tests.test_connection.QuicConnectionTest.test_handle_max_streams_bidi_frame
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_data_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends MAX_DATA: 12345
server._pending_flow_control.append(b"\x10\x70\x39")
server._send_pending()
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_stream_data_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- # server sends MAX_STREAM_DATA: 0, 1
- server._pending_flow_control.append(b"\x11\x00\x01")
- server._send_pending()
+ # client creates bidirectional stream 0
+ client.create_stream()
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_data_blocked_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends DATA_BLOCKED: 12345
server._pending_flow_control.append(b"\x14\x70\x39")
server._send_pending()
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_streams_bidi_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
self.assertEqual(client._remote_max_streams_bidi, 100)
# server sends MAX_STREAMS_BIDI: 101
server._pending_flow_control.append(b"\x12\x40\x65")
server._send_pending()
self.assertEqual(client._remote_max_streams_bidi, 101)
# server sends MAX_STREAMS_BIDI: 99 -> discarded
server._pending_flow_control.append(b"\x12\x40\x63")
server._send_pending()
self.assertEqual(client._remote_max_streams_bidi, 101)
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_handle_max_stream_data_frame_receive_only(self):
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False,
+ certificate=SERVER_CERTIFICATE,
+ private_key=SERVER_PRIVATE_KEY,
+ )
+
+ # perform handshake
+ client_transport, server_transport = create_transport(client, server)
+
+ # server creates unidirectional stream 3
+ server.create_stream(is_unidirectional=True)
+
+ # client receives MAX_STREAM_DATA: 3, 1
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_max_stream_data_frame(
+ tls.Epoch.ONE_RTT,
+ QuicFrameType.MAX_STREAM_DATA,
+ Buffer(data=b"\x03\x01"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA)
+ self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only")
+
===========changed ref 5===========
# module: aioquic.connection
+ def stream_is_client_initiated(stream_id: int) -> bool:
+ """
+ Returns True if the stream is client initiated.
+ """
+ return not (stream_id & 1)
+
===========changed ref 6===========
# module: aioquic.connection
+ def stream_is_unidirectional(stream_id: int) -> bool:
+ """
+ Returns True if the stream is unidirectional.
+ """
+ return bool(stream_id & 2)
+
===========changed ref 7===========
# module: aioquic.connection
class QuicConnection:
def _handle_stop_sending_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STOP_SENDING frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint16(buf) # application error code
|
tests.test_connection/QuicConnectionTest.test_handle_new_connection_id_frame
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<1>:<del>
<10>:<del> self.assertEqual(client_transport.sent, 4)
<11>:<del> self.assertEqual(server_transport.sent, 4)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_connection_id_frame(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10> self.assertEqual(client_transport.sent, 4)
<11> self.assertEqual(server_transport.sent, 4)
<12>
<13> # server sends NEW_CONNECTION_ID
<14> server._pending_flow_control.append(
<15> binascii.unhexlify(
<16> "1802117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8"
<17> )
<18> )
<19> server._send_pending()
<20>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
_send_pending() -> None
at: aioquic.connection.QuicConnection.__init__
self._pending_flow_control: List[bytes] = []
self._remote_max_streams_uni = 0
at: aioquic.connection.QuicConnection._handle_max_streams_uni_frame
self._remote_max_streams_uni = max_streams
at: aioquic.connection.QuicConnection._parse_transport_parameters
self._remote_max_streams_uni = (
quic_transport_parameters.initial_max_streams_uni
)
at: aioquic.connection.QuicConnection._write_application
self._pending_flow_control = []
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: tests.test_connection.QuicConnectionTest.test_handle_max_streams_uni_frame
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_data_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends MAX_DATA: 12345
server._pending_flow_control.append(b"\x10\x70\x39")
server._send_pending()
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_stream_data_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- # server sends MAX_STREAM_DATA: 0, 1
- server._pending_flow_control.append(b"\x11\x00\x01")
- server._send_pending()
+ # client creates bidirectional stream 0
+ client.create_stream()
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_data_blocked_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends DATA_BLOCKED: 12345
server._pending_flow_control.append(b"\x14\x70\x39")
server._send_pending()
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_streams_uni_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
self.assertEqual(client._remote_max_streams_uni, 0)
# server sends MAX_STREAMS_UNI: 1
server._pending_flow_control.append(b"\x13\x01")
server._send_pending()
self.assertEqual(client._remote_max_streams_uni, 1)
# server sends MAX_STREAMS_UNI: 0 -> discarded
server._pending_flow_control.append(b"\x13\x00")
server._send_pending()
self.assertEqual(client._remote_max_streams_uni, 1)
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_streams_bidi_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
self.assertEqual(client._remote_max_streams_bidi, 100)
# server sends MAX_STREAMS_BIDI: 101
server._pending_flow_control.append(b"\x12\x40\x65")
server._send_pending()
self.assertEqual(client._remote_max_streams_bidi, 101)
# server sends MAX_STREAMS_BIDI: 99 -> discarded
server._pending_flow_control.append(b"\x12\x40\x63")
server._send_pending()
self.assertEqual(client._remote_max_streams_bidi, 101)
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_handle_max_stream_data_frame_receive_only(self):
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False,
+ certificate=SERVER_CERTIFICATE,
+ private_key=SERVER_PRIVATE_KEY,
+ )
+
+ # perform handshake
+ client_transport, server_transport = create_transport(client, server)
+
+ # server creates unidirectional stream 3
+ server.create_stream(is_unidirectional=True)
+
+ # client receives MAX_STREAM_DATA: 3, 1
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_max_stream_data_frame(
+ tls.Epoch.ONE_RTT,
+ QuicFrameType.MAX_STREAM_DATA,
+ Buffer(data=b"\x03\x01"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA)
+ self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only")
+
|
tests.test_connection/QuicConnectionTest.test_handle_new_token_frame
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<1>:<del>
<10>:<del> self.assertEqual(client_transport.sent, 4)
<11>:<del> self.assertEqual(server_transport.sent, 4)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10> self.assertEqual(client_transport.sent, 4)
<11> self.assertEqual(server_transport.sent, 4)
<12>
<13> # server sends NEW_TOKEN
<14> server._pending_flow_control.append(binascii.unhexlify("07080102030405060708"))
<15> server._send_pending()
<16>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
_send_pending() -> None
at: aioquic.connection.QuicConnection.__init__
self._pending_flow_control: List[bytes] = []
at: aioquic.connection.QuicConnection._write_application
self._pending_flow_control = []
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: tests.test_connection.QuicConnectionTest.test_handle_new_connection_id_frame
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_connection_id_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends NEW_CONNECTION_ID
server._pending_flow_control.append(
binascii.unhexlify(
"1802117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8"
)
)
server._send_pending()
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_data_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends MAX_DATA: 12345
server._pending_flow_control.append(b"\x10\x70\x39")
server._send_pending()
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_stream_data_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- # server sends MAX_STREAM_DATA: 0, 1
- server._pending_flow_control.append(b"\x11\x00\x01")
- server._send_pending()
+ # client creates bidirectional stream 0
+ client.create_stream()
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_data_blocked_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends DATA_BLOCKED: 12345
server._pending_flow_control.append(b"\x14\x70\x39")
server._send_pending()
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_streams_uni_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
self.assertEqual(client._remote_max_streams_uni, 0)
# server sends MAX_STREAMS_UNI: 1
server._pending_flow_control.append(b"\x13\x01")
server._send_pending()
self.assertEqual(client._remote_max_streams_uni, 1)
# server sends MAX_STREAMS_UNI: 0 -> discarded
server._pending_flow_control.append(b"\x13\x00")
server._send_pending()
self.assertEqual(client._remote_max_streams_uni, 1)
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_streams_bidi_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
self.assertEqual(client._remote_max_streams_bidi, 100)
# server sends MAX_STREAMS_BIDI: 101
server._pending_flow_control.append(b"\x12\x40\x65")
server._send_pending()
self.assertEqual(client._remote_max_streams_bidi, 101)
# server sends MAX_STREAMS_BIDI: 99 -> discarded
server._pending_flow_control.append(b"\x12\x40\x63")
server._send_pending()
self.assertEqual(client._remote_max_streams_bidi, 101)
|
tests.test_connection/QuicConnectionTest.test_handle_path_challenge_frame
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<1>:<del>
<10>:<del> self.assertEqual(client_transport.sent, 4)
<11>:<del> self.assertEqual(server_transport.sent, 4)
<12>:<del> self.assertEqual(client._remote_max_streams_bidi, 100)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_path_challenge_frame(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10> self.assertEqual(client_transport.sent, 4)
<11> self.assertEqual(server_transport.sent, 4)
<12> self.assertEqual(client._remote_max_streams_bidi, 100)
<13>
<14> # server sends PATH_CHALLENGE
<15> server._send_path_challenge()
<16>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
_send_pending() -> None
at: aioquic.connection.QuicConnection.__init__
self._pending_flow_control: List[bytes] = []
at: aioquic.connection.QuicConnection._write_application
self._pending_flow_control = []
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
create_transport(client, server)
at: tests.test_connection.QuicConnectionTest.test_handle_new_token_frame
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends NEW_TOKEN
server._pending_flow_control.append(binascii.unhexlify("07080102030405060708"))
server._send_pending()
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_connection_id_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends NEW_CONNECTION_ID
server._pending_flow_control.append(
binascii.unhexlify(
"1802117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8"
)
)
server._send_pending()
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_data_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends MAX_DATA: 12345
server._pending_flow_control.append(b"\x10\x70\x39")
server._send_pending()
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_stream_data_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- # server sends MAX_STREAM_DATA: 0, 1
- server._pending_flow_control.append(b"\x11\x00\x01")
- server._send_pending()
+ # client creates bidirectional stream 0
+ client.create_stream()
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_data_blocked_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends DATA_BLOCKED: 12345
server._pending_flow_control.append(b"\x14\x70\x39")
server._send_pending()
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_streams_uni_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
self.assertEqual(client._remote_max_streams_uni, 0)
# server sends MAX_STREAMS_UNI: 1
server._pending_flow_control.append(b"\x13\x01")
server._send_pending()
self.assertEqual(client._remote_max_streams_uni, 1)
# server sends MAX_STREAMS_UNI: 0 -> discarded
server._pending_flow_control.append(b"\x13\x00")
server._send_pending()
self.assertEqual(client._remote_max_streams_uni, 1)
===========changed ref 6===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_streams_bidi_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
self.assertEqual(client._remote_max_streams_bidi, 100)
# server sends MAX_STREAMS_BIDI: 101
server._pending_flow_control.append(b"\x12\x40\x65")
server._send_pending()
self.assertEqual(client._remote_max_streams_bidi, 101)
# server sends MAX_STREAMS_BIDI: 99 -> discarded
server._pending_flow_control.append(b"\x12\x40\x63")
server._send_pending()
self.assertEqual(client._remote_max_streams_bidi, 101)
|
tests.test_connection/QuicConnectionTest.test_handle_path_response_frame_bad
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<1>:<del>
<10>:<del> self.assertEqual(client_transport.sent, 4)
<11>:<del> self.assertEqual(server_transport.sent, 4)
<12>:<del> self.assertEqual(client._remote_max_streams_bidi, 100)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_path_response_frame_bad(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10> self.assertEqual(client_transport.sent, 4)
<11> self.assertEqual(server_transport.sent, 4)
<12> self.assertEqual(client._remote_max_streams_bidi, 100)
<13>
<14> # server receives unsollicited PATH_RESPONSE
<15> with self.assertRaises(QuicConnectionError) as cm:
<16> server._handle_path_response_frame(
<17> tls.Epoch.ONE_RTT,
<18> QuicFrameType.PATH_RESPONSE,
<19> Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"),
<20> )
<21> self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
<22> self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)
<23>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
_handle_path_response_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_send_path_challenge() -> None
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.tls
Epoch()
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
create_transport(client, server)
at: tests.test_connection.QuicConnectionTest.test_handle_path_challenge_frame
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========unchanged ref 1===========
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_connection
class QuicConnectionTest(TestCase):
def test_handle_path_challenge_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- self.assertEqual(client._remote_max_streams_bidi, 100)
# server sends PATH_CHALLENGE
server._send_path_challenge()
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends NEW_TOKEN
server._pending_flow_control.append(binascii.unhexlify("07080102030405060708"))
server._send_pending()
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_connection_id_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends NEW_CONNECTION_ID
server._pending_flow_control.append(
binascii.unhexlify(
"1802117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8"
)
)
server._send_pending()
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_data_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends MAX_DATA: 12345
server._pending_flow_control.append(b"\x10\x70\x39")
server._send_pending()
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_stream_data_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- # server sends MAX_STREAM_DATA: 0, 1
- server._pending_flow_control.append(b"\x11\x00\x01")
- server._send_pending()
+ # client creates bidirectional stream 0
+ client.create_stream()
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_data_blocked_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends DATA_BLOCKED: 12345
server._pending_flow_control.append(b"\x14\x70\x39")
server._send_pending()
|
tests.test_connection/QuicConnectionTest.test_handle_reset_stream_frame
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<1>:<del>
<10>:<del> self.assertEqual(client_transport.sent, 4)
<11>:<del> self.assertEqual(server_transport.sent, 4)
<13>:<del> # server sends RESET_STREAM
<14>:<del> server._pending_flow_control.append(binascii.unhexlify("04001122000001"))
<15>:<del> server._send_pending()
<16>:<add> # client creates bidirectional stream 0
<add> client.create_stream()
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_reset_stream_frame(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10> self.assertEqual(client_transport.sent, 4)
<11> self.assertEqual(server_transport.sent, 4)
<12>
<13> # server sends RESET_STREAM
<14> server._pending_flow_control.append(binascii.unhexlify("04001122000001"))
<15> server._send_pending()
<16>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
_handle_reset_stream_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.tls
Epoch()
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
create_transport(client, server)
at: tests.test_connection.QuicConnectionTest.test_handle_reset_stream_frame
client = QuicConnection(is_client=True)
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def _handle_reset_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RESET_STREAM frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint16(buf) # application error code
pull_uint16(buf) # unused
pull_uint_var(buf) # final size
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_path_challenge_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- self.assertEqual(client._remote_max_streams_bidi, 100)
# server sends PATH_CHALLENGE
server._send_path_challenge()
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends NEW_TOKEN
server._pending_flow_control.append(binascii.unhexlify("07080102030405060708"))
server._send_pending()
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_connection_id_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends NEW_CONNECTION_ID
server._pending_flow_control.append(
binascii.unhexlify(
"1802117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8"
)
)
server._send_pending()
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_path_response_frame_bad(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- self.assertEqual(client._remote_max_streams_bidi, 100)
# server receives unsollicited PATH_RESPONSE
with self.assertRaises(QuicConnectionError) as cm:
server._handle_path_response_frame(
tls.Epoch.ONE_RTT,
QuicFrameType.PATH_RESPONSE,
Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"),
)
self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_data_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends MAX_DATA: 12345
server._pending_flow_control.append(b"\x10\x70\x39")
server._send_pending()
===========changed ref 6===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_stream_data_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- # server sends MAX_STREAM_DATA: 0, 1
- server._pending_flow_control.append(b"\x11\x00\x01")
- server._send_pending()
+ # client creates bidirectional stream 0
+ client.create_stream()
|
tests.test_connection/QuicConnectionTest.test_handle_retire_connection_id_frame
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<1>:<del>
<10>:<del> self.assertEqual(client_transport.sent, 4)
<11>:<del> self.assertEqual(server_transport.sent, 4)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10> self.assertEqual(client_transport.sent, 4)
<11> self.assertEqual(server_transport.sent, 4)
<12>
<13> # server sends RETIRE_CONNECTION_ID
<14> server._pending_flow_control.append(b"\x19\x02")
<15> server._send_pending()
<16>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
create_transport(client, server)
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_connection
class QuicConnectionTest(TestCase):
def test_handle_reset_stream_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- # server sends RESET_STREAM
- server._pending_flow_control.append(binascii.unhexlify("04001122000001"))
- server._send_pending()
+ # client creates bidirectional stream 0
+ client.create_stream()
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_path_challenge_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- self.assertEqual(client._remote_max_streams_bidi, 100)
# server sends PATH_CHALLENGE
server._send_path_challenge()
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends NEW_TOKEN
server._pending_flow_control.append(binascii.unhexlify("07080102030405060708"))
server._send_pending()
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_connection_id_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends NEW_CONNECTION_ID
server._pending_flow_control.append(
binascii.unhexlify(
"1802117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8"
)
)
server._send_pending()
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_path_response_frame_bad(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- self.assertEqual(client._remote_max_streams_bidi, 100)
# server receives unsollicited PATH_RESPONSE
with self.assertRaises(QuicConnectionError) as cm:
server._handle_path_response_frame(
tls.Epoch.ONE_RTT,
QuicFrameType.PATH_RESPONSE,
Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"),
)
self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_data_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends MAX_DATA: 12345
server._pending_flow_control.append(b"\x10\x70\x39")
server._send_pending()
===========changed ref 6===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_stream_data_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- # server sends MAX_STREAM_DATA: 0, 1
- server._pending_flow_control.append(b"\x11\x00\x01")
- server._send_pending()
+ # client creates bidirectional stream 0
+ client.create_stream()
|
tests.test_connection/QuicConnectionTest.test_handle_stop_sending_frame
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<1>:<del>
<10>:<del> self.assertEqual(client_transport.sent, 4)
<11>:<del> self.assertEqual(server_transport.sent, 4)
<13>:<del> # server sends STOP_SENDING
<14>:<del> server._pending_flow_control.append(binascii.unhexlify("05001122"))
<15>:<del> server._send_pending()
<16>:<add> # client creates bidirectional stream 0
<add> client.create_stream()
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stop_sending_frame(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10> self.assertEqual(client_transport.sent, 4)
<11> self.assertEqual(server_transport.sent, 4)
<12>
<13> # server sends STOP_SENDING
<14> server._pending_flow_control.append(binascii.unhexlify("05001122"))
<15> server._send_pending()
<16>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.tls
Epoch()
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends RETIRE_CONNECTION_ID
server._pending_flow_control.append(b"\x19\x02")
server._send_pending()
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_reset_stream_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- # server sends RESET_STREAM
- server._pending_flow_control.append(binascii.unhexlify("04001122000001"))
- server._send_pending()
+ # client creates bidirectional stream 0
+ client.create_stream()
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_path_challenge_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- self.assertEqual(client._remote_max_streams_bidi, 100)
# server sends PATH_CHALLENGE
server._send_path_challenge()
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends NEW_TOKEN
server._pending_flow_control.append(binascii.unhexlify("07080102030405060708"))
server._send_pending()
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_handle_reset_stream_frame_send_only(self):
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False,
+ certificate=SERVER_CERTIFICATE,
+ private_key=SERVER_PRIVATE_KEY,
+ )
+
+ # perform handshake
+ client_transport, server_transport = create_transport(client, server)
+
+ # client creates unidirectional stream 2
+ client.create_stream(is_unidirectional=True)
+
+ # client receives RESET_STREAM
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_reset_stream_frame(
+ tls.Epoch.ONE_RTT,
+ QuicFrameType.RESET_STREAM,
+ Buffer(data=binascii.unhexlify("021122000001")),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.RESET_STREAM)
+ self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
+
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_connection_id_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends NEW_CONNECTION_ID
server._pending_flow_control.append(
binascii.unhexlify(
"1802117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8"
)
)
server._send_pending()
|
tests.test_connection/QuicConnectionTest.test_handle_stream_data_blocked_frame
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<1>:<del>
<10>:<del> self.assertEqual(client_transport.sent, 4)
<11>:<del> self.assertEqual(server_transport.sent, 4)
<12>:<del> self.assertEqual(client._remote_max_streams_bidi, 100)
<14>:<del> # server sends STREAM_DATA_BLOCKED: 0, 1
<15>:<del> server._pending_flow_control.append(b"\x15\x00\x01")
<16>:<del> server._send_pending()
<17>:<add> # client creates bidirectional stream 0
<add> client.create_stream()
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_data_blocked_frame(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10> self.assertEqual(client_transport.sent, 4)
<11> self.assertEqual(server_transport.sent, 4)
<12> self.assertEqual(client._remote_max_streams_bidi, 100)
<13>
<14> # server sends STREAM_DATA_BLOCKED: 0, 1
<15> server._pending_flow_control.append(b"\x15\x00\x01")
<16> server._send_pending()
<17>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
_handle_stop_sending_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.tls
Epoch()
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
create_transport(client, server)
at: tests.test_connection.QuicConnectionTest.test_handle_stop_sending_frame_receive_only
client = QuicConnection(is_client=True)
===========unchanged ref 1===========
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: aioquic.connection
class QuicConnection:
def _handle_stop_sending_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STOP_SENDING frame.
"""
+ stream_id = pull_uint_var(buf)
- pull_uint_var(buf) # stream id
pull_uint16(buf) # application error code
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends RETIRE_CONNECTION_ID
server._pending_flow_control.append(b"\x19\x02")
server._send_pending()
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stop_sending_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- # server sends STOP_SENDING
- server._pending_flow_control.append(binascii.unhexlify("05001122"))
- server._send_pending()
+ # client creates bidirectional stream 0
+ client.create_stream()
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_reset_stream_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- # server sends RESET_STREAM
- server._pending_flow_control.append(binascii.unhexlify("04001122000001"))
- server._send_pending()
+ # client creates bidirectional stream 0
+ client.create_stream()
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_path_challenge_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- self.assertEqual(client._remote_max_streams_bidi, 100)
# server sends PATH_CHALLENGE
server._send_path_challenge()
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_handle_stop_sending_frame_receive_only(self):
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False,
+ certificate=SERVER_CERTIFICATE,
+ private_key=SERVER_PRIVATE_KEY,
+ )
+
+ # perform handshake
+ client_transport, server_transport = create_transport(client, server)
+
+ # server creates unidirectional stream 3
+ server.create_stream(is_unidirectional=True)
+
+ # client receives STOP_SENDING
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_stop_sending_frame(
+ tls.Epoch.ONE_RTT,
+ QuicFrameType.STOP_SENDING,
+ Buffer(data=b"\x03\x11\x22"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.STOP_SENDING)
+ self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only")
+
===========changed ref 6===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends NEW_TOKEN
server._pending_flow_control.append(binascii.unhexlify("07080102030405060708"))
server._send_pending()
|
tests.test_connection/QuicConnectionTest.test_handle_streams_blocked_uni_frame
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<1>:<del>
<10>:<del> self.assertEqual(client_transport.sent, 4)
<11>:<del> self.assertEqual(server_transport.sent, 4)
<12>:<del> self.assertEqual(client._remote_max_streams_bidi, 100)
<14>:<add> # server sends STREAM_BLOCKED_UNI: 0
<del> # server sends STREAM_DATA_BLOCKED: 0, 1
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_streams_blocked_uni_frame(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10> self.assertEqual(client_transport.sent, 4)
<11> self.assertEqual(server_transport.sent, 4)
<12> self.assertEqual(client._remote_max_streams_bidi, 100)
<13>
<14> # server sends STREAM_DATA_BLOCKED: 0, 1
<15> server._pending_flow_control.append(b"\x17\x00")
<16> server._send_pending()
<17>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
create_transport(client, server)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_data_blocked_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- self.assertEqual(client._remote_max_streams_bidi, 100)
- # server sends STREAM_DATA_BLOCKED: 0, 1
- server._pending_flow_control.append(b"\x15\x00\x01")
- server._send_pending()
+ # client creates bidirectional stream 0
+ client.create_stream()
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends RETIRE_CONNECTION_ID
server._pending_flow_control.append(b"\x19\x02")
server._send_pending()
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stop_sending_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- # server sends STOP_SENDING
- server._pending_flow_control.append(binascii.unhexlify("05001122"))
- server._send_pending()
+ # client creates bidirectional stream 0
+ client.create_stream()
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_reset_stream_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- # server sends RESET_STREAM
- server._pending_flow_control.append(binascii.unhexlify("04001122000001"))
- server._send_pending()
+ # client creates bidirectional stream 0
+ client.create_stream()
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_handle_stop_sending_frame_receive_only(self):
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False,
+ certificate=SERVER_CERTIFICATE,
+ private_key=SERVER_PRIVATE_KEY,
+ )
+
+ # perform handshake
+ client_transport, server_transport = create_transport(client, server)
+
+ # server creates unidirectional stream 3
+ server.create_stream(is_unidirectional=True)
+
+ # client receives STOP_SENDING
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_stop_sending_frame(
+ tls.Epoch.ONE_RTT,
+ QuicFrameType.STOP_SENDING,
+ Buffer(data=b"\x03\x11\x22"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.STOP_SENDING)
+ self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only")
+
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_path_challenge_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- self.assertEqual(client._remote_max_streams_bidi, 100)
# server sends PATH_CHALLENGE
server._send_path_challenge()
===========changed ref 6===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends NEW_TOKEN
server._pending_flow_control.append(binascii.unhexlify("07080102030405060708"))
server._send_pending()
|
tests.test_connection/QuicConnectionTest.test_handle_unknown_frame
|
Modified
|
aiortc~aioquic
|
cd09e010a75905560813b0d47a0b8ed01eab58e0
|
[connection] check stream direction when handling frames
|
<10>:<del> self.assertEqual(client_transport.sent, 4)
<11>:<del> self.assertEqual(server_transport.sent, 4)
<12>:<del> self.assertEqual(client._remote_max_streams_bidi, 100)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_unknown_frame(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10> self.assertEqual(client_transport.sent, 4)
<11> self.assertEqual(server_transport.sent, 4)
<12> self.assertEqual(client._remote_max_streams_bidi, 100)
<13>
<14> # server sends unknown frame
<15> server._pending_flow_control.append(b"\x1e")
<16> server._send_pending()
<17>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
_handle_stream_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.tls
Epoch()
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
create_transport(client, server)
at: tests.test_connection.QuicConnectionTest.test_handle_stream_frame_send_only
client = QuicConnection(is_client=True)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========unchanged ref 1===========
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: aioquic.connection
class QuicConnection:
def _handle_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STREAM frame.
"""
flags = frame_type & STREAM_FLAGS
stream_id = pull_uint_var(buf)
if flags & QuicStreamFlag.OFF:
offset = pull_uint_var(buf)
else:
offset = 0
if flags & QuicStreamFlag.LEN:
length = pull_uint_var(buf)
else:
length = buf.capacity - buf.tell()
frame = QuicStreamFrame(
offset=offset,
data=pull_bytes(buf, length),
fin=bool(flags & QuicStreamFlag.FIN),
)
+ # check stream direction
- # check stream is allowed to receive data
+ self._assert_stream_can_receive(frame_type, stream_id)
- if not self._stream_can_receive(stream_id):
- raise QuicConnectionError(
- error_code=QuicErrorCode.STREAM_STATE_ERROR,
- frame_type=frame_type,
- reason_phrase="Cannot receive data on unidirectional stream",
- )
stream = self._get_or_create_stream(stream_id)
stream.add_frame(frame)
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_streams_blocked_uni_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- self.assertEqual(client._remote_max_streams_bidi, 100)
+ # server sends STREAM_BLOCKED_UNI: 0
- # server sends STREAM_DATA_BLOCKED: 0, 1
server._pending_flow_control.append(b"\x17\x00")
server._send_pending()
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_data_blocked_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- self.assertEqual(client._remote_max_streams_bidi, 100)
- # server sends STREAM_DATA_BLOCKED: 0, 1
- server._pending_flow_control.append(b"\x15\x00\x01")
- server._send_pending()
+ # client creates bidirectional stream 0
+ client.create_stream()
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
# server sends RETIRE_CONNECTION_ID
server._pending_flow_control.append(b"\x19\x02")
server._send_pending()
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stop_sending_frame(self):
client = QuicConnection(is_client=True)
-
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
- # server sends STOP_SENDING
- server._pending_flow_control.append(binascii.unhexlify("05001122"))
- server._send_pending()
+ # client creates bidirectional stream 0
+ client.create_stream()
|
aioquic.connection/QuicConnection.create_stream
|
Modified
|
aiortc~aioquic
|
8f5fd4d08058c6983abc4ac0faa0bb79f09f8b34
|
[connection] check peer respects max streams
|
<9>:<add>
<add> # create stream
<add> stream = self.streams[stream_id] = QuicStream(
<add> connection=self, stream_id=stream_id
<add> )
<add> self.stream_created_cb(stream.reader, stream.writer)
<add>
<del> stream = self._get_or_create_stream(stream_id)
|
# module: aioquic.connection
class QuicConnection:
def create_stream(
self, is_unidirectional: bool = False
) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]:
<0> """
<1> Create a QUIC stream and return a pair of (reader, writer) objects.
<2>
<3> The returned reader and writer objects are instances of :class:`asyncio.StreamReader`
<4> and :class:`asyncio.StreamWriter` classes.
<5> """
<6> stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
<7> while stream_id in self.streams:
<8> stream_id += 4
<9> stream = self._get_or_create_stream(stream_id)
<10> return stream.reader, stream.writer
<11>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
at: asyncio.streams
StreamWriter(transport: transports.BaseTransport, protocol: protocols.BaseProtocol, reader: Optional[StreamReader], loop: events.AbstractEventLoop)
StreamReader(limit: int=..., loop: Optional[events.AbstractEventLoop]=...)
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
|
aioquic.connection/QuicConnection._get_or_create_stream
|
Modified
|
aiortc~aioquic
|
8f5fd4d08058c6983abc4ac0faa0bb79f09f8b34
|
[connection] check peer respects max streams
|
<0>:<add> """
<add> Get or create a stream in response to a received frame.
<add> """
<add> stream = self.streams.get(stream_id, None)
<add> if stream is None:
<add> # check initiator
<add> if stream_is_client_initiated(stream_id) == self.is_client:
<add> raise QuicConnectionError(
<add> error_code=QuicErrorCode.STREAM_STATE_ERROR,
<add> frame_type=frame_type,
<add> reason_phrase="Wrong stream initiator",
<add> )
<add>
<add> # check max streams
<add> if stream_is_unidirectional(stream_id):
<add> max_streams = self.__local_max_streams_uni
<add> else:
<add> max_streams = self.__local_max_streams_bidi
<add> if stream_id // 4 >= max_streams:
<add> raise QuicConnectionError(
<add> error_code=QuicErrorCode.STREAM_LIMIT_ERROR,
<add> frame_type=frame_type,
<add> reason_phrase="Too many streams open",
|
# module: aioquic.connection
class QuicConnection:
+ def _get_or_create_stream(self, frame_type: int, stream_id: int) -> QuicStream:
- def _get_or_create_stream(self, stream_id: int) -> QuicStream:
<0> if stream_id not in self.streams:
<1> self.streams[stream_id] = QuicStream(connection=self, stream_id=stream_id)
<2> self.stream_created_cb(
<3> self.streams[stream_id].reader, self.streams[stream_id].writer
<4> )
<5> return self.streams[stream_id]
<6>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None)
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def create_stream(
self, is_unidirectional: bool = False
) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]:
"""
Create a QUIC stream and return a pair of (reader, writer) objects.
The returned reader and writer objects are instances of :class:`asyncio.StreamReader`
and :class:`asyncio.StreamWriter` classes.
"""
stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
while stream_id in self.streams:
stream_id += 4
+
+ # create stream
+ stream = self.streams[stream_id] = QuicStream(
+ connection=self, stream_id=stream_id
+ )
+ self.stream_created_cb(stream.reader, stream.writer)
+
- stream = self._get_or_create_stream(stream_id)
return stream.reader, stream.writer
|
aioquic.connection/QuicConnection._handle_max_stream_data_frame
|
Modified
|
aiortc~aioquic
|
8f5fd4d08058c6983abc4ac0faa0bb79f09f8b34
|
[connection] check peer respects max streams
|
<11>:<add> self._get_or_create_stream(frame_type, stream_id)
<del> self._get_or_create_stream(stream_id)
|
# module: aioquic.connection
class QuicConnection:
def _handle_max_stream_data_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a MAX_STREAM_DATA frame.
<2>
<3> This adjusts the amount of data we can send on a specific stream.
<4> """
<5> stream_id = pull_uint_var(buf)
<6> pull_uint_var(buf) # limit
<7>
<8> # check stream direction
<9> self._assert_stream_can_send(frame_type, stream_id)
<10>
<11> self._get_or_create_stream(stream_id)
<12>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection.QuicConnection
_parse_transport_parameters(data: bytes) -> None
at: aioquic.connection.QuicConnection.__init__
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self.__logger)
at: aioquic.tls
Epoch()
State()
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls.Context.__init__
self.received_extensions: List[Extension] = []
at: aioquic.tls.Context._client_handle_encrypted_extensions
self.received_extensions = encrypted_extensions.other_extensions
at: aioquic.tls.Context._server_handle_hello
self.received_extensions = peer_hello.other_extensions
at: asyncio.locks.Event
is_set() -> bool
set() -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def create_stream(
self, is_unidirectional: bool = False
) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]:
"""
Create a QUIC stream and return a pair of (reader, writer) objects.
The returned reader and writer objects are instances of :class:`asyncio.StreamReader`
and :class:`asyncio.StreamWriter` classes.
"""
stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
while stream_id in self.streams:
stream_id += 4
+
+ # create stream
+ stream = self.streams[stream_id] = QuicStream(
+ connection=self, stream_id=stream_id
+ )
+ self.stream_created_cb(stream.reader, stream.writer)
+
- stream = self._get_or_create_stream(stream_id)
return stream.reader, stream.writer
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
+ def _get_or_create_stream(self, frame_type: int, stream_id: int) -> QuicStream:
- def _get_or_create_stream(self, 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",
+ )
+
+ # check max streams
+ if stream_is_unidirectional(stream_id):
+ max_streams = self.__local_max_streams_uni
+ else:
+ max_streams = self.__local_max_streams_bidi
+ 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
+ stream = self.streams[stream_id] = QuicStream(
+ connection=self, stream_id=stream_id
- if stream_id not in self.streams:
- self.streams[stream_id] = QuicStream(connection=self, stream_id=stream_id)
- self.stream_created_cb(
- self.streams[stream_id].reader, self.streams[stream_id].writer
)
+ self.stream_created_cb(stream.reader, stream.writer)
+ return stream
- return self.streams[stream_id]
|
aioquic.connection/QuicConnection._handle_reset_stream_frame
|
Modified
|
aiortc~aioquic
|
8f5fd4d08058c6983abc4ac0faa0bb79f09f8b34
|
[connection] check peer respects max streams
|
<11>:<add> self._get_or_create_stream(frame_type, stream_id)
<del> self._get_or_create_stream(stream_id)
|
# module: aioquic.connection
class QuicConnection:
def _handle_reset_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a RESET_STREAM frame.
<2> """
<3> stream_id = pull_uint_var(buf)
<4> pull_uint16(buf) # application error code
<5> pull_uint16(buf) # unused
<6> pull_uint_var(buf) # final size
<7>
<8> # check stream direction
<9> self._assert_stream_can_receive(frame_type, stream_id)
<10>
<11> self._get_or_create_stream(stream_id)
<12>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def _handle_max_stream_data_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAM_DATA frame.
This adjusts the amount of data we can send on a specific stream.
"""
stream_id = pull_uint_var(buf)
pull_uint_var(buf) # limit
# check stream direction
self._assert_stream_can_send(frame_type, stream_id)
+ self._get_or_create_stream(frame_type, stream_id)
- self._get_or_create_stream(stream_id)
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def create_stream(
self, is_unidirectional: bool = False
) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]:
"""
Create a QUIC stream and return a pair of (reader, writer) objects.
The returned reader and writer objects are instances of :class:`asyncio.StreamReader`
and :class:`asyncio.StreamWriter` classes.
"""
stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
while stream_id in self.streams:
stream_id += 4
+
+ # create stream
+ stream = self.streams[stream_id] = QuicStream(
+ connection=self, stream_id=stream_id
+ )
+ self.stream_created_cb(stream.reader, stream.writer)
+
- stream = self._get_or_create_stream(stream_id)
return stream.reader, stream.writer
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
+ def _get_or_create_stream(self, frame_type: int, stream_id: int) -> QuicStream:
- def _get_or_create_stream(self, 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",
+ )
+
+ # check max streams
+ if stream_is_unidirectional(stream_id):
+ max_streams = self.__local_max_streams_uni
+ else:
+ max_streams = self.__local_max_streams_bidi
+ 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
+ stream = self.streams[stream_id] = QuicStream(
+ connection=self, stream_id=stream_id
- if stream_id not in self.streams:
- self.streams[stream_id] = QuicStream(connection=self, stream_id=stream_id)
- self.stream_created_cb(
- self.streams[stream_id].reader, self.streams[stream_id].writer
)
+ self.stream_created_cb(stream.reader, stream.writer)
+ return stream
- return self.streams[stream_id]
|
aioquic.connection/QuicConnection._handle_stop_sending_frame
|
Modified
|
aiortc~aioquic
|
8f5fd4d08058c6983abc4ac0faa0bb79f09f8b34
|
[connection] check peer respects max streams
|
<9>:<add> self._get_or_create_stream(frame_type, stream_id)
<del> self._get_or_create_stream(stream_id)
|
# module: aioquic.connection
class QuicConnection:
def _handle_stop_sending_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a STOP_SENDING frame.
<2> """
<3> stream_id = pull_uint_var(buf)
<4> pull_uint16(buf) # application error code
<5>
<6> # check stream direction
<7> self._assert_stream_can_send(frame_type, stream_id)
<8>
<9> self._get_or_create_stream(stream_id)
<10>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
at: aioquic.connection.QuicConnection.__init__
self.__path_challenge: Optional[bytes] = None
at: aioquic.connection.QuicConnection._handle_path_response_frame
data = pull_bytes(buf, 8)
at: aioquic.connection.QuicConnection._send_path_challenge
self.__path_challenge = os.urandom(8)
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def _handle_reset_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RESET_STREAM frame.
"""
stream_id = pull_uint_var(buf)
pull_uint16(buf) # application error code
pull_uint16(buf) # unused
pull_uint_var(buf) # final size
# check stream direction
self._assert_stream_can_receive(frame_type, stream_id)
+ self._get_or_create_stream(frame_type, stream_id)
- self._get_or_create_stream(stream_id)
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def _handle_max_stream_data_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAM_DATA frame.
This adjusts the amount of data we can send on a specific stream.
"""
stream_id = pull_uint_var(buf)
pull_uint_var(buf) # limit
# check stream direction
self._assert_stream_can_send(frame_type, stream_id)
+ self._get_or_create_stream(frame_type, stream_id)
- self._get_or_create_stream(stream_id)
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def create_stream(
self, is_unidirectional: bool = False
) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]:
"""
Create a QUIC stream and return a pair of (reader, writer) objects.
The returned reader and writer objects are instances of :class:`asyncio.StreamReader`
and :class:`asyncio.StreamWriter` classes.
"""
stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
while stream_id in self.streams:
stream_id += 4
+
+ # create stream
+ stream = self.streams[stream_id] = QuicStream(
+ connection=self, stream_id=stream_id
+ )
+ self.stream_created_cb(stream.reader, stream.writer)
+
- stream = self._get_or_create_stream(stream_id)
return stream.reader, stream.writer
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
+ def _get_or_create_stream(self, frame_type: int, stream_id: int) -> QuicStream:
- def _get_or_create_stream(self, 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",
+ )
+
+ # check max streams
+ if stream_is_unidirectional(stream_id):
+ max_streams = self.__local_max_streams_uni
+ else:
+ max_streams = self.__local_max_streams_bidi
+ 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
+ stream = self.streams[stream_id] = QuicStream(
+ connection=self, stream_id=stream_id
- if stream_id not in self.streams:
- self.streams[stream_id] = QuicStream(connection=self, stream_id=stream_id)
- self.stream_created_cb(
- self.streams[stream_id].reader, self.streams[stream_id].writer
)
+ self.stream_created_cb(stream.reader, stream.writer)
+ return stream
- return self.streams[stream_id]
|
aioquic.connection/QuicConnection._handle_stream_frame
|
Modified
|
aiortc~aioquic
|
8f5fd4d08058c6983abc4ac0faa0bb79f09f8b34
|
[connection] check peer respects max streams
|
<22>:<add> stream = self._get_or_create_stream(frame_type, stream_id)
<del> stream = self._get_or_create_stream(stream_id)
|
# module: aioquic.connection
class QuicConnection:
def _handle_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a STREAM frame.
<2> """
<3> flags = frame_type & STREAM_FLAGS
<4> stream_id = pull_uint_var(buf)
<5> if flags & QuicStreamFlag.OFF:
<6> offset = pull_uint_var(buf)
<7> else:
<8> offset = 0
<9> if flags & QuicStreamFlag.LEN:
<10> length = pull_uint_var(buf)
<11> else:
<12> length = buf.capacity - buf.tell()
<13> frame = QuicStreamFrame(
<14> offset=offset,
<15> data=pull_bytes(buf, length),
<16> fin=bool(flags & QuicStreamFlag.FIN),
<17> )
<18>
<19> # check stream direction
<20> self._assert_stream_can_receive(frame_type, stream_id)
<21>
<22> stream = self._get_or_create_stream(stream_id)
<23> stream.add_frame(frame)
<24>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_uint16(buf: Buffer) -> int
at: aioquic.connection.QuicConnection
_assert_stream_can_receive(frame_type: int, stream_id: int) -> None
_get_or_create_stream(frame_type: int, stream_id: int) -> QuicStream
_get_or_create_stream(self, frame_type: int, stream_id: int) -> QuicStream
at: aioquic.connection.QuicConnection._handle_reset_stream_frame
stream_id = pull_uint_var(buf)
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
+ def _get_or_create_stream(self, frame_type: int, stream_id: int) -> QuicStream:
- def _get_or_create_stream(self, 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",
+ )
+
+ # check max streams
+ if stream_is_unidirectional(stream_id):
+ max_streams = self.__local_max_streams_uni
+ else:
+ max_streams = self.__local_max_streams_bidi
+ 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
+ stream = self.streams[stream_id] = QuicStream(
+ connection=self, stream_id=stream_id
- if stream_id not in self.streams:
- self.streams[stream_id] = QuicStream(connection=self, stream_id=stream_id)
- self.stream_created_cb(
- self.streams[stream_id].reader, self.streams[stream_id].writer
)
+ self.stream_created_cb(stream.reader, stream.writer)
+ return stream
- return self.streams[stream_id]
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def _handle_stop_sending_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STOP_SENDING frame.
"""
stream_id = pull_uint_var(buf)
pull_uint16(buf) # application error code
# check stream direction
self._assert_stream_can_send(frame_type, stream_id)
+ self._get_or_create_stream(frame_type, stream_id)
- self._get_or_create_stream(stream_id)
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def _handle_reset_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RESET_STREAM frame.
"""
stream_id = pull_uint_var(buf)
pull_uint16(buf) # application error code
pull_uint16(buf) # unused
pull_uint_var(buf) # final size
# check stream direction
self._assert_stream_can_receive(frame_type, stream_id)
+ self._get_or_create_stream(frame_type, stream_id)
- self._get_or_create_stream(stream_id)
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
def _handle_max_stream_data_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAM_DATA frame.
This adjusts the amount of data we can send on a specific stream.
"""
stream_id = pull_uint_var(buf)
pull_uint_var(buf) # limit
# check stream direction
self._assert_stream_can_send(frame_type, stream_id)
+ self._get_or_create_stream(frame_type, stream_id)
- self._get_or_create_stream(stream_id)
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection:
def create_stream(
self, is_unidirectional: bool = False
) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]:
"""
Create a QUIC stream and return a pair of (reader, writer) objects.
The returned reader and writer objects are instances of :class:`asyncio.StreamReader`
and :class:`asyncio.StreamWriter` classes.
"""
stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
while stream_id in self.streams:
stream_id += 4
+
+ # create stream
+ stream = self.streams[stream_id] = QuicStream(
+ connection=self, stream_id=stream_id
+ )
+ self.stream_created_cb(stream.reader, stream.writer)
+
- stream = self._get_or_create_stream(stream_id)
return stream.reader, stream.writer
|
aioquic.connection/QuicConnection._handle_stream_data_blocked_frame
|
Modified
|
aiortc~aioquic
|
8f5fd4d08058c6983abc4ac0faa0bb79f09f8b34
|
[connection] check peer respects max streams
|
<9>:<add> self._get_or_create_stream(frame_type, stream_id)
<del> self._get_or_create_stream(stream_id)
|
# module: aioquic.connection
class QuicConnection:
def _handle_stream_data_blocked_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a STREAM_DATA_BLOCKED frame.
<2> """
<3> stream_id = pull_uint_var(buf)
<4> pull_uint_var(buf) # limit
<5>
<6> # check stream direction
<7> self._assert_stream_can_receive(frame_type, stream_id)
<8>
<9> self._get_or_create_stream(stream_id)
<10>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
STREAM_FLAGS = 0x07
at: aioquic.connection.QuicConnection
_get_or_create_stream(frame_type: int, stream_id: int) -> QuicStream
_get_or_create_stream(self, frame_type: int, stream_id: int) -> QuicStream
at: aioquic.connection.QuicConnection._handle_stop_sending_frame
stream_id = pull_uint_var(buf)
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
+ def _get_or_create_stream(self, frame_type: int, stream_id: int) -> QuicStream:
- def _get_or_create_stream(self, 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",
+ )
+
+ # check max streams
+ if stream_is_unidirectional(stream_id):
+ max_streams = self.__local_max_streams_uni
+ else:
+ max_streams = self.__local_max_streams_bidi
+ 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
+ stream = self.streams[stream_id] = QuicStream(
+ connection=self, stream_id=stream_id
- if stream_id not in self.streams:
- self.streams[stream_id] = QuicStream(connection=self, stream_id=stream_id)
- self.stream_created_cb(
- self.streams[stream_id].reader, self.streams[stream_id].writer
)
+ self.stream_created_cb(stream.reader, stream.writer)
+ return stream
- return self.streams[stream_id]
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def _handle_stop_sending_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STOP_SENDING frame.
"""
stream_id = pull_uint_var(buf)
pull_uint16(buf) # application error code
# check stream direction
self._assert_stream_can_send(frame_type, stream_id)
+ self._get_or_create_stream(frame_type, stream_id)
- self._get_or_create_stream(stream_id)
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def _handle_reset_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RESET_STREAM frame.
"""
stream_id = pull_uint_var(buf)
pull_uint16(buf) # application error code
pull_uint16(buf) # unused
pull_uint_var(buf) # final size
# check stream direction
self._assert_stream_can_receive(frame_type, stream_id)
+ self._get_or_create_stream(frame_type, stream_id)
- self._get_or_create_stream(stream_id)
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
def _handle_stream_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STREAM frame.
"""
flags = frame_type & STREAM_FLAGS
stream_id = pull_uint_var(buf)
if flags & QuicStreamFlag.OFF:
offset = pull_uint_var(buf)
else:
offset = 0
if flags & QuicStreamFlag.LEN:
length = pull_uint_var(buf)
else:
length = buf.capacity - buf.tell()
frame = QuicStreamFrame(
offset=offset,
data=pull_bytes(buf, length),
fin=bool(flags & QuicStreamFlag.FIN),
)
# check stream direction
self._assert_stream_can_receive(frame_type, stream_id)
+ stream = self._get_or_create_stream(frame_type, stream_id)
- stream = self._get_or_create_stream(stream_id)
stream.add_frame(frame)
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection:
def _handle_max_stream_data_frame(
self, epoch: tls.Epoch, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAM_DATA frame.
This adjusts the amount of data we can send on a specific stream.
"""
stream_id = pull_uint_var(buf)
pull_uint_var(buf) # limit
# check stream direction
self._assert_stream_can_send(frame_type, stream_id)
+ self._get_or_create_stream(frame_type, stream_id)
- self._get_or_create_stream(stream_id)
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection:
def create_stream(
self, is_unidirectional: bool = False
) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]:
"""
Create a QUIC stream and return a pair of (reader, writer) objects.
The returned reader and writer objects are instances of :class:`asyncio.StreamReader`
and :class:`asyncio.StreamWriter` classes.
"""
stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
while stream_id in self.streams:
stream_id += 4
+
+ # create stream
+ stream = self.streams[stream_id] = QuicStream(
+ connection=self, stream_id=stream_id
+ )
+ self.stream_created_cb(stream.reader, stream.writer)
+
- stream = self._get_or_create_stream(stream_id)
return stream.reader, stream.writer
|
aioquic.packet/pull_quic_header
|
Modified
|
aiortc~aioquic
|
adba3d0b1f9547be1be368758f1749f3d0326072
|
[packet] remove useless if condition
|
<20>:<add> if not (first_byte & PACKET_FIXED_BIT):
<del> if version and not (first_byte & PACKET_FIXED_BIT):
|
# module: aioquic.packet
def pull_quic_header(buf: Buffer, host_cid_length: Optional[int] = None) -> QuicHeader:
<0> first_byte = pull_uint8(buf)
<1>
<2> original_destination_cid = b""
<3> token = b""
<4> if is_long_header(first_byte):
<5> # long header packet
<6> version = pull_uint32(buf)
<7> cid_lengths = pull_uint8(buf)
<8>
<9> destination_cid_length = decode_cid_length(cid_lengths // 16)
<10> destination_cid = pull_bytes(buf, destination_cid_length)
<11>
<12> source_cid_length = decode_cid_length(cid_lengths % 16)
<13> source_cid = pull_bytes(buf, source_cid_length)
<14>
<15> if version == QuicProtocolVersion.NEGOTIATION:
<16> # version negotiation
<17> packet_type = None
<18> rest_length = buf.capacity - buf.tell()
<19> else:
<20> if version and not (first_byte & PACKET_FIXED_BIT):
<21> raise ValueError("Packet fixed bit is zero")
<22>
<23> packet_type = first_byte & PACKET_TYPE_MASK
<24> if packet_type == PACKET_TYPE_INITIAL:
<25> token_length = pull_uint_var(buf)
<26> token = pull_bytes(buf, token_length)
<27> rest_length = pull_uint_var(buf)
<28> elif packet_type == PACKET_TYPE_RETRY:
<29> original_destination_cid_length = decode_cid_length(first_byte & 0xF)
<30> original_destination_cid = pull_bytes(
<31> buf, original_destination_cid_length
<32> )
<33> token = pull_bytes(buf, buf.capacity - buf.tell())
<34> rest_length = 0
<35> else:
<36> rest_length = pull_uint_var(buf)
<37>
<38> return QuicHeader(
<39> version=version,
<40> packet_type=packet_type</s>
|
===========below chunk 0===========
# module: aioquic.packet
def pull_quic_header(buf: Buffer, host_cid_length: Optional[int] = None) -> QuicHeader:
# offset: 1
destination_cid=destination_cid,
source_cid=source_cid,
original_destination_cid=original_destination_cid,
token=token,
rest_length=rest_length,
)
else:
# short header packet
if not (first_byte & PACKET_FIXED_BIT):
raise ValueError("Packet fixed bit is zero")
packet_type = first_byte & PACKET_TYPE_MASK
destination_cid = pull_bytes(buf, host_cid_length)
return QuicHeader(
version=None,
packet_type=packet_type,
destination_cid=destination_cid,
source_cid=b"",
token=b"",
rest_length=buf.capacity - buf.tell(),
)
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
pull_uint8(buf: Buffer) -> int
pull_uint32(buf: Buffer) -> int
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.packet
PACKET_FIXED_BIT = 0x40
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30
PACKET_TYPE_MASK = 0xF0
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicHeader(version: Optional[int], packet_type: int, destination_cid: bytes, source_cid: bytes, original_destination_cid: bytes=b"", token: bytes=b"", rest_length: int=0)
decode_cid_length(length: int) -> int
is_long_header(first_byte: int) -> bool
pull_uint_var(buf: Buffer) -> int
at: aioquic.packet.QuicHeader
version: Optional[int]
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
|
aioquic.crypto/CryptoContext.__init__
|
Modified
|
aiortc~aioquic
|
33b15e6b4b9805e668faed7d90b0693ff7f63fcd
|
[crypto] implement key update
|
<0>:<add> self.aead: Optional[Any]
<3>:<add> self.key_phase = key_phase
<add> self.secret: Optional[bytes]
|
# module: aioquic.crypto
class CryptoContext:
+ def __init__(self, key_phase: int = 0) -> None:
- def __init__(self) -> None:
<0> self.cipher_suite: Optional[CipherSuite]
<1> self.hp: Optional[bytes]
<2> self.iv: Optional[bytes]
<3>
<4> self.teardown()
<5>
|
===========unchanged ref 0===========
at: aioquic.crypto.CryptoContext.apply_key_phase
self.aead = crypto.aead
at: aioquic.crypto.CryptoContext.setup
key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret)
self.aead = cipher_suite_aead(cipher_suite, key)
self.cipher_suite = cipher_suite
at: aioquic.crypto.CryptoContext.teardown
self.aead = None
self.cipher_suite = None
self.hp = None
at: aioquic.tls
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
|
aioquic.crypto/CryptoContext.decrypt_packet
|
Modified
|
aiortc~aioquic
|
33b15e6b4b9805e668faed7d90b0693ff7f63fcd
|
[crypto] implement key update
|
<20>:<add> # detect key phase change
<add> crypto = self
<add> if not is_long_header(packet[0]):
<add> key_phase = (packet[0] & 4) >> 2
<add> if key_phase != self.key_phase:
<add> crypto = self.next_key_phase()
<add>
<21>:<add> nonce = bytearray(len(crypto.iv) - pn_length) + bytearray(pn)
<del> nonce = bytearray(len(self.iv) - pn_length) + bytearray(pn)
<22>:<add> for i in range(len(crypto.iv)):
<del> for i in range(len(self.iv)):
<23>:<add> nonce[i] ^= crypto.iv[i]
<del> nonce[i] ^= self.iv[i]
<25>:<add> payload = crypto.aead.decrypt(
<del> payload = self.aead.decrypt(
<36>:<add> return plain_header, payload, packet_number, crypto != self
<del> return plain_header, payload, packet_number
|
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int
+ ) -> Tuple[bytes, bytes, int, bool]:
- ) -> Tuple[bytes, bytes, int]:
<0> packet = bytearray(packet)
<1>
<2> # header protection
<3> sample_offset = encrypted_offset + MAX_PN_SIZE
<4> sample = packet[sample_offset : sample_offset + SAMPLE_SIZE]
<5> mask = self.header_protection_mask(sample)
<6>
<7> if is_long_header(packet[0]):
<8> # long header
<9> packet[0] ^= mask[0] & 0x0F
<10> else:
<11> # short header
<12> packet[0] ^= mask[0] & 0x1F
<13>
<14> pn_length = (packet[0] & 0x03) + 1
<15> for i in range(pn_length):
<16> packet[encrypted_offset + i] ^= mask[1 + i]
<17> pn = packet[encrypted_offset : encrypted_offset + pn_length]
<18> plain_header = bytes(packet[: encrypted_offset + pn_length])
<19>
<20> # payload protection
<21> nonce = bytearray(len(self.iv) - pn_length) + bytearray(pn)
<22> for i in range(len(self.iv)):
<23> nonce[i] ^= self.iv[i]
<24> try:
<25> payload = self.aead.decrypt(
<26> nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header
<27> )
<28> except InvalidTag:
<29> raise CryptoError("Payload decryption failed")
<30>
<31> # packet number
<32> packet_number = 0
<33> for i in range(pn_length):
<34> packet_number = (packet_number << 8) | pn[i]
<35>
<36> return plain_header, payload, packet_number
<37>
|
===========unchanged ref 0===========
at: aioquic.crypto
MAX_PN_SIZE = 4
SAMPLE_SIZE = 16
CryptoContext(key_phase: int=0)
at: aioquic.crypto.CryptoContext
header_protection_mask(sample: bytes) -> bytes
next_key_phase() -> CryptoContext
teardown() -> None
at: aioquic.crypto.CryptoContext.__init__
self.aead: Optional[Any]
self.iv: Optional[bytes]
at: aioquic.crypto.CryptoContext.setup
key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret)
self.aead = cipher_suite_aead(cipher_suite, key)
self.secret = secret
at: aioquic.crypto.CryptoContext.teardown
self.aead = None
self.iv = None
self.secret = None
at: aioquic.packet
is_long_header(first_byte: int) -> bool
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
===========changed ref 0===========
# module: aioquic.crypto
class CryptoContext:
+ def __init__(self, key_phase: int = 0) -> None:
- def __init__(self) -> None:
+ self.aead: Optional[Any]
self.cipher_suite: Optional[CipherSuite]
self.hp: Optional[bytes]
self.iv: Optional[bytes]
+ self.key_phase = key_phase
+ self.secret: Optional[bytes]
self.teardown()
|
aioquic.crypto/CryptoContext.setup
|
Modified
|
aiortc~aioquic
|
33b15e6b4b9805e668faed7d90b0693ff7f63fcd
|
[crypto] implement key update
|
<8>:<add> self.secret = secret
|
# module: aioquic.crypto
class CryptoContext:
def setup(self, cipher_suite: CipherSuite, secret: bytes) -> None:
<0> assert cipher_suite in [
<1> CipherSuite.AES_128_GCM_SHA256,
<2> CipherSuite.AES_256_GCM_SHA384,
<3> CipherSuite.CHACHA20_POLY1305_SHA256,
<4> ], "unsupported cipher suite"
<5> key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret)
<6> self.aead = cipher_suite_aead(cipher_suite, key)
<7> self.cipher_suite = cipher_suite
<8>
|
===========unchanged ref 0===========
at: aioquic.crypto.CryptoContext.__init__
self.hp: Optional[bytes]
at: aioquic.crypto.CryptoContext.setup
key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret)
at: aioquic.crypto.CryptoContext.teardown
self.hp = None
===========changed ref 0===========
# module: aioquic.crypto
class CryptoContext:
+ def apply_key_phase(self, crypto: CryptoContext) -> None:
+ self.aead = crypto.aead
+ self.iv = crypto.iv
+ self.key_phase = crypto.key_phase
+ self.secret = crypto.secret
+
===========changed ref 1===========
# module: aioquic.crypto
class CryptoContext:
+ def __init__(self, key_phase: int = 0) -> None:
- def __init__(self) -> None:
+ self.aead: Optional[Any]
self.cipher_suite: Optional[CipherSuite]
self.hp: Optional[bytes]
self.iv: Optional[bytes]
+ self.key_phase = key_phase
+ self.secret: Optional[bytes]
self.teardown()
===========changed ref 2===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int
+ ) -> Tuple[bytes, bytes, int, bool]:
- ) -> Tuple[bytes, bytes, int]:
packet = bytearray(packet)
# header protection
sample_offset = encrypted_offset + MAX_PN_SIZE
sample = packet[sample_offset : sample_offset + SAMPLE_SIZE]
mask = self.header_protection_mask(sample)
if is_long_header(packet[0]):
# long header
packet[0] ^= mask[0] & 0x0F
else:
# short header
packet[0] ^= mask[0] & 0x1F
pn_length = (packet[0] & 0x03) + 1
for i in range(pn_length):
packet[encrypted_offset + i] ^= mask[1 + i]
pn = packet[encrypted_offset : encrypted_offset + pn_length]
plain_header = bytes(packet[: encrypted_offset + pn_length])
+ # detect key phase change
+ crypto = self
+ if not is_long_header(packet[0]):
+ key_phase = (packet[0] & 4) >> 2
+ if key_phase != self.key_phase:
+ crypto = self.next_key_phase()
+
# payload protection
+ nonce = bytearray(len(crypto.iv) - pn_length) + bytearray(pn)
- nonce = bytearray(len(self.iv) - pn_length) + bytearray(pn)
+ for i in range(len(crypto.iv)):
- for i in range(len(self.iv)):
+ nonce[i] ^= crypto.iv[i]
- nonce[i] ^= self.iv[i]
try:
+ payload = crypto.aead.decrypt(
- payload = self.aead.decrypt(
nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header
)
except InvalidTag</s>
===========changed ref 3===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int
+ ) -> Tuple[bytes, bytes, int, bool]:
- ) -> Tuple[bytes, bytes, int]:
# offset: 1
<s>(
nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header
)
except InvalidTag:
raise CryptoError("Payload decryption failed")
# packet number
packet_number = 0
for i in range(pn_length):
packet_number = (packet_number << 8) | pn[i]
+ return plain_header, payload, packet_number, crypto != self
- return plain_header, payload, packet_number
|
aioquic.crypto/CryptoContext.teardown
|
Modified
|
aiortc~aioquic
|
33b15e6b4b9805e668faed7d90b0693ff7f63fcd
|
[crypto] implement key update
|
<4>:<add> self.secret = None
|
# module: aioquic.crypto
class CryptoContext:
def teardown(self) -> None:
<0> self.aead = None
<1> self.cipher_suite = None
<2> self.hp = None
<3> self.iv = None
<4>
|
===========unchanged ref 0===========
at: aioquic.crypto.CryptoContext.header_protection_mask
encryptor = Cipher(
algorithms.ChaCha20(key=self.hp, nonce=sample),
mode=None,
backend=default_backend(),
).encryptor()
encryptor = Cipher(
algorithms.AES(self.hp), mode=modes.ECB(), backend=default_backend()
).encryptor()
===========changed ref 0===========
# module: aioquic.crypto
class CryptoContext:
def setup(self, cipher_suite: CipherSuite, secret: bytes) -> None:
assert cipher_suite in [
CipherSuite.AES_128_GCM_SHA256,
CipherSuite.AES_256_GCM_SHA384,
CipherSuite.CHACHA20_POLY1305_SHA256,
], "unsupported cipher suite"
key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret)
self.aead = cipher_suite_aead(cipher_suite, key)
self.cipher_suite = cipher_suite
+ self.secret = secret
===========changed ref 1===========
# module: aioquic.crypto
class CryptoContext:
+ def apply_key_phase(self, crypto: CryptoContext) -> None:
+ self.aead = crypto.aead
+ self.iv = crypto.iv
+ self.key_phase = crypto.key_phase
+ self.secret = crypto.secret
+
===========changed ref 2===========
# module: aioquic.crypto
class CryptoContext:
+ def __init__(self, key_phase: int = 0) -> None:
- def __init__(self) -> None:
+ self.aead: Optional[Any]
self.cipher_suite: Optional[CipherSuite]
self.hp: Optional[bytes]
self.iv: Optional[bytes]
+ self.key_phase = key_phase
+ self.secret: Optional[bytes]
self.teardown()
===========changed ref 3===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int
+ ) -> Tuple[bytes, bytes, int, bool]:
- ) -> Tuple[bytes, bytes, int]:
packet = bytearray(packet)
# header protection
sample_offset = encrypted_offset + MAX_PN_SIZE
sample = packet[sample_offset : sample_offset + SAMPLE_SIZE]
mask = self.header_protection_mask(sample)
if is_long_header(packet[0]):
# long header
packet[0] ^= mask[0] & 0x0F
else:
# short header
packet[0] ^= mask[0] & 0x1F
pn_length = (packet[0] & 0x03) + 1
for i in range(pn_length):
packet[encrypted_offset + i] ^= mask[1 + i]
pn = packet[encrypted_offset : encrypted_offset + pn_length]
plain_header = bytes(packet[: encrypted_offset + pn_length])
+ # detect key phase change
+ crypto = self
+ if not is_long_header(packet[0]):
+ key_phase = (packet[0] & 4) >> 2
+ if key_phase != self.key_phase:
+ crypto = self.next_key_phase()
+
# payload protection
+ nonce = bytearray(len(crypto.iv) - pn_length) + bytearray(pn)
- nonce = bytearray(len(self.iv) - pn_length) + bytearray(pn)
+ for i in range(len(crypto.iv)):
- for i in range(len(self.iv)):
+ nonce[i] ^= crypto.iv[i]
- nonce[i] ^= self.iv[i]
try:
+ payload = crypto.aead.decrypt(
- payload = self.aead.decrypt(
nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header
)
except InvalidTag</s>
===========changed ref 4===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int
+ ) -> Tuple[bytes, bytes, int, bool]:
- ) -> Tuple[bytes, bytes, int]:
# offset: 1
<s>(
nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header
)
except InvalidTag:
raise CryptoError("Payload decryption failed")
# packet number
packet_number = 0
for i in range(pn_length):
packet_number = (packet_number << 8) | pn[i]
+ return plain_header, payload, packet_number, crypto != self
- return plain_header, payload, packet_number
|
aioquic.crypto/CryptoPair.decrypt_packet
|
Modified
|
aiortc~aioquic
|
33b15e6b4b9805e668faed7d90b0693ff7f63fcd
|
[crypto] implement key update
|
<0>:<add> plain_header, payload, packet_number, update_key = self.recv.decrypt_packet(
<add> packet, encrypted_offset
<add> )
<add> if update_key:
<add> self.update_key()
<add> return plain_header, payload, packet_number
<del> return self.recv.decrypt_packet(packet, encrypted_offset)
|
# module: aioquic.crypto
class CryptoPair:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int]:
<0> return self.recv.decrypt_packet(packet, encrypted_offset)
<1>
|
===========unchanged ref 0===========
at: aioquic.crypto.CryptoContext.next_key_phase
crypto = CryptoContext(key_phase=int(not self.key_phase))
at: aioquic.tls
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
===========changed ref 0===========
# module: aioquic.crypto
class CryptoContext:
def teardown(self) -> None:
self.aead = None
self.cipher_suite = None
self.hp = None
self.iv = None
+ self.secret = None
===========changed ref 1===========
# module: aioquic.crypto
class CryptoContext:
+ def next_key_phase(self) -> CryptoContext:
+ algorithm = cipher_suite_hash(self.cipher_suite)
+
+ crypto = CryptoContext(key_phase=int(not self.key_phase))
+ crypto.setup(
+ self.cipher_suite,
+ hkdf_expand_label(
+ algorithm, self.secret, b"traffic upd", b"", algorithm.digest_size
+ ),
+ )
+ return crypto
+
===========changed ref 2===========
# module: aioquic.crypto
class CryptoContext:
def setup(self, cipher_suite: CipherSuite, secret: bytes) -> None:
assert cipher_suite in [
CipherSuite.AES_128_GCM_SHA256,
CipherSuite.AES_256_GCM_SHA384,
CipherSuite.CHACHA20_POLY1305_SHA256,
], "unsupported cipher suite"
key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret)
self.aead = cipher_suite_aead(cipher_suite, key)
self.cipher_suite = cipher_suite
+ self.secret = secret
===========changed ref 3===========
# module: aioquic.crypto
class CryptoContext:
+ def apply_key_phase(self, crypto: CryptoContext) -> None:
+ self.aead = crypto.aead
+ self.iv = crypto.iv
+ self.key_phase = crypto.key_phase
+ self.secret = crypto.secret
+
===========changed ref 4===========
# module: aioquic.crypto
class CryptoContext:
+ def __init__(self, key_phase: int = 0) -> None:
- def __init__(self) -> None:
+ self.aead: Optional[Any]
self.cipher_suite: Optional[CipherSuite]
self.hp: Optional[bytes]
self.iv: Optional[bytes]
+ self.key_phase = key_phase
+ self.secret: Optional[bytes]
self.teardown()
===========changed ref 5===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int
+ ) -> Tuple[bytes, bytes, int, bool]:
- ) -> Tuple[bytes, bytes, int]:
packet = bytearray(packet)
# header protection
sample_offset = encrypted_offset + MAX_PN_SIZE
sample = packet[sample_offset : sample_offset + SAMPLE_SIZE]
mask = self.header_protection_mask(sample)
if is_long_header(packet[0]):
# long header
packet[0] ^= mask[0] & 0x0F
else:
# short header
packet[0] ^= mask[0] & 0x1F
pn_length = (packet[0] & 0x03) + 1
for i in range(pn_length):
packet[encrypted_offset + i] ^= mask[1 + i]
pn = packet[encrypted_offset : encrypted_offset + pn_length]
plain_header = bytes(packet[: encrypted_offset + pn_length])
+ # detect key phase change
+ crypto = self
+ if not is_long_header(packet[0]):
+ key_phase = (packet[0] & 4) >> 2
+ if key_phase != self.key_phase:
+ crypto = self.next_key_phase()
+
# payload protection
+ nonce = bytearray(len(crypto.iv) - pn_length) + bytearray(pn)
- nonce = bytearray(len(self.iv) - pn_length) + bytearray(pn)
+ for i in range(len(crypto.iv)):
- for i in range(len(self.iv)):
+ nonce[i] ^= crypto.iv[i]
- nonce[i] ^= self.iv[i]
try:
+ payload = crypto.aead.decrypt(
- payload = self.aead.decrypt(
nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header
)
except InvalidTag</s>
===========changed ref 6===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int
+ ) -> Tuple[bytes, bytes, int, bool]:
- ) -> Tuple[bytes, bytes, int]:
# offset: 1
<s>(
nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header
)
except InvalidTag:
raise CryptoError("Payload decryption failed")
# packet number
packet_number = 0
for i in range(pn_length):
packet_number = (packet_number << 8) | pn[i]
+ return plain_header, payload, packet_number, crypto != self
- return plain_header, payload, packet_number
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
33b15e6b4b9805e668faed7d90b0693ff7f63fcd
|
[crypto] implement key update
|
<9>:<add> push_uint8(
<add> buf,
<add> PACKET_FIXED_BIT | (space.crypto.key_phase << 2) | (SEND_PN_SIZE - 1),
<add> )
<del> push_uint8(buf, PACKET_FIXED_BIT | (SEND_PN_SIZE - 1))
|
# module: aioquic.connection
class QuicConnection:
def _write_application(self) -> Iterator[bytes]:
<0> epoch = tls.Epoch.ONE_RTT
<1> space = self.spaces[epoch]
<2> if not space.crypto.send.is_valid():
<3> return
<4>
<5> buf = Buffer(capacity=PACKET_MAX_SIZE)
<6>
<7> while True:
<8> # write header
<9> push_uint8(buf, PACKET_FIXED_BIT | (SEND_PN_SIZE - 1))
<10> push_bytes(buf, self.peer_cid)
<11> push_uint16(buf, self.packet_number)
<12> header_size = buf.tell()
<13>
<14> # ACK
<15> if self.send_ack[epoch] and space.ack_queue:
<16> push_uint_var(buf, QuicFrameType.ACK)
<17> packet.push_ack_frame(buf, space.ack_queue, 0)
<18> self.send_ack[epoch] = False
<19>
<20> # FLOW CONTROL
<21> for control_frame in self._pending_flow_control:
<22> push_bytes(buf, control_frame)
<23> self._pending_flow_control = []
<24>
<25> # CLOSE
<26> if self.__close and self.__epoch == epoch:
<27> push_close(buf, **self.__close)
<28> self.__close = None
<29>
<30> # STREAM
<31> for stream_id, stream in self.streams.items():
<32> if isinstance(stream_id, int) and stream.has_data_to_send():
<33> frame = stream.get_frame(
<34> PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6
<35> )
<36> flags = QuicStreamFlag.LEN
<37> if frame.offset:
<38> flags |= QuicStreamFlag.OFF
<39> if frame.fin:
<40> flags |= QuicStreamFlag.FIN
<41> push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)
<42> with push_stream</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _write_application(self) -> Iterator[bytes]:
# offset: 1
push_bytes(buf, frame.data)
packet_size = buf.tell()
if packet_size > header_size:
# encrypt
data = buf.data
yield space.crypto.encrypt_packet(
data[0:header_size], data[header_size:packet_size]
)
self.packet_number += 1
buf.seek(0)
else:
break
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
push_bytes(buf: Buffer, v: bytes) -> None
push_uint8(buf: Buffer, v: int) -> None
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.connection
PACKET_MAX_SIZE = 1280
SEND_PN_SIZE = 2
push_close(buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None
at: aioquic.connection.PacketSpace.__init__
self.ack_queue = RangeSet()
self.crypto = CryptoPair()
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
at: aioquic.connection.QuicConnection.__init__
self.peer_cid = os.urandom(8)
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__close: Optional[Dict] = None
self.__epoch = tls.Epoch.INITIAL
self._pending_flow_control: List[bytes] = []
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._initialize
self.send_ack = {
tls.Epoch.INITIAL: False,
tls.Epoch.HANDSHAKE: False,
tls.Epoch.ONE_RTT: False,
}
===========unchanged ref 1===========
self.spaces = {
tls.Epoch.INITIAL: PacketSpace(),
tls.Epoch.HANDSHAKE: PacketSpace(),
tls.Epoch.ONE_RTT: PacketSpace(),
}
self.packet_number = 0
at: aioquic.connection.QuicConnection._write_handshake
self.__close = None
self.packet_number += 1
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.datagram_received
self.peer_cid = header.source_cid
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair
encrypt_packet(plain_header: bytes, plain_payload: bytes) -> bytes
at: aioquic.crypto.CryptoPair.__init__
self.aead_tag_size = 16
self.send = CryptoContext()
at: aioquic.packet
PACKET_FIXED_BIT = 0x40
push_uint_var(buf: Buffer, value: int) -> None
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
push_ack_frame(buf: Buffer, rangeset: RangeSet, delay: int) -> None
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
push_stream_frame(buf: Buffer, stream_id: int, offset: int) -> Generator
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
===========unchanged ref 2===========
at: aioquic.stream.QuicStream
get_frame(size: int) -> QuicStreamFrame
has_data_to_send() -> bool
at: aioquic.tls
Epoch()
at: typing
Iterator = _alias(collections.abc.Iterator, 1)
===========changed ref 0===========
# module: aioquic.crypto
class CryptoPair:
+ @property
+ def key_phase(self) -> int:
+ return self.recv.key_phase
+
===========changed ref 1===========
# module: aioquic.crypto
class CryptoContext:
def teardown(self) -> None:
self.aead = None
self.cipher_suite = None
self.hp = None
self.iv = None
+ self.secret = None
===========changed ref 2===========
# module: aioquic.crypto
class CryptoContext:
+ def apply_key_phase(self, crypto: CryptoContext) -> None:
+ self.aead = crypto.aead
+ self.iv = crypto.iv
+ self.key_phase = crypto.key_phase
+ self.secret = crypto.secret
+
===========changed ref 3===========
# module: aioquic.crypto
class CryptoPair:
+ def update_key(self) -> None:
+ self.recv.apply_key_phase(self.recv.next_key_phase())
+ self.send.apply_key_phase(self.send.next_key_phase())
+
===========changed ref 4===========
# module: aioquic.crypto
class CryptoContext:
+ def __init__(self, key_phase: int = 0) -> None:
- def __init__(self) -> None:
+ self.aead: Optional[Any]
self.cipher_suite: Optional[CipherSuite]
self.hp: Optional[bytes]
self.iv: Optional[bytes]
+ self.key_phase = key_phase
+ self.secret: Optional[bytes]
self.teardown()
===========changed ref 5===========
# module: aioquic.crypto
class CryptoPair:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int]:
+ plain_header, payload, packet_number, update_key = self.recv.decrypt_packet(
+ packet, encrypted_offset
+ )
+ if update_key:
+ self.update_key()
+ return plain_header, payload, packet_number
- return self.recv.decrypt_packet(packet, encrypted_offset)
===========changed ref 6===========
# module: aioquic.crypto
class CryptoContext:
+ def next_key_phase(self) -> CryptoContext:
+ algorithm = cipher_suite_hash(self.cipher_suite)
+
+ crypto = CryptoContext(key_phase=int(not self.key_phase))
+ crypto.setup(
+ self.cipher_suite,
+ hkdf_expand_label(
+ algorithm, self.secret, b"traffic upd", b"", algorithm.digest_size
+ ),
+ )
+ return crypto
+
|
examples.server/run
|
Modified
|
aiortc~aioquic
|
05d00c7d3b2c291845cff7baea0653c45fe12dd1
|
[docs] add some information to README.rst
|
<9>:<add> logger.info("Listening on %s port %s" % (host, port))
|
# module: examples.server
def run(host, port, **kwargs):
<0> # if host is not an IP address, pass it to enable SNI
<1> try:
<2> ipaddress.ip_address(host)
<3> except ValueError:
<4> kwargs["server_name"] = host
<5>
<6> _, protocol = await loop.create_datagram_endpoint(
<7> lambda: QuicServerProtocol(**kwargs), local_addr=(host, port)
<8> )
<9> return protocol
<10>
|
===========unchanged ref 0===========
at: asyncio.events.AbstractEventLoop
create_datagram_endpoint(protocol_factory: _ProtocolFactory, local_addr: Optional[Tuple[str, int]]=..., remote_addr: Optional[Tuple[str, int]]=..., *, family: int=..., proto: int=..., flags: int=..., reuse_address: Optional[bool]=..., reuse_port: Optional[bool]=..., allow_broadcast: Optional[bool]=..., sock: Optional[socket]=...) -> _TransProtPair
at: examples.server
logger = logging.getLogger("server")
QuicServerProtocol(**kwargs)
loop = asyncio.get_event_loop()
at: ipaddress
ip_address(address: object) -> Any
at: logging.Logger
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
|
aioquic.packet/push_quic_transport_parameters
|
Modified
|
aiortc~aioquic
|
7b9aadbb4527c6f0ff18c07d978c5273e1989f3b
|
[packet] correctly serialize 0 values in transport parameters
|
<10>:<add> if param_value is not None and param_value is not False:
<del> if param_value not in [None, False]:
|
# module: aioquic.packet
def push_quic_transport_parameters(
buf: Buffer, params: QuicTransportParameters, is_client: Optional[bool] = None
) -> None:
<0> # version < DRAFT_19
<1> if is_client:
<2> push_protocol_version(buf, params.initial_version)
<3> elif is_client is False:
<4> push_protocol_version(buf, params.negotiated_version)
<5> push_list(buf, 1, push_protocol_version, params.supported_versions)
<6>
<7> with push_block(buf, 2):
<8> for param_id, (param_name, param_type) in enumerate(PARAMS):
<9> param_value = getattr(params, param_name)
<10> if param_value not in [None, False]:
<11> push_uint16(buf, param_id)
<12> with push_block(buf, 2):
<13> if param_type == int:
<14> push_uint_var(buf, param_value)
<15> elif param_type == bytes:
<16> push_bytes(buf, param_value)
<17>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
push_bytes(buf: Buffer, v: bytes) -> None
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.packet
push_protocol_version = push_uint32
push_uint_var(buf: Buffer, value: int) -> None
QuicTransportParameters(initial_version: Optional[QuicProtocolVersion]=None, negotiated_version: Optional[QuicProtocolVersion]=None, supported_versions: List[QuicProtocolVersion]=field(default_factory=list), 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_migration: Optional[bool]=False, preferred_address: Optional[bytes]=None)
===========unchanged ref 1===========
PARAMS = [
("original_connection_id", bytes),
("idle_timeout", int),
("stateless_reset_token", bytes),
("max_packet_size", int),
("initial_max_data", int),
("initial_max_stream_data_bidi_local", int),
("initial_max_stream_data_bidi_remote", int),
("initial_max_stream_data_uni", int),
("initial_max_streams_bidi", int),
("initial_max_streams_uni", int),
("ack_delay_exponent", int),
("max_ack_delay", int),
("disable_migration", bool),
("preferred_address", bytes),
]
at: aioquic.packet.QuicTransportParameters
initial_version: Optional[QuicProtocolVersion] = None
negotiated_version: Optional[QuicProtocolVersion] = None
supported_versions: List[QuicProtocolVersion] = field(default_factory=list)
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_migration: Optional[bool] = False
preferred_address: Optional[bytes] = None
at: aioquic.tls
push_block(buf: Buffer, capacity: int) -> Generator
===========unchanged ref 2===========
push_list(buf: Buffer, capacity: int, func: Callable[[Buffer, T], None], values: Sequence[T]) -> None
|
aioquic.crypto/CryptoContext.decrypt_packet
|
Modified
|
aiortc~aioquic
|
8a679a56cf450571c1e816fc45ea4cb6488ea762
|
[crypto] assert encryption key is available
|
<0>:<add> assert self.is_valid(), 'Decryption key is not available'
<del> packet = bytearray(packet)
<3>:<add> packet = bytearray(packet)
|
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int, bool]:
<0> packet = bytearray(packet)
<1>
<2> # header protection
<3> sample_offset = encrypted_offset + MAX_PN_SIZE
<4> sample = packet[sample_offset : sample_offset + SAMPLE_SIZE]
<5> mask = self.header_protection_mask(sample)
<6>
<7> if is_long_header(packet[0]):
<8> # long header
<9> packet[0] ^= mask[0] & 0x0F
<10> else:
<11> # short header
<12> packet[0] ^= mask[0] & 0x1F
<13>
<14> pn_length = (packet[0] & 0x03) + 1
<15> for i in range(pn_length):
<16> packet[encrypted_offset + i] ^= mask[1 + i]
<17> pn = packet[encrypted_offset : encrypted_offset + pn_length]
<18> plain_header = bytes(packet[: encrypted_offset + pn_length])
<19>
<20> # detect key phase change
<21> crypto = self
<22> if not is_long_header(packet[0]):
<23> key_phase = (packet[0] & 4) >> 2
<24> if key_phase != self.key_phase:
<25> crypto = self.next_key_phase()
<26>
<27> # payload protection
<28> nonce = bytearray(len(crypto.iv) - pn_length) + bytearray(pn)
<29> for i in range(len(crypto.iv)):
<30> nonce[i] ^= crypto.iv[i]
<31> try:
<32> payload = crypto.aead.decrypt(
<33> nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header
<34> )
<35> except InvalidTag:
<36> raise CryptoError("Payload decryption failed")
<37>
<38> # packet number
<39> packet_number = 0
<40> for i in range(pn_length):
<41> packet_number = (packet_number << 8</s>
|
===========below chunk 0===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int, bool]:
# offset: 1
return plain_header, payload, packet_number, crypto != self
===========unchanged ref 0===========
at: aioquic.crypto
MAX_PN_SIZE = 4
SAMPLE_SIZE = 16
CryptoError(*args: object)
at: aioquic.crypto.CryptoContext
header_protection_mask(sample: bytes) -> bytes
is_valid() -> bool
next_key_phase() -> CryptoContext
at: aioquic.crypto.CryptoContext.__init__
self.iv: Optional[bytes]
self.key_phase = key_phase
at: aioquic.crypto.CryptoContext.apply_key_phase
self.iv = crypto.iv
self.key_phase = crypto.key_phase
at: aioquic.crypto.CryptoContext.setup
key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret)
at: aioquic.crypto.CryptoContext.teardown
self.iv = None
at: aioquic.packet
is_long_header(first_byte: int) -> bool
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
|
aioquic.crypto/CryptoContext.encrypt_packet
|
Modified
|
aiortc~aioquic
|
8a679a56cf450571c1e816fc45ea4cb6488ea762
|
[crypto] assert encryption key is available
|
<0>:<add> assert self.is_valid(), 'Encryption key is not available'
<add>
|
# module: aioquic.crypto
class CryptoContext:
def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
<0> pn_length = (plain_header[0] & 0x03) + 1
<1> pn_offset = len(plain_header) - pn_length
<2> pn = plain_header[pn_offset : pn_offset + pn_length]
<3>
<4> # payload protection
<5> nonce = bytearray(len(self.iv) - pn_length) + bytearray(pn)
<6> for i in range(len(self.iv)):
<7> nonce[i] ^= self.iv[i]
<8> protected_payload = self.aead.encrypt(nonce, plain_payload, plain_header)
<9>
<10> # header protection
<11> sample_offset = MAX_PN_SIZE - pn_length
<12> sample = protected_payload[sample_offset : sample_offset + SAMPLE_SIZE]
<13> mask = self.header_protection_mask(sample)
<14>
<15> packet = bytearray(plain_header + protected_payload)
<16> if is_long_header(packet[0]):
<17> # long header
<18> packet[0] ^= mask[0] & 0x0F
<19> else:
<20> # short header
<21> packet[0] ^= mask[0] & 0x1F
<22>
<23> for i in range(pn_length):
<24> packet[pn_offset + i] ^= mask[1 + i]
<25>
<26> return bytes(packet)
<27>
|
===========unchanged ref 0===========
at: aioquic.crypto
MAX_PN_SIZE = 4
SAMPLE_SIZE = 16
at: aioquic.crypto.CryptoContext
header_protection_mask(sample: bytes) -> bytes
is_valid() -> bool
at: aioquic.crypto.CryptoContext.__init__
self.aead: Optional[Any]
self.iv: Optional[bytes]
at: aioquic.crypto.CryptoContext.apply_key_phase
self.aead = crypto.aead
self.iv = crypto.iv
at: aioquic.crypto.CryptoContext.setup
key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret)
self.aead = cipher_suite_aead(cipher_suite, key)
at: aioquic.crypto.CryptoContext.teardown
self.aead = None
self.iv = None
at: aioquic.packet
is_long_header(first_byte: int) -> bool
===========changed ref 0===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int, bool]:
+ assert self.is_valid(), 'Decryption key is not available'
- packet = bytearray(packet)
# header protection
+ packet = bytearray(packet)
sample_offset = encrypted_offset + MAX_PN_SIZE
sample = packet[sample_offset : sample_offset + SAMPLE_SIZE]
mask = self.header_protection_mask(sample)
if is_long_header(packet[0]):
# long header
packet[0] ^= mask[0] & 0x0F
else:
# short header
packet[0] ^= mask[0] & 0x1F
pn_length = (packet[0] & 0x03) + 1
for i in range(pn_length):
packet[encrypted_offset + i] ^= mask[1 + i]
pn = packet[encrypted_offset : encrypted_offset + pn_length]
plain_header = bytes(packet[: encrypted_offset + pn_length])
# detect key phase change
crypto = self
if not is_long_header(packet[0]):
key_phase = (packet[0] & 4) >> 2
if key_phase != self.key_phase:
crypto = self.next_key_phase()
# payload protection
nonce = bytearray(len(crypto.iv) - pn_length) + bytearray(pn)
for i in range(len(crypto.iv)):
nonce[i] ^= crypto.iv[i]
try:
payload = crypto.aead.decrypt(
nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header
)
except InvalidTag:
raise CryptoError("Payload decryption failed")
# packet number
packet_number = 0
for i in range(pn_length):
packet_number = (packet_number << 8) | pn[i]
return plain_header,</s>
===========changed ref 1===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int, bool]:
# offset: 1
<s>pn_length):
packet_number = (packet_number << 8) | pn[i]
return plain_header, payload, packet_number, crypto != self
|
aioquic.connection/QuicConnection.datagram_received
|
Modified
|
aiortc~aioquic
|
d022cc20576dbd8197a85b7c1895e04c5c29f22a
|
[connection] don't try to decrypt packet if key is unavailable
|
<34>:<add> # server initialization
<add> if not self.is_client and not self.__initialized:
<add> assert (
<add> header.packet_type == PACKET_TYPE_INITIAL
<add> ), "first packet must be INITIAL"
<add> self._initialize(header.destination_cid)
<add>
<add> # decrypt packet
<38>:<del> if not self.is_client and not self.__initialized:
<39>:<del> self._initialize(header.destination_cid)
<40>:<del>
|
# module: aioquic.connection
class QuicConnection:
def datagram_received(self, data: bytes, addr: Any) -> None:
<0> """
<1> Handle an incoming datagram.
<2> """
<3> buf = Buffer(data=data)
<4>
<5> while not buf.eof():
<6> start_off = buf.tell()
<7> header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
<8>
<9> if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:
<10> # version negotiation
<11> versions = []
<12> while not buf.eof():
<13> versions.append(pull_uint32(buf))
<14> common = set(self.supported_versions).intersection(versions)
<15> if not common:
<16> self.__logger.error("Could not find a common protocol version")
<17> return
<18> self.version = QuicProtocolVersion(max(common))
<19> self.__logger.info("Retrying with %s" % self.version)
<20> self.connection_made(self.__transport)
<21> return
<22> elif self.is_client and header.packet_type == PACKET_TYPE_RETRY:
<23> # stateless retry
<24> if (
<25> header.destination_cid == self.host_cid
<26> and header.original_destination_cid == self.peer_cid
<27> ):
<28> self.__logger.info("Performing stateless retry")
<29> self.peer_cid = header.source_cid
<30> self.peer_token = header.token
<31> self.connection_made(self.__transport)
<32> return
<33>
<34> encrypted_off = buf.tell() - start_off
<35> end_off = buf.tell() + header.rest_length
<36> pull_bytes(buf, header.rest_length)
<37>
<38> if not self.is_client and not self.__initialized:
<39> self._initialize(header.destination_cid)
<40>
<41> epoch = get_epoch(header.packet_type)
<42> space = self.spaces</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def datagram_received(self, data: bytes, addr: Any) -> None:
# offset: 1
try:
plain_header, plain_payload, packet_number = space.crypto.decrypt_packet(
data[start_off:end_off], encrypted_off
)
except CryptoError as exc:
self.__logger.warning(exc)
return
if not self.peer_cid_set:
self.peer_cid = header.source_cid
self.peer_cid_set = True
# handle payload
try:
is_ack_only = self._payload_received(epoch, plain_payload)
except QuicConnectionError as exc:
self.__logger.warning(exc)
self.close(
error_code=exc.error_code,
frame_type=exc.frame_type,
reason_phrase=exc.reason_phrase,
)
return
# record packet as received
space.ack_queue.add(packet_number)
if not is_ack_only:
self.send_ack[epoch] = True
self._send_pending()
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
pull_uint32(buf: Buffer) -> int
at: aioquic.buffer.Buffer
eof() -> bool
tell() -> int
at: aioquic.connection
get_epoch(packet_type: int) -> tls.Epoch
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
at: aioquic.connection.PacketSpace.__init__
self.crypto = CryptoPair()
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
close(error_code: int, frame_type: Optional[int]=None, reason_phrase: str="") -> None
connection_made(transport: asyncio.DatagramTransport) -> None
_initialize(peer_cid: bytes) -> None
_payload_received(epoch: tls.Epoch, plain: bytes) -> bool
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.version = max(self.supported_versions)
self.__initialized = False
self.__logger = logger
self.__transport: Optional[asyncio.DatagramTransport] = None
at: aioquic.connection.QuicConnection._initialize
self.spaces = {
tls.Epoch.INITIAL: PacketSpace(),
tls.Epoch.HANDSHAKE: PacketSpace(),
tls.Epoch.ONE_RTT: PacketSpace(),
}
self.__initialized = True
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection.connection_made
self.__transport = transport
at: aioquic.connection.QuicConnectionError.__init__
self.error_code = error_code
self.frame_type = frame_type
self.reason_phrase = reason_phrase
at: aioquic.crypto
CryptoError(*args: object)
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair
decrypt_packet(packet: bytes, encrypted_offset: int) -> Tuple[bytes, bytes, int]
at: aioquic.crypto.CryptoPair.__init__
self.recv = CryptoContext()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader
at: aioquic.packet.QuicHeader
version: Optional[int]
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
at: logging.Logger
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
warning(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========unchanged ref 2===========
error(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
|
examples.server/QuicServerProtocol.datagram_received
|
Modified
|
aiortc~aioquic
|
d022cc20576dbd8197a85b7c1895e04c5c29f22a
|
[connection] don't try to decrypt packet if key is unavailable
|
<19>:<add> if connection is None and header.packet_type == PACKET_TYPE_INITIAL:
<del> if connection is None and header.is_long_header:
|
# module: examples.server
class QuicServerProtocol(asyncio.DatagramProtocol):
def datagram_received(self, datagram, addr):
<0> buf = Buffer(data=datagram)
<1> header = pull_quic_header(buf, host_cid_length=8)
<2>
<3> # version negotiation
<4> if (
<5> header.version is not None
<6> and header.version not in QuicConnection.supported_versions
<7> ):
<8> self._transport.sendto(
<9> encode_quic_version_negotiation(
<10> source_cid=header.destination_cid,
<11> destination_cid=header.source_cid,
<12> supported_versions=QuicConnection.supported_versions,
<13> ),
<14> addr,
<15> )
<16> return
<17>
<18> connection = self._connections.get(header.destination_cid, None)
<19> if connection is None and header.is_long_header:
<20> # create new connection
<21> connection = QuicConnection(is_client=False, **self._kwargs)
<22> connection.connection_made(QuicConnectionTransport(self, addr))
<23> connection.stream_created_cb = self.stream_created
<24> self._connections[connection.host_cid] = connection
<25> logger.info("%s New connection from %s" % (connection_id(connection), addr))
<26>
<27> if connection is not None:
<28> connection.datagram_received(datagram, addr)
<29>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
connection_made(transport: asyncio.DatagramTransport) -> None
at: aioquic.connection.QuicConnection.__init__
self.host_cid = os.urandom(8)
self.stream_created_cb: Callable[
[asyncio.StreamReader, asyncio.StreamWriter], None
] = lambda r, w: None
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader
encode_quic_version_negotiation(source_cid: bytes, destination_cid: bytes, supported_versions: List[QuicProtocolVersion]) -> bytes
at: aioquic.packet.QuicHeader
version: Optional[int]
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
at: asyncio.protocols.BaseProtocol
__slots__ = ()
connection_made(self, transport: transports.BaseTransport) -> None
at: asyncio.protocols.DatagramProtocol
__slots__ = ()
===========unchanged ref 1===========
datagram_received(self, data: bytes, addr: Tuple[str, int]) -> None
at: examples.server
QuicConnectionTransport(protocol, addr)
at: examples.server.QuicServerProtocol
stream_created(reader, writer)
at: examples.server.QuicServerProtocol.__init__
self._connections = {}
self._kwargs = kwargs
self._transport = None
at: typing.Mapping
get(key: _KT, default: Union[_VT_co, _T]) -> Union[_VT_co, _T]
get(key: _KT) -> Optional[_VT_co]
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def datagram_received(self, data: bytes, addr: Any) -> None:
"""
Handle an incoming datagram.
"""
buf = Buffer(data=data)
while not buf.eof():
start_off = buf.tell()
header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:
# version negotiation
versions = []
while not buf.eof():
versions.append(pull_uint32(buf))
common = set(self.supported_versions).intersection(versions)
if not common:
self.__logger.error("Could not find a common protocol version")
return
self.version = QuicProtocolVersion(max(common))
self.__logger.info("Retrying with %s" % self.version)
self.connection_made(self.__transport)
return
elif self.is_client and header.packet_type == PACKET_TYPE_RETRY:
# stateless retry
if (
header.destination_cid == self.host_cid
and header.original_destination_cid == self.peer_cid
):
self.__logger.info("Performing stateless retry")
self.peer_cid = header.source_cid
self.peer_token = header.token
self.connection_made(self.__transport)
return
+ # server initialization
+ if not self.is_client and not self.__initialized:
+ assert (
+ header.packet_type == PACKET_TYPE_INITIAL
+ ), "first packet must be INITIAL"
+ self._initialize(header.destination_cid)
+
+ # decrypt packet
encrypted_off = buf.tell() - start_off
end_off = buf.tell() + header.rest_length
pull_bytes(buf, header.rest_length)
- if not self.is_client and not self.__initialized:
</s>
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def datagram_received(self, data: bytes, addr: Any) -> None:
# offset: 1
<s> pull_bytes(buf, header.rest_length)
- if not self.is_client and not self.__initialized:
- self._initialize(header.destination_cid)
-
epoch = get_epoch(header.packet_type)
space = self.spaces[epoch]
+ if not space.crypto.recv.is_valid():
+ return
try:
plain_header, plain_payload, packet_number = space.crypto.decrypt_packet(
data[start_off:end_off], encrypted_off
)
except CryptoError as exc:
self.__logger.warning(exc)
return
if not self.peer_cid_set:
self.peer_cid = header.source_cid
self.peer_cid_set = True
# handle payload
try:
is_ack_only = self._payload_received(epoch, plain_payload)
except QuicConnectionError as exc:
self.__logger.warning(exc)
self.close(
error_code=exc.error_code,
frame_type=exc.frame_type,
reason_phrase=exc.reason_phrase,
)
return
# record packet as received
space.ack_queue.add(packet_number)
if not is_ack_only:
self.send_ack[epoch] = True
self._send_pending()
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
462facca6f695458172065099fc93295679b0f10
|
[connection] allow 128 bidi / uni streams
|
<23>:<add> self._local_idle_timeout = 60.0 # seconds
<del> self.__local_idle_timeout = 60.0 # seconds
<24>:<add> self._local_max_streams_bidi = 128
<del> self.__local_max_streams_bidi = 100
<25>:<add> self._local_max_streams_uni = 128
<del> self.__local_max_streams_uni = 0
|
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
<0> if not is_client:
<1> assert certificate is not None, "SSL certificate is required"
<2> assert private_key is not None, "SSL private key is required"
<3>
<4> self.alpn_protocols = alpn_protocols
<5> self.certificate = certificate
<6> self.is_client = is_client
<7> self.host_cid = os.urandom(8)
<8> self.peer_cid = os.urandom(8)
<9> self.peer_cid_set = False
<10> self.peer_token = b""
<11> self.private_key = private_key
<12> self.secrets_log_file = secrets_log_file
<13> self.server_name = server_name
<14> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<15>
<16> # protocol versions
<17> self.version = max(self.supported_versions)
<18>
<19> self.__close: Optional[Dict] = None
<20> self.__connected = asyncio.Event()
<21> self.__epoch = tls.Epoch.INITIAL
<22> self.__initialized = False
<23> self.__local_idle_timeout = 60.0 # seconds
<24> self.__local_max_streams_bidi = 100
<25> self.__local_max_streams_uni = 0
<26> self.__logger = logger
<27> self.__path_challenge: Optional[bytes] = None
<28> self._pending_flow_control: List[bytes] = []
<29> self._remote_idle_timeout = 0.0
<30> self._remote_max_streams_bidi = 0
<31> self._remote_max_streams_uni = 0
<32> self.__transport: Optional[asyncio.Dat</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
# callbacks
self.stream_created_cb: Callable[
[asyncio.StreamReader, asyncio.StreamWriter], None
] = lambda r, w: None
# frame handlers
self.__frame_handlers = [
self._handle_padding_frame,
self._handle_padding_frame,
self._handle_ack_frame,
self._handle_ack_frame,
self._handle_reset_stream_frame,
self._handle_stop_sending_frame,
self._handle_crypto_frame,
self._handle_new_token_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_max_data_frame,
self._handle_max_stream_data_frame,
self._handle_max_streams_bidi_frame,
self._handle_max_streams_uni_frame,
self._handle_data_blocked_frame,
self._handle_stream_data_blocked_frame,
self._handle_streams_blocked_frame,
self._handle_streams_blocked_frame,
self._handle_new_connection_id_frame,
self._handle_retire_connection_id_frame,
self._handle_path_challenge_frame,
self._handle_path_response_frame,
self._handle_connection_close_frame,
self._handle_connection_close_frame,</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 2
<s>path_response_frame,
self._handle_connection_close_frame,
self._handle_connection_close_frame,
]
===========unchanged ref 0===========
at: aioquic.connection
logger = logging.getLogger("quic")
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
_handle_ack_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_connection_close_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_crypto_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_data_blocked_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_max_data_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_max_stream_data_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_max_streams_bidi_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_max_streams_uni_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_new_connection_id_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_new_token_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_padding_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_path_challenge_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_path_response_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_reset_stream_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
===========unchanged ref 1===========
_handle_retire_connection_id_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_stop_sending_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_stream_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_stream_data_blocked_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
_handle_streams_blocked_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._handle_max_streams_bidi_frame
self._remote_max_streams_bidi = max_streams
at: aioquic.connection.QuicConnection._handle_max_streams_uni_frame
self._remote_max_streams_uni = max_streams
at: aioquic.connection.QuicConnection._initialize
self.__initialized = True
at: aioquic.connection.QuicConnection._parse_transport_parameters
self._remote_idle_timeout = quic_transport_parameters.idle_timeout
self._remote_idle_timeout = (
quic_transport_parameters.idle_timeout / 1000
)
self._remote_max_streams_bidi = (
quic_transport_parameters.initial_max_streams_bidi
)
self._remote_max_streams_uni = (
quic_transport_parameters.initial_max_streams_uni
)
at: aioquic.connection.QuicConnection._send_path_challenge
self.__path_challenge = os.urandom(8)
at: aioquic.connection.QuicConnection._write_application
self._pending_flow_control = []
self.__close = None
|
aioquic.connection/QuicConnection._get_or_create_stream
|
Modified
|
aiortc~aioquic
|
462facca6f695458172065099fc93295679b0f10
|
[connection] allow 128 bidi / uni streams
|
<15>:<add> max_streams = self._local_max_streams_uni
<del> max_streams = self.__local_max_streams_uni
<17>:<add> max_streams = self._local_max_streams_bidi
<del> max_streams = self.__local_max_streams_bidi
|
# module: aioquic.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> # check max streams
<14> if stream_is_unidirectional(stream_id):
<15> max_streams = self.__local_max_streams_uni
<16> else:
<17> max_streams = self.__local_max_streams_bidi
<18> if stream_id // 4 >= max_streams:
<19> raise QuicConnectionError(
<20> error_code=QuicErrorCode.STREAM_LIMIT_ERROR,
<21> frame_type=frame_type,
<22> reason_phrase="Too many streams open",
<23> )
<24>
<25> # create stream
<26> stream = self.streams[stream_id] = QuicStream(
<27> connection=self, stream_id=stream_id
<28> )
<29> self.stream_created_cb(stream.reader, stream.writer)
<30> return stream
<31>
|
===========unchanged ref 0===========
at: aioquic.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.connection.QuicConnection.__init__
self.is_client = is_client
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self.stream_created_cb: Callable[
[asyncio.StreamReader, asyncio.StreamWriter], None
] = lambda r, w: None
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None)
at: aioquic.stream.QuicStream.__init__
self.reader = asyncio.StreamReader()
self.reader = None
self.writer = None
self.writer = asyncio.StreamWriter(self, None, self.reader, None)
at: typing.Mapping
get(key: _KT, default: Union[_VT_co, _T]) -> Union[_VT_co, _T]
get(key: _KT) -> Optional[_VT_co]
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# protocol versions
self.version = max(self.supported_versions)
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
+ self._local_idle_timeout = 60.0 # seconds
- self.__local_idle_timeout = 60.0 # seconds
+ self._local_max_streams_bidi = 128
- self.__local_max_streams_bidi = 100
+ self._local_max_streams_uni = 128
- self.__local_max_streams_uni = 0
self.__logger = logger
self.__path_challenge: Optional[bytes] = None
self._pending_flow_control: List[bytes] = []
self._remote_idle_timeout = 0.0
self._remote_max_streams_bidi = 0
self._remote_max_streams</s>
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
<s>idle_timeout = 0.0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self.__transport: Optional[asyncio.DatagramTransport] = None
# callbacks
self.stream_created_cb: Callable[
[asyncio.StreamReader, asyncio.StreamWriter], None
] = lambda r, w: None
# frame handlers
self.__frame_handlers = [
self._handle_padding_frame,
self._handle_padding_frame,
self._handle_ack_frame,
self._handle_ack_frame,
self._handle_reset_stream_frame,
self._handle_stop_sending_frame,
self._handle_crypto_frame,
self._handle_new_token_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_stream_frame,
self._handle_max_data_frame,
self._handle_max_stream_data_frame,
self._handle_max_streams_bidi_frame,
self._handle_max_streams_uni_frame,
self._handle_data_blocked_frame,
self._handle_stream_data_blocked_frame,
self._handle_streams_blocked_frame,
self</s>
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 2
<s>_streams_blocked_frame,
self._handle_new_connection_id_frame,
self._handle_retire_connection_id_frame,
self._handle_path_challenge_frame,
self._handle_path_response_frame,
self._handle_connection_close_frame,
self._handle_connection_close_frame,
]
|
aioquic.connection/QuicConnection._serialize_transport_parameters
|
Modified
|
aiortc~aioquic
|
462facca6f695458172065099fc93295679b0f10
|
[connection] allow 128 bidi / uni streams
|
<5>:<add> initial_max_streams_bidi=self._local_max_streams_bidi,
<del> initial_max_streams_bidi=self.__local_max_streams_bidi,
<6>:<add> initial_max_streams_uni=self._local_max_streams_uni,
<del> initial_max_streams_uni=self.__local_max_streams_uni,
<12>:<add> self._local_idle_timeout * 1000
<del> self.__local_idle_timeout * 1000
<16>:<add> quic_transport_parameters.idle_timeout = int(self._local_idle_timeout)
<del> quic_transport_parameters.idle_timeout = int(self.__local_idle_timeout)
|
# module: aioquic.connection
class QuicConnection:
def _serialize_transport_parameters(self) -> bytes:
<0> quic_transport_parameters = QuicTransportParameters(
<1> initial_max_data=16777216,
<2> initial_max_stream_data_bidi_local=1048576,
<3> initial_max_stream_data_bidi_remote=1048576,
<4> initial_max_stream_data_uni=1048576,
<5> initial_max_streams_bidi=self.__local_max_streams_bidi,
<6> initial_max_streams_uni=self.__local_max_streams_uni,
<7> ack_delay_exponent=10,
<8> )
<9> if self.version >= QuicProtocolVersion.DRAFT_19:
<10> is_client = None
<11> quic_transport_parameters.idle_timeout = int(
<12> self.__local_idle_timeout * 1000
<13> )
<14> else:
<15> is_client = self.is_client
<16> quic_transport_parameters.idle_timeout = int(self.__local_idle_timeout)
<17> if self.is_client:
<18> quic_transport_parameters.initial_version = self.version
<19> else:
<20> quic_transport_parameters.negotiated_version = self.version
<21> quic_transport_parameters.supported_versions = self.supported_versions
<22> quic_transport_parameters.stateless_reset_token = bytes(16)
<23>
<24> buf = Buffer(capacity=512)
<25> push_quic_transport_parameters(
<26> buf, quic_transport_parameters, is_client=is_client
<27> )
<28> return buf.data
<29>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.version = max(self.supported_versions)
self._local_idle_timeout = 60.0 # seconds
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
===========unchanged ref 1===========
QuicTransportParameters(initial_version: Optional[QuicProtocolVersion]=None, negotiated_version: Optional[QuicProtocolVersion]=None, supported_versions: List[QuicProtocolVersion]=field(default_factory=list), 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_migration: Optional[bool]=False, preferred_address: Optional[bytes]=None)
push_quic_transport_parameters(buf: Buffer, params: QuicTransportParameters, is_client: Optional[bool]=None) -> None
at: aioquic.packet.QuicTransportParameters
initial_version: Optional[QuicProtocolVersion] = None
negotiated_version: Optional[QuicProtocolVersion] = None
supported_versions: List[QuicProtocolVersion] = field(default_factory=list)
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
===========unchanged ref 2===========
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_migration: Optional[bool] = False
preferred_address: Optional[bytes] = None
===========changed ref 0===========
# module: aioquic.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",
)
# check max streams
if stream_is_unidirectional(stream_id):
+ max_streams = self._local_max_streams_uni
- max_streams = self.__local_max_streams_uni
else:
+ max_streams = self._local_max_streams_bidi
- max_streams = self.__local_max_streams_bidi
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
stream = self.streams[stream_id] = QuicStream(
connection=self, stream_id=stream_id
)
self.stream_created_cb(stream.reader, stream.writer)
return stream
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# protocol versions
self.version = max(self.supported_versions)
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
+ self._local_idle_timeout = 60.0 # seconds
- self.__local_idle_timeout = 60.0 # seconds
+ self._local_max_streams_bidi = 128
- self.__local_max_streams_bidi = 100
+ self._local_max_streams_uni = 128
- self.__local_max_streams_uni = 0
self.__logger = logger
self.__path_challenge: Optional[bytes] = None
self._pending_flow_control: List[bytes] = []
self._remote_idle_timeout = 0.0
self._remote_max_streams_bidi = 0
self._remote_max_streams</s>
|
tests.test_connection/QuicConnectionTest.test_handle_max_streams_bidi_frame
|
Modified
|
aiortc~aioquic
|
462facca6f695458172065099fc93295679b0f10
|
[connection] allow 128 bidi / uni streams
|
<9>:<add> self.assertEqual(client._remote_max_streams_bidi, 128)
<del> self.assertEqual(client._remote_max_streams_bidi, 100)
<11>:<add> # server sends MAX_STREAMS_BIDI: 129
<del> # server sends MAX_STREAMS_BIDI: 101
<12>:<add> server._pending_flow_control.append(b"\x12\x40\x81")
<del> server._pending_flow_control.append(b"\x12\x40\x65")
<14>:<add> self.assertEqual(client._remote_max_streams_bidi, 129)
<del> self.assertEqual(client._remote_max_streams_bidi, 101)
<16>:<add> # server sends MAX_STREAMS_BIDI: 127 -> discarded
<del> # server sends MAX_STREAMS_BIDI: 99 -> discarded
<17>:<add> server._pending_flow_control.append(b"\x12\x40\x7f")
<del> server._pending_flow_control.append(b"\x12\x40\x63")
<19>:<add> self.assertEqual(client._remote_max_streams_bidi, 129)
<del> self.assertEqual(client._remote_max_streams_bidi, 101)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_streams_bidi_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client._remote_max_streams_bidi, 100)
<10>
<11> # server sends MAX_STREAMS_BIDI: 101
<12> server._pending_flow_control.append(b"\x12\x40\x65")
<13> server._send_pending()
<14> self.assertEqual(client._remote_max_streams_bidi, 101)
<15>
<16> # server sends MAX_STREAMS_BIDI: 99 -> discarded
<17> server._pending_flow_control.append(b"\x12\x40\x63")
<18> server._send_pending()
<19> self.assertEqual(client._remote_max_streams_bidi, 101)
<20>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
_send_pending() -> None
at: aioquic.connection.QuicConnection.__init__
self._pending_flow_control: List[bytes] = []
self._remote_max_streams_bidi = 0
at: aioquic.connection.QuicConnection._handle_max_streams_bidi_frame
self._remote_max_streams_bidi = max_streams
at: aioquic.connection.QuicConnection._parse_transport_parameters
self._remote_max_streams_bidi = (
quic_transport_parameters.initial_max_streams_bidi
)
at: aioquic.connection.QuicConnection._write_application
self._pending_flow_control = []
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
create_transport(client, server)
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.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",
)
# check max streams
if stream_is_unidirectional(stream_id):
+ max_streams = self._local_max_streams_uni
- max_streams = self.__local_max_streams_uni
else:
+ max_streams = self._local_max_streams_bidi
- max_streams = self.__local_max_streams_bidi
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
stream = self.streams[stream_id] = QuicStream(
connection=self, stream_id=stream_id
)
self.stream_created_cb(stream.reader, stream.writer)
return stream
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def _serialize_transport_parameters(self) -> bytes:
quic_transport_parameters = QuicTransportParameters(
initial_max_data=16777216,
initial_max_stream_data_bidi_local=1048576,
initial_max_stream_data_bidi_remote=1048576,
initial_max_stream_data_uni=1048576,
+ initial_max_streams_bidi=self._local_max_streams_bidi,
- initial_max_streams_bidi=self.__local_max_streams_bidi,
+ initial_max_streams_uni=self._local_max_streams_uni,
- initial_max_streams_uni=self.__local_max_streams_uni,
ack_delay_exponent=10,
)
if self.version >= QuicProtocolVersion.DRAFT_19:
is_client = None
quic_transport_parameters.idle_timeout = int(
+ self._local_idle_timeout * 1000
- self.__local_idle_timeout * 1000
)
else:
is_client = self.is_client
+ quic_transport_parameters.idle_timeout = int(self._local_idle_timeout)
- quic_transport_parameters.idle_timeout = int(self.__local_idle_timeout)
if self.is_client:
quic_transport_parameters.initial_version = self.version
else:
quic_transport_parameters.negotiated_version = self.version
quic_transport_parameters.supported_versions = self.supported_versions
quic_transport_parameters.stateless_reset_token = bytes(16)
buf = Buffer(capacity=512)
push_quic_transport_parameters(
buf, quic_transport_parameters, is_client=is_client
)
return buf.data
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# protocol versions
self.version = max(self.supported_versions)
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
+ self._local_idle_timeout = 60.0 # seconds
- self.__local_idle_timeout = 60.0 # seconds
+ self._local_max_streams_bidi = 128
- self.__local_max_streams_bidi = 100
+ self._local_max_streams_uni = 128
- self.__local_max_streams_uni = 0
self.__logger = logger
self.__path_challenge: Optional[bytes] = None
self._pending_flow_control: List[bytes] = []
self._remote_idle_timeout = 0.0
self._remote_max_streams_bidi = 0
self._remote_max_streams</s>
|
tests.test_connection/QuicConnectionTest.test_handle_max_streams_uni_frame
|
Modified
|
aiortc~aioquic
|
462facca6f695458172065099fc93295679b0f10
|
[connection] allow 128 bidi / uni streams
|
<9>:<add> self.assertEqual(client._remote_max_streams_uni, 128)
<del> self.assertEqual(client._remote_max_streams_uni, 0)
<11>:<add> # server sends MAX_STREAMS_UNI: 129
<del> # server sends MAX_STREAMS_UNI: 1
<12>:<add> server._pending_flow_control.append(b"\x13\x40\x81")
<del> server._pending_flow_control.append(b"\x13\x01")
<14>:<add> self.assertEqual(client._remote_max_streams_uni, 129)
<del> self.assertEqual(client._remote_max_streams_uni, 1)
<16>:<add> # server sends MAX_STREAMS_UNI: 129 -> discarded
<del> # server sends MAX_STREAMS_UNI: 0 -> discarded
<17>:<add> server._pending_flow_control.append(b"\x13\x40\x7f")
<del> server._pending_flow_control.append(b"\x13\x00")
<19>:<add> self.assertEqual(client._remote_max_streams_uni, 129)
<del> self.assertEqual(client._remote_max_streams_uni, 1)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_streams_uni_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client._remote_max_streams_uni, 0)
<10>
<11> # server sends MAX_STREAMS_UNI: 1
<12> server._pending_flow_control.append(b"\x13\x01")
<13> server._send_pending()
<14> self.assertEqual(client._remote_max_streams_uni, 1)
<15>
<16> # server sends MAX_STREAMS_UNI: 0 -> discarded
<17> server._pending_flow_control.append(b"\x13\x00")
<18> server._send_pending()
<19> self.assertEqual(client._remote_max_streams_uni, 1)
<20>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
_send_pending() -> None
at: aioquic.connection.QuicConnection.__init__
self._pending_flow_control: List[bytes] = []
self._remote_max_streams_uni = 0
at: aioquic.connection.QuicConnection._handle_max_streams_uni_frame
self._remote_max_streams_uni = max_streams
at: aioquic.connection.QuicConnection._parse_transport_parameters
self._remote_max_streams_uni = (
quic_transport_parameters.initial_max_streams_uni
)
at: aioquic.connection.QuicConnection._write_application
self._pending_flow_control = []
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
create_transport(client, server)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_streams_bidi_frame(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client._remote_max_streams_bidi, 128)
- self.assertEqual(client._remote_max_streams_bidi, 100)
+ # server sends MAX_STREAMS_BIDI: 129
- # server sends MAX_STREAMS_BIDI: 101
+ server._pending_flow_control.append(b"\x12\x40\x81")
- server._pending_flow_control.append(b"\x12\x40\x65")
server._send_pending()
+ self.assertEqual(client._remote_max_streams_bidi, 129)
- self.assertEqual(client._remote_max_streams_bidi, 101)
+ # server sends MAX_STREAMS_BIDI: 127 -> discarded
- # server sends MAX_STREAMS_BIDI: 99 -> discarded
+ server._pending_flow_control.append(b"\x12\x40\x7f")
- server._pending_flow_control.append(b"\x12\x40\x63")
server._send_pending()
+ self.assertEqual(client._remote_max_streams_bidi, 129)
- self.assertEqual(client._remote_max_streams_bidi, 101)
===========changed ref 1===========
# module: aioquic.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",
)
# check max streams
if stream_is_unidirectional(stream_id):
+ max_streams = self._local_max_streams_uni
- max_streams = self.__local_max_streams_uni
else:
+ max_streams = self._local_max_streams_bidi
- max_streams = self.__local_max_streams_bidi
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
stream = self.streams[stream_id] = QuicStream(
connection=self, stream_id=stream_id
)
self.stream_created_cb(stream.reader, stream.writer)
return stream
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def _serialize_transport_parameters(self) -> bytes:
quic_transport_parameters = QuicTransportParameters(
initial_max_data=16777216,
initial_max_stream_data_bidi_local=1048576,
initial_max_stream_data_bidi_remote=1048576,
initial_max_stream_data_uni=1048576,
+ initial_max_streams_bidi=self._local_max_streams_bidi,
- initial_max_streams_bidi=self.__local_max_streams_bidi,
+ initial_max_streams_uni=self._local_max_streams_uni,
- initial_max_streams_uni=self.__local_max_streams_uni,
ack_delay_exponent=10,
)
if self.version >= QuicProtocolVersion.DRAFT_19:
is_client = None
quic_transport_parameters.idle_timeout = int(
+ self._local_idle_timeout * 1000
- self.__local_idle_timeout * 1000
)
else:
is_client = self.is_client
+ quic_transport_parameters.idle_timeout = int(self._local_idle_timeout)
- quic_transport_parameters.idle_timeout = int(self.__local_idle_timeout)
if self.is_client:
quic_transport_parameters.initial_version = self.version
else:
quic_transport_parameters.negotiated_version = self.version
quic_transport_parameters.supported_versions = self.supported_versions
quic_transport_parameters.stateless_reset_token = bytes(16)
buf = Buffer(capacity=512)
push_quic_transport_parameters(
buf, quic_transport_parameters, is_client=is_client
)
return buf.data
|
tests.test_connection/QuicConnectionTest.test_handle_stream_frame_over_limit
|
Modified
|
aiortc~aioquic
|
462facca6f695458172065099fc93295679b0f10
|
[connection] allow 128 bidi / uni streams
|
<13>:<add> tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b"\x42\x03")
<del> tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b"\x03")
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_over_limit(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # client receives STREAM frame
<11> with self.assertRaises(QuicConnectionError) as cm:
<12> client._handle_stream_frame(
<13> tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b"\x03")
<14> )
<15> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR)
<16> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
<17> self.assertEqual(cm.exception.reason_phrase, "Too many streams open")
<18>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
_handle_stream_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.tls
Epoch()
at: tests.test_connection
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
create_transport(client, server)
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
===========unchanged ref 1===========
at: unittest.case._AssertRaisesContext.__exit__
self.exception = exc_value.with_traceback(None)
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_streams_uni_frame(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client._remote_max_streams_uni, 128)
- self.assertEqual(client._remote_max_streams_uni, 0)
+ # server sends MAX_STREAMS_UNI: 129
- # server sends MAX_STREAMS_UNI: 1
+ server._pending_flow_control.append(b"\x13\x40\x81")
- server._pending_flow_control.append(b"\x13\x01")
server._send_pending()
+ self.assertEqual(client._remote_max_streams_uni, 129)
- self.assertEqual(client._remote_max_streams_uni, 1)
+ # server sends MAX_STREAMS_UNI: 129 -> discarded
- # server sends MAX_STREAMS_UNI: 0 -> discarded
+ server._pending_flow_control.append(b"\x13\x40\x7f")
- server._pending_flow_control.append(b"\x13\x00")
server._send_pending()
+ self.assertEqual(client._remote_max_streams_uni, 129)
- self.assertEqual(client._remote_max_streams_uni, 1)
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_streams_bidi_frame(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client._remote_max_streams_bidi, 128)
- self.assertEqual(client._remote_max_streams_bidi, 100)
+ # server sends MAX_STREAMS_BIDI: 129
- # server sends MAX_STREAMS_BIDI: 101
+ server._pending_flow_control.append(b"\x12\x40\x81")
- server._pending_flow_control.append(b"\x12\x40\x65")
server._send_pending()
+ self.assertEqual(client._remote_max_streams_bidi, 129)
- self.assertEqual(client._remote_max_streams_bidi, 101)
+ # server sends MAX_STREAMS_BIDI: 127 -> discarded
- # server sends MAX_STREAMS_BIDI: 99 -> discarded
+ server._pending_flow_control.append(b"\x12\x40\x7f")
- server._pending_flow_control.append(b"\x12\x40\x63")
server._send_pending()
+ self.assertEqual(client._remote_max_streams_bidi, 129)
- self.assertEqual(client._remote_max_streams_bidi, 101)
===========changed ref 2===========
# module: aioquic.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",
)
# check max streams
if stream_is_unidirectional(stream_id):
+ max_streams = self._local_max_streams_uni
- max_streams = self.__local_max_streams_uni
else:
+ max_streams = self._local_max_streams_bidi
- max_streams = self.__local_max_streams_bidi
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
stream = self.streams[stream_id] = QuicStream(
connection=self, stream_id=stream_id
)
self.stream_created_cb(stream.reader, stream.writer)
return stream
|
aioquic.stream/QuicStream.add_frame
|
Modified
|
aiortc~aioquic
|
96f7c2c9bac00178fec196913f30337b5ba2392c
|
[stream] do not bomb if we receive empty data
|
<15>:<add> if count:
<add> self._recv_ranges.add(frame.offset, frame.offset + count)
<del> self._recv_ranges.add(frame.offset, frame.offset + count)
|
# module: aioquic.stream
class QuicStream:
def add_frame(self, frame: QuicStreamFrame) -> None:
<0> """
<1> Add a frame of received data.
<2> """
<3> pos = frame.offset - self._recv_start
<4> count = len(frame.data)
<5>
<6> if pos + count > 0:
<7> # frame has been partially consumed
<8> if pos < 0:
<9> count += pos
<10> frame.data = frame.data[-pos:]
<11> frame.offset -= pos
<12> pos = 0
<13>
<14> # marked received
<15> self._recv_ranges.add(frame.offset, frame.offset + count)
<16>
<17> # add data
<18> gap = pos - len(self._recv_buffer)
<19> if gap > 0:
<20> self._recv_buffer += bytearray(gap)
<21> self._recv_buffer[pos : pos + count] = frame.data
<22>
<23> if self.reader:
<24> if self.has_data_to_read():
<25> self.reader.feed_data(self.pull_data())
<26> if frame.fin:
<27> self.reader.feed_eof()
<28>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.rangeset.RangeSet
add(start: int, stop: Optional[int]=None) -> None
at: aioquic.stream.QuicStream
has_data_to_read() -> bool
pull_data() -> bytes
at: aioquic.stream.QuicStream.__init__
self.reader = asyncio.StreamReader()
self.reader = None
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
at: aioquic.stream.QuicStream.pull_data
self._recv_buffer = self._recv_buffer[pos:]
self._recv_start = r.stop
at: asyncio.streams.StreamReader
_source_traceback = None
feed_data(data: bytes) -> None
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.