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.recovery/QuicPacketSpace.__init__
|
Modified
|
aiortc~aioquic
|
23a4f24bdd43335246b755d140840e7f616f7493
|
[connection] delay ACKs by 1ms
|
<0>:<add> self.ack_at: Optional[float] = None
<1>:<del> self.ack_required = False
|
# module: aioquic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
<0> self.ack_queue = RangeSet()
<1> self.ack_required = False
<2> self.expected_packet_number = 0
<3> self.largest_received_packet = 0
<4>
<5> # sent packets and loss
<6> self.ack_eliciting_in_flight = 0
<7> self.crypto_packet_in_flight = 0
<8> self.largest_acked_packet = 0
<9> self.loss_time: Optional[float] = None
<10> self.sent_packets: Dict[int, QuicSentPacket] = {}
<11>
|
===========unchanged ref 0===========
at: aioquic.packet_builder
QuicSentPacket(epoch: Epoch, in_flight: bool, is_ack_eliciting: bool, is_crypto_packet: bool, packet_number: int, sent_time: Optional[float]=None, sent_bytes: int=0, delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]]=field(
default_factory=list
))
at: aioquic.rangeset
RangeSet(ranges: Iterable[range]=[])
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
|
aioquic.recovery/QuicPacketRecovery.discard_space
|
Modified
|
aiortc~aioquic
|
23a4f24bdd43335246b755d140840e7f616f7493
|
[connection] delay ACKs by 1ms
|
<7>:<add> space.ack_at = None
|
# module: aioquic.recovery
class QuicPacketRecovery:
def discard_space(self, space: QuicPacketSpace) -> None:
<0> assert space in self.spaces
<1>
<2> for packet in space.sent_packets.values():
<3> if packet.in_flight:
<4> self.on_packet_expired(packet)
<5> space.sent_packets.clear()
<6>
<7> space.ack_eliciting_in_flight = 0
<8> space.crypto_packet_in_flight = 0
<9> space.loss_time = None
<10>
|
===========unchanged ref 0===========
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: aioquic.recovery
QuicPacketSpace()
at: aioquic.recovery.QuicPacketRecovery
on_packet_expired(packet: QuicSentPacket) -> None
at: aioquic.recovery.QuicPacketRecovery.__init__
self.spaces: List[QuicPacketSpace] = []
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_at: Optional[float] = None
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
self.sent_packets: Dict[int, QuicSentPacket] = {}
===========changed ref 0===========
# module: aioquic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
+ self.ack_at: Optional[float] = None
self.ack_queue = RangeSet()
- self.ack_required = False
self.expected_packet_number = 0
self.largest_received_packet = 0
# sent packets and loss
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
self.largest_acked_packet = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
|
aioquic.connection/QuicConnection._on_timeout
|
Modified
|
aiortc~aioquic
|
23a4f24bdd43335246b755d140840e7f616f7493
|
[connection] delay ACKs by 1ms
|
<0>:<add> now = self._loop.time() + K_GRANULARITY
<del> now = self._loop.time()
<5>:<add> if now >= self._close_at:
<del> if now + K_GRANULARITY >= self._close_at:
<10>:<add> if self._loss_at is not None and now >= self._loss_at:
<add> self._logger.info("Loss detection triggered")
<del> self._logger.info("Loss detection triggered")
<11>:<add> self._loss.on_loss_detection_timeout(now=now)
<del> self._loss.on_loss_detection_timeout(now=now)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _on_timeout(self) -> None:
<0> now = self._loop.time()
<1> self._timer = None
<2> self._timer_at = None
<3>
<4> # idle timeout
<5> if now + K_GRANULARITY >= self._close_at:
<6> self.connection_lost(self._close_exception)
<7> return
<8>
<9> # loss detection timeout
<10> self._logger.info("Loss detection triggered")
<11> self._loss.on_loss_detection_timeout(now=now)
<12> self._send_pending()
<13>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
connection_lost(exc: Exception) -> None
at: aioquic.connection.QuicConnection.__init__
self._close_at: Optional[float] = None
self._close_exception: Optional[Exception] = None
self._loop = loop
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(send_probe=self._send_probe)
self._timer: Optional[asyncio.TimerHandle] = None
self._timer_at: Optional[float] = None
at: aioquic.connection.QuicConnection._close
self._close_at = self._loop.time() + 3 * self._loss.get_probe_timeout()
at: aioquic.connection.QuicConnection._connect
self._close_at = self._loop.time() + self._local_idle_timeout
at: aioquic.connection.QuicConnection._handle_connection_close_frame
self._close_exception = QuicConnectionError(
error_code=error_code,
frame_type=frame_type,
reason_phrase=reason_phrase,
)
at: aioquic.connection.QuicConnection._set_timer
self._loss_at = self._loss.get_loss_detection_time()
self._timer = None
self._timer = self._loop.call_at(timer_at, self._on_timeout)
self._timer_at = timer_at
at: aioquic.connection.QuicConnection.datagram_received
self._close_exception = exc
self._close_at = now + self._local_idle_timeout
at: aioquic.recovery
K_GRANULARITY = 0.001 # seconds
===========unchanged ref 1===========
at: aioquic.recovery.QuicPacketRecovery
on_loss_detection_timeout(now: float) -> None
at: asyncio.events.AbstractEventLoop
time() -> float
at: logging.LoggerAdapter
logger: Logger
extra: Mapping[str, Any]
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.recovery
class QuicPacketRecovery:
def discard_space(self, space: QuicPacketSpace) -> None:
assert space in self.spaces
for packet in space.sent_packets.values():
if packet.in_flight:
self.on_packet_expired(packet)
space.sent_packets.clear()
+ space.ack_at = None
space.ack_eliciting_in_flight = 0
space.crypto_packet_in_flight = 0
space.loss_time = None
===========changed ref 1===========
# module: aioquic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
+ self.ack_at: Optional[float] = None
self.ack_queue = RangeSet()
- self.ack_required = False
self.expected_packet_number = 0
self.largest_received_packet = 0
# sent packets and loss
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
self.largest_acked_packet = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
"""
Handle an incoming datagram.
"""
# stop handling packets when closing
if self._state in END_STATES:
return
data = cast(bytes, data)
buf = Buffer(data=data)
now = self._loop.time()
while not buf.eof():
start_off = buf.tell()
header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
# check destination CID matches
destination_cid_seq: Optional[int] = None
for connection_id in self._host_cids:
if header.destination_cid == connection_id.cid:
destination_cid_seq = connection_id.sequence_number
break
if self.is_client and destination_cid_seq is None:
return
# check protocol version
if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:
# version negotiation
versions = []
while not buf.eof():
versions.append(buf.pull_uint32())
common = set(self.supported_versions).intersection(versions)
if not common:
self._logger.error("Could not find a common protocol version")
self.connection_lost(
QuicConnectionError(
error_code=QuicErrorCode.INTERNAL_ERROR,
frame_type=None,
reason_phrase="Could not find a common protocol version",
)
)
return
self._version = QuicProtocolVersion(max(common))
self._version_negotiation_count += 1
self._logger.info("Retrying with %s", self._version)
self._connect()
return
elif (
header.version is not None
and header.version not in self.supported_versions
):
# unsupported version
return
if self.is_client</s>
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
# offset: 1
<s>.version not in self.supported_versions
):
# unsupported version
return
if 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
and not self._stateless_retry_count
):
self._original_connection_id = self._peer_cid
self._peer_cid = header.source_cid
self._peer_token = header.token
self._stateless_retry_count += 1
self._logger.info("Performing stateless retry")
self._connect()
return
network_path = self._find_network_path(addr)
# server initialization
if not self.is_client and self._state == QuicConnectionState.FIRSTFLIGHT:
assert (
header.packet_type == PACKET_TYPE_INITIAL
), "first packet must be INITIAL"
self._network_paths = [network_path]
self._version = QuicProtocolVersion(header.version)
self._initialize(header.destination_cid)
# determine crypto and packet space
epoch = get_epoch(header.packet_type)
crypto = self._cryptos[epoch]
if epoch == tls.Epoch.ZERO_RTT:
space = self._spaces[tls.Epoch.ONE_RTT]
else:
space = self._spaces[epoch]
# decrypt packet
encrypted_off = buf.tell() - start_off
end_off = buf.tell() + header.rest_length
buf.seek(end_off)
try:
plain_header,</s>
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
23a4f24bdd43335246b755d140840e7f616f7493
|
[connection] delay ACKs by 1ms
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
<0> network_path = self._network_paths[0]
<1>
<2> self._send_task = None
<3> if self._state in END_STATES:
<4> return
<5>
<6> # build datagrams
<7> builder = QuicPacketBuilder(
<8> host_cid=self.host_cid,
<9> packet_number=self._packet_number,
<10> pad_first_datagram=(
<11> self.is_client and self._state == QuicConnectionState.FIRSTFLIGHT
<12> ),
<13> peer_cid=self._peer_cid,
<14> peer_token=self._peer_token,
<15> spin_bit=self._spin_bit,
<16> version=self._version,
<17> )
<18> if self._close_pending:
<19> for epoch, packet_type in (
<20> (tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
<21> (tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
<22> (tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
<23> ):
<24> crypto = self._cryptos[epoch]
<25> if crypto.send.is_valid():
<26> builder.start_packet(packet_type, crypto)
<27> write_close_frame(builder, **self._close_pending)
<28> builder.end_packet()
<29> self._close_pending = None
<30> break
<31> self._close(is_initiator=True)
<32> else:
<33> # data is limited by congestion control and whether the network path is validated
<34> max_bytes = self._loss.congestion_window - self._loss.bytes_in_flight
<35> if not network_path.is_validated:
<36> max_bytes = min(
<37> max_bytes, network_path.bytes_received * 3 - network_path.bytes_sent
<38> )
<39>
<40> if not self._handshake_confirmed:
<41> </s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
self._write_handshake(builder, epoch, max_bytes)
self._write_application(builder, max_bytes, network_path)
datagrams, packets = builder.flush()
if datagrams:
self._packet_number = builder.packet_number
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
# register packets
now = self._loop.time()
sent_handshake = False
for packet in packets:
packet.sent_time = now
self._loss.on_packet_sent(
packet=packet, space=self._spaces[packet.epoch]
)
if packet.epoch == tls.Epoch.HANDSHAKE:
sent_handshake = True
# check if we can discard initial keys
if sent_handshake and self.is_client:
self._discard_epoch(tls.Epoch.INITIAL)
# arm timer
self._set_timer()
===========unchanged ref 0===========
at: aioquic.connection
write_close_frame(builder: QuicPacketBuilder, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None
QuicConnectionState()
END_STATES = frozenset([QuicConnectionState.CLOSING, QuicConnectionState.DRAINING])
at: aioquic.connection.QuicConnection
_close(is_initiator: bool) -> None
_write_application(self, builder: QuicPacketBuilder, max_bytes: int, network_path: QuicNetworkPath, now: float) -> None
_write_application(builder: QuicPacketBuilder, max_bytes: int, network_path: QuicNetworkPath, now: float) -> None
_write_handshake(builder: QuicPacketBuilder, epoch: tls.Epoch, max_bytes: int) -> None
_write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch, max_bytes: int) -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._handshake_confirmed = False
self.host_cid = self._host_cids[0].cid
self._loop = loop
self._loss = QuicPacketRecovery(send_probe=self._send_probe)
self._network_paths: List[QuicNetworkPath] = []
self._packet_number = 0
self._peer_cid = os.urandom(8)
self._peer_token = b""
self._spin_bit = False
self._state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
self._close_pending: Optional[Dict] = None
self._send_task: Optional[asyncio.Handle] = None
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._consume_connection_id
self._peer_cid = connection_id.cid
at: aioquic.connection.QuicConnection._handle_ack_frame
self._handshake_confirmed = True
at: aioquic.connection.QuicConnection._initialize
self._cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self._packet_number = 0
at: aioquic.connection.QuicConnection._send_soon
self._send_task = self._loop.call_soon(self._send_pending)
at: aioquic.connection.QuicConnection._set_state
self._state = state
at: aioquic.connection.QuicConnection.close
self._close_pending = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.connect
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
self._version = max(self.supported_versions)
self._version = protocol_version
at: aioquic.connection.QuicConnection.connection_made
self._transport = cast(asyncio.DatagramTransport, transport)
at: aioquic.connection.QuicConnection.datagram_received
self._version = QuicProtocolVersion(header.version)
self._version = QuicProtocolVersion(max(common))
self._peer_cid = header.source_cid
self._peer_token = header.token
self._network_paths = [network_path]
self._spin_bit = self._spin_bit_peer
self._spin_bit = not self._spin_bit_peer
self.host_cid = context.host_cid
===========unchanged ref 2===========
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
bytes_received: int = 0
bytes_sent: int = 0
is_validated: bool = False
local_challenge: Optional[bytes] = None
remote_challenge: Optional[bytes] = None
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair.__init__
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
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> Tuple[List[bytes], List[QuicSentPacket]]
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: aioquic.recovery.QuicPacketRecovery.__init__
self.bytes_in_flight = 0
self.congestion_window = K_INITIAL_WINDOW
|
|
aioquic.connection/QuicConnection._set_timer
|
Modified
|
aiortc~aioquic
|
23a4f24bdd43335246b755d140840e7f616f7493
|
[connection] delay ACKs by 1ms
|
<3>:<add> # ack timer
<add> for space in self._loss.spaces:
<add> if space.ack_at is not None and space.ack_at < timer_at:
<add> timer_at = space.ack_at
<add>
<add> # loss detection timer
<add> self._loss_at = self._loss.get_loss_detection_time()
<del> loss_at = self._loss.get_loss_detection_time()
<4>:<add> if self._loss_at is not None and self._loss_at < timer_at:
<del> if loss_at is not None and loss_at < timer_at:
<5>:<add> timer_at = self._loss_at
<del> timer_at = loss_at
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _set_timer(self) -> None:
<0> # determine earliest timeout
<1> timer_at = self._close_at
<2> if self._state not in END_STATES:
<3> loss_at = self._loss.get_loss_detection_time()
<4> if loss_at is not None and loss_at < timer_at:
<5> timer_at = loss_at
<6>
<7> # re-arm timer
<8> if self._timer is not None and self._timer_at != timer_at:
<9> self._timer.cancel()
<10> self._timer = None
<11> if self._timer is None and timer_at is not None:
<12> self._timer = self._loop.call_at(timer_at, self._on_timeout)
<13> self._timer_at = timer_at
<14>
|
===========unchanged ref 0===========
at: aioquic.connection
END_STATES = frozenset([QuicConnectionState.CLOSING, QuicConnectionState.DRAINING])
at: aioquic.connection.QuicConnection.__init__
self._close_at: Optional[float] = None
self._loss = QuicPacketRecovery(send_probe=self._send_probe)
self._state = QuicConnectionState.FIRSTFLIGHT
at: aioquic.connection.QuicConnection._close
self._close_at = self._loop.time() + 3 * self._loss.get_probe_timeout()
at: aioquic.connection.QuicConnection._connect
self._close_at = self._loop.time() + self._local_idle_timeout
at: aioquic.connection.QuicConnection._set_state
self._state = state
at: aioquic.connection.QuicConnection.datagram_received
self._close_at = now + self._local_idle_timeout
at: aioquic.recovery.QuicPacketRecovery
get_loss_detection_time() -> float
at: aioquic.recovery.QuicPacketRecovery.__init__
self.spaces: List[QuicPacketSpace] = []
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_at: Optional[float] = None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _on_timeout(self) -> None:
+ now = self._loop.time() + K_GRANULARITY
- now = self._loop.time()
self._timer = None
self._timer_at = None
# idle timeout
+ if now >= self._close_at:
- if now + K_GRANULARITY >= self._close_at:
self.connection_lost(self._close_exception)
return
# loss detection timeout
+ if self._loss_at is not None and now >= self._loss_at:
+ self._logger.info("Loss detection triggered")
- self._logger.info("Loss detection triggered")
+ self._loss.on_loss_detection_timeout(now=now)
- self._loss.on_loss_detection_timeout(now=now)
self._send_pending()
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
network_path = self._network_paths[0]
self._send_task = None
if self._state in END_STATES:
return
# build datagrams
builder = QuicPacketBuilder(
host_cid=self.host_cid,
packet_number=self._packet_number,
pad_first_datagram=(
self.is_client and self._state == QuicConnectionState.FIRSTFLIGHT
),
peer_cid=self._peer_cid,
peer_token=self._peer_token,
spin_bit=self._spin_bit,
version=self._version,
)
if self._close_pending:
for epoch, packet_type in (
(tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
(tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
(tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
):
crypto = self._cryptos[epoch]
if crypto.send.is_valid():
builder.start_packet(packet_type, crypto)
write_close_frame(builder, **self._close_pending)
builder.end_packet()
self._close_pending = None
break
self._close(is_initiator=True)
else:
# data is limited by congestion control and whether the network path is validated
max_bytes = self._loss.congestion_window - self._loss.bytes_in_flight
if not network_path.is_validated:
max_bytes = min(
max_bytes, network_path.bytes_received * 3 - network_path.bytes_sent
)
if not self._handshake_confirmed:
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch, max_bytes)
+ self._write_</s>
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
<s>Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch, max_bytes)
+ self._write_application(builder, max_bytes, network_path, self._loop.time())
- self._write_application(builder, max_bytes, network_path)
datagrams, packets = builder.flush()
if datagrams:
self._packet_number = builder.packet_number
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
# register packets
now = self._loop.time()
sent_handshake = False
for packet in packets:
packet.sent_time = now
self._loss.on_packet_sent(
packet=packet, space=self._spaces[packet.epoch]
)
if packet.epoch == tls.Epoch.HANDSHAKE:
sent_handshake = True
# check if we can discard initial keys
if sent_handshake and self.is_client:
self._discard_epoch(tls.Epoch.INITIAL)
# arm timer
self._set_timer()
===========changed ref 3===========
# module: aioquic.recovery
class QuicPacketRecovery:
def discard_space(self, space: QuicPacketSpace) -> None:
assert space in self.spaces
for packet in space.sent_packets.values():
if packet.in_flight:
self.on_packet_expired(packet)
space.sent_packets.clear()
+ space.ack_at = None
space.ack_eliciting_in_flight = 0
space.crypto_packet_in_flight = 0
space.loss_time = None
===========changed ref 4===========
# module: aioquic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
+ self.ack_at: Optional[float] = None
self.ack_queue = RangeSet()
- self.ack_required = False
self.expected_packet_number = 0
self.largest_received_packet = 0
# sent packets and loss
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
self.largest_acked_packet = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
23a4f24bdd43335246b755d140840e7f616f7493
|
[connection] delay ACKs by 1ms
|
<20>:<add> if space.ack_at is not None and space.ack_at <= now:
<del> if space.ack_required:
<27>:<add> space.ack_at = None
<del> space.ack_required = False
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
+ self,
+ builder: QuicPacketBuilder,
+ max_bytes: int,
+ network_path: QuicNetworkPath,
+ now: float,
- self, builder: QuicPacketBuilder, max_bytes: int, network_path: QuicNetworkPath
) -> None:
<0> crypto_stream: Optional[QuicStream] = None
<1> if self._cryptos[tls.Epoch.ONE_RTT].send.is_valid():
<2> crypto = self._cryptos[tls.Epoch.ONE_RTT]
<3> crypto_stream = self._crypto_streams[tls.Epoch.ONE_RTT]
<4> packet_type = PACKET_TYPE_ONE_RTT
<5> elif self._cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
<6> crypto = self._cryptos[tls.Epoch.ZERO_RTT]
<7> packet_type = PACKET_TYPE_ZERO_RTT
<8> else:
<9> return
<10> space = self._spaces[tls.Epoch.ONE_RTT]
<11>
<12> buf = builder.buffer
<13>
<14> while builder.flight_bytes < max_bytes or self._probe_pending:
<15> # write header
<16> builder.start_packet(packet_type, crypto)
<17>
<18> if self._handshake_complete:
<19> # ACK
<20> if space.ack_required:
<21> builder.start_frame(
<22> QuicFrameType.ACK,
<23> self._on_ack_delivery,
<24> (space, space.largest_received_packet),
<25> )
<26> push_ack_frame(buf, space.ack_queue, 0)
<27> space.ack_required = False
<28>
<29> # PATH CHALLENGE
<30> if (
<31> not network_path.is_validated
<32> and network_path.local_challenge is None
<33> ):
<34> self._logger.info(
<35> "Network path %s sending challenge",</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
+ self,
+ builder: QuicPacketBuilder,
+ max_bytes: int,
+ network_path: QuicNetworkPath,
+ now: float,
- self, builder: QuicPacketBuilder, max_bytes: int, network_path: QuicNetworkPath
) -> None:
# offset: 1
)
network_path.local_challenge = os.urandom(8)
builder.start_frame(QuicFrameType.PATH_CHALLENGE)
buf.push_bytes(network_path.local_challenge)
# PATH RESPONSE
if network_path.remote_challenge is not None:
builder.start_frame(QuicFrameType.PATH_RESPONSE)
buf.push_bytes(network_path.remote_challenge)
network_path.remote_challenge = None
# NEW_CONNECTION_ID
for connection_id in self._host_cids:
if not connection_id.was_sent:
builder.start_frame(
QuicFrameType.NEW_CONNECTION_ID,
self._on_new_connection_id_delivery,
(connection_id,),
)
push_new_connection_id_frame(
buf,
connection_id.sequence_number,
connection_id.cid,
connection_id.stateless_reset_token,
)
connection_id.was_sent = True
self._connection_id_issued_handler(connection_id.cid)
# RETIRE_CONNECTION_ID
while self._retire_connection_ids:
sequence_number = self._retire_connection_ids.pop(0)
builder.start_frame(
QuicFrameType.RETIRE_CONNECTION_ID,
self._on_retire_connection_id_delivery,
(sequence_number,),
)
buf.push_uint_var(sequence_number)
# connection-level limits
self._write_connection_</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
+ self,
+ builder: QuicPacketBuilder,
+ max_bytes: int,
+ network_path: QuicNetworkPath,
+ now: float,
- self, builder: QuicPacketBuilder, max_bytes: int, network_path: QuicNetworkPath
) -> None:
# offset: 2
<s>
buf.push_uint_var(sequence_number)
# connection-level limits
self._write_connection_limits(builder=builder, space=space)
# stream-level limits
for stream in self._streams.values():
self._write_stream_limits(builder=builder, space=space, stream=stream)
# PING (user-request)
if self._ping_pending:
self._logger.info("Sending PING in packet %d", builder.packet_number)
builder.start_frame(QuicFrameType.PING, self._on_ping_delivery)
self._ping_pending = False
# PING (probe)
if self._probe_pending:
self._logger.info("Sending probe")
builder.start_frame(QuicFrameType.PING)
self._probe_pending = False
# CRYPTO
if crypto_stream is not None and not crypto_stream.send_buffer_is_empty:
write_crypto_frame(builder=builder, space=space, stream=crypto_stream)
for stream in self._streams.values():
# STREAM
if not stream.send_buffer_is_empty:
self._remote_max_data_used += write_stream_frame(
builder=builder,
space=space,
stream=stream,
max_offset=min(
stream._send_highest
+ self._remote_max_data
- self._remote_max_data_used,
stream.max
===========unchanged ref 0===========
at: aioquic.buffer.Buffer
push_bytes(v: bytes) -> None
push_uint_var(value: int) -> None
at: aioquic.connection
write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
write_stream_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream, max_offset: int) -> int
QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, is_validated: bool=False, local_challenge: Optional[bytes]=None, remote_challenge: Optional[bytes]=None)
at: aioquic.connection.QuicConnection
_on_ack_delivery(delivery: QuicDeliveryState, space: QuicPacketSpace, highest_acked: int) -> None
_on_new_connection_id_delivery(delivery: QuicDeliveryState, connection_id: QuicConnectionId) -> None
_on_ping_delivery(delivery: QuicDeliveryState) -> None
_on_retire_connection_id_delivery(delivery: QuicDeliveryState, sequence_number: int) -> None
_write_connection_limits(builder: QuicPacketBuilder, space: QuicPacketSpace) -> None
_write_stream_limits(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
at: aioquic.connection.QuicConnection.__init__
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
self._handshake_complete = False
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
===========unchanged ref 1===========
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._remote_max_data_used = 0
self._spaces: Dict[tls.Epoch, QuicPacketSpace] = {}
self._streams: Dict[int, QuicStream] = {}
self._ping_pending = False
self._probe_pending = False
self._retire_connection_ids: List[int] = []
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
at: aioquic.connection.QuicConnection._handle_crypto_frame
self._handshake_complete = True
at: aioquic.connection.QuicConnection._initialize
self._cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self._crypto_streams = {
tls.Epoch.INITIAL: QuicStream(),
tls.Epoch.HANDSHAKE: QuicStream(),
tls.Epoch.ONE_RTT: QuicStream(),
}
self._spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.connection.QuicConnection._on_ping_delivery
self._ping_pending = True
at: aioquic.connection.QuicConnection._send_probe
self._probe_pending = True
at: aioquic.connection.QuicConnection.ping
self._ping_pending = True
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
is_validated: bool = False
local_challenge: Optional[bytes] = None
remote_challenge: Optional[bytes] = None
|
aioquic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
23a4f24bdd43335246b755d140840e7f616f7493
|
[connection] delay ACKs by 1ms
|
<16>:<add> if space.ack_at is not None:
<del> if space.ack_required:
<19>:<add> space.ack_at = None
<del> space.ack_required = False
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(
self, builder: QuicPacketBuilder, epoch: tls.Epoch, max_bytes: int
) -> None:
<0> crypto = self._cryptos[epoch]
<1> if not crypto.send.is_valid():
<2> return
<3>
<4> buf = builder.buffer
<5> crypto_stream = self._crypto_streams[epoch]
<6> space = self._spaces[epoch]
<7>
<8> while builder.flight_bytes < max_bytes:
<9> if epoch == tls.Epoch.INITIAL:
<10> packet_type = PACKET_TYPE_INITIAL
<11> else:
<12> packet_type = PACKET_TYPE_HANDSHAKE
<13> builder.start_packet(packet_type, crypto)
<14>
<15> # ACK
<16> if space.ack_required:
<17> builder.start_frame(QuicFrameType.ACK)
<18> push_ack_frame(buf, space.ack_queue, 0)
<19> space.ack_required = False
<20>
<21> # CRYPTO
<22> if not crypto_stream.send_buffer_is_empty:
<23> write_crypto_frame(builder=builder, space=space, stream=crypto_stream)
<24>
<25> if not builder.end_packet():
<26> break
<27>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection.__init__
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
self._remote_max_data = 0
self._remote_max_data_used = 0
self._spaces: Dict[tls.Epoch, QuicPacketSpace] = {}
at: aioquic.connection.QuicConnection._handle_max_data_frame
self._remote_max_data = max_data
at: aioquic.connection.QuicConnection._initialize
self._cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self._crypto_streams = {
tls.Epoch.INITIAL: QuicStream(),
tls.Epoch.HANDSHAKE: QuicStream(),
tls.Epoch.ONE_RTT: QuicStream(),
}
self._spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.connection.QuicConnection._write_application
self._remote_max_data_used += write_stream_frame(
builder=builder,
space=space,
stream=stream,
max_offset=min(
stream._send_highest
+ self._remote_max_data
- self._remote_max_data_used,
stream.max_stream_data_remote,
),
)
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
===========unchanged ref 1===========
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _set_timer(self) -> None:
# determine earliest timeout
timer_at = self._close_at
if self._state not in END_STATES:
+ # ack timer
+ for space in self._loss.spaces:
+ if space.ack_at is not None and space.ack_at < timer_at:
+ timer_at = space.ack_at
+
+ # loss detection timer
+ self._loss_at = self._loss.get_loss_detection_time()
- loss_at = self._loss.get_loss_detection_time()
+ if self._loss_at is not None and self._loss_at < timer_at:
- if loss_at is not None and loss_at < timer_at:
+ timer_at = self._loss_at
- timer_at = loss_at
# re-arm timer
if self._timer is not None and self._timer_at != timer_at:
self._timer.cancel()
self._timer = None
if self._timer is None and timer_at is not None:
self._timer = self._loop.call_at(timer_at, self._on_timeout)
self._timer_at = timer_at
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _on_timeout(self) -> None:
+ now = self._loop.time() + K_GRANULARITY
- now = self._loop.time()
self._timer = None
self._timer_at = None
# idle timeout
+ if now >= self._close_at:
- if now + K_GRANULARITY >= self._close_at:
self.connection_lost(self._close_exception)
return
# loss detection timeout
+ if self._loss_at is not None and now >= self._loss_at:
+ self._logger.info("Loss detection triggered")
- self._logger.info("Loss detection triggered")
+ self._loss.on_loss_detection_timeout(now=now)
- self._loss.on_loss_detection_timeout(now=now)
self._send_pending()
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
network_path = self._network_paths[0]
self._send_task = None
if self._state in END_STATES:
return
# build datagrams
builder = QuicPacketBuilder(
host_cid=self.host_cid,
packet_number=self._packet_number,
pad_first_datagram=(
self.is_client and self._state == QuicConnectionState.FIRSTFLIGHT
),
peer_cid=self._peer_cid,
peer_token=self._peer_token,
spin_bit=self._spin_bit,
version=self._version,
)
if self._close_pending:
for epoch, packet_type in (
(tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
(tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
(tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
):
crypto = self._cryptos[epoch]
if crypto.send.is_valid():
builder.start_packet(packet_type, crypto)
write_close_frame(builder, **self._close_pending)
builder.end_packet()
self._close_pending = None
break
self._close(is_initiator=True)
else:
# data is limited by congestion control and whether the network path is validated
max_bytes = self._loss.congestion_window - self._loss.bytes_in_flight
if not network_path.is_validated:
max_bytes = min(
max_bytes, network_path.bytes_received * 3 - network_path.bytes_sent
)
if not self._handshake_confirmed:
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch, max_bytes)
+ self._write_</s>
|
tests.test_connection/QuicConnectionTest.test_consume_connection_id
|
Modified
|
aiortc~aioquic
|
23a4f24bdd43335246b755d140840e7f616f7493
|
[connection] delay ACKs by 1ms
|
<13>:<add> # wait one RTT
<add> run(asyncio.sleep(RTT))
<add>
<14>:<del> run(asyncio.sleep(0))
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_consume_connection_id(self):
<0> with client_and_server() as (client, server):
<1> run(client.wait_connected())
<2> self.assertEqual(
<3> sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<4> )
<5>
<6> # change connection ID
<7> client._consume_connection_id()
<8> client._send_pending()
<9> self.assertEqual(
<10> sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
<11> )
<12>
<13> # the server provides a new connection ID
<14> run(asyncio.sleep(0))
<15> self.assertEqual(
<16> sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
<17> )
<18>
|
===========unchanged ref 0===========
at: asyncio.tasks
sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: tests.test_connection
RTT = 0.005
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
sequence_numbers(connection_ids)
at: tests.test_connection.QuicConnectionTest.test_connection_lost_with_exception
exc = Exception("some error")
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
at: unittest.case._AssertRaisesContext.__exit__
self.exception = exc_value.with_traceback(None)
===========changed ref 0===========
# module: tests.test_connection
+ RTT = 0.005
+
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
===========changed ref 1===========
# module: aioquic.recovery
class QuicPacketRecovery:
def discard_space(self, space: QuicPacketSpace) -> None:
assert space in self.spaces
for packet in space.sent_packets.values():
if packet.in_flight:
self.on_packet_expired(packet)
space.sent_packets.clear()
+ space.ack_at = None
space.ack_eliciting_in_flight = 0
space.crypto_packet_in_flight = 0
space.loss_time = None
===========changed ref 2===========
# module: aioquic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
+ self.ack_at: Optional[float] = None
self.ack_queue = RangeSet()
- self.ack_required = False
self.expected_packet_number = 0
self.largest_received_packet = 0
# sent packets and loss
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
self.largest_acked_packet = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _on_timeout(self) -> None:
+ now = self._loop.time() + K_GRANULARITY
- now = self._loop.time()
self._timer = None
self._timer_at = None
# idle timeout
+ if now >= self._close_at:
- if now + K_GRANULARITY >= self._close_at:
self.connection_lost(self._close_exception)
return
# loss detection timeout
+ if self._loss_at is not None and now >= self._loss_at:
+ self._logger.info("Loss detection triggered")
- self._logger.info("Loss detection triggered")
+ self._loss.on_loss_detection_timeout(now=now)
- self._loss.on_loss_detection_timeout(now=now)
self._send_pending()
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(
self, builder: QuicPacketBuilder, epoch: tls.Epoch, max_bytes: int
) -> None:
crypto = self._cryptos[epoch]
if not crypto.send.is_valid():
return
buf = builder.buffer
crypto_stream = self._crypto_streams[epoch]
space = self._spaces[epoch]
while builder.flight_bytes < max_bytes:
if epoch == tls.Epoch.INITIAL:
packet_type = PACKET_TYPE_INITIAL
else:
packet_type = PACKET_TYPE_HANDSHAKE
builder.start_packet(packet_type, crypto)
# ACK
+ if space.ack_at is not None:
- if space.ack_required:
builder.start_frame(QuicFrameType.ACK)
push_ack_frame(buf, space.ack_queue, 0)
+ space.ack_at = None
- space.ack_required = False
# CRYPTO
if not crypto_stream.send_buffer_is_empty:
write_crypto_frame(builder=builder, space=space, stream=crypto_stream)
if not builder.end_packet():
break
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _set_timer(self) -> None:
# determine earliest timeout
timer_at = self._close_at
if self._state not in END_STATES:
+ # ack timer
+ for space in self._loss.spaces:
+ if space.ack_at is not None and space.ack_at < timer_at:
+ timer_at = space.ack_at
+
+ # loss detection timer
+ self._loss_at = self._loss.get_loss_detection_time()
- loss_at = self._loss.get_loss_detection_time()
+ if self._loss_at is not None and self._loss_at < timer_at:
- if loss_at is not None and loss_at < timer_at:
+ timer_at = self._loss_at
- timer_at = loss_at
# re-arm timer
if self._timer is not None and self._timer_at != timer_at:
self._timer.cancel()
self._timer = None
if self._timer is None and timer_at is not None:
self._timer = self._loop.call_at(timer_at, self._on_timeout)
self._timer_at = timer_at
|
tests.test_connection/QuicConnectionTest.test_handle_path_challenge_frame
|
Modified
|
aiortc~aioquic
|
23a4f24bdd43335246b755d140840e7f616f7493
|
[connection] delay ACKs by 1ms
|
<5>:<add>
<add> # wait one RTT
<add> run(asyncio.sleep(RTT))
<del> run(asyncio.sleep(0))
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_path_challenge_frame(self):
<0> with client_and_server() as (client, server):
<1> # client changes address and sends some data
<2> client._transport.local_addr = ("1.2.3.4", 2345)
<3> reader, writer = run(client.create_stream())
<4> writer.write(b"01234567")
<5> run(asyncio.sleep(0))
<6>
<7> # server sends PATH_CHALLENGE and receives PATH_RESPONSE
<8> self.assertEqual(len(server._network_paths), 2)
<9>
<10> # check new path
<11> self.assertEqual(server._network_paths[0].addr, ("1.2.3.4", 2345))
<12> self.assertTrue(server._network_paths[0].is_validated)
<13>
<14> # check old path
<15> self.assertEqual(server._network_paths[1].addr, ("1.2.3.4", 1234))
<16> self.assertTrue(server._network_paths[1].is_validated)
<17>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: asyncio.tasks
sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_connection
RTT = 0.005
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_consume_connection_id(self):
with client_and_server() as (client, server):
run(client.wait_connected())
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
# change connection ID
client._consume_connection_id()
client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
)
+ # wait one RTT
+ run(asyncio.sleep(RTT))
+
# the server provides a new connection ID
- run(asyncio.sleep(0))
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
)
===========changed ref 1===========
# module: tests.test_connection
+ RTT = 0.005
+
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
===========changed ref 2===========
# module: aioquic.recovery
class QuicPacketRecovery:
def discard_space(self, space: QuicPacketSpace) -> None:
assert space in self.spaces
for packet in space.sent_packets.values():
if packet.in_flight:
self.on_packet_expired(packet)
space.sent_packets.clear()
+ space.ack_at = None
space.ack_eliciting_in_flight = 0
space.crypto_packet_in_flight = 0
space.loss_time = None
===========changed ref 3===========
# module: aioquic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
+ self.ack_at: Optional[float] = None
self.ack_queue = RangeSet()
- self.ack_required = False
self.expected_packet_number = 0
self.largest_received_packet = 0
# sent packets and loss
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
self.largest_acked_packet = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _on_timeout(self) -> None:
+ now = self._loop.time() + K_GRANULARITY
- now = self._loop.time()
self._timer = None
self._timer_at = None
# idle timeout
+ if now >= self._close_at:
- if now + K_GRANULARITY >= self._close_at:
self.connection_lost(self._close_exception)
return
# loss detection timeout
+ if self._loss_at is not None and now >= self._loss_at:
+ self._logger.info("Loss detection triggered")
- self._logger.info("Loss detection triggered")
+ self._loss.on_loss_detection_timeout(now=now)
- self._loss.on_loss_detection_timeout(now=now)
self._send_pending()
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(
self, builder: QuicPacketBuilder, epoch: tls.Epoch, max_bytes: int
) -> None:
crypto = self._cryptos[epoch]
if not crypto.send.is_valid():
return
buf = builder.buffer
crypto_stream = self._crypto_streams[epoch]
space = self._spaces[epoch]
while builder.flight_bytes < max_bytes:
if epoch == tls.Epoch.INITIAL:
packet_type = PACKET_TYPE_INITIAL
else:
packet_type = PACKET_TYPE_HANDSHAKE
builder.start_packet(packet_type, crypto)
# ACK
+ if space.ack_at is not None:
- if space.ack_required:
builder.start_frame(QuicFrameType.ACK)
push_ack_frame(buf, space.ack_queue, 0)
+ space.ack_at = None
- space.ack_required = False
# CRYPTO
if not crypto_stream.send_buffer_is_empty:
write_crypto_frame(builder=builder, space=space, stream=crypto_stream)
if not builder.end_packet():
break
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _set_timer(self) -> None:
# determine earliest timeout
timer_at = self._close_at
if self._state not in END_STATES:
+ # ack timer
+ for space in self._loss.spaces:
+ if space.ack_at is not None and space.ack_at < timer_at:
+ timer_at = space.ack_at
+
+ # loss detection timer
+ self._loss_at = self._loss.get_loss_detection_time()
- loss_at = self._loss.get_loss_detection_time()
+ if self._loss_at is not None and self._loss_at < timer_at:
- if loss_at is not None and loss_at < timer_at:
+ timer_at = self._loss_at
- timer_at = loss_at
# re-arm timer
if self._timer is not None and self._timer_at != timer_at:
self._timer.cancel()
self._timer = None
if self._timer is None and timer_at is not None:
self._timer = self._loop.call_at(timer_at, self._on_timeout)
self._timer_at = timer_at
|
aioquic.crypto/CryptoContext.__init__
|
Modified
|
aiortc~aioquic
|
bc15d4de59d7328a9df12fa471c0bd24b74a1dd4
|
[crypto] pass packet_number to AEAD code
|
<3>:<del> self.iv: Optional[bytes] = None
|
# module: aioquic.crypto
class CryptoContext:
def __init__(self, key_phase: int = 0) -> None:
<0> self.aead: Optional[AEAD] = None
<1> self.cipher_suite: Optional[CipherSuite] = None
<2> self.hp: Optional[HeaderProtection] = None
<3> self.iv: Optional[bytes] = None
<4> self.key_phase = key_phase
<5> self.secret: Optional[bytes] = None
<6>
|
===========unchanged ref 0===========
at: aioquic._crypto
AEAD(cipher_name: bytes, key: bytes)
HeaderProtection(cipher_name: bytes, key: bytes)
at: aioquic.crypto.CryptoContext.setup
key, iv, hp = derive_key_iv_hp(cipher_suite, secret)
self.hp = HeaderProtection(hp_cipher_name, hp)
self.aead = AEAD(aead_cipher_name, key, iv)
self.cipher_suite = cipher_suite
self.secret = secret
at: aioquic.crypto.CryptoContext.teardown
self.aead = None
self.cipher_suite = None
self.hp = None
self.secret = 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
|
bc15d4de59d7328a9df12fa471c0bd24b74a1dd4
|
[crypto] pass packet_number to AEAD code
|
<6>:<add>
<add> # packet number
<add> packet_number = 0
<add> pn_length = (first_byte & 0x03) + 1
<add> for i in range(pn_length):
<add> packet_number = (packet_number << 8) | plain_header[encrypted_offset + i]
<add> packet_number = decode_packet_number(
<add> packet_number, pn_length * 8, expected_packet_number
<add> )
<16>:<add> packet[len(plain_header) :], plain_header, packet_number
<del> crypto.iv, packet[len(plain_header) :], plain_header
<17>:<del> )
<18>:<del>
<19>:<del> # packet number
<20>:<del> packet_number = 0
<21>:<del> pn_length = (first_byte & 0x03) + 1
<22>:<del> for i in range(pn_length):
<23>:<del> packet_number = (packet_number << 8) | plain_header[encrypted_offset + i]
<24>:<del> packet_number = decode_packet_number(
<25>:<del> packet_number, pn_length * 8, expected_packet_number
|
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int, expected_packet_number: int
) -> Tuple[bytes, bytes, int, bool]:
<0> if self.aead is None:
<1> raise CryptoError("Decryption key is not available")
<2>
<3> # header protection
<4> plain_header = self.hp.remove(packet, encrypted_offset)
<5> first_byte = plain_header[0]
<6>
<7> # detect key phase change
<8> crypto = self
<9> if not is_long_header(first_byte):
<10> key_phase = (first_byte & 4) >> 2
<11> if key_phase != self.key_phase:
<12> crypto = next_key_phase(self)
<13>
<14> # payload protection
<15> payload = crypto.aead.decrypt(
<16> crypto.iv, packet[len(plain_header) :], plain_header
<17> )
<18>
<19> # packet number
<20> packet_number = 0
<21> pn_length = (first_byte & 0x03) + 1
<22> for i in range(pn_length):
<23> packet_number = (packet_number << 8) | plain_header[encrypted_offset + i]
<24> packet_number = decode_packet_number(
<25> packet_number, pn_length * 8, expected_packet_number
<26> )
<27>
<28> return plain_header, payload, packet_number, crypto != self
<29>
|
===========unchanged ref 0===========
at: aioquic._crypto
CryptoError(*args: object)
at: aioquic._crypto.AEAD
decrypt(nonce: bytes, data: bytes, associated_data: bytes) -> bytes
at: aioquic._crypto.HeaderProtection
remove(packet: bytes, encrypted_offset: int) -> bytes
at: aioquic.crypto
next_key_phase(self: CryptoContext) -> CryptoContext
at: aioquic.crypto.CryptoContext.__init__
self.aead: Optional[AEAD] = None
self.hp: Optional[HeaderProtection] = None
self.key_phase = key_phase
at: aioquic.crypto.CryptoContext.setup
key, iv, hp = derive_key_iv_hp(cipher_suite, secret)
self.hp = HeaderProtection(hp_cipher_name, hp)
self.aead = AEAD(aead_cipher_name, key, iv)
at: aioquic.crypto.CryptoContext.teardown
self.aead = None
self.hp = None
at: aioquic.packet
decode_packet_number(truncated: int, num_bits: int, expected: int) -> int
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:
self.aead: Optional[AEAD] = None
self.cipher_suite: Optional[CipherSuite] = None
self.hp: Optional[HeaderProtection] = None
- self.iv: Optional[bytes] = None
self.key_phase = key_phase
self.secret: Optional[bytes] = None
|
aioquic.crypto/CryptoContext.encrypt_packet
|
Modified
|
aiortc~aioquic
|
bc15d4de59d7328a9df12fa471c0bd24b74a1dd4
|
[crypto] pass packet_number to AEAD code
|
<3>:<add> protected_payload = self.aead.encrypt(
<add> plain_payload, plain_header, packet_number
<add> )
<del> protected_payload = self.aead.encrypt(self.iv, plain_payload, plain_header)
|
# module: aioquic.crypto
class CryptoContext:
+ def encrypt_packet(
+ self, plain_header: bytes, plain_payload: bytes, packet_number: int
+ ) -> bytes:
- def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
<0> assert self.is_valid(), "Encryption key is not available"
<1>
<2> # payload protection
<3> protected_payload = self.aead.encrypt(self.iv, plain_payload, plain_header)
<4>
<5> # header protection
<6> return self.hp.apply(plain_header, protected_payload)
<7>
|
===========unchanged ref 0===========
at: aioquic._crypto.AEAD
encrypt(nonce: bytes, data: bytes, associated_data: bytes) -> bytes
at: aioquic.crypto.CryptoContext
is_valid(self) -> bool
is_valid() -> bool
at: aioquic.crypto.CryptoContext.__init__
self.aead: Optional[AEAD] = None
at: aioquic.crypto.CryptoContext.setup
self.aead = AEAD(aead_cipher_name, key, iv)
at: aioquic.crypto.CryptoContext.teardown
self.aead = None
===========changed ref 0===========
# module: aioquic.crypto
class CryptoContext:
def __init__(self, key_phase: int = 0) -> None:
self.aead: Optional[AEAD] = None
self.cipher_suite: Optional[CipherSuite] = None
self.hp: Optional[HeaderProtection] = None
- self.iv: Optional[bytes] = None
self.key_phase = key_phase
self.secret: Optional[bytes] = None
===========changed ref 1===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int, expected_packet_number: int
) -> Tuple[bytes, bytes, int, bool]:
if self.aead is None:
raise CryptoError("Decryption key is not available")
# header protection
plain_header = self.hp.remove(packet, encrypted_offset)
first_byte = plain_header[0]
+
+ # packet number
+ packet_number = 0
+ pn_length = (first_byte & 0x03) + 1
+ for i in range(pn_length):
+ packet_number = (packet_number << 8) | plain_header[encrypted_offset + i]
+ packet_number = decode_packet_number(
+ packet_number, pn_length * 8, expected_packet_number
+ )
# detect key phase change
crypto = self
if not is_long_header(first_byte):
key_phase = (first_byte & 4) >> 2
if key_phase != self.key_phase:
crypto = next_key_phase(self)
# payload protection
payload = crypto.aead.decrypt(
+ packet[len(plain_header) :], plain_header, packet_number
- crypto.iv, packet[len(plain_header) :], plain_header
- )
-
- # packet number
- packet_number = 0
- pn_length = (first_byte & 0x03) + 1
- for i in range(pn_length):
- packet_number = (packet_number << 8) | plain_header[encrypted_offset + i]
- packet_number = decode_packet_number(
- packet_number, pn_length * 8, expected_packet_number
)
return plain_header, payload, packet_number, crypto != self
|
aioquic.crypto/CryptoContext.setup
|
Modified
|
aiortc~aioquic
|
bc15d4de59d7328a9df12fa471c0bd24b74a1dd4
|
[crypto] pass packet_number to AEAD code
|
<2>:<add> key, iv, hp = derive_key_iv_hp(cipher_suite, secret)
<del> key, self.iv, hp = derive_key_iv_hp(cipher_suite, secret)
<3>:<add> self.aead = AEAD(aead_cipher_name, key, iv)
<del> self.aead = AEAD(aead_cipher_name, key)
|
# module: aioquic.crypto
class CryptoContext:
def setup(self, cipher_suite: CipherSuite, secret: bytes) -> None:
<0> hp_cipher_name, aead_cipher_name = CIPHER_SUITES[cipher_suite]
<1>
<2> key, self.iv, hp = derive_key_iv_hp(cipher_suite, secret)
<3> self.aead = AEAD(aead_cipher_name, key)
<4> self.cipher_suite = cipher_suite
<5> self.hp = HeaderProtection(hp_cipher_name, hp)
<6> self.secret = secret
<7>
|
===========unchanged ref 0===========
at: aioquic._crypto
AEAD(cipher_name: bytes, key: bytes)
at: aioquic.crypto
CIPHER_SUITES = {
CipherSuite.AES_128_GCM_SHA256: (b"aes-128-ecb", b"aes-128-gcm"),
CipherSuite.AES_256_GCM_SHA384: (b"aes-256-ecb", b"aes-256-gcm"),
CipherSuite.CHACHA20_POLY1305_SHA256: (b"chacha20", b"chacha20-poly1305"),
}
derive_key_iv_hp(cipher_suite: CipherSuite, secret: bytes) -> Tuple[bytes, bytes, bytes]
at: aioquic.crypto.CryptoContext.__init__
self.aead: Optional[AEAD] = None
at: aioquic.crypto.CryptoContext.teardown
self.aead = None
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 encrypt_packet(
+ self, plain_header: bytes, plain_payload: bytes, packet_number: int
+ ) -> bytes:
- def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
assert self.is_valid(), "Encryption key is not available"
# payload protection
+ protected_payload = self.aead.encrypt(
+ plain_payload, plain_header, packet_number
+ )
- protected_payload = self.aead.encrypt(self.iv, plain_payload, plain_header)
# header protection
return self.hp.apply(plain_header, protected_payload)
===========changed ref 1===========
# module: aioquic.crypto
class CryptoContext:
def __init__(self, key_phase: int = 0) -> None:
self.aead: Optional[AEAD] = None
self.cipher_suite: Optional[CipherSuite] = None
self.hp: Optional[HeaderProtection] = None
- self.iv: Optional[bytes] = None
self.key_phase = key_phase
self.secret: Optional[bytes] = None
===========changed ref 2===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int, expected_packet_number: int
) -> Tuple[bytes, bytes, int, bool]:
if self.aead is None:
raise CryptoError("Decryption key is not available")
# header protection
plain_header = self.hp.remove(packet, encrypted_offset)
first_byte = plain_header[0]
+
+ # packet number
+ packet_number = 0
+ pn_length = (first_byte & 0x03) + 1
+ for i in range(pn_length):
+ packet_number = (packet_number << 8) | plain_header[encrypted_offset + i]
+ packet_number = decode_packet_number(
+ packet_number, pn_length * 8, expected_packet_number
+ )
# detect key phase change
crypto = self
if not is_long_header(first_byte):
key_phase = (first_byte & 4) >> 2
if key_phase != self.key_phase:
crypto = next_key_phase(self)
# payload protection
payload = crypto.aead.decrypt(
+ packet[len(plain_header) :], plain_header, packet_number
- crypto.iv, packet[len(plain_header) :], plain_header
- )
-
- # packet number
- packet_number = 0
- pn_length = (first_byte & 0x03) + 1
- for i in range(pn_length):
- packet_number = (packet_number << 8) | plain_header[encrypted_offset + i]
- packet_number = decode_packet_number(
- packet_number, pn_length * 8, expected_packet_number
)
return plain_header, payload, packet_number, crypto != self
|
aioquic.crypto/CryptoContext.teardown
|
Modified
|
aiortc~aioquic
|
bc15d4de59d7328a9df12fa471c0bd24b74a1dd4
|
[crypto] pass packet_number to AEAD code
|
<3>:<del> self.iv = 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> self.secret = None
<5>
|
===========unchanged ref 0===========
at: aioquic._crypto
HeaderProtection(cipher_name: bytes, key: bytes)
at: aioquic.crypto.CryptoContext.__init__
self.aead: Optional[AEAD] = None
self.cipher_suite: Optional[CipherSuite] = None
self.hp: Optional[HeaderProtection] = None
self.secret: Optional[bytes] = None
at: aioquic.crypto.CryptoContext.setup
hp_cipher_name, aead_cipher_name = CIPHER_SUITES[cipher_suite]
self.aead = AEAD(aead_cipher_name, key, iv)
self.cipher_suite = cipher_suite
at: aioquic.crypto.CryptoContext.teardown
self.hp = None
self.secret = None
===========changed ref 0===========
# module: aioquic.crypto
class CryptoContext:
+ def encrypt_packet(
+ self, plain_header: bytes, plain_payload: bytes, packet_number: int
+ ) -> bytes:
- def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
assert self.is_valid(), "Encryption key is not available"
# payload protection
+ protected_payload = self.aead.encrypt(
+ plain_payload, plain_header, packet_number
+ )
- protected_payload = self.aead.encrypt(self.iv, plain_payload, plain_header)
# header protection
return self.hp.apply(plain_header, protected_payload)
===========changed ref 1===========
# module: aioquic.crypto
class CryptoContext:
def __init__(self, key_phase: int = 0) -> None:
self.aead: Optional[AEAD] = None
self.cipher_suite: Optional[CipherSuite] = None
self.hp: Optional[HeaderProtection] = None
- self.iv: Optional[bytes] = None
self.key_phase = key_phase
self.secret: Optional[bytes] = None
===========changed ref 2===========
# module: aioquic.crypto
class CryptoContext:
def setup(self, cipher_suite: CipherSuite, secret: bytes) -> None:
hp_cipher_name, aead_cipher_name = CIPHER_SUITES[cipher_suite]
+ key, iv, hp = derive_key_iv_hp(cipher_suite, secret)
- key, self.iv, hp = derive_key_iv_hp(cipher_suite, secret)
+ self.aead = AEAD(aead_cipher_name, key, iv)
- self.aead = AEAD(aead_cipher_name, key)
self.cipher_suite = cipher_suite
self.hp = HeaderProtection(hp_cipher_name, hp)
self.secret = secret
===========changed ref 3===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int, expected_packet_number: int
) -> Tuple[bytes, bytes, int, bool]:
if self.aead is None:
raise CryptoError("Decryption key is not available")
# header protection
plain_header = self.hp.remove(packet, encrypted_offset)
first_byte = plain_header[0]
+
+ # packet number
+ packet_number = 0
+ pn_length = (first_byte & 0x03) + 1
+ for i in range(pn_length):
+ packet_number = (packet_number << 8) | plain_header[encrypted_offset + i]
+ packet_number = decode_packet_number(
+ packet_number, pn_length * 8, expected_packet_number
+ )
# detect key phase change
crypto = self
if not is_long_header(first_byte):
key_phase = (first_byte & 4) >> 2
if key_phase != self.key_phase:
crypto = next_key_phase(self)
# payload protection
payload = crypto.aead.decrypt(
+ packet[len(plain_header) :], plain_header, packet_number
- crypto.iv, packet[len(plain_header) :], plain_header
- )
-
- # packet number
- packet_number = 0
- pn_length = (first_byte & 0x03) + 1
- for i in range(pn_length):
- packet_number = (packet_number << 8) | plain_header[encrypted_offset + i]
- packet_number = decode_packet_number(
- packet_number, pn_length * 8, expected_packet_number
)
return plain_header, payload, packet_number, crypto != self
|
aioquic.crypto/apply_key_phase
|
Modified
|
aiortc~aioquic
|
bc15d4de59d7328a9df12fa471c0bd24b74a1dd4
|
[crypto] pass packet_number to AEAD code
|
<1>:<del> self.iv = crypto.iv
|
# module: aioquic.crypto
def apply_key_phase(self: CryptoContext, crypto: CryptoContext) -> None:
<0> self.aead = crypto.aead
<1> self.iv = crypto.iv
<2> self.key_phase = crypto.key_phase
<3> self.secret = crypto.secret
<4>
|
===========unchanged ref 0===========
at: aioquic.crypto
CryptoContext(key_phase: int=0)
at: aioquic.crypto.CryptoContext.__init__
self.aead: Optional[AEAD] = None
self.key_phase = key_phase
at: aioquic.crypto.CryptoContext.setup
self.aead = AEAD(aead_cipher_name, key, iv)
at: aioquic.crypto.CryptoContext.teardown
self.aead = None
===========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 encrypt_packet(
+ self, plain_header: bytes, plain_payload: bytes, packet_number: int
+ ) -> bytes:
- def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
assert self.is_valid(), "Encryption key is not available"
# payload protection
+ protected_payload = self.aead.encrypt(
+ plain_payload, plain_header, packet_number
+ )
- protected_payload = self.aead.encrypt(self.iv, plain_payload, plain_header)
# header protection
return self.hp.apply(plain_header, protected_payload)
===========changed ref 2===========
# module: aioquic.crypto
class CryptoContext:
def __init__(self, key_phase: int = 0) -> None:
self.aead: Optional[AEAD] = None
self.cipher_suite: Optional[CipherSuite] = None
self.hp: Optional[HeaderProtection] = None
- self.iv: Optional[bytes] = None
self.key_phase = key_phase
self.secret: Optional[bytes] = None
===========changed ref 3===========
# module: aioquic.crypto
class CryptoContext:
def setup(self, cipher_suite: CipherSuite, secret: bytes) -> None:
hp_cipher_name, aead_cipher_name = CIPHER_SUITES[cipher_suite]
+ key, iv, hp = derive_key_iv_hp(cipher_suite, secret)
- key, self.iv, hp = derive_key_iv_hp(cipher_suite, secret)
+ self.aead = AEAD(aead_cipher_name, key, iv)
- self.aead = AEAD(aead_cipher_name, key)
self.cipher_suite = cipher_suite
self.hp = HeaderProtection(hp_cipher_name, hp)
self.secret = secret
===========changed ref 4===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int, expected_packet_number: int
) -> Tuple[bytes, bytes, int, bool]:
if self.aead is None:
raise CryptoError("Decryption key is not available")
# header protection
plain_header = self.hp.remove(packet, encrypted_offset)
first_byte = plain_header[0]
+
+ # packet number
+ packet_number = 0
+ pn_length = (first_byte & 0x03) + 1
+ for i in range(pn_length):
+ packet_number = (packet_number << 8) | plain_header[encrypted_offset + i]
+ packet_number = decode_packet_number(
+ packet_number, pn_length * 8, expected_packet_number
+ )
# detect key phase change
crypto = self
if not is_long_header(first_byte):
key_phase = (first_byte & 4) >> 2
if key_phase != self.key_phase:
crypto = next_key_phase(self)
# payload protection
payload = crypto.aead.decrypt(
+ packet[len(plain_header) :], plain_header, packet_number
- crypto.iv, packet[len(plain_header) :], plain_header
- )
-
- # packet number
- packet_number = 0
- pn_length = (first_byte & 0x03) + 1
- for i in range(pn_length):
- packet_number = (packet_number << 8) | plain_header[encrypted_offset + i]
- packet_number = decode_packet_number(
- packet_number, pn_length * 8, expected_packet_number
)
return plain_header, payload, packet_number, crypto != self
|
aioquic.crypto/CryptoPair.encrypt_packet
|
Modified
|
aiortc~aioquic
|
bc15d4de59d7328a9df12fa471c0bd24b74a1dd4
|
[crypto] pass packet_number to AEAD code
|
<2>:<add> return self.send.encrypt_packet(plain_header, plain_payload, packet_number)
<del> return self.send.encrypt_packet(plain_header, plain_payload)
|
# module: aioquic.crypto
class CryptoPair:
+ def encrypt_packet(
+ self, plain_header: bytes, plain_payload: bytes, packet_number: int
+ ) -> bytes:
- def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
<0> if self._update_key_requested:
<1> self._update_key()
<2> return self.send.encrypt_packet(plain_header, plain_payload)
<3>
|
===========changed ref 0===========
# module: aioquic.crypto
def apply_key_phase(self: CryptoContext, 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 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 encrypt_packet(
+ self, plain_header: bytes, plain_payload: bytes, packet_number: int
+ ) -> bytes:
- def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
assert self.is_valid(), "Encryption key is not available"
# payload protection
+ protected_payload = self.aead.encrypt(
+ plain_payload, plain_header, packet_number
+ )
- protected_payload = self.aead.encrypt(self.iv, plain_payload, plain_header)
# header protection
return self.hp.apply(plain_header, protected_payload)
===========changed ref 3===========
# module: aioquic.crypto
class CryptoContext:
def __init__(self, key_phase: int = 0) -> None:
self.aead: Optional[AEAD] = None
self.cipher_suite: Optional[CipherSuite] = None
self.hp: Optional[HeaderProtection] = None
- self.iv: Optional[bytes] = None
self.key_phase = key_phase
self.secret: Optional[bytes] = None
===========changed ref 4===========
# module: aioquic.crypto
class CryptoContext:
def setup(self, cipher_suite: CipherSuite, secret: bytes) -> None:
hp_cipher_name, aead_cipher_name = CIPHER_SUITES[cipher_suite]
+ key, iv, hp = derive_key_iv_hp(cipher_suite, secret)
- key, self.iv, hp = derive_key_iv_hp(cipher_suite, secret)
+ self.aead = AEAD(aead_cipher_name, key, iv)
- self.aead = AEAD(aead_cipher_name, key)
self.cipher_suite = cipher_suite
self.hp = HeaderProtection(hp_cipher_name, hp)
self.secret = secret
===========changed ref 5===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int, expected_packet_number: int
) -> Tuple[bytes, bytes, int, bool]:
if self.aead is None:
raise CryptoError("Decryption key is not available")
# header protection
plain_header = self.hp.remove(packet, encrypted_offset)
first_byte = plain_header[0]
+
+ # packet number
+ packet_number = 0
+ pn_length = (first_byte & 0x03) + 1
+ for i in range(pn_length):
+ packet_number = (packet_number << 8) | plain_header[encrypted_offset + i]
+ packet_number = decode_packet_number(
+ packet_number, pn_length * 8, expected_packet_number
+ )
# detect key phase change
crypto = self
if not is_long_header(first_byte):
key_phase = (first_byte & 4) >> 2
if key_phase != self.key_phase:
crypto = next_key_phase(self)
# payload protection
payload = crypto.aead.decrypt(
+ packet[len(plain_header) :], plain_header, packet_number
- crypto.iv, packet[len(plain_header) :], plain_header
- )
-
- # packet number
- packet_number = 0
- pn_length = (first_byte & 0x03) + 1
- for i in range(pn_length):
- packet_number = (packet_number << 8) | plain_header[encrypted_offset + i]
- packet_number = decode_packet_number(
- packet_number, pn_length * 8, expected_packet_number
)
return plain_header, payload, packet_number, crypto != self
|
aioquic.packet_builder/QuicPacketBuilder.end_packet
|
Modified
|
aiortc~aioquic
|
bc15d4de59d7328a9df12fa471c0bd24b74a1dd4
|
[crypto] pass packet_number to AEAD code
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
<0> """
<1> Ends the current packet.
<2>
<3> Returns `True` if the packet contains data, `False` otherwise.
<4> """
<5> buf = self.buffer
<6> empty = True
<7> packet_size = buf.tell() - self._packet_start
<8> if packet_size > self._header_size:
<9> empty = False
<10>
<11> # pad initial datagram
<12> if self._pad_first_datagram:
<13> buf.push_bytes(bytes(self.remaining_space))
<14> packet_size = buf.tell() - self._packet_start
<15> self._pad_first_datagram = False
<16>
<17> # write header
<18> if is_long_header(self._packet_type):
<19> length = (
<20> packet_size
<21> - self._header_size
<22> + PACKET_NUMBER_SEND_SIZE
<23> + self._packet_crypto.aead_tag_size
<24> )
<25>
<26> buf.seek(self._packet_start)
<27> buf.push_uint8(self._packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
<28> buf.push_uint32(self._version)
<29> buf.push_uint8(
<30> (encode_cid_length(len(self._peer_cid)) << 4)
<31> | encode_cid_length(len(self._host_cid))
<32> )
<33> buf.push_bytes(self._peer_cid)
<34> buf.push_bytes(self._host_cid)
<35> if (self._packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
<36> buf.push_uint_var(len(self._peer_token))
<37> buf.push_bytes(self._peer_token)
<38> buf.push_uint16(length | 0x4000)
<39> buf.push_uint16(self._packet_number & 0xFFFF)
<40> else:
<41> buf</s>
|
===========below chunk 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
# offset: 1
buf.push_uint8(
self._packet_type
| (self._spin_bit << 5)
| (self._packet_crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1)
)
buf.push_bytes(self._peer_cid)
buf.push_uint16(self._packet_number & 0xFFFF)
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
buf.seek(self._packet_start + packet_size)
buf.push_bytes(bytes(padding_size))
packet_size += padding_size
# encrypt in place
plain = buf.data_slice(self._packet_start, self._packet_start + packet_size)
buf.seek(self._packet_start)
buf.push_bytes(
self._packet_crypto.encrypt_packet(
plain[0 : self._header_size], plain[self._header_size : packet_size]
)
)
self._packet.sent_bytes = buf.tell() - self._packet_start
self._packets.append(self._packet)
# short header packets cannot be coallesced, we need a new datagram
if not is_long_header(self._packet_type):
self._flush_current_datagram()
self._packet_number += 1
else:
# "cancel" the packet
buf.seek(self._packet_start)
self._packet = None
return not empty
===========unchanged ref 0===========
at: aioquic.buffer.Buffer
data_slice(start: int, end: int) -> bytes
seek(pos: int) -> None
tell() -> int
push_bytes(v: bytes) -> None
push_uint8(v: int) -> None
push_uint16(v: int) -> None
push_uint32(v: int) -> None
push_uint_var(value: int) -> None
at: aioquic.crypto.CryptoPair
encrypt_packet(plain_header: bytes, plain_payload: bytes, packet_number: int) -> bytes
at: aioquic.crypto.CryptoPair.__init__
self.aead_tag_size = 16
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_MASK = 0xF0
PACKET_NUMBER_MAX_SIZE = 4
encode_cid_length(length: int) -> int
is_long_header(first_byte: int) -> bool
at: aioquic.packet_builder
PACKET_NUMBER_SEND_SIZE = 2
at: aioquic.packet_builder.QuicPacketBuilder
_flush_current_datagram() -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._host_cid = host_cid
self._pad_first_datagram = pad_first_datagram
self._peer_cid = peer_cid
self._peer_token = peer_token
self._spin_bit = spin_bit
self._version = version
self._packets: List[QuicSentPacket] = []
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
===========unchanged ref 1===========
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.packet_builder.QuicPacketBuilder.flush
self._packets = []
at: aioquic.packet_builder.QuicPacketBuilder.start_packet
self._packet = QuicSentPacket(
epoch=epoch,
in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_crypto = crypto
self._packet_start = buf.tell()
self._packet_type = packet_type
self._header_size = 10 + len(self._peer_cid) + len(self._host_cid)
self._header_size += size_uint_var(token_length) + token_length
self._header_size = 3 + len(self._peer_cid)
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
===========changed ref 0===========
# module: aioquic.crypto
class CryptoPair:
+ def encrypt_packet(
+ self, plain_header: bytes, plain_payload: bytes, packet_number: int
+ ) -> bytes:
- def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
if self._update_key_requested:
self._update_key()
+ return self.send.encrypt_packet(plain_header, plain_payload, packet_number)
- return self.send.encrypt_packet(plain_header, plain_payload)
===========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
def apply_key_phase(self: CryptoContext, 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 CryptoContext:
def __init__(self, key_phase: int = 0) -> None:
self.aead: Optional[AEAD] = None
self.cipher_suite: Optional[CipherSuite] = None
self.hp: Optional[HeaderProtection] = None
- self.iv: Optional[bytes] = None
self.key_phase = key_phase
self.secret: Optional[bytes] = None
===========changed ref 4===========
# module: aioquic.crypto
class CryptoContext:
+ def encrypt_packet(
+ self, plain_header: bytes, plain_payload: bytes, packet_number: int
+ ) -> bytes:
- def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
assert self.is_valid(), "Encryption key is not available"
# payload protection
+ protected_payload = self.aead.encrypt(
+ plain_payload, plain_header, packet_number
+ )
- protected_payload = self.aead.encrypt(self.iv, plain_payload, plain_header)
# header protection
return self.hp.apply(plain_header, protected_payload)
|
|
tests.test_crypto/CryptoTest.create_crypto
|
Modified
|
aiortc~aioquic
|
bc15d4de59d7328a9df12fa471c0bd24b74a1dd4
|
[crypto] pass packet_number to AEAD code
|
<4>:<del> if is_client:
<5>:<del> self.assertEqual(
<6>:<del> pair.send.iv, binascii.unhexlify("19e94387805eb0b46c03a788")
<7>:<del> )
<8>:<del> self.assertEqual(
<9>:<del> pair.recv.iv, binascii.unhexlify("0a82086d32205ba22241d8dc")
<10>:<del> )
<11>:<del> else:
<12>:<del> self.assertEqual(
<13>:<del> pair.send.iv, binascii.unhexlify("0a82086d32205ba22241d8dc")
<14>:<del> )
<15>:<del> self.assertEqual(
<16>:<del> pair.recv.iv, binascii.unhexlify("19e94387805eb0b46c03a788")
<17>:<del> )
|
# module: tests.test_crypto
class CryptoTest(TestCase):
def create_crypto(self, is_client):
<0> pair = CryptoPair()
<1> pair.setup_initial(
<2> cid=binascii.unhexlify("8394c8f03e515708"), is_client=is_client
<3> )
<4> if is_client:
<5> self.assertEqual(
<6> pair.send.iv, binascii.unhexlify("19e94387805eb0b46c03a788")
<7> )
<8> self.assertEqual(
<9> pair.recv.iv, binascii.unhexlify("0a82086d32205ba22241d8dc")
<10> )
<11> else:
<12> self.assertEqual(
<13> pair.send.iv, binascii.unhexlify("0a82086d32205ba22241d8dc")
<14> )
<15> self.assertEqual(
<16> pair.recv.iv, binascii.unhexlify("19e94387805eb0b46c03a788")
<17> )
<18> return pair
<19>
|
===========unchanged ref 0===========
at: aioquic.crypto
INITIAL_CIPHER_SUITE = CipherSuite.AES_128_GCM_SHA256
derive_key_iv_hp(cipher_suite: CipherSuite, secret: bytes) -> Tuple[bytes, bytes, bytes]
CryptoPair()
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
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.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
def apply_key_phase(self: CryptoContext, 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 CryptoPair:
+ def encrypt_packet(
+ self, plain_header: bytes, plain_payload: bytes, packet_number: int
+ ) -> bytes:
- def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
if self._update_key_requested:
self._update_key()
+ return self.send.encrypt_packet(plain_header, plain_payload, packet_number)
- return self.send.encrypt_packet(plain_header, plain_payload)
===========changed ref 3===========
# module: aioquic.crypto
class CryptoContext:
def __init__(self, key_phase: int = 0) -> None:
self.aead: Optional[AEAD] = None
self.cipher_suite: Optional[CipherSuite] = None
self.hp: Optional[HeaderProtection] = None
- self.iv: Optional[bytes] = None
self.key_phase = key_phase
self.secret: Optional[bytes] = None
===========changed ref 4===========
# module: aioquic.crypto
class CryptoContext:
+ def encrypt_packet(
+ self, plain_header: bytes, plain_payload: bytes, packet_number: int
+ ) -> bytes:
- def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
assert self.is_valid(), "Encryption key is not available"
# payload protection
+ protected_payload = self.aead.encrypt(
+ plain_payload, plain_header, packet_number
+ )
- protected_payload = self.aead.encrypt(self.iv, plain_payload, plain_header)
# header protection
return self.hp.apply(plain_header, protected_payload)
===========changed ref 5===========
# module: aioquic.crypto
class CryptoContext:
def setup(self, cipher_suite: CipherSuite, secret: bytes) -> None:
hp_cipher_name, aead_cipher_name = CIPHER_SUITES[cipher_suite]
+ key, iv, hp = derive_key_iv_hp(cipher_suite, secret)
- key, self.iv, hp = derive_key_iv_hp(cipher_suite, secret)
+ self.aead = AEAD(aead_cipher_name, key, iv)
- self.aead = AEAD(aead_cipher_name, key)
self.cipher_suite = cipher_suite
self.hp = HeaderProtection(hp_cipher_name, hp)
self.secret = secret
===========changed ref 6===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int, expected_packet_number: int
) -> Tuple[bytes, bytes, int, bool]:
if self.aead is None:
raise CryptoError("Decryption key is not available")
# header protection
plain_header = self.hp.remove(packet, encrypted_offset)
first_byte = plain_header[0]
+
+ # packet number
+ packet_number = 0
+ pn_length = (first_byte & 0x03) + 1
+ for i in range(pn_length):
+ packet_number = (packet_number << 8) | plain_header[encrypted_offset + i]
+ packet_number = decode_packet_number(
+ packet_number, pn_length * 8, expected_packet_number
+ )
# detect key phase change
crypto = self
if not is_long_header(first_byte):
key_phase = (first_byte & 4) >> 2
if key_phase != self.key_phase:
crypto = next_key_phase(self)
# payload protection
payload = crypto.aead.decrypt(
+ packet[len(plain_header) :], plain_header, packet_number
- crypto.iv, packet[len(plain_header) :], plain_header
- )
-
- # packet number
- packet_number = 0
- pn_length = (first_byte & 0x03) + 1
- for i in range(pn_length):
- packet_number = (packet_number << 8) | plain_header[encrypted_offset + i]
- packet_number = decode_packet_number(
- packet_number, pn_length * 8, expected_packet_number
)
return plain_header, payload, packet_number, crypto != self
===========changed ref 7===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
"""
Ends the current packet.
Returns `True` if the packet contains data, `False` otherwise.
"""
buf = self.buffer
empty = True
packet_size = buf.tell() - self._packet_start
if packet_size > self._header_size:
empty = False
# pad initial datagram
if self._pad_first_datagram:
buf.push_bytes(bytes(self.remaining_space))
packet_size = buf.tell() - self._packet_start
self._pad_first_datagram = False
# write header
if is_long_header(self._packet_type):
length = (
packet_size
- self._header_size
+ PACKET_NUMBER_SEND_SIZE
+ self._packet_crypto.aead_tag_size
)
buf.seek(self._packet_start)
buf.push_uint8(self._packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
buf.push_uint32(self._version)
buf.push_uint8(
(encode_cid_length(len(self._peer_cid)) << 4)
| encode_cid_length(len(self._host_cid))
)
buf.push_bytes(self._peer_cid)
buf.push_bytes(self._host_cid)
if (self._packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
buf.push_uint_var(len(self._peer_token))
buf.push_bytes(self._peer_token)
buf.push_uint16(length | 0x4000)
buf.push_uint16(self._packet_number & 0xFFFF)
else:
buf.seek(self._packet_start)
buf.push_uint8(
self._packet_type
| (self._spin_bit << 5)
| (self</s>
|
tests.test_crypto/CryptoTest.test_decrypt_chacha20
|
Modified
|
aiortc~aioquic
|
bc15d4de59d7328a9df12fa471c0bd24b74a1dd4
|
[crypto] pass packet_number to AEAD code
|
<13>:<add> self.assertEqual(packet_number, CHACHA20_CLIENT_PACKET_NUMBER)
<del> self.assertEqual(packet_number, 2)
|
# module: tests.test_crypto
class CryptoTest(TestCase):
@skipIf(os.environ.get("TRAVIS") == "true", "travis lacks a modern OpenSSL")
def test_decrypt_chacha20(self):
<0> pair = CryptoPair()
<1> pair.recv.setup(
<2> CipherSuite.CHACHA20_POLY1305_SHA256,
<3> binascii.unhexlify(
<4> "fcc211ac3ff1f3fe1b096a41e701e30033cbd899494ebabbbc009ee2626d987e"
<5> ),
<6> )
<7>
<8> plain_header, plain_payload, packet_number = pair.decrypt_packet(
<9> CHACHA20_CLIENT_ENCRYPTED_PACKET, 34, 0
<10> )
<11> self.assertEqual(plain_header, CHACHA20_CLIENT_PLAIN_HEADER)
<12> self.assertEqual(plain_payload, CHACHA20_CLIENT_PLAIN_PAYLOAD)
<13> self.assertEqual(packet_number, 2)
<14>
|
===========unchanged ref 0===========
at: aioquic.crypto.CryptoPair
decrypt_packet(packet: bytes, encrypted_offset: int, expected_packet_number: int) -> Tuple[bytes, bytes, int]
at: tests.test_crypto
CHACHA20_CLIENT_PACKET_NUMBER = 2
CHACHA20_CLIENT_PLAIN_HEADER = binascii.unhexlify(
"e1ff000014f5b06e20f064d8783dfab56c61e5e16e8024c0e1d6ddc2a43565a240170002"
)
CHACHA20_CLIENT_PLAIN_PAYLOAD = binascii.unhexlify("0200000000")
CHACHA20_CLIENT_ENCRYPTED_PACKET = binascii.unhexlify(
"e7ff000014f5b06e20f064d8783dfab56c61e5e16e8024c0e1d6ddc2a43565a240175554"
"c9ead500f378c5b1dd3eebab26c089128698919bee"
)
LONG_CLIENT_PACKET_NUMBER = 2
LONG_CLIENT_PLAIN_HEADER = binascii.unhexlify(
"c3ff000012508394c8f03e51570800449f00000002"
)
===========unchanged ref 1===========
LONG_CLIENT_PLAIN_PAYLOAD = binascii.unhexlify(
"060040c4010000c003036660261ff947cea49cce6cfad687f457cf1b14531ba1"
"4131a0e8f309a1d0b9c4000006130113031302010000910000000b0009000006"
"736572766572ff01000100000a00140012001d00170018001901000101010201"
"03010400230000003300260024001d00204cfdfcd178b784bf328cae793b136f"
"2aedce005ff183d7bb1495207236647037002b0003020304000d0020001e0403"
"05030603020308040805080604010501060102010402050206020202002d0002"
"0101001c00024001"
) + bytes(963)
===========unchanged ref 2===========
LONG_CLIENT_ENCRYPTED_PACKET = binascii.unhexlify(
"c1ff000012508394c8f03e51570800449f0dbc195a0000f3a694c75775b4e546"
"172ce9e047cd0b5bee5181648c727adc87f7eae54473ec6cba6bdad4f5982317"
"4b769f12358abd292d4f3286934484fb8b239c38732e1f3bbbc6a003056487eb"
"8b5c88b9fd9279ffff3b0f4ecf95c4624db6d65d4113329ee9b0bf8cdd7c8a8d"
"72806d55df25ecb66488bc119d7c9a29abaf99bb33c56b08ad8c26995f838bb3"
"b7a3d5c1858b8ec06b839db2dcf918d5ea9317f1acd6b663cc8925868e2f6a1b"
"da546695f3c3f33175944db4a11a346afb07e78489e509b02add51b7b203eda5"
"c330b03641179a31fbba9b56ce00f3d5b5e3d7d9c5429aebb9576f2f7eacbe27"
"bc1b8082aaf68fb69c921aa5d33ec0c8510410865a178d86d7e54122d55ef2c2"
"bbc040be46d7fece73fe8a1b24495ec160df2da9b20a7ba2f26dfa2a44366dbc"
"63de5cd7d7c94c57172fe6d79c901f025c00</s>
===========unchanged ref 3===========
at: tests.test_crypto.CryptoTest
create_crypto(is_client)
create_crypto(self, is_client)
at: tests.test_crypto.CryptoTest.test_decrypt_chacha20
pair = CryptoPair()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def create_crypto(self, is_client):
pair = CryptoPair()
pair.setup_initial(
cid=binascii.unhexlify("8394c8f03e515708"), is_client=is_client
)
- if is_client:
- self.assertEqual(
- pair.send.iv, binascii.unhexlify("19e94387805eb0b46c03a788")
- )
- self.assertEqual(
- pair.recv.iv, binascii.unhexlify("0a82086d32205ba22241d8dc")
- )
- else:
- self.assertEqual(
- pair.send.iv, binascii.unhexlify("0a82086d32205ba22241d8dc")
- )
- self.assertEqual(
- pair.recv.iv, binascii.unhexlify("19e94387805eb0b46c03a788")
- )
return pair
===========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
def apply_key_phase(self: CryptoContext, 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 encrypt_packet(
+ self, plain_header: bytes, plain_payload: bytes, packet_number: int
+ ) -> bytes:
- def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
if self._update_key_requested:
self._update_key()
+ return self.send.encrypt_packet(plain_header, plain_payload, packet_number)
- return self.send.encrypt_packet(plain_header, plain_payload)
===========changed ref 4===========
# module: aioquic.crypto
class CryptoContext:
def __init__(self, key_phase: int = 0) -> None:
self.aead: Optional[AEAD] = None
self.cipher_suite: Optional[CipherSuite] = None
self.hp: Optional[HeaderProtection] = None
- self.iv: Optional[bytes] = None
self.key_phase = key_phase
self.secret: Optional[bytes] = None
|
tests.test_crypto/CryptoTest.test_decrypt_long_client
|
Modified
|
aiortc~aioquic
|
bc15d4de59d7328a9df12fa471c0bd24b74a1dd4
|
[crypto] pass packet_number to AEAD code
|
<7>:<add> self.assertEqual(packet_number, LONG_CLIENT_PACKET_NUMBER)
<del> self.assertEqual(packet_number, 2)
|
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_client(self):
<0> pair = self.create_crypto(is_client=False)
<1>
<2> plain_header, plain_payload, packet_number = pair.decrypt_packet(
<3> LONG_CLIENT_ENCRYPTED_PACKET, 17, 0
<4> )
<5> self.assertEqual(plain_header, LONG_CLIENT_PLAIN_HEADER)
<6> self.assertEqual(plain_payload, LONG_CLIENT_PLAIN_PAYLOAD)
<7> self.assertEqual(packet_number, 2)
<8>
|
===========unchanged ref 0===========
at: aioquic.crypto.CryptoPair
decrypt_packet(packet: bytes, encrypted_offset: int, expected_packet_number: int) -> Tuple[bytes, bytes, int]
at: tests.test_crypto
LONG_SERVER_PACKET_NUMBER = 1
LONG_SERVER_PLAIN_HEADER = binascii.unhexlify("c1ff00001205f067a5502a4262b50040740001")
LONG_SERVER_PLAIN_PAYLOAD = binascii.unhexlify(
"0d0000000018410a020000560303eefce7f7b37ba1d1632e96677825ddf73988"
"cfc79825df566dc5430b9a045a1200130100002e00330024001d00209d3c940d"
"89690b84d08a60993c144eca684d1081287c834d5311bcf32bb9da1a002b0002"
"0304"
)
LONG_SERVER_ENCRYPTED_PACKET = binascii.unhexlify(
"c4ff00001205f067a5502a4262b5004074f7ed5f01c4c2a2303d297e3c519bf6"
"b22386e3d0bd6dfc66121677298031041bb9a79c9f0f9d4c5877270a660f5da3"
"6207d98b73839b2fdf2ef8e7df5a51b17b8c68d864fd3e708c6c1b71a98a3318"
"15599ef5014ea38c44bdfd387c03b5275c35e009b6238f831420047c7271281c"
"cb54df7884"
)
at: tests.test_crypto.CryptoTest
create_crypto(is_client)
create_crypto(self, is_client)
===========unchanged ref 1===========
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def create_crypto(self, is_client):
pair = CryptoPair()
pair.setup_initial(
cid=binascii.unhexlify("8394c8f03e515708"), is_client=is_client
)
- if is_client:
- self.assertEqual(
- pair.send.iv, binascii.unhexlify("19e94387805eb0b46c03a788")
- )
- self.assertEqual(
- pair.recv.iv, binascii.unhexlify("0a82086d32205ba22241d8dc")
- )
- else:
- self.assertEqual(
- pair.send.iv, binascii.unhexlify("0a82086d32205ba22241d8dc")
- )
- self.assertEqual(
- pair.recv.iv, binascii.unhexlify("19e94387805eb0b46c03a788")
- )
return pair
===========changed ref 1===========
# module: tests.test_crypto
class CryptoTest(TestCase):
@skipIf(os.environ.get("TRAVIS") == "true", "travis lacks a modern OpenSSL")
def test_decrypt_chacha20(self):
pair = CryptoPair()
pair.recv.setup(
CipherSuite.CHACHA20_POLY1305_SHA256,
binascii.unhexlify(
"fcc211ac3ff1f3fe1b096a41e701e30033cbd899494ebabbbc009ee2626d987e"
),
)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
CHACHA20_CLIENT_ENCRYPTED_PACKET, 34, 0
)
self.assertEqual(plain_header, CHACHA20_CLIENT_PLAIN_HEADER)
self.assertEqual(plain_payload, CHACHA20_CLIENT_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, CHACHA20_CLIENT_PACKET_NUMBER)
- self.assertEqual(packet_number, 2)
===========changed ref 2===========
# 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 3===========
# module: aioquic.crypto
def apply_key_phase(self: CryptoContext, 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 CryptoPair:
+ def encrypt_packet(
+ self, plain_header: bytes, plain_payload: bytes, packet_number: int
+ ) -> bytes:
- def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
if self._update_key_requested:
self._update_key()
+ return self.send.encrypt_packet(plain_header, plain_payload, packet_number)
- return self.send.encrypt_packet(plain_header, plain_payload)
===========changed ref 5===========
# module: aioquic.crypto
class CryptoContext:
def __init__(self, key_phase: int = 0) -> None:
self.aead: Optional[AEAD] = None
self.cipher_suite: Optional[CipherSuite] = None
self.hp: Optional[HeaderProtection] = None
- self.iv: Optional[bytes] = None
self.key_phase = key_phase
self.secret: Optional[bytes] = None
===========changed ref 6===========
# module: aioquic.crypto
class CryptoContext:
+ def encrypt_packet(
+ self, plain_header: bytes, plain_payload: bytes, packet_number: int
+ ) -> bytes:
- def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
assert self.is_valid(), "Encryption key is not available"
# payload protection
+ protected_payload = self.aead.encrypt(
+ plain_payload, plain_header, packet_number
+ )
- protected_payload = self.aead.encrypt(self.iv, plain_payload, plain_header)
# header protection
return self.hp.apply(plain_header, protected_payload)
===========changed ref 7===========
# module: aioquic.crypto
class CryptoContext:
def setup(self, cipher_suite: CipherSuite, secret: bytes) -> None:
hp_cipher_name, aead_cipher_name = CIPHER_SUITES[cipher_suite]
+ key, iv, hp = derive_key_iv_hp(cipher_suite, secret)
- key, self.iv, hp = derive_key_iv_hp(cipher_suite, secret)
+ self.aead = AEAD(aead_cipher_name, key, iv)
- self.aead = AEAD(aead_cipher_name, key)
self.cipher_suite = cipher_suite
self.hp = HeaderProtection(hp_cipher_name, hp)
self.secret = secret
|
tests.test_crypto/CryptoTest.test_decrypt_long_server
|
Modified
|
aiortc~aioquic
|
bc15d4de59d7328a9df12fa471c0bd24b74a1dd4
|
[crypto] pass packet_number to AEAD code
|
<7>:<add> self.assertEqual(packet_number, LONG_SERVER_PACKET_NUMBER)
<del> self.assertEqual(packet_number, 1)
|
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_server(self):
<0> pair = self.create_crypto(is_client=True)
<1>
<2> plain_header, plain_payload, packet_number = pair.decrypt_packet(
<3> LONG_SERVER_ENCRYPTED_PACKET, 17, 0
<4> )
<5> self.assertEqual(plain_header, LONG_SERVER_PLAIN_HEADER)
<6> self.assertEqual(plain_payload, LONG_SERVER_PLAIN_PAYLOAD)
<7> self.assertEqual(packet_number, 1)
<8>
|
===========unchanged ref 0===========
at: aioquic._crypto
CryptoError(*args: object)
at: aioquic.crypto
INITIAL_CIPHER_SUITE = CipherSuite.AES_128_GCM_SHA256
CryptoPair()
at: aioquic.crypto.CryptoContext
setup(cipher_suite: CipherSuite, secret: bytes) -> None
at: aioquic.crypto.CryptoPair
decrypt_packet(packet: bytes, encrypted_offset: int, expected_packet_number: int) -> Tuple[bytes, bytes, int]
at: aioquic.crypto.CryptoPair.__init__
self.recv = CryptoContext()
at: tests.test_crypto
LONG_SERVER_ENCRYPTED_PACKET = binascii.unhexlify(
"c4ff00001205f067a5502a4262b5004074f7ed5f01c4c2a2303d297e3c519bf6"
"b22386e3d0bd6dfc66121677298031041bb9a79c9f0f9d4c5877270a660f5da3"
"6207d98b73839b2fdf2ef8e7df5a51b17b8c68d864fd3e708c6c1b71a98a3318"
"15599ef5014ea38c44bdfd387c03b5275c35e009b6238f831420047c7271281c"
"cb54df7884"
)
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.crypto
class CryptoContext:
def setup(self, cipher_suite: CipherSuite, secret: bytes) -> None:
hp_cipher_name, aead_cipher_name = CIPHER_SUITES[cipher_suite]
+ key, iv, hp = derive_key_iv_hp(cipher_suite, secret)
- key, self.iv, hp = derive_key_iv_hp(cipher_suite, secret)
+ self.aead = AEAD(aead_cipher_name, key, iv)
- self.aead = AEAD(aead_cipher_name, key)
self.cipher_suite = cipher_suite
self.hp = HeaderProtection(hp_cipher_name, hp)
self.secret = secret
===========changed ref 1===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_client(self):
pair = self.create_crypto(is_client=False)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
LONG_CLIENT_ENCRYPTED_PACKET, 17, 0
)
self.assertEqual(plain_header, LONG_CLIENT_PLAIN_HEADER)
self.assertEqual(plain_payload, LONG_CLIENT_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, LONG_CLIENT_PACKET_NUMBER)
- self.assertEqual(packet_number, 2)
===========changed ref 2===========
# module: tests.test_crypto
class CryptoTest(TestCase):
@skipIf(os.environ.get("TRAVIS") == "true", "travis lacks a modern OpenSSL")
def test_decrypt_chacha20(self):
pair = CryptoPair()
pair.recv.setup(
CipherSuite.CHACHA20_POLY1305_SHA256,
binascii.unhexlify(
"fcc211ac3ff1f3fe1b096a41e701e30033cbd899494ebabbbc009ee2626d987e"
),
)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
CHACHA20_CLIENT_ENCRYPTED_PACKET, 34, 0
)
self.assertEqual(plain_header, CHACHA20_CLIENT_PLAIN_HEADER)
self.assertEqual(plain_payload, CHACHA20_CLIENT_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, CHACHA20_CLIENT_PACKET_NUMBER)
- self.assertEqual(packet_number, 2)
===========changed ref 3===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def create_crypto(self, is_client):
pair = CryptoPair()
pair.setup_initial(
cid=binascii.unhexlify("8394c8f03e515708"), is_client=is_client
)
- if is_client:
- self.assertEqual(
- pair.send.iv, binascii.unhexlify("19e94387805eb0b46c03a788")
- )
- self.assertEqual(
- pair.recv.iv, binascii.unhexlify("0a82086d32205ba22241d8dc")
- )
- else:
- self.assertEqual(
- pair.send.iv, binascii.unhexlify("0a82086d32205ba22241d8dc")
- )
- self.assertEqual(
- pair.recv.iv, binascii.unhexlify("19e94387805eb0b46c03a788")
- )
return pair
===========changed ref 4===========
# 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 5===========
# module: aioquic.crypto
def apply_key_phase(self: CryptoContext, crypto: CryptoContext) -> None:
self.aead = crypto.aead
- self.iv = crypto.iv
self.key_phase = crypto.key_phase
self.secret = crypto.secret
===========changed ref 6===========
# module: aioquic.crypto
class CryptoPair:
+ def encrypt_packet(
+ self, plain_header: bytes, plain_payload: bytes, packet_number: int
+ ) -> bytes:
- def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
if self._update_key_requested:
self._update_key()
+ return self.send.encrypt_packet(plain_header, plain_payload, packet_number)
- return self.send.encrypt_packet(plain_header, plain_payload)
===========changed ref 7===========
# module: aioquic.crypto
class CryptoContext:
def __init__(self, key_phase: int = 0) -> None:
self.aead: Optional[AEAD] = None
self.cipher_suite: Optional[CipherSuite] = None
self.hp: Optional[HeaderProtection] = None
- self.iv: Optional[bytes] = None
self.key_phase = key_phase
self.secret: Optional[bytes] = None
===========changed ref 8===========
# module: aioquic.crypto
class CryptoContext:
+ def encrypt_packet(
+ self, plain_header: bytes, plain_payload: bytes, packet_number: int
+ ) -> bytes:
- def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
assert self.is_valid(), "Encryption key is not available"
# payload protection
+ protected_payload = self.aead.encrypt(
+ plain_payload, plain_header, packet_number
+ )
- protected_payload = self.aead.encrypt(self.iv, plain_payload, plain_header)
# header protection
return self.hp.apply(plain_header, protected_payload)
|
tests.test_crypto/CryptoTest.test_decrypt_short_server
|
Modified
|
aiortc~aioquic
|
bc15d4de59d7328a9df12fa471c0bd24b74a1dd4
|
[crypto] pass packet_number to AEAD code
|
<13>:<add> self.assertEqual(packet_number, SHORT_SERVER_PACKET_NUMBER)
<del> self.assertEqual(packet_number, 3)
|
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_short_server(self):
<0> pair = CryptoPair()
<1> pair.recv.setup(
<2> INITIAL_CIPHER_SUITE,
<3> binascii.unhexlify(
<4> "310281977cb8c1c1c1212d784b2d29e5a6489e23de848d370a5a2f9537f3a100"
<5> ),
<6> )
<7>
<8> plain_header, plain_payload, packet_number = pair.decrypt_packet(
<9> SHORT_SERVER_ENCRYPTED_PACKET, 9, 0
<10> )
<11> self.assertEqual(plain_header, SHORT_SERVER_PLAIN_HEADER)
<12> self.assertEqual(plain_payload, SHORT_SERVER_PLAIN_PAYLOAD)
<13> self.assertEqual(packet_number, 3)
<14>
|
===========unchanged ref 0===========
at: _collections_abc.Mapping
__slots__ = ()
__abc_tpflags__ = 1 << 6 # Py_TPFLAGS_MAPPING
get(key, default=None)
__reversed__ = None
at: aioquic.crypto
CryptoPair()
at: aioquic.crypto.CryptoContext
setup(cipher_suite: CipherSuite, secret: bytes) -> None
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.tls
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: os
environ = _createenviron()
at: tests.test_crypto
SHORT_SERVER_PACKET_NUMBER = 3
SHORT_SERVER_PLAIN_HEADER = binascii.unhexlify("41b01fd24a586a9cf30003")
SHORT_SERVER_PLAIN_PAYLOAD = binascii.unhexlify(
"06003904000035000151805a4bebf5000020b098c8dc4183e4c182572e10ac3e"
"2b88897e0524c8461847548bd2dffa2c0ae60008002a0004ffffffff"
)
SHORT_SERVER_ENCRYPTED_PACKET = binascii.unhexlify(
"5db01fd24a586a9cf33dec094aaec6d6b4b7a5e15f5a3f05d06cf1ad0355c19d"
"cce0807eecf7bf1c844a66e1ecd1f74b2a2d69bfd25d217833edd973246597bd"
"5107ea15cb1e210045396afa602fe23432f4ab24ce251b"
)
===========unchanged ref 1===========
at: tests.test_crypto.CryptoTest.test_decrypt_short_server
plain_header, plain_payload, packet_number = pair.decrypt_packet(
SHORT_SERVER_ENCRYPTED_PACKET, 9, 0
)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
SHORT_SERVER_ENCRYPTED_PACKET, 9, 0
)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
SHORT_SERVER_ENCRYPTED_PACKET, 9, 0
)
at: unittest.case
skipIf(condition: object, reason: str) -> Callable[[_FT], _FT]
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.crypto
class CryptoContext:
def setup(self, cipher_suite: CipherSuite, secret: bytes) -> None:
hp_cipher_name, aead_cipher_name = CIPHER_SUITES[cipher_suite]
+ key, iv, hp = derive_key_iv_hp(cipher_suite, secret)
- key, self.iv, hp = derive_key_iv_hp(cipher_suite, secret)
+ self.aead = AEAD(aead_cipher_name, key, iv)
- self.aead = AEAD(aead_cipher_name, key)
self.cipher_suite = cipher_suite
self.hp = HeaderProtection(hp_cipher_name, hp)
self.secret = secret
===========changed ref 1===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_server(self):
pair = self.create_crypto(is_client=True)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
LONG_SERVER_ENCRYPTED_PACKET, 17, 0
)
self.assertEqual(plain_header, LONG_SERVER_PLAIN_HEADER)
self.assertEqual(plain_payload, LONG_SERVER_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, LONG_SERVER_PACKET_NUMBER)
- self.assertEqual(packet_number, 1)
===========changed ref 2===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_client(self):
pair = self.create_crypto(is_client=False)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
LONG_CLIENT_ENCRYPTED_PACKET, 17, 0
)
self.assertEqual(plain_header, LONG_CLIENT_PLAIN_HEADER)
self.assertEqual(plain_payload, LONG_CLIENT_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, LONG_CLIENT_PACKET_NUMBER)
- self.assertEqual(packet_number, 2)
===========changed ref 3===========
# module: tests.test_crypto
class CryptoTest(TestCase):
@skipIf(os.environ.get("TRAVIS") == "true", "travis lacks a modern OpenSSL")
def test_decrypt_chacha20(self):
pair = CryptoPair()
pair.recv.setup(
CipherSuite.CHACHA20_POLY1305_SHA256,
binascii.unhexlify(
"fcc211ac3ff1f3fe1b096a41e701e30033cbd899494ebabbbc009ee2626d987e"
),
)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
CHACHA20_CLIENT_ENCRYPTED_PACKET, 34, 0
)
self.assertEqual(plain_header, CHACHA20_CLIENT_PLAIN_HEADER)
self.assertEqual(plain_payload, CHACHA20_CLIENT_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, CHACHA20_CLIENT_PACKET_NUMBER)
- self.assertEqual(packet_number, 2)
===========changed ref 4===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def create_crypto(self, is_client):
pair = CryptoPair()
pair.setup_initial(
cid=binascii.unhexlify("8394c8f03e515708"), is_client=is_client
)
- if is_client:
- self.assertEqual(
- pair.send.iv, binascii.unhexlify("19e94387805eb0b46c03a788")
- )
- self.assertEqual(
- pair.recv.iv, binascii.unhexlify("0a82086d32205ba22241d8dc")
- )
- else:
- self.assertEqual(
- pair.send.iv, binascii.unhexlify("0a82086d32205ba22241d8dc")
- )
- self.assertEqual(
- pair.recv.iv, binascii.unhexlify("19e94387805eb0b46c03a788")
- )
return pair
===========changed ref 5===========
# 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 6===========
# module: aioquic.crypto
def apply_key_phase(self: CryptoContext, crypto: CryptoContext) -> None:
self.aead = crypto.aead
- self.iv = crypto.iv
self.key_phase = crypto.key_phase
self.secret = crypto.secret
|
tests.test_crypto/CryptoTest.test_encrypt_chacha20
|
Modified
|
aiortc~aioquic
|
bc15d4de59d7328a9df12fa471c0bd24b74a1dd4
|
[crypto] pass packet_number to AEAD code
|
<9>:<add> CHACHA20_CLIENT_PLAIN_HEADER,
<add> CHACHA20_CLIENT_PLAIN_PAYLOAD,
<add> CHACHA20_CLIENT_PACKET_NUMBER,
<del> CHACHA20_CLIENT_PLAIN_HEADER, CHACHA20_CLIENT_PLAIN_PAYLOAD
|
# module: tests.test_crypto
class CryptoTest(TestCase):
@skipIf(os.environ.get("TRAVIS") == "true", "travis lacks a modern OpenSSL")
def test_encrypt_chacha20(self):
<0> pair = CryptoPair()
<1> pair.send.setup(
<2> CipherSuite.CHACHA20_POLY1305_SHA256,
<3> binascii.unhexlify(
<4> "fcc211ac3ff1f3fe1b096a41e701e30033cbd899494ebabbbc009ee2626d987e"
<5> ),
<6> )
<7>
<8> packet = pair.encrypt_packet(
<9> CHACHA20_CLIENT_PLAIN_HEADER, CHACHA20_CLIENT_PLAIN_PAYLOAD
<10> )
<11> self.assertEqual(packet, CHACHA20_CLIENT_ENCRYPTED_PACKET)
<12>
|
===========unchanged ref 0===========
at: aioquic.crypto.CryptoPair
encrypt_packet(plain_header: bytes, plain_payload: bytes, packet_number: int) -> bytes
at: tests.test_crypto
CHACHA20_CLIENT_PACKET_NUMBER = 2
CHACHA20_CLIENT_PLAIN_HEADER = binascii.unhexlify(
"e1ff000014f5b06e20f064d8783dfab56c61e5e16e8024c0e1d6ddc2a43565a240170002"
)
CHACHA20_CLIENT_PLAIN_PAYLOAD = binascii.unhexlify("0200000000")
CHACHA20_CLIENT_ENCRYPTED_PACKET = binascii.unhexlify(
"e7ff000014f5b06e20f064d8783dfab56c61e5e16e8024c0e1d6ddc2a43565a240175554"
"c9ead500f378c5b1dd3eebab26c089128698919bee"
)
LONG_CLIENT_PACKET_NUMBER = 2
LONG_CLIENT_PLAIN_HEADER = binascii.unhexlify(
"c3ff000012508394c8f03e51570800449f00000002"
)
===========unchanged ref 1===========
LONG_CLIENT_PLAIN_PAYLOAD = binascii.unhexlify(
"060040c4010000c003036660261ff947cea49cce6cfad687f457cf1b14531ba1"
"4131a0e8f309a1d0b9c4000006130113031302010000910000000b0009000006"
"736572766572ff01000100000a00140012001d00170018001901000101010201"
"03010400230000003300260024001d00204cfdfcd178b784bf328cae793b136f"
"2aedce005ff183d7bb1495207236647037002b0003020304000d0020001e0403"
"05030603020308040805080604010501060102010402050206020202002d0002"
"0101001c00024001"
) + bytes(963)
at: tests.test_crypto.CryptoTest
create_crypto(is_client)
create_crypto(self, is_client)
at: tests.test_crypto.CryptoTest.test_encrypt_chacha20
pair = CryptoPair()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def create_crypto(self, is_client):
pair = CryptoPair()
pair.setup_initial(
cid=binascii.unhexlify("8394c8f03e515708"), is_client=is_client
)
- if is_client:
- self.assertEqual(
- pair.send.iv, binascii.unhexlify("19e94387805eb0b46c03a788")
- )
- self.assertEqual(
- pair.recv.iv, binascii.unhexlify("0a82086d32205ba22241d8dc")
- )
- else:
- self.assertEqual(
- pair.send.iv, binascii.unhexlify("0a82086d32205ba22241d8dc")
- )
- self.assertEqual(
- pair.recv.iv, binascii.unhexlify("19e94387805eb0b46c03a788")
- )
return pair
===========changed ref 1===========
# module: aioquic.crypto
class CryptoPair:
+ def encrypt_packet(
+ self, plain_header: bytes, plain_payload: bytes, packet_number: int
+ ) -> bytes:
- def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
if self._update_key_requested:
self._update_key()
+ return self.send.encrypt_packet(plain_header, plain_payload, packet_number)
- return self.send.encrypt_packet(plain_header, plain_payload)
===========changed ref 2===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_server(self):
pair = self.create_crypto(is_client=True)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
LONG_SERVER_ENCRYPTED_PACKET, 17, 0
)
self.assertEqual(plain_header, LONG_SERVER_PLAIN_HEADER)
self.assertEqual(plain_payload, LONG_SERVER_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, LONG_SERVER_PACKET_NUMBER)
- self.assertEqual(packet_number, 1)
===========changed ref 3===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_client(self):
pair = self.create_crypto(is_client=False)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
LONG_CLIENT_ENCRYPTED_PACKET, 17, 0
)
self.assertEqual(plain_header, LONG_CLIENT_PLAIN_HEADER)
self.assertEqual(plain_payload, LONG_CLIENT_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, LONG_CLIENT_PACKET_NUMBER)
- self.assertEqual(packet_number, 2)
===========changed ref 4===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_short_server(self):
pair = CryptoPair()
pair.recv.setup(
INITIAL_CIPHER_SUITE,
binascii.unhexlify(
"310281977cb8c1c1c1212d784b2d29e5a6489e23de848d370a5a2f9537f3a100"
),
)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
SHORT_SERVER_ENCRYPTED_PACKET, 9, 0
)
self.assertEqual(plain_header, SHORT_SERVER_PLAIN_HEADER)
self.assertEqual(plain_payload, SHORT_SERVER_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, SHORT_SERVER_PACKET_NUMBER)
- self.assertEqual(packet_number, 3)
===========changed ref 5===========
# module: tests.test_crypto
class CryptoTest(TestCase):
@skipIf(os.environ.get("TRAVIS") == "true", "travis lacks a modern OpenSSL")
def test_decrypt_chacha20(self):
pair = CryptoPair()
pair.recv.setup(
CipherSuite.CHACHA20_POLY1305_SHA256,
binascii.unhexlify(
"fcc211ac3ff1f3fe1b096a41e701e30033cbd899494ebabbbc009ee2626d987e"
),
)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
CHACHA20_CLIENT_ENCRYPTED_PACKET, 34, 0
)
self.assertEqual(plain_header, CHACHA20_CLIENT_PLAIN_HEADER)
self.assertEqual(plain_payload, CHACHA20_CLIENT_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, CHACHA20_CLIENT_PACKET_NUMBER)
- self.assertEqual(packet_number, 2)
===========changed ref 6===========
# 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
|
tests.test_crypto/CryptoTest.test_encrypt_long_client
|
Modified
|
aiortc~aioquic
|
bc15d4de59d7328a9df12fa471c0bd24b74a1dd4
|
[crypto] pass packet_number to AEAD code
|
<3>:<add> LONG_CLIENT_PLAIN_HEADER,
<add> LONG_CLIENT_PLAIN_PAYLOAD,
<add> LONG_CLIENT_PACKET_NUMBER,
<del> LONG_CLIENT_PLAIN_HEADER, LONG_CLIENT_PLAIN_PAYLOAD
|
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_encrypt_long_client(self):
<0> pair = self.create_crypto(is_client=True)
<1>
<2> packet = pair.encrypt_packet(
<3> LONG_CLIENT_PLAIN_HEADER, LONG_CLIENT_PLAIN_PAYLOAD
<4> )
<5> self.assertEqual(packet, LONG_CLIENT_ENCRYPTED_PACKET)
<6>
|
===========unchanged ref 0===========
at: aioquic.crypto.CryptoPair
encrypt_packet(plain_header: bytes, plain_payload: bytes, packet_number: int) -> bytes
===========unchanged ref 1===========
at: tests.test_crypto
LONG_CLIENT_ENCRYPTED_PACKET = binascii.unhexlify(
"c1ff000012508394c8f03e51570800449f0dbc195a0000f3a694c75775b4e546"
"172ce9e047cd0b5bee5181648c727adc87f7eae54473ec6cba6bdad4f5982317"
"4b769f12358abd292d4f3286934484fb8b239c38732e1f3bbbc6a003056487eb"
"8b5c88b9fd9279ffff3b0f4ecf95c4624db6d65d4113329ee9b0bf8cdd7c8a8d"
"72806d55df25ecb66488bc119d7c9a29abaf99bb33c56b08ad8c26995f838bb3"
"b7a3d5c1858b8ec06b839db2dcf918d5ea9317f1acd6b663cc8925868e2f6a1b"
"da546695f3c3f33175944db4a11a346afb07e78489e509b02add51b7b203eda5"
"c330b03641179a31fbba9b56ce00f3d5b5e3d7d9c5429aebb9576f2f7eacbe27"
"bc1b8082aaf68fb69c921aa5d33ec0c8510410865a178d86d7e54122d55ef2c2"
"bbc040be46d7fece73fe8a1b24495ec160df2da9b20a7ba2f26dfa2a44366dbc"
"63de5cd7d7c94c57172fe6d79</s>
===========unchanged ref 2===========
LONG_SERVER_PLAIN_HEADER = binascii.unhexlify("c1ff00001205f067a5502a4262b50040740001")
at: tests.test_crypto.CryptoTest
create_crypto(is_client)
create_crypto(self, is_client)
at: tests.test_crypto.CryptoTest.test_encrypt_long_client
packet = pair.encrypt_packet(
LONG_CLIENT_PLAIN_HEADER,
LONG_CLIENT_PLAIN_PAYLOAD,
LONG_CLIENT_PACKET_NUMBER,
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def create_crypto(self, is_client):
pair = CryptoPair()
pair.setup_initial(
cid=binascii.unhexlify("8394c8f03e515708"), is_client=is_client
)
- if is_client:
- self.assertEqual(
- pair.send.iv, binascii.unhexlify("19e94387805eb0b46c03a788")
- )
- self.assertEqual(
- pair.recv.iv, binascii.unhexlify("0a82086d32205ba22241d8dc")
- )
- else:
- self.assertEqual(
- pair.send.iv, binascii.unhexlify("0a82086d32205ba22241d8dc")
- )
- self.assertEqual(
- pair.recv.iv, binascii.unhexlify("19e94387805eb0b46c03a788")
- )
return pair
===========changed ref 1===========
# module: aioquic.crypto
class CryptoPair:
+ def encrypt_packet(
+ self, plain_header: bytes, plain_payload: bytes, packet_number: int
+ ) -> bytes:
- def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
if self._update_key_requested:
self._update_key()
+ return self.send.encrypt_packet(plain_header, plain_payload, packet_number)
- return self.send.encrypt_packet(plain_header, plain_payload)
===========changed ref 2===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_server(self):
pair = self.create_crypto(is_client=True)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
LONG_SERVER_ENCRYPTED_PACKET, 17, 0
)
self.assertEqual(plain_header, LONG_SERVER_PLAIN_HEADER)
self.assertEqual(plain_payload, LONG_SERVER_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, LONG_SERVER_PACKET_NUMBER)
- self.assertEqual(packet_number, 1)
===========changed ref 3===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_client(self):
pair = self.create_crypto(is_client=False)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
LONG_CLIENT_ENCRYPTED_PACKET, 17, 0
)
self.assertEqual(plain_header, LONG_CLIENT_PLAIN_HEADER)
self.assertEqual(plain_payload, LONG_CLIENT_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, LONG_CLIENT_PACKET_NUMBER)
- self.assertEqual(packet_number, 2)
===========changed ref 4===========
# module: tests.test_crypto
class CryptoTest(TestCase):
@skipIf(os.environ.get("TRAVIS") == "true", "travis lacks a modern OpenSSL")
def test_encrypt_chacha20(self):
pair = CryptoPair()
pair.send.setup(
CipherSuite.CHACHA20_POLY1305_SHA256,
binascii.unhexlify(
"fcc211ac3ff1f3fe1b096a41e701e30033cbd899494ebabbbc009ee2626d987e"
),
)
packet = pair.encrypt_packet(
+ CHACHA20_CLIENT_PLAIN_HEADER,
+ CHACHA20_CLIENT_PLAIN_PAYLOAD,
+ CHACHA20_CLIENT_PACKET_NUMBER,
- CHACHA20_CLIENT_PLAIN_HEADER, CHACHA20_CLIENT_PLAIN_PAYLOAD
)
self.assertEqual(packet, CHACHA20_CLIENT_ENCRYPTED_PACKET)
===========changed ref 5===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_short_server(self):
pair = CryptoPair()
pair.recv.setup(
INITIAL_CIPHER_SUITE,
binascii.unhexlify(
"310281977cb8c1c1c1212d784b2d29e5a6489e23de848d370a5a2f9537f3a100"
),
)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
SHORT_SERVER_ENCRYPTED_PACKET, 9, 0
)
self.assertEqual(plain_header, SHORT_SERVER_PLAIN_HEADER)
self.assertEqual(plain_payload, SHORT_SERVER_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, SHORT_SERVER_PACKET_NUMBER)
- self.assertEqual(packet_number, 3)
|
tests.test_crypto/CryptoTest.test_encrypt_long_server
|
Modified
|
aiortc~aioquic
|
bc15d4de59d7328a9df12fa471c0bd24b74a1dd4
|
[crypto] pass packet_number to AEAD code
|
<3>:<add> LONG_SERVER_PLAIN_HEADER,
<add> LONG_SERVER_PLAIN_PAYLOAD,
<add> LONG_SERVER_PACKET_NUMBER,
<del> LONG_SERVER_PLAIN_HEADER, LONG_SERVER_PLAIN_PAYLOAD
|
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_encrypt_long_server(self):
<0> pair = self.create_crypto(is_client=False)
<1>
<2> packet = pair.encrypt_packet(
<3> LONG_SERVER_PLAIN_HEADER, LONG_SERVER_PLAIN_PAYLOAD
<4> )
<5> self.assertEqual(packet, LONG_SERVER_ENCRYPTED_PACKET)
<6>
|
===========unchanged ref 0===========
at: aioquic.crypto
CryptoPair()
at: aioquic.crypto.CryptoContext
setup(cipher_suite: CipherSuite, secret: bytes) -> None
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: tests.test_crypto
LONG_SERVER_PACKET_NUMBER = 1
LONG_SERVER_ENCRYPTED_PACKET = binascii.unhexlify(
"c4ff00001205f067a5502a4262b5004074f7ed5f01c4c2a2303d297e3c519bf6"
"b22386e3d0bd6dfc66121677298031041bb9a79c9f0f9d4c5877270a660f5da3"
"6207d98b73839b2fdf2ef8e7df5a51b17b8c68d864fd3e708c6c1b71a98a3318"
"15599ef5014ea38c44bdfd387c03b5275c35e009b6238f831420047c7271281c"
"cb54df7884"
)
at: tests.test_crypto.CryptoTest.test_encrypt_long_server
packet = pair.encrypt_packet(
LONG_SERVER_PLAIN_HEADER,
LONG_SERVER_PLAIN_PAYLOAD,
LONG_SERVER_PACKET_NUMBER,
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.crypto
class CryptoContext:
def setup(self, cipher_suite: CipherSuite, secret: bytes) -> None:
hp_cipher_name, aead_cipher_name = CIPHER_SUITES[cipher_suite]
+ key, iv, hp = derive_key_iv_hp(cipher_suite, secret)
- key, self.iv, hp = derive_key_iv_hp(cipher_suite, secret)
+ self.aead = AEAD(aead_cipher_name, key, iv)
- self.aead = AEAD(aead_cipher_name, key)
self.cipher_suite = cipher_suite
self.hp = HeaderProtection(hp_cipher_name, hp)
self.secret = secret
===========changed ref 1===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_encrypt_long_client(self):
pair = self.create_crypto(is_client=True)
packet = pair.encrypt_packet(
+ LONG_CLIENT_PLAIN_HEADER,
+ LONG_CLIENT_PLAIN_PAYLOAD,
+ LONG_CLIENT_PACKET_NUMBER,
- LONG_CLIENT_PLAIN_HEADER, LONG_CLIENT_PLAIN_PAYLOAD
)
self.assertEqual(packet, LONG_CLIENT_ENCRYPTED_PACKET)
===========changed ref 2===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_server(self):
pair = self.create_crypto(is_client=True)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
LONG_SERVER_ENCRYPTED_PACKET, 17, 0
)
self.assertEqual(plain_header, LONG_SERVER_PLAIN_HEADER)
self.assertEqual(plain_payload, LONG_SERVER_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, LONG_SERVER_PACKET_NUMBER)
- self.assertEqual(packet_number, 1)
===========changed ref 3===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_client(self):
pair = self.create_crypto(is_client=False)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
LONG_CLIENT_ENCRYPTED_PACKET, 17, 0
)
self.assertEqual(plain_header, LONG_CLIENT_PLAIN_HEADER)
self.assertEqual(plain_payload, LONG_CLIENT_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, LONG_CLIENT_PACKET_NUMBER)
- self.assertEqual(packet_number, 2)
===========changed ref 4===========
# module: tests.test_crypto
class CryptoTest(TestCase):
@skipIf(os.environ.get("TRAVIS") == "true", "travis lacks a modern OpenSSL")
def test_encrypt_chacha20(self):
pair = CryptoPair()
pair.send.setup(
CipherSuite.CHACHA20_POLY1305_SHA256,
binascii.unhexlify(
"fcc211ac3ff1f3fe1b096a41e701e30033cbd899494ebabbbc009ee2626d987e"
),
)
packet = pair.encrypt_packet(
+ CHACHA20_CLIENT_PLAIN_HEADER,
+ CHACHA20_CLIENT_PLAIN_PAYLOAD,
+ CHACHA20_CLIENT_PACKET_NUMBER,
- CHACHA20_CLIENT_PLAIN_HEADER, CHACHA20_CLIENT_PLAIN_PAYLOAD
)
self.assertEqual(packet, CHACHA20_CLIENT_ENCRYPTED_PACKET)
===========changed ref 5===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_short_server(self):
pair = CryptoPair()
pair.recv.setup(
INITIAL_CIPHER_SUITE,
binascii.unhexlify(
"310281977cb8c1c1c1212d784b2d29e5a6489e23de848d370a5a2f9537f3a100"
),
)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
SHORT_SERVER_ENCRYPTED_PACKET, 9, 0
)
self.assertEqual(plain_header, SHORT_SERVER_PLAIN_HEADER)
self.assertEqual(plain_payload, SHORT_SERVER_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, SHORT_SERVER_PACKET_NUMBER)
- self.assertEqual(packet_number, 3)
===========changed ref 6===========
# module: tests.test_crypto
class CryptoTest(TestCase):
@skipIf(os.environ.get("TRAVIS") == "true", "travis lacks a modern OpenSSL")
def test_decrypt_chacha20(self):
pair = CryptoPair()
pair.recv.setup(
CipherSuite.CHACHA20_POLY1305_SHA256,
binascii.unhexlify(
"fcc211ac3ff1f3fe1b096a41e701e30033cbd899494ebabbbc009ee2626d987e"
),
)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
CHACHA20_CLIENT_ENCRYPTED_PACKET, 34, 0
)
self.assertEqual(plain_header, CHACHA20_CLIENT_PLAIN_HEADER)
self.assertEqual(plain_payload, CHACHA20_CLIENT_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, CHACHA20_CLIENT_PACKET_NUMBER)
- self.assertEqual(packet_number, 2)
|
tests.test_crypto/CryptoTest.test_encrypt_short_server
|
Modified
|
aiortc~aioquic
|
bc15d4de59d7328a9df12fa471c0bd24b74a1dd4
|
[crypto] pass packet_number to AEAD code
|
<9>:<add> SHORT_SERVER_PLAIN_HEADER,
<add> SHORT_SERVER_PLAIN_PAYLOAD,
<add> SHORT_SERVER_PACKET_NUMBER,
<del> SHORT_SERVER_PLAIN_HEADER, SHORT_SERVER_PLAIN_PAYLOAD
|
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_encrypt_short_server(self):
<0> pair = CryptoPair()
<1> pair.send.setup(
<2> INITIAL_CIPHER_SUITE,
<3> binascii.unhexlify(
<4> "310281977cb8c1c1c1212d784b2d29e5a6489e23de848d370a5a2f9537f3a100"
<5> ),
<6> )
<7>
<8> packet = pair.encrypt_packet(
<9> SHORT_SERVER_PLAIN_HEADER, SHORT_SERVER_PLAIN_PAYLOAD
<10> )
<11> self.assertEqual(packet, SHORT_SERVER_ENCRYPTED_PACKET)
<12>
|
===========unchanged ref 0===========
at: aioquic.crypto.CryptoPair
encrypt_packet(plain_header: bytes, plain_payload: bytes, packet_number: int) -> bytes
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_crypto
SHORT_SERVER_PACKET_NUMBER = 3
SHORT_SERVER_PLAIN_HEADER = binascii.unhexlify("41b01fd24a586a9cf30003")
SHORT_SERVER_PLAIN_PAYLOAD = binascii.unhexlify(
"06003904000035000151805a4bebf5000020b098c8dc4183e4c182572e10ac3e"
"2b88897e0524c8461847548bd2dffa2c0ae60008002a0004ffffffff"
)
SHORT_SERVER_ENCRYPTED_PACKET = binascii.unhexlify(
"5db01fd24a586a9cf33dec094aaec6d6b4b7a5e15f5a3f05d06cf1ad0355c19d"
"cce0807eecf7bf1c844a66e1ecd1f74b2a2d69bfd25d217833edd973246597bd"
"5107ea15cb1e210045396afa602fe23432f4ab24ce251b"
)
at: tests.test_crypto.CryptoTest.test_encrypt_short_server
pair = CryptoPair()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.crypto
class CryptoPair:
+ def encrypt_packet(
+ self, plain_header: bytes, plain_payload: bytes, packet_number: int
+ ) -> bytes:
- def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
if self._update_key_requested:
self._update_key()
+ return self.send.encrypt_packet(plain_header, plain_payload, packet_number)
- return self.send.encrypt_packet(plain_header, plain_payload)
===========changed ref 1===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_encrypt_long_server(self):
pair = self.create_crypto(is_client=False)
packet = pair.encrypt_packet(
+ LONG_SERVER_PLAIN_HEADER,
+ LONG_SERVER_PLAIN_PAYLOAD,
+ LONG_SERVER_PACKET_NUMBER,
- LONG_SERVER_PLAIN_HEADER, LONG_SERVER_PLAIN_PAYLOAD
)
self.assertEqual(packet, LONG_SERVER_ENCRYPTED_PACKET)
===========changed ref 2===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_encrypt_long_client(self):
pair = self.create_crypto(is_client=True)
packet = pair.encrypt_packet(
+ LONG_CLIENT_PLAIN_HEADER,
+ LONG_CLIENT_PLAIN_PAYLOAD,
+ LONG_CLIENT_PACKET_NUMBER,
- LONG_CLIENT_PLAIN_HEADER, LONG_CLIENT_PLAIN_PAYLOAD
)
self.assertEqual(packet, LONG_CLIENT_ENCRYPTED_PACKET)
===========changed ref 3===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_server(self):
pair = self.create_crypto(is_client=True)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
LONG_SERVER_ENCRYPTED_PACKET, 17, 0
)
self.assertEqual(plain_header, LONG_SERVER_PLAIN_HEADER)
self.assertEqual(plain_payload, LONG_SERVER_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, LONG_SERVER_PACKET_NUMBER)
- self.assertEqual(packet_number, 1)
===========changed ref 4===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_client(self):
pair = self.create_crypto(is_client=False)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
LONG_CLIENT_ENCRYPTED_PACKET, 17, 0
)
self.assertEqual(plain_header, LONG_CLIENT_PLAIN_HEADER)
self.assertEqual(plain_payload, LONG_CLIENT_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, LONG_CLIENT_PACKET_NUMBER)
- self.assertEqual(packet_number, 2)
===========changed ref 5===========
# module: tests.test_crypto
class CryptoTest(TestCase):
@skipIf(os.environ.get("TRAVIS") == "true", "travis lacks a modern OpenSSL")
def test_encrypt_chacha20(self):
pair = CryptoPair()
pair.send.setup(
CipherSuite.CHACHA20_POLY1305_SHA256,
binascii.unhexlify(
"fcc211ac3ff1f3fe1b096a41e701e30033cbd899494ebabbbc009ee2626d987e"
),
)
packet = pair.encrypt_packet(
+ CHACHA20_CLIENT_PLAIN_HEADER,
+ CHACHA20_CLIENT_PLAIN_PAYLOAD,
+ CHACHA20_CLIENT_PACKET_NUMBER,
- CHACHA20_CLIENT_PLAIN_HEADER, CHACHA20_CLIENT_PLAIN_PAYLOAD
)
self.assertEqual(packet, CHACHA20_CLIENT_ENCRYPTED_PACKET)
===========changed ref 6===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_short_server(self):
pair = CryptoPair()
pair.recv.setup(
INITIAL_CIPHER_SUITE,
binascii.unhexlify(
"310281977cb8c1c1c1212d784b2d29e5a6489e23de848d370a5a2f9537f3a100"
),
)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
SHORT_SERVER_ENCRYPTED_PACKET, 9, 0
)
self.assertEqual(plain_header, SHORT_SERVER_PLAIN_HEADER)
self.assertEqual(plain_payload, SHORT_SERVER_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, SHORT_SERVER_PACKET_NUMBER)
- self.assertEqual(packet_number, 3)
===========changed ref 7===========
# module: tests.test_crypto
class CryptoTest(TestCase):
@skipIf(os.environ.get("TRAVIS") == "true", "travis lacks a modern OpenSSL")
def test_decrypt_chacha20(self):
pair = CryptoPair()
pair.recv.setup(
CipherSuite.CHACHA20_POLY1305_SHA256,
binascii.unhexlify(
"fcc211ac3ff1f3fe1b096a41e701e30033cbd899494ebabbbc009ee2626d987e"
),
)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
CHACHA20_CLIENT_ENCRYPTED_PACKET, 34, 0
)
self.assertEqual(plain_header, CHACHA20_CLIENT_PLAIN_HEADER)
self.assertEqual(plain_payload, CHACHA20_CLIENT_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, CHACHA20_CLIENT_PACKET_NUMBER)
- self.assertEqual(packet_number, 2)
|
tests.test_crypto/CryptoTest.test_key_update
|
Modified
|
aiortc~aioquic
|
bc15d4de59d7328a9df12fa471c0bd24b74a1dd4
|
[crypto] pass packet_number to AEAD code
|
<3>:<add> def create_packet(key_phase, packet_number):
<del> def create_packet(key_phase, packet_number=0):
<10>:<add> def send(sender, receiver, packet_number=0):
<del> def send(sender, receiver):
<11>:<add> plain_header, plain_payload = create_packet(
<del> plain_header, plain_payload = create_packet(key_phase=sender.key_phase)
<12>:<add> key_phase=sender.key_phase, packet_number=packet_number
<add> )
<add> encrypted = sender.encrypt_packet(
<del> encrypted = sender.encrypt_packet(plain_header, plain_payload)
<13>:<add> plain_header, plain_payload, packet_number
<add> )
<add> recov_header, recov_payload, recov_packet_number = receiver.decrypt_packet(
<del> recov_header, recov_payload, _ = receiver.decrypt_packet(
<18>:<add> self.assertEqual(recov_packet_number, packet_number)
<20>:<add> send(pair1, pair2, 0)
<del> send(pair1, pair2)
<21>:<add> send(pair2, pair1, 0)
<del> send(pair2, pair1)
<29>:<add> send(pair1, pair2, 1)
<del> send(pair1, pair2)
<30>:<add> send(pair2, pair1, 1)
<del> send(pair2, pair1)
<38>:<add> send(pair2, pair1, 2
|
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_key_update(self):
<0> pair1 = self.create_crypto(is_client=True)
<1> pair2 = self.create_crypto(is_client=False)
<2>
<3> def create_packet(key_phase, packet_number=0):
<4> buf = Buffer(capacity=100)
<5> buf.push_uint8(PACKET_FIXED_BIT | key_phase << 2 | 1)
<6> buf.push_bytes(binascii.unhexlify("8394c8f03e515708"))
<7> buf.push_uint16(packet_number)
<8> return buf.data, b"\x00\x01\x02\x03"
<9>
<10> def send(sender, receiver):
<11> plain_header, plain_payload = create_packet(key_phase=sender.key_phase)
<12> encrypted = sender.encrypt_packet(plain_header, plain_payload)
<13> recov_header, recov_payload, _ = receiver.decrypt_packet(
<14> encrypted, len(plain_header) - 2, 0
<15> )
<16> self.assertEqual(recov_header, plain_header)
<17> self.assertEqual(recov_payload, plain_payload)
<18>
<19> # roundtrip
<20> send(pair1, pair2)
<21> send(pair2, pair1)
<22> self.assertEqual(pair1.key_phase, 0)
<23> self.assertEqual(pair2.key_phase, 0)
<24>
<25> # pair 1 key update
<26> pair1.update_key()
<27>
<28> # roundtrip
<29> send(pair1, pair2)
<30> send(pair2, pair1)
<31> self.assertEqual(pair1.key_phase, 1)
<32> self.assertEqual(pair2.key_phase, 1)
<33>
<34> # pair 2 key update
<35> pair2.update_key()
<36>
<37> # roundtrip
<38> send(pair2, pair1)
<39> send(pair1, pair2</s>
|
===========below chunk 0===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_key_update(self):
# offset: 1
self.assertEqual(pair1.key_phase, 0)
self.assertEqual(pair2.key_phase, 0)
# pair 1 key - update, but not next to send
pair1.update_key()
# roundtrip
send(pair2, pair1)
send(pair1, pair2)
self.assertEqual(pair1.key_phase, 1)
self.assertEqual(pair2.key_phase, 1)
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.buffer.Buffer
push_bytes(v: bytes) -> None
push_uint8(v: int) -> None
push_uint16(v: int) -> None
at: aioquic.crypto.CryptoPair
encrypt_packet(plain_header: bytes, plain_payload: bytes, packet_number: int) -> bytes
at: aioquic.packet
PACKET_FIXED_BIT = 0x40
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_crypto.CryptoTest
create_crypto(is_client)
create_crypto(self, is_client)
at: tests.test_crypto.CryptoTest.test_key_update
pair1 = self.create_crypto(is_client=True)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def create_crypto(self, is_client):
pair = CryptoPair()
pair.setup_initial(
cid=binascii.unhexlify("8394c8f03e515708"), is_client=is_client
)
- if is_client:
- self.assertEqual(
- pair.send.iv, binascii.unhexlify("19e94387805eb0b46c03a788")
- )
- self.assertEqual(
- pair.recv.iv, binascii.unhexlify("0a82086d32205ba22241d8dc")
- )
- else:
- self.assertEqual(
- pair.send.iv, binascii.unhexlify("0a82086d32205ba22241d8dc")
- )
- self.assertEqual(
- pair.recv.iv, binascii.unhexlify("19e94387805eb0b46c03a788")
- )
return pair
===========changed ref 1===========
# module: aioquic.crypto
class CryptoPair:
+ def encrypt_packet(
+ self, plain_header: bytes, plain_payload: bytes, packet_number: int
+ ) -> bytes:
- def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
if self._update_key_requested:
self._update_key()
+ return self.send.encrypt_packet(plain_header, plain_payload, packet_number)
- return self.send.encrypt_packet(plain_header, plain_payload)
===========changed ref 2===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_encrypt_long_server(self):
pair = self.create_crypto(is_client=False)
packet = pair.encrypt_packet(
+ LONG_SERVER_PLAIN_HEADER,
+ LONG_SERVER_PLAIN_PAYLOAD,
+ LONG_SERVER_PACKET_NUMBER,
- LONG_SERVER_PLAIN_HEADER, LONG_SERVER_PLAIN_PAYLOAD
)
self.assertEqual(packet, LONG_SERVER_ENCRYPTED_PACKET)
===========changed ref 3===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_encrypt_long_client(self):
pair = self.create_crypto(is_client=True)
packet = pair.encrypt_packet(
+ LONG_CLIENT_PLAIN_HEADER,
+ LONG_CLIENT_PLAIN_PAYLOAD,
+ LONG_CLIENT_PACKET_NUMBER,
- LONG_CLIENT_PLAIN_HEADER, LONG_CLIENT_PLAIN_PAYLOAD
)
self.assertEqual(packet, LONG_CLIENT_ENCRYPTED_PACKET)
===========changed ref 4===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_encrypt_short_server(self):
pair = CryptoPair()
pair.send.setup(
INITIAL_CIPHER_SUITE,
binascii.unhexlify(
"310281977cb8c1c1c1212d784b2d29e5a6489e23de848d370a5a2f9537f3a100"
),
)
packet = pair.encrypt_packet(
+ SHORT_SERVER_PLAIN_HEADER,
+ SHORT_SERVER_PLAIN_PAYLOAD,
+ SHORT_SERVER_PACKET_NUMBER,
- SHORT_SERVER_PLAIN_HEADER, SHORT_SERVER_PLAIN_PAYLOAD
)
self.assertEqual(packet, SHORT_SERVER_ENCRYPTED_PACKET)
===========changed ref 5===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_server(self):
pair = self.create_crypto(is_client=True)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
LONG_SERVER_ENCRYPTED_PACKET, 17, 0
)
self.assertEqual(plain_header, LONG_SERVER_PLAIN_HEADER)
self.assertEqual(plain_payload, LONG_SERVER_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, LONG_SERVER_PACKET_NUMBER)
- self.assertEqual(packet_number, 1)
===========changed ref 6===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_client(self):
pair = self.create_crypto(is_client=False)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
LONG_CLIENT_ENCRYPTED_PACKET, 17, 0
)
self.assertEqual(plain_header, LONG_CLIENT_PLAIN_HEADER)
self.assertEqual(plain_payload, LONG_CLIENT_PLAIN_PAYLOAD)
+ self.assertEqual(packet_number, LONG_CLIENT_PACKET_NUMBER)
- self.assertEqual(packet_number, 2)
===========changed ref 7===========
# module: tests.test_crypto
class CryptoTest(TestCase):
@skipIf(os.environ.get("TRAVIS") == "true", "travis lacks a modern OpenSSL")
def test_encrypt_chacha20(self):
pair = CryptoPair()
pair.send.setup(
CipherSuite.CHACHA20_POLY1305_SHA256,
binascii.unhexlify(
"fcc211ac3ff1f3fe1b096a41e701e30033cbd899494ebabbbc009ee2626d987e"
),
)
packet = pair.encrypt_packet(
+ CHACHA20_CLIENT_PLAIN_HEADER,
+ CHACHA20_CLIENT_PLAIN_PAYLOAD,
+ CHACHA20_CLIENT_PACKET_NUMBER,
- CHACHA20_CLIENT_PLAIN_HEADER, CHACHA20_CLIENT_PLAIN_PAYLOAD
)
self.assertEqual(packet, CHACHA20_CLIENT_ENCRYPTED_PACKET)
|
aioquic.crypto/CryptoContext.decrypt_packet
|
Modified
|
aiortc~aioquic
|
8c2625ff0ad3daa02dffc66752a25c1a8ff8a2c7
|
[crypto] move truncated packet number extraction
|
<4>:<add> plain_header, packet_number = self.hp.remove(packet, encrypted_offset)
<del> plain_header = self.hp.remove(packet, encrypted_offset)
<8>:<del> packet_number = 0
<10>:<del> for i in range(pn_length):
<11>:<del> packet_number = (packet_number << 8) | plain_header[encrypted_offset + i]
|
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int, expected_packet_number: int
) -> Tuple[bytes, bytes, int, bool]:
<0> if self.aead is None:
<1> raise CryptoError("Decryption key is not available")
<2>
<3> # header protection
<4> plain_header = self.hp.remove(packet, encrypted_offset)
<5> first_byte = plain_header[0]
<6>
<7> # packet number
<8> packet_number = 0
<9> pn_length = (first_byte & 0x03) + 1
<10> for i in range(pn_length):
<11> packet_number = (packet_number << 8) | plain_header[encrypted_offset + i]
<12> packet_number = decode_packet_number(
<13> packet_number, pn_length * 8, expected_packet_number
<14> )
<15>
<16> # detect key phase change
<17> crypto = self
<18> if not is_long_header(first_byte):
<19> key_phase = (first_byte & 4) >> 2
<20> if key_phase != self.key_phase:
<21> crypto = next_key_phase(self)
<22>
<23> # payload protection
<24> payload = crypto.aead.decrypt(
<25> packet[len(plain_header) :], plain_header, packet_number
<26> )
<27>
<28> return plain_header, payload, packet_number, crypto != self
<29>
|
===========unchanged ref 0===========
at: aioquic._crypto
CryptoError(*args: object)
at: aioquic._crypto.AEAD
decrypt(data: bytes, associated_data: bytes, packet_number: int) -> bytes
at: aioquic._crypto.HeaderProtection
remove(packet: bytes, encrypted_offset: int) -> Tuple[bytes, int]
at: aioquic.crypto
next_key_phase(self: CryptoContext) -> CryptoContext
at: aioquic.crypto.CryptoContext.__init__
self.aead: Optional[AEAD] = None
self.hp: Optional[HeaderProtection] = None
self.key_phase = key_phase
at: aioquic.crypto.CryptoContext.setup
self.aead = AEAD(aead_cipher_name, key, iv)
self.hp = HeaderProtection(hp_cipher_name, hp)
at: aioquic.crypto.CryptoContext.teardown
self.aead = None
self.hp = None
at: aioquic.packet
decode_packet_number(truncated: int, num_bits: int, expected: int) -> int
is_long_header(first_byte: int) -> bool
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
|
aioquic.connection/QuicConnection.connection_lost
|
Modified
|
aiortc~aioquic
|
aa755bf042a22358e1f6ccb1baabd2bcd855232a
|
[connection] raise ConnectionError if connection times out
|
<6>:<add> self._connected_waiter.set_exception(exc or ConnectionError)
<del> self._connected_waiter.set_exception(exc)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
# asyncio.DatagramProtocol
def connection_lost(self, exc: Exception) -> None:
<0> self._logger.info("Connection closed")
<1> for epoch in self._spaces.keys():
<2> self._discard_epoch(epoch)
<3> for stream in self._streams.values():
<4> stream.connection_lost(exc)
<5> if not self._connected_waiter.done():
<6> self._connected_waiter.set_exception(exc)
<7> self._closed.set()
<8>
|
===========unchanged ref 0===========
at: _asyncio.Future
done()
set_exception(exception, /)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_discard_epoch(epoch: tls.Epoch) -> None
at: aioquic.connection.QuicConnection.__init__
self._closed = asyncio.Event()
self._connected_waiter = loop.create_future()
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._spaces: Dict[tls.Epoch, QuicPacketSpace] = {}
self._streams: Dict[int, QuicStream] = {}
at: aioquic.connection.QuicConnection._initialize
self._spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.stream.QuicStream
connection_lost(exc: Exception) -> None
at: asyncio.futures.Future
_state = _PENDING
_result = None
_exception = None
_loop = None
_source_traceback = None
_cancel_message = None
_cancelled_exc = None
_asyncio_future_blocking = False
__log_traceback = False
__class_getitem__ = classmethod(GenericAlias)
done() -> bool
set_exception(exception: Union[type, BaseException], /) -> None
__iter__ = __await__ # make compatible with 'yield from'.
at: asyncio.locks.Event
set() -> None
at: asyncio.protocols.BaseProtocol
__slots__ = ()
connection_lost(self, exc: Optional[Exception]) -> None
at: logging.LoggerAdapter
logger: Logger
extra: Mapping[str, Any]
===========unchanged ref 1===========
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
<s>[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
if is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
assert certificate is not None, "SSL certificate is required for a server"
assert private_key is not None, "SSL private key is required for a server"
loop = asyncio.get_event_loop()
self.is_client = is_client
if supported_versions is not None:
self.supported_versions = supported_versions
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
# TLS configuration
self._alpn_protocols = alpn_protocols
self._certificate = certificate
self._private_key = private_key
self._secrets_log_file = secrets_log_file
self._server_name = server_name
self._close_at: Optional[float] = None
self._close_exception: Optional[Exception] = None
self._closed = asyncio.Event()
self._connect_called = False
self._connected_waiter = loop.create_future()
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._crypto_buffers: Dict[tls.Epoch, Buffer] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
self._handshake_complete = False
self._handshake_confirmed = False
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8</s>
===========changed ref 1===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
<s>confirmed = False
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
+ self._local_idle_timeout = idle_timeout or 60.0 # seconds
- self._local_idle_timeout = 60.0 # seconds
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._loop = loop
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(send_probe=self._send_probe)
self._loss_detection_at: Optional[float] = None</s>
|
aioquic.client/connect
|
Modified
|
aiortc~aioquic
|
aa755bf042a22358e1f6ccb1baabd2bcd855232a
|
[connection] raise ConnectionError if connection times out
|
<s> port: int,
*,
alpn_protocols: Optional[List[str]] = None,
+ idle_timeout: Optional[float] = None,
protocol_version: Optional[int] = None,
secrets_log_file: Optional[TextIO] = None,
session_ticket: Optional[SessionTicket] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> AsyncGenerator[QuicConnection, None]:
<0> """
<1> Connect to a QUIC server at the given `host` and `port`.
<2>
<3> :meth:`connect()` returns an awaitable. Awaiting it yields a
<4> :class:`~aioquic.QuicConnection` which can be used to create streams.
<5>
<6> :func:`connect` also accepts the following optional arguments:
<7>
<8> * ``alpn_protocols`` is a list of ALPN protocols to offer in the
<9> ClientHello.
<10> * ``secrets_log_file`` is a file-like object in which to log traffic
<11> secrets. This is useful to analyze traffic captures with Wireshark.
<12> * ``session_ticket`` is a TLS session ticket which should be used for
<13> resumption.
<14> * ``session_ticket_handler`` is a callback which is invoked by the TLS
<15> engine when a new session ticket is received.
<16> * ``stream_handler`` is a callback which is invoked whenever a stream is
<17> created. It must accept two arguments: a :class:`asyncio.StreamReader`
<18> and a :class:`asyncio.StreamWriter`.
<19> """
<20> loop = asyncio.get_event_loop()
<21>
<22> # if host is not an IP address, pass it to enable SNI
<23> try:
<24> ipaddress.ip_address(host)
<25> server_name = None
<26> except ValueError:
<27> server_name = host
<28>
<29> # lookup remote address
<30> infos = await loop.getaddrinfo(host, port, type=socket.SOCK_DGRAM)
<31> addr = infos[0][4]</s>
|
===========below chunk 0===========
<s> *,
alpn_protocols: Optional[List[str]] = None,
+ idle_timeout: Optional[float] = None,
protocol_version: Optional[int] = None,
secrets_log_file: Optional[TextIO] = None,
session_ticket: Optional[SessionTicket] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> AsyncGenerator[QuicConnection, None]:
# offset: 1
addr = ("::ffff:" + addr[0], addr[1], 0, 0)
# connect
_, protocol = await loop.create_datagram_endpoint(
lambda: QuicConnection(
alpn_protocols=alpn_protocols,
is_client=True,
secrets_log_file=secrets_log_file,
server_name=server_name,
session_ticket=session_ticket,
session_ticket_handler=session_ticket_handler,
stream_handler=stream_handler,
),
local_addr=("::", 0),
)
protocol = cast(QuicConnection, protocol)
protocol.connect(addr, protocol_version=protocol_version)
await protocol.wait_connected()
try:
yield protocol
finally:
protocol.close()
await protocol.wait_closed()
===========unchanged ref 0===========
at: _asyncio
get_event_loop()
at: aioquic.compat
asynccontextmanager = _asynccontextmanager
asynccontextmanager = None
at: aioquic.connection
QuicStreamHandler = Callable[[asyncio.StreamReader, asyncio.StreamWriter], None]
QuicConnection(*, idle_timeout: Optional[float]=None, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, supported_versions: Optional[List[QuicProtocolVersion]]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
connect(addr: NetworkAddress, protocol_version: Optional[int]=None) -> None
wait_connected() -> None
at: aioquic.tls
SessionTicket(age_add: int, cipher_suite: CipherSuite, not_valid_after: datetime.datetime, not_valid_before: datetime.datetime, resumption_secret: bytes, server_name: str, ticket: bytes, max_early_data_size: Optional[int]=None, other_extensions: List[Tuple[int, bytes]]=field(default_factory=list))
SessionTicketHandler = Callable[[SessionTicket], None]
at: asyncio.events
get_event_loop() -> AbstractEventLoop
===========unchanged ref 1===========
at: asyncio.events.AbstractEventLoop
getaddrinfo(host: Optional[str], port: Union[str, int, None], *, family: int=..., type: int=..., proto: int=..., flags: int=...) -> List[Tuple[AddressFamily, SocketKind, int, str, Union[Tuple[str, int], Tuple[str, int, int, int]]]]
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: contextlib
asynccontextmanager(func: Callable[..., AsyncIterator[_T]]) -> Callable[..., AsyncContextManager[_T]]
at: ipaddress
ip_address(address: object) -> Any
at: socket
SOCK_DGRAM: SocketKind
at: typing
cast(typ: Type[_T], val: Any) -> _T
cast(typ: str, val: Any) -> Any
cast(typ: object, val: Any) -> Any
List = _alias(list, 1, inst=False, name='List')
AsyncGenerator = _alias(collections.abc.AsyncGenerator, 2)
TextIO()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
# asyncio.DatagramProtocol
def connection_lost(self, exc: Exception) -> None:
self._logger.info("Connection closed")
for epoch in self._spaces.keys():
self._discard_epoch(epoch)
for stream in self._streams.values():
stream.connection_lost(exc)
if not self._connected_waiter.done():
+ self._connected_waiter.set_exception(exc or ConnectionError)
- self._connected_waiter.set_exception(exc)
self._closed.set()
===========changed ref 1===========
<s>[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
if is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
assert certificate is not None, "SSL certificate is required for a server"
assert private_key is not None, "SSL private key is required for a server"
loop = asyncio.get_event_loop()
self.is_client = is_client
if supported_versions is not None:
self.supported_versions = supported_versions
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
# TLS configuration
self._alpn_protocols = alpn_protocols
self._certificate = certificate
self._private_key = private_key
self._secrets_log_file = secrets_log_file
self._server_name = server_name
self._close_at: Optional[float] = None
self._close_exception: Optional[Exception] = None
self._closed = asyncio.Event()
self._connect_called = False
self._connected_waiter = loop.create_future()
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._crypto_buffers: Dict[tls.Epoch, Buffer] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
self._handshake_complete = False
self._handshake_confirmed = False
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8</s>
|
|
aioquic.server/QuicServer.__init__
|
Modified
|
aiortc~aioquic
|
aa755bf042a22358e1f6ccb1baabd2bcd855232a
|
[connection] raise ConnectionError if connection times out
|
<3>:<add> self._idle_timeout = idle_timeout
|
<s>_protocols: Optional[List[str]] = None,
connection_handler: Optional[QuicConnectionHandler] = None,
+ idle_timeout: Optional[float] = None,
secrets_log_file: Optional[TextIO] = None,
session_ticket_fetcher: Optional[SessionTicketFetcher] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stateless_retry: bool = False,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
<0> self._alpn_protocols = alpn_protocols
<1> self._certificate = certificate
<2> self._connections: Dict[bytes, QuicConnection] = {}
<3> self._private_key = private_key
<4> self._secrets_log_file = secrets_log_file
<5> self._session_ticket_fetcher = session_ticket_fetcher
<6> self._session_ticket_handler = session_ticket_handler
<7> self._transport: Optional[asyncio.DatagramTransport] = None
<8>
<9> if connection_handler is not None:
<10> self._connection_handler = connection_handler
<11> else:
<12> self._connection_handler = lambda c: None
<13>
<14> self._stream_handler = stream_handler
<15>
<16> if stateless_retry:
<17> self._retry_key = rsa.generate_private_key(
<18> public_exponent=65537, key_size=1024, backend=default_backend()
<19> )
<20> else:
<21> self._retry_key = None
<22>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicStreamHandler = Callable[[asyncio.StreamReader, asyncio.StreamWriter], None]
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, supported_versions: Optional[List[QuicProtocolVersion]]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.server
QuicConnectionHandler = Callable[[QuicConnection], None]
at: aioquic.server.QuicServer.connection_made
self._transport = cast(asyncio.DatagramTransport, transport)
at: aioquic.tls
SessionTicketFetcher = Callable[[bytes], Optional[SessionTicket]]
SessionTicketHandler = Callable[[SessionTicket], None]
at: asyncio.transports
DatagramTransport(extra: Optional[Mapping[Any, Any]]=...)
at: typing
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
TextIO()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
# asyncio.DatagramProtocol
def connection_lost(self, exc: Exception) -> None:
self._logger.info("Connection closed")
for epoch in self._spaces.keys():
self._discard_epoch(epoch)
for stream in self._streams.values():
stream.connection_lost(exc)
if not self._connected_waiter.done():
+ self._connected_waiter.set_exception(exc or ConnectionError)
- self._connected_waiter.set_exception(exc)
self._closed.set()
===========changed ref 1===========
<s> port: int,
*,
alpn_protocols: Optional[List[str]] = None,
+ idle_timeout: Optional[float] = None,
protocol_version: Optional[int] = None,
secrets_log_file: Optional[TextIO] = None,
session_ticket: Optional[SessionTicket] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> AsyncGenerator[QuicConnection, None]:
"""
Connect to a QUIC server at the given `host` and `port`.
:meth:`connect()` returns an awaitable. Awaiting it yields a
:class:`~aioquic.QuicConnection` which can be used to create streams.
:func:`connect` also accepts the following optional arguments:
* ``alpn_protocols`` is a list of ALPN protocols to offer in the
ClientHello.
* ``secrets_log_file`` is a file-like object in which to log traffic
secrets. This is useful to analyze traffic captures with Wireshark.
* ``session_ticket`` is a TLS session ticket which should be used for
resumption.
* ``session_ticket_handler`` is a callback which is invoked by the TLS
engine when a new session ticket is received.
* ``stream_handler`` is a callback which is invoked whenever a stream is
created. It must accept two arguments: a :class:`asyncio.StreamReader`
and a :class:`asyncio.StreamWriter`.
"""
loop = asyncio.get_event_loop()
# if host is not an IP address, pass it to enable SNI
try:
ipaddress.ip_address(host)
server_name = None
except ValueError:
server_name = host
# lookup remote address
infos = await loop.getaddrinfo(host, port, type=socket.SOCK_DGRAM)
addr = infos[0][4]
if len(addr) == 2:
addr = ("::ffff:" + addr[0], addr[1], 0, 0)
</s>
===========changed ref 2===========
<s> *,
alpn_protocols: Optional[List[str]] = None,
+ idle_timeout: Optional[float] = None,
protocol_version: Optional[int] = None,
secrets_log_file: Optional[TextIO] = None,
session_ticket: Optional[SessionTicket] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> AsyncGenerator[QuicConnection, None]:
# offset: 1
<s> if len(addr) == 2:
addr = ("::ffff:" + addr[0], addr[1], 0, 0)
# connect
_, protocol = await loop.create_datagram_endpoint(
lambda: QuicConnection(
alpn_protocols=alpn_protocols,
+ idle_timeout=idle_timeout,
is_client=True,
secrets_log_file=secrets_log_file,
server_name=server_name,
session_ticket=session_ticket,
session_ticket_handler=session_ticket_handler,
stream_handler=stream_handler,
),
local_addr=("::", 0),
)
protocol = cast(QuicConnection, protocol)
protocol.connect(addr, protocol_version=protocol_version)
await protocol.wait_connected()
try:
yield protocol
finally:
protocol.close()
await protocol.wait_closed()
===========changed ref 3===========
<s>[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
if is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
assert certificate is not None, "SSL certificate is required for a server"
assert private_key is not None, "SSL private key is required for a server"
loop = asyncio.get_event_loop()
self.is_client = is_client
if supported_versions is not None:
self.supported_versions = supported_versions
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
# TLS configuration
self._alpn_protocols = alpn_protocols
self._certificate = certificate
self._private_key = private_key
self._secrets_log_file = secrets_log_file
self._server_name = server_name
self._close_at: Optional[float] = None
self._close_exception: Optional[Exception] = None
self._closed = asyncio.Event()
self._connect_called = False
self._connected_waiter = loop.create_future()
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._crypto_buffers: Dict[tls.Epoch, Buffer] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
self._handshake_complete = False
self._handshake_confirmed = False
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8</s>
|
aioquic.server/QuicServer.datagram_received
|
Modified
|
aiortc~aioquic
|
aa755bf042a22358e1f6ccb1baabd2bcd855232a
|
[connection] raise ConnectionError if connection times out
|
# module: aioquic.server
class QuicServer(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
<0> data = cast(bytes, data)
<1> buf = Buffer(data=data)
<2> header = pull_quic_header(buf, host_cid_length=8)
<3>
<4> # version negotiation
<5> if (
<6> header.version is not None
<7> and header.version not in QuicConnection.supported_versions
<8> ):
<9> self._transport.sendto(
<10> encode_quic_version_negotiation(
<11> source_cid=header.destination_cid,
<12> destination_cid=header.source_cid,
<13> supported_versions=QuicConnection.supported_versions,
<14> ),
<15> addr,
<16> )
<17> return
<18>
<19> connection = self._connections.get(header.destination_cid, None)
<20> original_connection_id: Optional[bytes] = None
<21> if connection is None and header.packet_type == PACKET_TYPE_INITIAL:
<22> # stateless retry
<23> if self._retry_key is not None:
<24> if not header.token:
<25> retry_message = encode_address(addr) + b"|" + header.destination_cid
<26> retry_token = self._retry_key.public_key().encrypt(
<27> retry_message,
<28> padding.OAEP(
<29> mgf=padding.MGF1(hashes.SHA256()),
<30> algorithm=hashes.SHA256(),
<31> label=None,
<32> ),
<33> )
<34> self._transport.sendto(
<35> encode_quic_retry(
<36> version=header.version,
<37> source_cid=os.urandom(8),
<38> destination_cid=header.source_cid,
<39> original_destination_cid=header.destination_cid,
<40> retry_token=retry_token,
<41> ),
<42> addr,
<43> )
<44> return
<45> else:</s>
|
===========below chunk 0===========
# module: aioquic.server
class QuicServer(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
# offset: 1
retry_message = self._retry_key.decrypt(
header.token,
padding.OAEP(
mgf=padding.MGF1(hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None,
),
)
encoded_addr, original_connection_id = retry_message.split(
b"|", maxsplit=1
)
if encoded_addr != encode_address(addr):
return
except ValueError:
return
# create new connection
connection = QuicConnection(
alpn_protocols=self._alpn_protocols,
certificate=self._certificate,
is_client=False,
original_connection_id=original_connection_id,
private_key=self._private_key,
secrets_log_file=self._secrets_log_file,
session_ticket_fetcher=self._session_ticket_fetcher,
session_ticket_handler=self._session_ticket_handler,
stream_handler=self._stream_handler,
)
self._connections[header.destination_cid] = connection
def connection_id_issued(cid: bytes) -> None:
self._connections[cid] = connection
def connection_id_retired(cid: bytes) -> None:
del self._connections[cid]
connection._connection_id_issued_handler = connection_id_issued
connection._connection_id_retired_handler = connection_id_retired
connection.connection_made(self._transport)
self._connections[connection.host_cid] = connection
self._connection_handler(connection)
if connection is not None:
connection.datagram_received(data, addr)
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
NetworkAddress = Any
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, supported_versions: Optional[List[QuicProtocolVersion]]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
connection_made(transport: asyncio.BaseTransport) -> None
at: aioquic.connection.QuicConnection.__init__
self.host_cid = self._host_cids[0].cid
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionIdHandler = lambda c: None
at: aioquic.connection.QuicConnection.datagram_received
self.host_cid = context.host_cid
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_retry(version: int, source_cid: bytes, destination_cid: bytes, original_destination_cid: bytes, retry_token: bytes) -> bytes
===========unchanged ref 1===========
encode_quic_version_negotiation(source_cid: bytes, destination_cid: bytes, supported_versions: List[QuicProtocolVersion]) -> bytes
at: aioquic.packet.QuicHeader
is_long_header: bool
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: aioquic.server
encode_address(addr: NetworkAddress) -> bytes
at: aioquic.server.QuicServer.__init__
self._alpn_protocols = alpn_protocols
self._certificate = certificate
self._connections: Dict[bytes, QuicConnection] = {}
self._idle_timeout = idle_timeout
self._private_key = private_key
self._secrets_log_file = secrets_log_file
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
self._transport: Optional[asyncio.DatagramTransport] = None
self._connection_handler = connection_handler
self._connection_handler = lambda c: None
self._stream_handler = stream_handler
self._retry_key = None
self._retry_key = rsa.generate_private_key(
public_exponent=65537, key_size=1024, backend=default_backend()
)
at: asyncio.protocols.DatagramProtocol
__slots__ = ()
datagram_received(self, data: bytes, addr: Tuple[str, int]) -> None
at: asyncio.transports
DatagramTransport(extra: Optional[Mapping[Any, Any]]=...)
at: asyncio.transports.DatagramTransport
__slots__ = ()
sendto(data: Any, addr: Optional[_Address]=...) -> None
at: os
urandom(size: int, /) -> bytes
===========unchanged ref 2===========
at: typing
cast(typ: Type[_T], val: Any) -> _T
cast(typ: str, val: Any) -> Any
cast(typ: object, val: Any) -> Any
Text = str
at: typing.Mapping
get(key: _KT, default: Union[_VT_co, _T]) -> Union[_VT_co, _T]
get(key: _KT) -> Optional[_VT_co]
===========changed ref 0===========
<s>_protocols: Optional[List[str]] = None,
connection_handler: Optional[QuicConnectionHandler] = None,
+ idle_timeout: Optional[float] = None,
secrets_log_file: Optional[TextIO] = None,
session_ticket_fetcher: Optional[SessionTicketFetcher] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stateless_retry: bool = False,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
self._alpn_protocols = alpn_protocols
self._certificate = certificate
self._connections: Dict[bytes, QuicConnection] = {}
+ self._idle_timeout = idle_timeout
self._private_key = private_key
self._secrets_log_file = secrets_log_file
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
self._transport: Optional[asyncio.DatagramTransport] = None
if connection_handler is not None:
self._connection_handler = connection_handler
else:
self._connection_handler = lambda c: None
self._stream_handler = stream_handler
if stateless_retry:
self._retry_key = rsa.generate_private_key(
public_exponent=65537, key_size=1024, backend=default_backend()
)
else:
self._retry_key = None
|
|
tests.test_high_level/run_client
|
Modified
|
aiortc~aioquic
|
aa755bf042a22358e1f6ccb1baabd2bcd855232a
|
[connection] raise ConnectionError if connection times out
|
<0>:<add> async with connect(host, port, **kwargs) as client:
<del> async with connect(host, 4433, **kwargs) as client:
|
# module: tests.test_high_level
+ def run_client(host, port=4433, request=b"ping", **kwargs):
- def run_client(host, request=b"ping", **kwargs):
<0> async with connect(host, 4433, **kwargs) as client:
<1> reader, writer = await client.create_stream()
<2>
<3> writer.write(request)
<4> writer.write_eof()
<5>
<6> return await reader.read()
<7>
|
===========unchanged ref 0===========
at: aioquic.client
connect(*args, **kwds)
connect(host: str, port: int, *, alpn_protocols: Optional[List[str]]=None, idle_timeout: Optional[float]=None, protocol_version: Optional[int]=None, secrets_log_file: Optional[TextIO]=None, session_ticket: Optional[SessionTicket]=None, session_ticket_handler: Optional[SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None) -> AsyncGenerator[QuicConnection, None]
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
at: asyncio.streams.StreamReader
_source_traceback = None
read(n: int=...) -> bytes
at: asyncio.streams.StreamWriter
write(data: bytes) -> None
write_eof() -> None
===========changed ref 0===========
<s> port: int,
*,
alpn_protocols: Optional[List[str]] = None,
+ idle_timeout: Optional[float] = None,
protocol_version: Optional[int] = None,
secrets_log_file: Optional[TextIO] = None,
session_ticket: Optional[SessionTicket] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> AsyncGenerator[QuicConnection, None]:
"""
Connect to a QUIC server at the given `host` and `port`.
:meth:`connect()` returns an awaitable. Awaiting it yields a
:class:`~aioquic.QuicConnection` which can be used to create streams.
:func:`connect` also accepts the following optional arguments:
* ``alpn_protocols`` is a list of ALPN protocols to offer in the
ClientHello.
* ``secrets_log_file`` is a file-like object in which to log traffic
secrets. This is useful to analyze traffic captures with Wireshark.
* ``session_ticket`` is a TLS session ticket which should be used for
resumption.
* ``session_ticket_handler`` is a callback which is invoked by the TLS
engine when a new session ticket is received.
* ``stream_handler`` is a callback which is invoked whenever a stream is
created. It must accept two arguments: a :class:`asyncio.StreamReader`
and a :class:`asyncio.StreamWriter`.
"""
loop = asyncio.get_event_loop()
# if host is not an IP address, pass it to enable SNI
try:
ipaddress.ip_address(host)
server_name = None
except ValueError:
server_name = host
# lookup remote address
infos = await loop.getaddrinfo(host, port, type=socket.SOCK_DGRAM)
addr = infos[0][4]
if len(addr) == 2:
addr = ("::ffff:" + addr[0], addr[1], 0, 0)
</s>
===========changed ref 1===========
<s> *,
alpn_protocols: Optional[List[str]] = None,
+ idle_timeout: Optional[float] = None,
protocol_version: Optional[int] = None,
secrets_log_file: Optional[TextIO] = None,
session_ticket: Optional[SessionTicket] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> AsyncGenerator[QuicConnection, None]:
# offset: 1
<s> if len(addr) == 2:
addr = ("::ffff:" + addr[0], addr[1], 0, 0)
# connect
_, protocol = await loop.create_datagram_endpoint(
lambda: QuicConnection(
alpn_protocols=alpn_protocols,
+ idle_timeout=idle_timeout,
is_client=True,
secrets_log_file=secrets_log_file,
server_name=server_name,
session_ticket=session_ticket,
session_ticket_handler=session_ticket_handler,
stream_handler=stream_handler,
),
local_addr=("::", 0),
)
protocol = cast(QuicConnection, protocol)
protocol.connect(addr, protocol_version=protocol_version)
await protocol.wait_connected()
try:
yield protocol
finally:
protocol.close()
await protocol.wait_closed()
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
# asyncio.DatagramProtocol
def connection_lost(self, exc: Exception) -> None:
self._logger.info("Connection closed")
for epoch in self._spaces.keys():
self._discard_epoch(epoch)
for stream in self._streams.values():
stream.connection_lost(exc)
if not self._connected_waiter.done():
+ self._connected_waiter.set_exception(exc or ConnectionError)
- self._connected_waiter.set_exception(exc)
self._closed.set()
===========changed ref 3===========
<s>_protocols: Optional[List[str]] = None,
connection_handler: Optional[QuicConnectionHandler] = None,
+ idle_timeout: Optional[float] = None,
secrets_log_file: Optional[TextIO] = None,
session_ticket_fetcher: Optional[SessionTicketFetcher] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stateless_retry: bool = False,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
self._alpn_protocols = alpn_protocols
self._certificate = certificate
self._connections: Dict[bytes, QuicConnection] = {}
+ self._idle_timeout = idle_timeout
self._private_key = private_key
self._secrets_log_file = secrets_log_file
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
self._transport: Optional[asyncio.DatagramTransport] = None
if connection_handler is not None:
self._connection_handler = connection_handler
else:
self._connection_handler = lambda c: None
self._stream_handler = stream_handler
if stateless_retry:
self._retry_key = rsa.generate_private_key(
public_exponent=65537, key_size=1024, backend=default_backend()
)
else:
self._retry_key = None
|
aioquic.packet_builder/QuicPacketBuilder.__init__
|
Modified
|
aiortc~aioquic
|
78d2a722613cfba1c61ef8cb5cff8fd7976d88a1
|
[packet builder] rework packet builder limits
|
<0>:<add> self.max_flight_bytes: Optional[int] = None
<add> self.max_total_bytes: Optional[int] = None
<add>
<10>:<add> self._datagram_init = True
<11>:<add> self._flight_bytes = 0
<17>:<add> self._packet_long_header = False
<del> self._packet_epoch: Optional[Epoch] = None
<23>:<add> self._buffer_capacity = PACKET_MAX_SIZE
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
pad_first_datagram: bool = False,
packet_number: int = 0,
peer_token: bytes = b"",
spin_bit: bool = False,
):
<0> self._host_cid = host_cid
<1> self._pad_first_datagram = pad_first_datagram
<2> self._peer_cid = peer_cid
<3> self._peer_token = peer_token
<4> self._spin_bit = spin_bit
<5> self._version = version
<6>
<7> # assembled datagrams and packets
<8> self._ack_eliciting = False
<9> self._datagrams: List[bytes] = []
<10> self._packets: List[QuicSentPacket] = []
<11> self._total_bytes = 0
<12>
<13> # current packet
<14> self._header_size = 0
<15> self._packet: Optional[QuicSentPacket] = None
<16> self._packet_crypto: Optional[CryptoPair] = None
<17> self._packet_epoch: Optional[Epoch] = None
<18> self._packet_number = packet_number
<19> self._packet_start = 0
<20> self._packet_type = 0
<21>
<22> self.buffer = Buffer(PACKET_MAX_SIZE)
<23>
|
===========unchanged ref 0===========
at: aioquic.packet_builder
QuicSentPacket(epoch: Epoch, in_flight: bool, is_ack_eliciting: bool, is_crypto_packet: bool, packet_number: int, sent_time: Optional[float]=None, sent_bytes: int=0, delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]]=field(
default_factory=list
))
at: aioquic.packet_builder.QuicPacketBuilder._flush_current_datagram
self._datagram_init = True
self._flight_bytes += datagram_bytes
self._total_bytes += datagram_bytes
at: aioquic.packet_builder.QuicPacketBuilder.end_packet
self._pad_first_datagram = False
at: aioquic.packet_builder.QuicPacketBuilder.flush
self._datagrams = []
self._packets = []
at: aioquic.packet_builder.QuicPacketBuilder.start_frame
self._ack_eliciting = True
at: aioquic.packet_builder.QuicPacketBuilder.start_packet
self._ack_eliciting = False
self._datagram_init = False
at: typing
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: aioquic.packet_builder
+ class QuicPacketBuilderStop(Exception):
+ pass
+
|
aioquic.packet_builder/QuicPacketBuilder.remaining_space
|
Modified
|
aiortc~aioquic
|
78d2a722613cfba1c61ef8cb5cff8fd7976d88a1
|
[packet builder] rework packet builder limits
|
<5>:<add> self._buffer_capacity
<del> self.buffer.capacity
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
<0> """
<1> Returns the remaining number of bytes which can be used in
<2> the current packet.
<3> """
<4> return (
<5> self.buffer.capacity
<6> - self.buffer.tell()
<7> - self._packet_crypto.aead_tag_size
<8> )
<9>
|
===========unchanged ref 0===========
at: aioquic._buffer.Buffer
tell() -> int
at: aioquic.crypto.CryptoPair.__init__
self.aead_tag_size = 16
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._packet_crypto: Optional[CryptoPair] = None
self.buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
at: aioquic.packet_builder.QuicPacketBuilder.start_packet
self._buffer_capacity = remaining_flight_bytes
self._buffer_capacity = remaining_total_bytes
self._packet_crypto = crypto
===========changed ref 0===========
# module: aioquic.packet_builder
+ class QuicPacketBuilderStop(Exception):
+ pass
+
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
- @property
- def flight_bytes(self) -> int:
- """
- Returns the total number of bytes which will count towards
- congestion control.
- """
- total = self._total_bytes
- if self._ack_eliciting:
- total += self.buffer.tell()
- return total
-
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
pad_first_datagram: bool = False,
packet_number: int = 0,
peer_token: bytes = b"",
spin_bit: bool = False,
):
+ self.max_flight_bytes: Optional[int] = None
+ self.max_total_bytes: Optional[int] = None
+
self._host_cid = host_cid
self._pad_first_datagram = pad_first_datagram
self._peer_cid = peer_cid
self._peer_token = peer_token
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._ack_eliciting = False
self._datagrams: List[bytes] = []
+ self._datagram_init = True
self._packets: List[QuicSentPacket] = []
+ self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
+ self._packet_long_header = False
- self._packet_epoch: Optional[Epoch] = None
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
+ self._buffer_capacity = PACKET_MAX_SIZE
|
aioquic.packet_builder/QuicPacketBuilder.start_packet
|
Modified
|
aiortc~aioquic
|
78d2a722613cfba1c61ef8cb5cff8fd7976d88a1
|
[packet builder] rework packet builder limits
|
<8>:<add> packet_start = buf.tell()
<add> if self._buffer_capacity - packet_start < 128:
<del> if buf.capacity - buf.tell() < 128:
<10>:<add> packet_start = 0
<add>
<add> # initialize datagram if needed
<add> if self._datagram_init:
<add> if self.max_flight_bytes is not None and not is_probe:
<add> remaining_flight_bytes = self.max_flight_bytes - self._flight_bytes
<add> if remaining_flight_bytes < self._buffer_capacity:
<add> self._buffer_capacity = remaining_flight_bytes
<add> if self.max_total_bytes is not None:
<add> remaining_total_bytes = self.max_total_bytes - self._total_bytes
<add> if remaining_total_bytes < self._buffer_capacity:
<add> self._buffer_capacity = remaining_total_bytes
<add> self._datagram_init = False
<add>
<add> # calculate header size
<add> packet_long_header = is_long_header(packet_type)
<add> if packet_long_header
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def start_packet(
+ self, packet_type: int, crypto: CryptoPair, is_probe=False
+ ) -> None:
- def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
<0> """
<1> Starts a new packet.
<2> """
<3> buf = self.buffer
<4> self._ack_eliciting = False
<5>
<6> # if there is too little space remaining, start a new datagram
<7> # FIXME: the limit is arbitrary!
<8> if buf.capacity - buf.tell() < 128:
<9> self._flush_current_datagram()
<10>
<11> # determine ack epoch
<12> if packet_type == PACKET_TYPE_INITIAL:
<13> epoch = Epoch.INITIAL
<14> elif packet_type == PACKET_TYPE_HANDSHAKE:
<15> epoch = Epoch.HANDSHAKE
<16> else:
<17> epoch = Epoch.ONE_RTT
<18>
<19> self._packet = QuicSentPacket(
<20> epoch=epoch,
<21> in_flight=False,
<22> is_ack_eliciting=False,
<23> is_crypto_packet=False,
<24> packet_number=self._packet_number,
<25> )
<26> self._packet_crypto = crypto
<27> self._packet_epoch = epoch
<28> self._packet_start = buf.tell()
<29> self._packet_type = packet_type
<30>
<31> # calculate header size
<32> if is_long_header(packet_type):
<33> self._header_size = 10 + len(self._peer_cid) + len(self._host_cid)
<34> if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
<35> token_length = len(self._peer_token)
<36> self._header_size += size_uint_var(token_length) + token_length
<37> else:
<38> self._header_size = 3 + len(self._peer_cid)
<39>
<40> buf</s>
|
===========below chunk 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def start_packet(
+ self, packet_type: int, crypto: CryptoPair, is_probe=False
+ ) -> None:
- def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
===========unchanged ref 0===========
at: aioquic._buffer.Buffer
tell() -> int
at: aioquic.buffer
size_uint_var(value: int) -> int
at: aioquic.crypto
CryptoPair()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_MASK = 0xF0
is_long_header(first_byte: int) -> bool
at: aioquic.packet_builder
QuicPacketBuilderStop(*args: object)
at: aioquic.packet_builder.QuicPacketBuilder
_flush_current_datagram() -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
self._host_cid = host_cid
self._peer_cid = peer_cid
self._peer_token = peer_token
self._ack_eliciting = False
self._datagram_init = True
self._flight_bytes = 0
self._total_bytes = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
self._buffer_capacity = PACKET_MAX_SIZE
at: aioquic.packet_builder.QuicPacketBuilder._flush_current_datagram
self._datagram_init = True
self._flight_bytes += datagram_bytes
self._total_bytes += datagram_bytes
at: aioquic.packet_builder.QuicPacketBuilder.start_frame
self._ack_eliciting = True
===========changed ref 0===========
# module: aioquic.packet_builder
+ class QuicPacketBuilderStop(Exception):
+ pass
+
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
"""
Returns the remaining number of bytes which can be used in
the current packet.
"""
return (
+ self._buffer_capacity
- self.buffer.capacity
- self.buffer.tell()
- self._packet_crypto.aead_tag_size
)
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
- @property
- def flight_bytes(self) -> int:
- """
- Returns the total number of bytes which will count towards
- congestion control.
- """
- total = self._total_bytes
- if self._ack_eliciting:
- total += self.buffer.tell()
- return total
-
===========changed ref 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
pad_first_datagram: bool = False,
packet_number: int = 0,
peer_token: bytes = b"",
spin_bit: bool = False,
):
+ self.max_flight_bytes: Optional[int] = None
+ self.max_total_bytes: Optional[int] = None
+
self._host_cid = host_cid
self._pad_first_datagram = pad_first_datagram
self._peer_cid = peer_cid
self._peer_token = peer_token
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._ack_eliciting = False
self._datagrams: List[bytes] = []
+ self._datagram_init = True
self._packets: List[QuicSentPacket] = []
+ self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
+ self._packet_long_header = False
- self._packet_epoch: Optional[Epoch] = None
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
+ self._buffer_capacity = PACKET_MAX_SIZE
|
aioquic.packet_builder/QuicPacketBuilder.end_packet
|
Modified
|
aiortc~aioquic
|
78d2a722613cfba1c61ef8cb5cff8fd7976d88a1
|
[packet builder] rework packet builder limits
|
<18>:<add> if self._packet_long_header:
<del> if is_long_header(self._packet_type):
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
<0> """
<1> Ends the current packet.
<2>
<3> Returns `True` if the packet contains data, `False` otherwise.
<4> """
<5> buf = self.buffer
<6> empty = True
<7> packet_size = buf.tell() - self._packet_start
<8> if packet_size > self._header_size:
<9> empty = False
<10>
<11> # pad initial datagram
<12> if self._pad_first_datagram:
<13> buf.push_bytes(bytes(self.remaining_space))
<14> packet_size = buf.tell() - self._packet_start
<15> self._pad_first_datagram = False
<16>
<17> # write header
<18> if is_long_header(self._packet_type):
<19> length = (
<20> packet_size
<21> - self._header_size
<22> + PACKET_NUMBER_SEND_SIZE
<23> + self._packet_crypto.aead_tag_size
<24> )
<25>
<26> buf.seek(self._packet_start)
<27> buf.push_uint8(self._packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
<28> buf.push_uint32(self._version)
<29> buf.push_uint8(
<30> (encode_cid_length(len(self._peer_cid)) << 4)
<31> | encode_cid_length(len(self._host_cid))
<32> )
<33> buf.push_bytes(self._peer_cid)
<34> buf.push_bytes(self._host_cid)
<35> if (self._packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
<36> buf.push_uint_var(len(self._peer_token))
<37> buf.push_bytes(self._peer_token)
<38> buf.push_uint16(length | 0x4000)
<39> buf.push_uint16(self._packet_number & 0xFFFF)
<40> else:
<41> buf</s>
|
===========below chunk 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
# offset: 1
buf.push_uint8(
self._packet_type
| (self._spin_bit << 5)
| (self._packet_crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1)
)
buf.push_bytes(self._peer_cid)
buf.push_uint16(self._packet_number & 0xFFFF)
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
buf.seek(self._packet_start + packet_size)
buf.push_bytes(bytes(padding_size))
packet_size += padding_size
# encrypt in place
plain = buf.data_slice(self._packet_start, self._packet_start + packet_size)
buf.seek(self._packet_start)
buf.push_bytes(
self._packet_crypto.encrypt_packet(
plain[0 : self._header_size],
plain[self._header_size : packet_size],
self._packet_number,
)
)
self._packet.sent_bytes = buf.tell() - self._packet_start
self._packets.append(self._packet)
# short header packets cannot be coallesced, we need a new datagram
if not is_long_header(self._packet_type):
self._flush_current_datagram()
self._packet_number += 1
else:
# "cancel" the packet
buf.seek(self._packet_start)
self._packet = None
return not empty
===========unchanged ref 0===========
at: aioquic._buffer.Buffer
data_slice(start: int, end: int) -> bytes
seek(pos: int) -> None
tell() -> int
push_bytes(value: bytes) -> None
push_uint8(value: int) -> None
push_uint16(value: int) -> None
push_uint32(v: int) -> None
push_uint_var(value: int) -> None
at: aioquic.crypto.CryptoPair.__init__
self.aead_tag_size = 16
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_MASK = 0xF0
PACKET_NUMBER_MAX_SIZE = 4
encode_cid_length(length: int) -> int
at: aioquic.packet_builder
PACKET_NUMBER_SEND_SIZE = 2
QuicSentPacket(epoch: Epoch, in_flight: bool, is_ack_eliciting: bool, is_crypto_packet: bool, packet_number: int, sent_time: Optional[float]=None, sent_bytes: int=0, delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]]=field(
default_factory=list
))
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._host_cid = host_cid
self._pad_first_datagram = pad_first_datagram
self._peer_cid = peer_cid
self._peer_token = peer_token
self._spin_bit = spin_bit
self._version = version
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_long_header = False
===========unchanged ref 1===========
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.packet_builder.QuicPacketBuilder.end_packet
self._packet_number += 1
self._packet = None
at: aioquic.packet_builder.QuicPacketBuilder.start_packet
buf = self.buffer
packet_start = buf.tell()
packet_start = 0
packet_long_header = is_long_header(packet_type)
header_size += size_uint_var(token_length) + token_length
header_size = 10 + len(self._peer_cid) + len(self._host_cid)
header_size = 3 + len(self._peer_cid)
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
"""
Returns the remaining number of bytes which can be used in
the current packet.
"""
return (
+ self._buffer_capacity
- self.buffer.capacity
- self.buffer.tell()
- self._packet_crypto.aead_tag_size
)
===========changed ref 1===========
# module: aioquic.packet_builder
+ class QuicPacketBuilderStop(Exception):
+ pass
+
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
- @property
- def flight_bytes(self) -> int:
- """
- Returns the total number of bytes which will count towards
- congestion control.
- """
- total = self._total_bytes
- if self._ack_eliciting:
- total += self.buffer.tell()
- return total
-
===========changed ref 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
pad_first_datagram: bool = False,
packet_number: int = 0,
peer_token: bytes = b"",
spin_bit: bool = False,
):
+ self.max_flight_bytes: Optional[int] = None
+ self.max_total_bytes: Optional[int] = None
+
self._host_cid = host_cid
self._pad_first_datagram = pad_first_datagram
self._peer_cid = peer_cid
self._peer_token = peer_token
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._ack_eliciting = False
self._datagrams: List[bytes] = []
+ self._datagram_init = True
self._packets: List[QuicSentPacket] = []
+ self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
+ self._packet_long_header = False
- self._packet_epoch: Optional[Epoch] = None
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
+ self._buffer_capacity = PACKET_MAX_SIZE
|
aioquic.packet_builder/QuicPacketBuilder._flush_current_datagram
|
Modified
|
aiortc~aioquic
|
78d2a722613cfba1c61ef8cb5cff8fd7976d88a1
|
[packet builder] rework packet builder limits
|
<0>:<add> datagram_bytes = self.buffer.tell()
<add> if datagram_bytes:
<del> if self.buffer.tell():
<2>:<add> self._datagram_init = True
<3>:<add> self._flight_bytes += datagram_bytes
<add> self._total_bytes += datagram_bytes
<del> self._total_bytes += self.buffer.tell()
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def _flush_current_datagram(self) -> None:
<0> if self.buffer.tell():
<1> self._datagrams.append(self.buffer.data)
<2> if self._ack_eliciting:
<3> self._total_bytes += self.buffer.tell()
<4> self.buffer.seek(0)
<5>
|
===========unchanged ref 0===========
at: aioquic._buffer.Buffer
tell() -> int
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_number = packet_number
self._packet_start = 0
at: aioquic.packet_builder.QuicPacketBuilder.end_packet
buf = self.buffer
packet_size = buf.tell() - self._packet_start
packet_size += padding_size
plain = buf.data_slice(self._packet_start, self._packet_start + packet_size)
self._packet_number += 1
self._packet = None
at: aioquic.packet_builder.QuicPacketBuilder.start_packet
self._header_size = header_size
self._packet = QuicSentPacket(
epoch=epoch,
in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_start = packet_start
at: aioquic.packet_builder.QuicSentPacket
sent_bytes: int = 0
===========changed ref 0===========
# module: aioquic.packet_builder
+ class QuicPacketBuilderStop(Exception):
+ pass
+
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
"""
Returns the remaining number of bytes which can be used in
the current packet.
"""
return (
+ self._buffer_capacity
- self.buffer.capacity
- self.buffer.tell()
- self._packet_crypto.aead_tag_size
)
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
- @property
- def flight_bytes(self) -> int:
- """
- Returns the total number of bytes which will count towards
- congestion control.
- """
- total = self._total_bytes
- if self._ack_eliciting:
- total += self.buffer.tell()
- return total
-
===========changed ref 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
pad_first_datagram: bool = False,
packet_number: int = 0,
peer_token: bytes = b"",
spin_bit: bool = False,
):
+ self.max_flight_bytes: Optional[int] = None
+ self.max_total_bytes: Optional[int] = None
+
self._host_cid = host_cid
self._pad_first_datagram = pad_first_datagram
self._peer_cid = peer_cid
self._peer_token = peer_token
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._ack_eliciting = False
self._datagrams: List[bytes] = []
+ self._datagram_init = True
self._packets: List[QuicSentPacket] = []
+ self._flight_bytes = 0
self._total_bytes = 0
# current packet
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
+ self._packet_long_header = False
- self._packet_epoch: Optional[Epoch] = None
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
+ self._buffer_capacity = PACKET_MAX_SIZE
===========changed ref 4===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
"""
Ends the current packet.
Returns `True` if the packet contains data, `False` otherwise.
"""
buf = self.buffer
empty = True
packet_size = buf.tell() - self._packet_start
if packet_size > self._header_size:
empty = False
# pad initial datagram
if self._pad_first_datagram:
buf.push_bytes(bytes(self.remaining_space))
packet_size = buf.tell() - self._packet_start
self._pad_first_datagram = False
# write header
+ if self._packet_long_header:
- if is_long_header(self._packet_type):
length = (
packet_size
- self._header_size
+ PACKET_NUMBER_SEND_SIZE
+ self._packet_crypto.aead_tag_size
)
buf.seek(self._packet_start)
buf.push_uint8(self._packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
buf.push_uint32(self._version)
buf.push_uint8(
(encode_cid_length(len(self._peer_cid)) << 4)
| encode_cid_length(len(self._host_cid))
)
buf.push_bytes(self._peer_cid)
buf.push_bytes(self._host_cid)
if (self._packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
buf.push_uint_var(len(self._peer_token))
buf.push_bytes(self._peer_token)
buf.push_uint16(length | 0x4000)
buf.push_uint16(self._packet_number & 0xFFFF)
else:
buf.seek(self._packet_start)
buf.push_uint8(
self._packet_type
| (</s>
===========changed ref 5===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
# offset: 1
<s> buf.seek(self._packet_start)
buf.push_uint8(
self._packet_type
| (self._spin_bit << 5)
| (self._packet_crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1)
)
buf.push_bytes(self._peer_cid)
buf.push_uint16(self._packet_number & 0xFFFF)
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
buf.seek(self._packet_start + packet_size)
buf.push_bytes(bytes(padding_size))
packet_size += padding_size
# encrypt in place
plain = buf.data_slice(self._packet_start, self._packet_start + packet_size)
buf.seek(self._packet_start)
buf.push_bytes(
self._packet_crypto.encrypt_packet(
plain[0 : self._header_size],
plain[self._header_size : packet_size],
self._packet_number,
)
)
self._packet.sent_bytes = buf.tell() - self._packet_start
self._packets.append(self._packet)
# short header packets cannot be coallesced, we need a new datagram
+ if not self._packet_long_header:
- if not is_long_header(self._packet_type):
self._flush_current_datagram()
self._packet_number += 1
else:
# "cancel" the packet
buf.seek(self._packet_start)
self._
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
78d2a722613cfba1c61ef8cb5cff8fd7976d88a1
|
[packet builder] rework packet builder limits
|
<33>:<add> # congestion control
<add> builder.max_flight_bytes = (
<del> # data is limited by congestion control and whether the network path is validated
<34>:<add> self._loss.congestion_window - self._loss.bytes_in_flight
<del> max_bytes = self._loss.congestion_window - self._loss.bytes_in_flight
<35>:<add> )
<36>:<add> # limit data on un-validated network paths
<add> builder.max_total_bytes = (
<del> max_bytes = min(
<37>:<add> network_path.bytes_received * 3 - network_path.bytes_sent
<del> max_bytes, network_path.bytes_received * 3 - network_path.bytes_sent
<40>:<add> try:
<add> if not self._handshake_confirmed:
<del> if not self._handshake_confirmed:
<41>:<add> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<del>
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
<0> network_path = self._network_paths[0]
<1>
<2> self._send_task = None
<3> if self._state in END_STATES:
<4> return
<5>
<6> # build datagrams
<7> builder = QuicPacketBuilder(
<8> host_cid=self.host_cid,
<9> packet_number=self._packet_number,
<10> pad_first_datagram=(
<11> self.is_client and self._state == QuicConnectionState.FIRSTFLIGHT
<12> ),
<13> peer_cid=self._peer_cid,
<14> peer_token=self._peer_token,
<15> spin_bit=self._spin_bit,
<16> version=self._version,
<17> )
<18> if self._close_pending:
<19> for epoch, packet_type in (
<20> (tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
<21> (tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
<22> (tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
<23> ):
<24> crypto = self._cryptos[epoch]
<25> if crypto.send.is_valid():
<26> builder.start_packet(packet_type, crypto)
<27> write_close_frame(builder, **self._close_pending)
<28> builder.end_packet()
<29> self._close_pending = None
<30> break
<31> self._close(is_initiator=True)
<32> else:
<33> # data is limited by congestion control and whether the network path is validated
<34> max_bytes = self._loss.congestion_window - self._loss.bytes_in_flight
<35> if not network_path.is_validated:
<36> max_bytes = min(
<37> max_bytes, network_path.bytes_received * 3 - network_path.bytes_sent
<38> )
<39>
<40> if not self._handshake_confirmed:
<41> </s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
self._write_handshake(builder, epoch, max_bytes)
self._write_application(builder, max_bytes, network_path, self._loop.time())
datagrams, packets = builder.flush()
if datagrams:
self._packet_number = builder.packet_number
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
# register packets
now = self._loop.time()
sent_handshake = False
for packet in packets:
packet.sent_time = now
self._loss.on_packet_sent(
packet=packet, space=self._spaces[packet.epoch]
)
if packet.epoch == tls.Epoch.HANDSHAKE:
sent_handshake = True
# check if we can discard initial keys
if sent_handshake and self.is_client:
self._discard_epoch(tls.Epoch.INITIAL)
# arm timer
self._set_timer()
===========unchanged ref 0===========
at: aioquic.connection
write_close_frame(builder: QuicPacketBuilder, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None
QuicConnectionState()
END_STATES = frozenset([QuicConnectionState.CLOSING, QuicConnectionState.DRAINING])
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_close(is_initiator: bool) -> None
_write_application(builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float) -> None
_write_application(self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float) -> None
_write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None
_write_handshake(builder: QuicPacketBuilder, epoch: tls.Epoch) -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._handshake_confirmed = False
self.host_cid = self._host_cids[0].cid
self._loop = loop
self._loss = QuicPacketRecovery(send_probe=self._send_probe)
self._network_paths: List[QuicNetworkPath] = []
self._packet_number = 0
self._peer_cid = os.urandom(8)
self._peer_token = b""
self._spin_bit = False
self._state = QuicConnectionState.FIRSTFLIGHT
self._version: Optional[int] = None
self._close_pending: Optional[Dict] = None
self._send_task: Optional[asyncio.Handle] = None
at: aioquic.connection.QuicConnection._consume_connection_id
self._peer_cid = connection_id.cid
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._handle_ack_frame
self._handshake_confirmed = True
at: aioquic.connection.QuicConnection._initialize
self._cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self._packet_number = 0
at: aioquic.connection.QuicConnection._send_soon
self._send_task = self._loop.call_soon(self._send_pending)
at: aioquic.connection.QuicConnection._set_state
self._state = state
at: aioquic.connection.QuicConnection.close
self._close_pending = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.connect
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
self._version = max(self.supported_versions)
self._version = protocol_version
at: aioquic.connection.QuicConnection.datagram_received
self._version = QuicProtocolVersion(header.version)
self._version = QuicProtocolVersion(max(common))
self._peer_cid = header.source_cid
self._peer_token = header.token
self._network_paths = [network_path]
self._spin_bit = self._spin_bit_peer
self._spin_bit = not self._spin_bit_peer
self.host_cid = context.host_cid
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
bytes_received: int = 0
bytes_sent: int = 0
is_validated: bool = False
local_challenge: Optional[bytes] = None
===========unchanged ref 2===========
remote_challenge: Optional[bytes] = None
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair.__init__
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
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
at: aioquic.packet_builder
QuicPacketBuilderStop(*args: object)
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> Tuple[List[bytes], List[QuicSentPacket]]
start_packet(packet_type: int, crypto: CryptoPair, is_probe=False) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
at: aioquic.recovery.QuicPacketRecovery.__init__
self.bytes_in_flight = 0
self.congestion_window = K_INITIAL_WINDOW
at: aioquic.recovery.QuicPacketRecovery.on_loss_detection_timeout
self.bytes_in_flight -= packet.sent_bytes
at: aioquic.recovery.QuicPacketRecovery.on_packet_acked
self.bytes_in_flight -= packet.sent_bytes
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
78d2a722613cfba1c61ef8cb5cff8fd7976d88a1
|
[packet builder] rework packet builder limits
|
<14>:<add> while True:
<del> while builder.flight_bytes < max_bytes or self._probe_pending:
<16>:<add> builder.start_packet(packet_type, crypto, is_probe=self._probe_pending)
<del> builder.start_packet(packet_type, crypto)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
- self,
- builder: QuicPacketBuilder,
- max_bytes: int,
- network_path: QuicNetworkPath,
- now: float,
+ self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
<0> crypto_stream: Optional[QuicStream] = None
<1> if self._cryptos[tls.Epoch.ONE_RTT].send.is_valid():
<2> crypto = self._cryptos[tls.Epoch.ONE_RTT]
<3> crypto_stream = self._crypto_streams[tls.Epoch.ONE_RTT]
<4> packet_type = PACKET_TYPE_ONE_RTT
<5> elif self._cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
<6> crypto = self._cryptos[tls.Epoch.ZERO_RTT]
<7> packet_type = PACKET_TYPE_ZERO_RTT
<8> else:
<9> return
<10> space = self._spaces[tls.Epoch.ONE_RTT]
<11>
<12> buf = builder.buffer
<13>
<14> while builder.flight_bytes < max_bytes or self._probe_pending:
<15> # write header
<16> builder.start_packet(packet_type, crypto)
<17>
<18> if self._handshake_complete:
<19> # ACK
<20> if space.ack_at is not None and space.ack_at <= now:
<21> builder.start_frame(
<22> QuicFrameType.ACK,
<23> self._on_ack_delivery,
<24> (space, space.largest_received_packet),
<25> )
<26> push_ack_frame(buf, space.ack_queue, 0)
<27> space.ack_at = None
<28>
<29> # PATH CHALLENGE
<30> if (
<31> not network_path.is_validated
<32> and network_path.local_challenge is None
<33> ):
<34> self._logger.info(
<35> </s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
- self,
- builder: QuicPacketBuilder,
- max_bytes: int,
- network_path: QuicNetworkPath,
- now: float,
+ self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
# offset: 1
)
network_path.local_challenge = os.urandom(8)
builder.start_frame(QuicFrameType.PATH_CHALLENGE)
buf.push_bytes(network_path.local_challenge)
# PATH RESPONSE
if network_path.remote_challenge is not None:
builder.start_frame(QuicFrameType.PATH_RESPONSE)
buf.push_bytes(network_path.remote_challenge)
network_path.remote_challenge = None
# NEW_CONNECTION_ID
for connection_id in self._host_cids:
if not connection_id.was_sent:
builder.start_frame(
QuicFrameType.NEW_CONNECTION_ID,
self._on_new_connection_id_delivery,
(connection_id,),
)
push_new_connection_id_frame(
buf,
connection_id.sequence_number,
connection_id.cid,
connection_id.stateless_reset_token,
)
connection_id.was_sent = True
self._connection_id_issued_handler(connection_id.cid)
# RETIRE_CONNECTION_ID
while self._retire_connection_ids:
sequence_number = self._retire_connection_ids.pop(0)
builder.start_frame(
QuicFrameType.RETIRE_CONNECTION_ID,
self._on_retire_connection_id_delivery,
(sequence_number,),
)
buf.push_uint_var(sequence_number)
# connection-level limits
self._write_connection_limits(</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
- self,
- builder: QuicPacketBuilder,
- max_bytes: int,
- network_path: QuicNetworkPath,
- now: float,
+ self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
# offset: 2
<s> buf.push_uint_var(sequence_number)
# connection-level limits
self._write_connection_limits(builder=builder, space=space)
# stream-level limits
for stream in self._streams.values():
self._write_stream_limits(builder=builder, space=space, stream=stream)
# PING (user-request)
if self._ping_pending:
self._logger.info("Sending PING in packet %d", builder.packet_number)
builder.start_frame(QuicFrameType.PING, self._on_ping_delivery)
self._ping_pending = False
# PING (probe)
if self._probe_pending:
self._logger.info("Sending probe")
builder.start_frame(QuicFrameType.PING)
self._probe_pending = False
# CRYPTO
if crypto_stream is not None and not crypto_stream.send_buffer_is_empty:
write_crypto_frame(builder=builder, space=space, stream=crypto_stream)
for stream in self._streams.values():
# STREAM
if not stream.send_buffer_is_empty:
self._remote_max_data_used += write_stream_frame(
builder=builder,
space=space,
stream=stream,
max_offset=min(
stream._send_highest
+ self._remote_max_data
- self._remote_max_data_used,
stream.max_stream_data
===========unchanged ref 0===========
at: aioquic._buffer.Buffer
push_bytes(value: bytes) -> None
push_uint_var(value: int) -> None
at: aioquic.connection
write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
write_stream_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream, max_offset: int) -> int
QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, is_validated: bool=False, local_challenge: Optional[bytes]=None, remote_challenge: Optional[bytes]=None)
at: aioquic.connection.QuicConnection
_on_ack_delivery(delivery: QuicDeliveryState, space: QuicPacketSpace, highest_acked: int) -> None
_on_new_connection_id_delivery(delivery: QuicDeliveryState, connection_id: QuicConnectionId) -> None
_on_ping_delivery(delivery: QuicDeliveryState) -> None
_on_retire_connection_id_delivery(delivery: QuicDeliveryState, sequence_number: int) -> None
_write_connection_limits(builder: QuicPacketBuilder, space: QuicPacketSpace) -> None
_write_stream_limits(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
at: aioquic.connection.QuicConnection.__init__
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
self._handshake_complete = False
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
===========unchanged ref 1===========
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._remote_max_data = 0
self._remote_max_data_used = 0
self._spaces: Dict[tls.Epoch, QuicPacketSpace] = {}
self._streams: Dict[int, QuicStream] = {}
self._ping_pending = False
self._probe_pending = False
self._retire_connection_ids: List[int] = []
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
at: aioquic.connection.QuicConnection._handle_crypto_frame
self._handshake_complete = True
at: aioquic.connection.QuicConnection._handle_max_data_frame
self._remote_max_data = max_data
at: aioquic.connection.QuicConnection._initialize
self._cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self._crypto_streams = {
tls.Epoch.INITIAL: QuicStream(),
tls.Epoch.HANDSHAKE: QuicStream(),
tls.Epoch.ONE_RTT: QuicStream(),
}
self._spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.connection.QuicConnection._on_ping_delivery
self._ping_pending = True
at: aioquic.connection.QuicConnection._send_probe
self._probe_pending = True
at: aioquic.connection.QuicConnection.ping
self._ping_pending = True
at: aioquic.connection.QuicConnectionId
cid: bytes
|
aioquic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
78d2a722613cfba1c61ef8cb5cff8fd7976d88a1
|
[packet builder] rework packet builder limits
|
<8>:<add> while True:
<del> while builder.flight_bytes < max_bytes:
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
- def _write_handshake(
- self, builder: QuicPacketBuilder, epoch: tls.Epoch, max_bytes: int
- ) -> None:
+ def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
<0> crypto = self._cryptos[epoch]
<1> if not crypto.send.is_valid():
<2> return
<3>
<4> buf = builder.buffer
<5> crypto_stream = self._crypto_streams[epoch]
<6> space = self._spaces[epoch]
<7>
<8> while builder.flight_bytes < max_bytes:
<9> if epoch == tls.Epoch.INITIAL:
<10> packet_type = PACKET_TYPE_INITIAL
<11> else:
<12> packet_type = PACKET_TYPE_HANDSHAKE
<13> builder.start_packet(packet_type, crypto)
<14>
<15> # ACK
<16> if space.ack_at is not None:
<17> builder.start_frame(QuicFrameType.ACK)
<18> push_ack_frame(buf, space.ack_queue, 0)
<19> space.ack_at = None
<20>
<21> # CRYPTO
<22> if not crypto_stream.send_buffer_is_empty:
<23> write_crypto_frame(builder=builder, space=space, stream=crypto_stream)
<24>
<25> if not builder.end_packet():
<26> break
<27>
|
===========unchanged ref 0===========
at: aioquic.connection
write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
at: aioquic.connection.QuicConnection.__init__
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
self._spaces: Dict[tls.Epoch, QuicPacketSpace] = {}
at: aioquic.connection.QuicConnection._initialize
self._cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self._crypto_streams = {
tls.Epoch.INITIAL: QuicStream(),
tls.Epoch.HANDSHAKE: QuicStream(),
tls.Epoch.ONE_RTT: QuicStream(),
}
self._spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair.__init__
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
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 1===========
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
start_frame(frame_type: int, handler: Optional[QuicDeliveryHandler]=None, args: Sequence[Any]=[]) -> None
start_packet(packet_type: int, crypto: CryptoPair, is_probe=False) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_at: Optional[float] = None
self.ack_queue = RangeSet()
at: aioquic.stream.QuicStream.__init__
self.send_buffer_is_empty = True
at: aioquic.stream.QuicStream.get_frame
self.send_buffer_is_empty = True
at: aioquic.stream.QuicStream.on_data_delivery
self.send_buffer_is_empty = False
at: aioquic.stream.QuicStream.write
self.send_buffer_is_empty = False
at: aioquic.stream.QuicStream.write_eof
self.send_buffer_is_empty = False
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def start_packet(
+ self, packet_type: int, crypto: CryptoPair, is_probe=False
+ ) -> None:
- def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
buf = self.buffer
self._ack_eliciting = False
# if there is too little space remaining, start a new datagram
# FIXME: the limit is arbitrary!
+ packet_start = buf.tell()
+ if self._buffer_capacity - packet_start < 128:
- if buf.capacity - buf.tell() < 128:
self._flush_current_datagram()
+ packet_start = 0
+
+ # initialize datagram if needed
+ if self._datagram_init:
+ if self.max_flight_bytes is not None and not is_probe:
+ remaining_flight_bytes = self.max_flight_bytes - self._flight_bytes
+ if remaining_flight_bytes < self._buffer_capacity:
+ self._buffer_capacity = remaining_flight_bytes
+ if self.max_total_bytes is not None:
+ remaining_total_bytes = self.max_total_bytes - self._total_bytes
+ if remaining_total_bytes < self._buffer_capacity:
+ self._buffer_capacity = remaining_total_bytes
+ self._datagram_init = False
+
+ # calculate header size
+ packet_long_header = is_long_header(packet_type)
+ if packet_long_header:
+ header_size = 10 + len(self._peer_cid) + len(self._host_cid)
+ if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
+ token_length = len(self._peer_token)
+ header_size += size_uint_var(token_length) + token_length
+ else:
+ header_size = 3 + len(</s>
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def start_packet(
+ self, packet_type: int, crypto: CryptoPair, is_probe=False
+ ) -> None:
- def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
<s> size_uint_var(token_length) + token_length
+ else:
+ header_size = 3 + len(self._peer_cid)
+
+ # check we have enough space
+ if packet_start + header_size >= self._buffer_capacity:
+ raise QuicPacketBuilderStop
# determine ack epoch
if packet_type == PACKET_TYPE_INITIAL:
epoch = Epoch.INITIAL
elif packet_type == PACKET_TYPE_HANDSHAKE:
epoch = Epoch.HANDSHAKE
else:
epoch = Epoch.ONE_RTT
+ self._header_size = header_size
self._packet = QuicSentPacket(
epoch=epoch,
in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_crypto = crypto
+ self._packet_long_header = packet_long_header
- self._packet_epoch = epoch
+ self._packet_start = packet_start
- self._packet_start = buf.tell()
self._packet_type = packet_type
-
- # calculate header size
- if is_long_header(packet_type):
- self._header_size = 10 + len(self._peer_cid) + len(self._host_cid)
- if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
- token_length = len(self._peer_token)
- self._header_size += size_uint_</s>
|
aioquic.connection/QuicConnection._write_connection_limits
|
Modified
|
aiortc~aioquic
|
402e0f66a26e9ec14251d01fa7a885f9aefab6fa
|
[connection] double MAX_DATA instead of additive increase
|
<1>:<add> if self._local_max_data_used > self._local_max_data * 0.75:
<del> if self._local_max_data_used + MAX_DATA_WINDOW // 2 > self._local_max_data:
<2>:<add> self._local_max_data *= 2
<del> self._local_max_data += MAX_DATA_WINDOW
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_connection_limits(
self, builder: QuicPacketBuilder, space: QuicPacketSpace
) -> None:
<0> # raise MAX_DATA if needed
<1> if self._local_max_data_used + MAX_DATA_WINDOW // 2 > self._local_max_data:
<2> self._local_max_data += MAX_DATA_WINDOW
<3> self._logger.info("Local max_data raised to %d", self._local_max_data)
<4> if self._local_max_data_sent != self._local_max_data:
<5> builder.start_frame(QuicFrameType.MAX_DATA, self._on_max_data_delivery)
<6> builder.buffer.push_uint_var(self._local_max_data)
<7> self._local_max_data_sent = self._local_max_data
<8>
|
===========unchanged ref 0===========
at: aioquic._buffer.Buffer
push_uint_var(value: int) -> None
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_on_max_data_delivery(delivery: QuicDeliveryState) -> None
at: aioquic.connection.QuicConnection.__init__
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
at: aioquic.connection.QuicConnection._handle_stream_frame
self._local_max_data_used += newly_received
at: aioquic.connection.QuicConnection._on_max_data_delivery
self._local_max_data_sent = 0
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
start_frame(frame_type: int, handler: Optional[QuicDeliveryHandler]=None, args: Sequence[Any]=[]) -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.recovery
QuicPacketSpace()
at: logging.LoggerAdapter
logger: Logger
extra: Mapping[str, Any]
===========unchanged ref 1===========
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
|
aioquic.connection/QuicConnection._write_stream_limits
|
Modified
|
aiortc~aioquic
|
402e0f66a26e9ec14251d01fa7a885f9aefab6fa
|
[connection] double MAX_DATA instead of additive increase
|
<1>:<add> if stream._recv_highest > stream.max_stream_data_local * 0.75:
<del> if stream._recv_highest + MAX_DATA_WINDOW // 2 > stream.max_stream_data_local:
<2>:<add> stream.max_stream_data_local *= 2
<del> stream.max_stream_data_local += MAX_DATA_WINDOW
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_stream_limits(
self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
<0> # raise MAX_STREAM_DATA if needed
<1> if stream._recv_highest + MAX_DATA_WINDOW // 2 > stream.max_stream_data_local:
<2> stream.max_stream_data_local += MAX_DATA_WINDOW
<3> self._logger.info(
<4> "Stream %d local max_stream_data raised to %d",
<5> stream.stream_id,
<6> stream.max_stream_data_local,
<7> )
<8> if stream.max_stream_data_local_sent != stream.max_stream_data_local:
<9> builder.start_frame(
<10> QuicFrameType.MAX_STREAM_DATA,
<11> self._on_max_stream_data_delivery,
<12> (stream,),
<13> )
<14> builder.buffer.push_uint_var(stream.stream_id)
<15> builder.buffer.push_uint_var(stream.max_stream_data_local)
<16> stream.max_stream_data_local_sent = stream.max_stream_data_local
<17>
|
===========unchanged ref 0===========
at: aioquic._buffer.Buffer
push_uint_var(value: int) -> None
at: aioquic.connection.QuicConnection
_on_max_stream_data_delivery(delivery: QuicDeliveryState, stream: QuicStream) -> None
at: aioquic.connection.QuicConnection.__init__
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
start_frame(frame_type: int, handler: Optional[QuicDeliveryHandler]=None, args: Sequence[Any]=[]) -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.recovery
QuicPacketSpace()
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.stream.QuicStream.__init__
self.max_stream_data_local = max_stream_data_local
self.max_stream_data_local_sent = max_stream_data_local
self._recv_highest = 0 # the highest offset ever seen
at: aioquic.stream.QuicStream.add_frame
self._recv_highest = frame_end
===========unchanged ref 1===========
at: logging.LoggerAdapter
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(asyncio.DatagramProtocol):
def _write_connection_limits(
self, builder: QuicPacketBuilder, space: QuicPacketSpace
) -> None:
# raise MAX_DATA if needed
+ if self._local_max_data_used > self._local_max_data * 0.75:
- if self._local_max_data_used + MAX_DATA_WINDOW // 2 > self._local_max_data:
+ self._local_max_data *= 2
- self._local_max_data += MAX_DATA_WINDOW
self._logger.info("Local max_data raised to %d", self._local_max_data)
if self._local_max_data_sent != self._local_max_data:
builder.start_frame(QuicFrameType.MAX_DATA, self._on_max_data_delivery)
builder.buffer.push_uint_var(self._local_max_data)
self._local_max_data_sent = self._local_max_data
|
aioquic.tls/Context._set_state
|
Modified
|
aiortc~aioquic
|
426460fc110220e1c776d0be5e3fcce6adb41b20
|
[logging] lower the logging verbosity
|
<1>:<add> self.__logger.debug("TLS %s -> %s", self.state, state)
<del> self.__logger.info("TLS %s -> %s", self.state, state)
|
# module: aioquic.tls
class Context:
def _set_state(self, state: State) -> None:
<0> if self.__logger:
<1> self.__logger.info("TLS %s -> %s", self.state, state)
<2> self.state = state
<3>
|
===========unchanged ref 0===========
at: aioquic.tls
State()
at: aioquic.tls.Context.__init__
self.__logger = logger
self.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: logging.Logger
debug(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
at: logging.LoggerAdapter
debug(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
__class_getitem__ = classmethod(GenericAlias)
|
aioquic.connection/QuicConnection._handle_max_data_frame
|
Modified
|
aiortc~aioquic
|
426460fc110220e1c776d0be5e3fcce6adb41b20
|
[logging] lower the logging verbosity
|
<7>:<add> self._logger.debug("Remote max_data raised to %d", max_data)
<del> self._logger.info("Remote max_data raised to %d", max_data)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_data_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a MAX_DATA frame.
<2>
<3> This adjusts the total amount of we can send to the peer.
<4> """
<5> max_data = buf.pull_uint_var()
<6> if max_data > self._remote_max_data:
<7> self._logger.info("Remote max_data raised to %d", max_data)
<8> self._remote_max_data = max_data
<9>
|
===========unchanged ref 0===========
at: aioquic._buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic._buffer.Buffer
pull_uint_var() -> int
at: aioquic.connection
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath, time: float)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
at: aioquic.connection.QuicConnection.__init__
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._remote_max_data = 0
at: logging.LoggerAdapter
logger: Logger
extra: Mapping[str, Any]
debug(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.tls
class Context:
def _set_state(self, state: State) -> None:
if self.__logger:
+ self.__logger.debug("TLS %s -> %s", self.state, state)
- self.__logger.info("TLS %s -> %s", self.state, state)
self.state = state
|
aioquic.connection/QuicConnection._handle_max_stream_data_frame
|
Modified
|
aiortc~aioquic
|
426460fc110220e1c776d0be5e3fcce6adb41b20
|
[logging] lower the logging verbosity
|
<13>:<add> self._logger.debug(
<del> self._logger.info(
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_stream_data_frame(
self, context: QuicReceiveContext, 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 = buf.pull_uint_var()
<6> max_stream_data = buf.pull_uint_var()
<7>
<8> # check stream direction
<9> self._assert_stream_can_send(frame_type, stream_id)
<10>
<11> stream = self._get_or_create_stream(frame_type, stream_id)
<12> if max_stream_data > stream.max_stream_data_remote:
<13> self._logger.info(
<14> "Stream %d remote max_stream_data raised to %d",
<15> stream_id,
<16> max_stream_data,
<17> )
<18> stream.max_stream_data_remote = max_stream_data
<19>
|
===========unchanged ref 0===========
at: aioquic._buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic._buffer.Buffer
pull_uint_var() -> int
at: aioquic.connection
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath, time: float)
at: aioquic.connection.QuicConnection
_assert_stream_can_send(frame_type: int, stream_id: int) -> None
_get_or_create_stream(frame_type: int, stream_id: int) -> QuicStream
at: aioquic.connection.QuicConnection.__init__
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
at: aioquic.stream.QuicStream.__init__
self.max_stream_data_remote = max_stream_data_remote
at: logging.LoggerAdapter
debug(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_data_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_DATA frame.
This adjusts the total amount of we can send to the peer.
"""
max_data = buf.pull_uint_var()
if max_data > self._remote_max_data:
+ self._logger.debug("Remote max_data raised to %d", max_data)
- self._logger.info("Remote max_data raised to %d", max_data)
self._remote_max_data = max_data
===========changed ref 1===========
# module: aioquic.tls
class Context:
def _set_state(self, state: State) -> None:
if self.__logger:
+ self.__logger.debug("TLS %s -> %s", self.state, state)
- self.__logger.info("TLS %s -> %s", self.state, state)
self.state = state
|
aioquic.connection/QuicConnection._handle_max_streams_bidi_frame
|
Modified
|
aiortc~aioquic
|
426460fc110220e1c776d0be5e3fcce6adb41b20
|
[logging] lower the logging verbosity
|
<7>:<add> self._logger.debug("Remote max_streams_bidi raised to %d", max_streams)
<del> self._logger.info("Remote max_streams_bidi raised to %d", max_streams)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_streams_bidi_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a MAX_STREAMS_BIDI frame.
<2>
<3> This raises number of bidirectional streams we can initiate to the peer.
<4> """
<5> max_streams = buf.pull_uint_var()
<6> if max_streams > self._remote_max_streams_bidi:
<7> self._logger.info("Remote max_streams_bidi raised to %d", max_streams)
<8> self._remote_max_streams_bidi = max_streams
<9>
|
===========unchanged ref 0===========
at: aioquic._buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic._buffer.Buffer
pull_uint_var() -> int
at: aioquic.connection
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath, time: float)
at: aioquic.connection.QuicConnection.__init__
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._remote_max_streams_bidi = 0
at: logging.LoggerAdapter
debug(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_data_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_DATA frame.
This adjusts the total amount of we can send to the peer.
"""
max_data = buf.pull_uint_var()
if max_data > self._remote_max_data:
+ self._logger.debug("Remote max_data raised to %d", max_data)
- self._logger.info("Remote max_data raised to %d", max_data)
self._remote_max_data = max_data
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_stream_data_frame(
self, context: QuicReceiveContext, 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 = buf.pull_uint_var()
max_stream_data = buf.pull_uint_var()
# check stream direction
self._assert_stream_can_send(frame_type, stream_id)
stream = self._get_or_create_stream(frame_type, stream_id)
if max_stream_data > stream.max_stream_data_remote:
+ self._logger.debug(
- self._logger.info(
"Stream %d remote max_stream_data raised to %d",
stream_id,
max_stream_data,
)
stream.max_stream_data_remote = max_stream_data
===========changed ref 2===========
# module: aioquic.tls
class Context:
def _set_state(self, state: State) -> None:
if self.__logger:
+ self.__logger.debug("TLS %s -> %s", self.state, state)
- self.__logger.info("TLS %s -> %s", self.state, state)
self.state = state
|
aioquic.connection/QuicConnection._handle_max_streams_uni_frame
|
Modified
|
aiortc~aioquic
|
426460fc110220e1c776d0be5e3fcce6adb41b20
|
[logging] lower the logging verbosity
|
<7>:<add> self._logger.debug("Remote max_streams_uni raised to %d", max_streams)
<del> self._logger.info("Remote max_streams_uni raised to %d", max_streams)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_streams_uni_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a MAX_STREAMS_UNI frame.
<2>
<3> This raises number of unidirectional streams we can initiate to the peer.
<4> """
<5> max_streams = buf.pull_uint_var()
<6> if max_streams > self._remote_max_streams_uni:
<7> self._logger.info("Remote max_streams_uni raised to %d", max_streams)
<8> self._remote_max_streams_uni = max_streams
<9>
|
===========unchanged ref 0===========
at: aioquic._buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic._buffer.Buffer
pull_uint_var() -> int
at: aioquic.connection
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath, time: float)
at: aioquic.connection.QuicConnection.__init__
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._remote_max_streams_uni = 0
at: logging.LoggerAdapter
debug(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_streams_bidi_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAMS_BIDI frame.
This raises number of bidirectional streams we can initiate to the peer.
"""
max_streams = buf.pull_uint_var()
if max_streams > self._remote_max_streams_bidi:
+ self._logger.debug("Remote max_streams_bidi raised to %d", max_streams)
- self._logger.info("Remote max_streams_bidi raised to %d", max_streams)
self._remote_max_streams_bidi = max_streams
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_data_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_DATA frame.
This adjusts the total amount of we can send to the peer.
"""
max_data = buf.pull_uint_var()
if max_data > self._remote_max_data:
+ self._logger.debug("Remote max_data raised to %d", max_data)
- self._logger.info("Remote max_data raised to %d", max_data)
self._remote_max_data = max_data
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_stream_data_frame(
self, context: QuicReceiveContext, 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 = buf.pull_uint_var()
max_stream_data = buf.pull_uint_var()
# check stream direction
self._assert_stream_can_send(frame_type, stream_id)
stream = self._get_or_create_stream(frame_type, stream_id)
if max_stream_data > stream.max_stream_data_remote:
+ self._logger.debug(
- self._logger.info(
"Stream %d remote max_stream_data raised to %d",
stream_id,
max_stream_data,
)
stream.max_stream_data_remote = max_stream_data
===========changed ref 3===========
# module: aioquic.tls
class Context:
def _set_state(self, state: State) -> None:
if self.__logger:
+ self.__logger.debug("TLS %s -> %s", self.state, state)
- self.__logger.info("TLS %s -> %s", self.state, state)
self.state = state
|
aioquic.connection/QuicConnection._handle_new_connection_id_frame
|
Modified
|
aiortc~aioquic
|
426460fc110220e1c776d0be5e3fcce6adb41b20
|
[logging] lower the logging verbosity
|
<4>:<add> self._logger.debug(
<del> self._logger.info(
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_new_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a NEW_CONNECTION_ID frame.
<2> """
<3> sequence_number, cid, stateless_reset_token = pull_new_connection_id_frame(buf)
<4> self._logger.info(
<5> "New connection ID received %d %s", sequence_number, dump_cid(cid)
<6> )
<7> self._peer_cid_available.append(
<8> QuicConnectionId(
<9> cid=cid,
<10> sequence_number=sequence_number,
<11> stateless_reset_token=stateless_reset_token,
<12> )
<13> )
<14>
|
===========unchanged ref 0===========
at: aioquic._buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
dump_cid(cid: bytes) -> str
QuicConnectionId(cid: bytes, sequence_number: int, stateless_reset_token: bytes=b"", was_sent: bool=False)
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath, time: float)
at: aioquic.connection.QuicConnection.__init__
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._peer_cid_available: List[QuicConnectionId] = []
at: aioquic.connection.QuicConnectionId
cid: bytes
sequence_number: int
stateless_reset_token: bytes = b""
was_sent: bool = False
at: aioquic.packet
pull_new_connection_id_frame(buf: Buffer) -> Tuple[int, bytes, bytes]
at: logging.LoggerAdapter
debug(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_streams_uni_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAMS_UNI frame.
This raises number of unidirectional streams we can initiate to the peer.
"""
max_streams = buf.pull_uint_var()
if max_streams > self._remote_max_streams_uni:
+ self._logger.debug("Remote max_streams_uni raised to %d", max_streams)
- self._logger.info("Remote max_streams_uni raised to %d", max_streams)
self._remote_max_streams_uni = max_streams
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_streams_bidi_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAMS_BIDI frame.
This raises number of bidirectional streams we can initiate to the peer.
"""
max_streams = buf.pull_uint_var()
if max_streams > self._remote_max_streams_bidi:
+ self._logger.debug("Remote max_streams_bidi raised to %d", max_streams)
- self._logger.info("Remote max_streams_bidi raised to %d", max_streams)
self._remote_max_streams_bidi = max_streams
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_data_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_DATA frame.
This adjusts the total amount of we can send to the peer.
"""
max_data = buf.pull_uint_var()
if max_data > self._remote_max_data:
+ self._logger.debug("Remote max_data raised to %d", max_data)
- self._logger.info("Remote max_data raised to %d", max_data)
self._remote_max_data = max_data
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_stream_data_frame(
self, context: QuicReceiveContext, 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 = buf.pull_uint_var()
max_stream_data = buf.pull_uint_var()
# check stream direction
self._assert_stream_can_send(frame_type, stream_id)
stream = self._get_or_create_stream(frame_type, stream_id)
if max_stream_data > stream.max_stream_data_remote:
+ self._logger.debug(
- self._logger.info(
"Stream %d remote max_stream_data raised to %d",
stream_id,
max_stream_data,
)
stream.max_stream_data_remote = max_stream_data
===========changed ref 4===========
# module: aioquic.tls
class Context:
def _set_state(self, state: State) -> None:
if self.__logger:
+ self.__logger.debug("TLS %s -> %s", self.state, state)
- self.__logger.info("TLS %s -> %s", self.state, state)
self.state = state
|
aioquic.connection/QuicConnection._on_timeout
|
Modified
|
aiortc~aioquic
|
426460fc110220e1c776d0be5e3fcce6adb41b20
|
[logging] lower the logging verbosity
|
<11>:<add> self._logger.debug("Loss detection triggered")
<del> self._logger.info("Loss detection triggered")
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _on_timeout(self) -> None:
<0> now = self._loop.time() + K_GRANULARITY
<1> self._timer = None
<2> self._timer_at = None
<3>
<4> # idle timeout
<5> if now >= self._close_at:
<6> self.connection_lost(self._close_exception)
<7> return
<8>
<9> # loss detection timeout
<10> if self._loss_at is not None and now >= self._loss_at:
<11> self._logger.info("Loss detection triggered")
<12> self._loss.on_loss_detection_timeout(now=now)
<13> self._send_pending()
<14>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
connection_lost(exc: Exception) -> None
_send_pending() -> None
at: aioquic.connection.QuicConnection.__init__
self._close_at: Optional[float] = None
self._close_exception: Optional[Exception] = None
self._loop = loop
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(send_probe=self._send_probe)
self._timer: Optional[asyncio.TimerHandle] = None
self._timer_at: Optional[float] = None
at: aioquic.connection.QuicConnection._close
self._close_at = self._loop.time() + 3 * self._loss.get_probe_timeout()
at: aioquic.connection.QuicConnection._connect
self._close_at = self._loop.time() + self._local_idle_timeout
at: aioquic.connection.QuicConnection._handle_connection_close_frame
self._close_exception = QuicConnectionError(
error_code=error_code,
frame_type=frame_type,
reason_phrase=reason_phrase,
)
at: aioquic.connection.QuicConnection._set_timer
self._loss_at = self._loss.get_loss_detection_time()
self._timer = None
self._timer = self._loop.call_at(timer_at, self._on_timeout)
self._timer_at = timer_at
at: aioquic.connection.QuicConnection.datagram_received
self._close_exception = exc
self._close_at = now + self._local_idle_timeout
at: aioquic.recovery
K_GRANULARITY = 0.001 # seconds
at: aioquic.recovery.QuicPacketRecovery
on_loss_detection_timeout(now: float) -> None
===========unchanged ref 1===========
at: asyncio.events.AbstractEventLoop
time() -> float
at: logging.LoggerAdapter
debug(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_new_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a NEW_CONNECTION_ID frame.
"""
sequence_number, cid, stateless_reset_token = pull_new_connection_id_frame(buf)
+ self._logger.debug(
- self._logger.info(
"New connection ID received %d %s", sequence_number, dump_cid(cid)
)
self._peer_cid_available.append(
QuicConnectionId(
cid=cid,
sequence_number=sequence_number,
stateless_reset_token=stateless_reset_token,
)
)
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_streams_uni_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAMS_UNI frame.
This raises number of unidirectional streams we can initiate to the peer.
"""
max_streams = buf.pull_uint_var()
if max_streams > self._remote_max_streams_uni:
+ self._logger.debug("Remote max_streams_uni raised to %d", max_streams)
- self._logger.info("Remote max_streams_uni raised to %d", max_streams)
self._remote_max_streams_uni = max_streams
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_streams_bidi_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAMS_BIDI frame.
This raises number of bidirectional streams we can initiate to the peer.
"""
max_streams = buf.pull_uint_var()
if max_streams > self._remote_max_streams_bidi:
+ self._logger.debug("Remote max_streams_bidi raised to %d", max_streams)
- self._logger.info("Remote max_streams_bidi raised to %d", max_streams)
self._remote_max_streams_bidi = max_streams
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_data_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_DATA frame.
This adjusts the total amount of we can send to the peer.
"""
max_data = buf.pull_uint_var()
if max_data > self._remote_max_data:
+ self._logger.debug("Remote max_data raised to %d", max_data)
- self._logger.info("Remote max_data raised to %d", max_data)
self._remote_max_data = max_data
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_stream_data_frame(
self, context: QuicReceiveContext, 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 = buf.pull_uint_var()
max_stream_data = buf.pull_uint_var()
# check stream direction
self._assert_stream_can_send(frame_type, stream_id)
stream = self._get_or_create_stream(frame_type, stream_id)
if max_stream_data > stream.max_stream_data_remote:
+ self._logger.debug(
- self._logger.info(
"Stream %d remote max_stream_data raised to %d",
stream_id,
max_stream_data,
)
stream.max_stream_data_remote = max_stream_data
===========changed ref 5===========
# module: aioquic.tls
class Context:
def _set_state(self, state: State) -> None:
if self.__logger:
+ self.__logger.debug("TLS %s -> %s", self.state, state)
- self.__logger.info("TLS %s -> %s", self.state, state)
self.state = state
|
aioquic.connection/QuicConnection._set_state
|
Modified
|
aiortc~aioquic
|
426460fc110220e1c776d0be5e3fcce6adb41b20
|
[logging] lower the logging verbosity
|
<0>:<add> self._logger.debug("%s -> %s", self._state, state)
<del> self._logger.info("%s -> %s", self._state, state)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _set_state(self, state: QuicConnectionState) -> None:
<0> self._logger.info("%s -> %s", self._state, state)
<1> self._state = state
<2>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnectionState()
at: aioquic.connection.QuicConnection.__init__
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._state = QuicConnectionState.FIRSTFLIGHT
at: logging.LoggerAdapter
debug(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _on_timeout(self) -> None:
now = self._loop.time() + K_GRANULARITY
self._timer = None
self._timer_at = None
# idle timeout
if now >= self._close_at:
self.connection_lost(self._close_exception)
return
# loss detection timeout
if self._loss_at is not None and now >= self._loss_at:
+ self._logger.debug("Loss detection triggered")
- self._logger.info("Loss detection triggered")
self._loss.on_loss_detection_timeout(now=now)
self._send_pending()
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_new_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a NEW_CONNECTION_ID frame.
"""
sequence_number, cid, stateless_reset_token = pull_new_connection_id_frame(buf)
+ self._logger.debug(
- self._logger.info(
"New connection ID received %d %s", sequence_number, dump_cid(cid)
)
self._peer_cid_available.append(
QuicConnectionId(
cid=cid,
sequence_number=sequence_number,
stateless_reset_token=stateless_reset_token,
)
)
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_streams_uni_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAMS_UNI frame.
This raises number of unidirectional streams we can initiate to the peer.
"""
max_streams = buf.pull_uint_var()
if max_streams > self._remote_max_streams_uni:
+ self._logger.debug("Remote max_streams_uni raised to %d", max_streams)
- self._logger.info("Remote max_streams_uni raised to %d", max_streams)
self._remote_max_streams_uni = max_streams
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_streams_bidi_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAMS_BIDI frame.
This raises number of bidirectional streams we can initiate to the peer.
"""
max_streams = buf.pull_uint_var()
if max_streams > self._remote_max_streams_bidi:
+ self._logger.debug("Remote max_streams_bidi raised to %d", max_streams)
- self._logger.info("Remote max_streams_bidi raised to %d", max_streams)
self._remote_max_streams_bidi = max_streams
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_data_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_DATA frame.
This adjusts the total amount of we can send to the peer.
"""
max_data = buf.pull_uint_var()
if max_data > self._remote_max_data:
+ self._logger.debug("Remote max_data raised to %d", max_data)
- self._logger.info("Remote max_data raised to %d", max_data)
self._remote_max_data = max_data
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_stream_data_frame(
self, context: QuicReceiveContext, 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 = buf.pull_uint_var()
max_stream_data = buf.pull_uint_var()
# check stream direction
self._assert_stream_can_send(frame_type, stream_id)
stream = self._get_or_create_stream(frame_type, stream_id)
if max_stream_data > stream.max_stream_data_remote:
+ self._logger.debug(
- self._logger.info(
"Stream %d remote max_stream_data raised to %d",
stream_id,
max_stream_data,
)
stream.max_stream_data_remote = max_stream_data
===========changed ref 6===========
# module: aioquic.tls
class Context:
def _set_state(self, state: State) -> None:
if self.__logger:
+ self.__logger.debug("TLS %s -> %s", self.state, state)
- self.__logger.info("TLS %s -> %s", self.state, state)
self.state = state
|
aioquic.connection/QuicConnection._write_connection_limits
|
Modified
|
aiortc~aioquic
|
426460fc110220e1c776d0be5e3fcce6adb41b20
|
[logging] lower the logging verbosity
|
<3>:<add> self._logger.debug("Local max_data raised to %d", self._local_max_data)
<del> self._logger.info("Local max_data raised to %d", self._local_max_data)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_connection_limits(
self, builder: QuicPacketBuilder, space: QuicPacketSpace
) -> None:
<0> # raise MAX_DATA if needed
<1> if self._local_max_data_used > self._local_max_data * 0.75:
<2> self._local_max_data *= 2
<3> self._logger.info("Local max_data raised to %d", self._local_max_data)
<4> if self._local_max_data_sent != self._local_max_data:
<5> builder.start_frame(QuicFrameType.MAX_DATA, self._on_max_data_delivery)
<6> builder.buffer.push_uint_var(self._local_max_data)
<7> self._local_max_data_sent = self._local_max_data
<8>
|
===========unchanged ref 0===========
at: aioquic._buffer.Buffer
push_uint_var(value: int) -> None
at: aioquic.connection.QuicConnection
_on_max_data_delivery(delivery: QuicDeliveryState) -> None
at: aioquic.connection.QuicConnection.__init__
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
at: aioquic.connection.QuicConnection._handle_stream_frame
self._local_max_data_used += newly_received
at: aioquic.connection.QuicConnection._on_max_data_delivery
self._local_max_data_sent = 0
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
start_frame(frame_type: int, handler: Optional[QuicDeliveryHandler]=None, args: Sequence[Any]=[]) -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.recovery
QuicPacketSpace()
at: logging.LoggerAdapter
debug(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _set_state(self, state: QuicConnectionState) -> None:
+ self._logger.debug("%s -> %s", self._state, state)
- self._logger.info("%s -> %s", self._state, state)
self._state = state
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _on_timeout(self) -> None:
now = self._loop.time() + K_GRANULARITY
self._timer = None
self._timer_at = None
# idle timeout
if now >= self._close_at:
self.connection_lost(self._close_exception)
return
# loss detection timeout
if self._loss_at is not None and now >= self._loss_at:
+ self._logger.debug("Loss detection triggered")
- self._logger.info("Loss detection triggered")
self._loss.on_loss_detection_timeout(now=now)
self._send_pending()
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_new_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a NEW_CONNECTION_ID frame.
"""
sequence_number, cid, stateless_reset_token = pull_new_connection_id_frame(buf)
+ self._logger.debug(
- self._logger.info(
"New connection ID received %d %s", sequence_number, dump_cid(cid)
)
self._peer_cid_available.append(
QuicConnectionId(
cid=cid,
sequence_number=sequence_number,
stateless_reset_token=stateless_reset_token,
)
)
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_streams_uni_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAMS_UNI frame.
This raises number of unidirectional streams we can initiate to the peer.
"""
max_streams = buf.pull_uint_var()
if max_streams > self._remote_max_streams_uni:
+ self._logger.debug("Remote max_streams_uni raised to %d", max_streams)
- self._logger.info("Remote max_streams_uni raised to %d", max_streams)
self._remote_max_streams_uni = max_streams
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_streams_bidi_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAMS_BIDI frame.
This raises number of bidirectional streams we can initiate to the peer.
"""
max_streams = buf.pull_uint_var()
if max_streams > self._remote_max_streams_bidi:
+ self._logger.debug("Remote max_streams_bidi raised to %d", max_streams)
- self._logger.info("Remote max_streams_bidi raised to %d", max_streams)
self._remote_max_streams_bidi = max_streams
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_data_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_DATA frame.
This adjusts the total amount of we can send to the peer.
"""
max_data = buf.pull_uint_var()
if max_data > self._remote_max_data:
+ self._logger.debug("Remote max_data raised to %d", max_data)
- self._logger.info("Remote max_data raised to %d", max_data)
self._remote_max_data = max_data
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_stream_data_frame(
self, context: QuicReceiveContext, 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 = buf.pull_uint_var()
max_stream_data = buf.pull_uint_var()
# check stream direction
self._assert_stream_can_send(frame_type, stream_id)
stream = self._get_or_create_stream(frame_type, stream_id)
if max_stream_data > stream.max_stream_data_remote:
+ self._logger.debug(
- self._logger.info(
"Stream %d remote max_stream_data raised to %d",
stream_id,
max_stream_data,
)
stream.max_stream_data_remote = max_stream_data
===========changed ref 7===========
# module: aioquic.tls
class Context:
def _set_state(self, state: State) -> None:
if self.__logger:
+ self.__logger.debug("TLS %s -> %s", self.state, state)
- self.__logger.info("TLS %s -> %s", self.state, state)
self.state = state
|
aioquic.connection/QuicConnection._write_stream_limits
|
Modified
|
aiortc~aioquic
|
426460fc110220e1c776d0be5e3fcce6adb41b20
|
[logging] lower the logging verbosity
|
<3>:<add> self._logger.debug(
<del> self._logger.info(
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_stream_limits(
self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
<0> # raise MAX_STREAM_DATA if needed
<1> if stream._recv_highest > stream.max_stream_data_local * 0.75:
<2> stream.max_stream_data_local *= 2
<3> self._logger.info(
<4> "Stream %d local max_stream_data raised to %d",
<5> stream.stream_id,
<6> stream.max_stream_data_local,
<7> )
<8> if stream.max_stream_data_local_sent != stream.max_stream_data_local:
<9> builder.start_frame(
<10> QuicFrameType.MAX_STREAM_DATA,
<11> self._on_max_stream_data_delivery,
<12> (stream,),
<13> )
<14> builder.buffer.push_uint_var(stream.stream_id)
<15> builder.buffer.push_uint_var(stream.max_stream_data_local)
<16> stream.max_stream_data_local_sent = stream.max_stream_data_local
<17>
|
===========unchanged ref 0===========
at: aioquic._buffer.Buffer
push_uint_var(value: int) -> None
at: aioquic.connection.QuicConnection
_on_max_stream_data_delivery(delivery: QuicDeliveryState, stream: QuicStream) -> None
at: aioquic.connection.QuicConnection.__init__
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
start_frame(frame_type: int, handler: Optional[QuicDeliveryHandler]=None, args: Sequence[Any]=[]) -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.recovery
QuicPacketSpace()
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.stream.QuicStream.__init__
self.max_stream_data_local = max_stream_data_local
self.max_stream_data_local_sent = max_stream_data_local
self._recv_highest = 0 # the highest offset ever seen
at: aioquic.stream.QuicStream.add_frame
self._recv_highest = frame_end
===========unchanged ref 1===========
at: logging.LoggerAdapter
debug(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_connection_limits(
self, builder: QuicPacketBuilder, space: QuicPacketSpace
) -> None:
# raise MAX_DATA if needed
if self._local_max_data_used > self._local_max_data * 0.75:
self._local_max_data *= 2
+ self._logger.debug("Local max_data raised to %d", self._local_max_data)
- self._logger.info("Local max_data raised to %d", self._local_max_data)
if self._local_max_data_sent != self._local_max_data:
builder.start_frame(QuicFrameType.MAX_DATA, self._on_max_data_delivery)
builder.buffer.push_uint_var(self._local_max_data)
self._local_max_data_sent = self._local_max_data
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _set_state(self, state: QuicConnectionState) -> None:
+ self._logger.debug("%s -> %s", self._state, state)
- self._logger.info("%s -> %s", self._state, state)
self._state = state
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _on_timeout(self) -> None:
now = self._loop.time() + K_GRANULARITY
self._timer = None
self._timer_at = None
# idle timeout
if now >= self._close_at:
self.connection_lost(self._close_exception)
return
# loss detection timeout
if self._loss_at is not None and now >= self._loss_at:
+ self._logger.debug("Loss detection triggered")
- self._logger.info("Loss detection triggered")
self._loss.on_loss_detection_timeout(now=now)
self._send_pending()
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_new_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a NEW_CONNECTION_ID frame.
"""
sequence_number, cid, stateless_reset_token = pull_new_connection_id_frame(buf)
+ self._logger.debug(
- self._logger.info(
"New connection ID received %d %s", sequence_number, dump_cid(cid)
)
self._peer_cid_available.append(
QuicConnectionId(
cid=cid,
sequence_number=sequence_number,
stateless_reset_token=stateless_reset_token,
)
)
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_streams_uni_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAMS_UNI frame.
This raises number of unidirectional streams we can initiate to the peer.
"""
max_streams = buf.pull_uint_var()
if max_streams > self._remote_max_streams_uni:
+ self._logger.debug("Remote max_streams_uni raised to %d", max_streams)
- self._logger.info("Remote max_streams_uni raised to %d", max_streams)
self._remote_max_streams_uni = max_streams
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_streams_bidi_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_STREAMS_BIDI frame.
This raises number of bidirectional streams we can initiate to the peer.
"""
max_streams = buf.pull_uint_var()
if max_streams > self._remote_max_streams_bidi:
+ self._logger.debug("Remote max_streams_bidi raised to %d", max_streams)
- self._logger.info("Remote max_streams_bidi raised to %d", max_streams)
self._remote_max_streams_bidi = max_streams
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_max_data_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a MAX_DATA frame.
This adjusts the total amount of we can send to the peer.
"""
max_data = buf.pull_uint_var()
if max_data > self._remote_max_data:
+ self._logger.debug("Remote max_data raised to %d", max_data)
- self._logger.info("Remote max_data raised to %d", max_data)
self._remote_max_data = max_data
|
aioquic.connection/QuicConnection.connect
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<6>:<add> self._is_client and not self._connect_called
<del> self.is_client and not self._connect_called
<14>:<add> self._version = max(self._configuration.supported_versions)
<del> self._version = max(self.supported_versions)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def connect(
self, addr: NetworkAddress, protocol_version: Optional[int] = None
) -> None:
<0> """
<1> Initiate the TLS handshake.
<2>
<3> This method can only be called for clients and a single time.
<4> """
<5> assert (
<6> self.is_client and not self._connect_called
<7> ), "connect() can only be called for clients and a single time"
<8> self._connect_called = True
<9>
<10> self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
<11> if protocol_version is not None:
<12> self._version = protocol_version
<13> else:
<14> self._version = max(self.supported_versions)
<15> self._connect()
<16>
|
===========unchanged ref 0===========
at: aioquic.configuration.QuicConfiguration
alpn_protocols: Optional[List[str]] = None
certificate: Any = None
idle_timeout: float = 60.0
is_client: bool = True
private_key: Any = None
secrets_log_file: TextIO = None
server_name: Optional[str] = None
session_ticket: Optional[tls.SessionTicket] = None
supported_versions: List[QuicProtocolVersion] = field(
default_factory=lambda: [
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
)
at: aioquic.connection.QuicConnection
_connect() -> None
at: aioquic.connection.QuicConnection.__init__
self._configuration = configuration
self._is_client = configuration.is_client
self._parameters_available = asyncio.Event()
self._streams: Dict[int, QuicStream] = {}
self._version: Optional[int] = None
at: aioquic.connection.QuicConnection.datagram_received
self._version = QuicProtocolVersion(header.version)
self._version = QuicProtocolVersion(max(common))
at: asyncio.locks.Event
wait() -> bool
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')
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
"""
A QUIC connection.
"""
- supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
-
===========changed ref 1===========
+ # module: aioquic.configuration
+
+
===========changed ref 2===========
+ # module: aioquic.configuration
+ @dataclass
+ class QuicConfiguration:
+ alpn_protocols: Optional[List[str]] = None
+ certificate: Any = None
+ idle_timeout: float = 60.0
+ is_client: bool = True
+ private_key: Any = None
+ secrets_log_file: TextIO = None
+ server_name: Optional[str] = None
+ session_ticket: Optional[tls.SessionTicket] = None
+ supported_versions: List[QuicProtocolVersion] = field(
+ default_factory=lambda: [
+ QuicProtocolVersion.DRAFT_19,
+ QuicProtocolVersion.DRAFT_20,
+ ]
+ )
+
===========changed ref 3===========
<s> None,
- secrets_log_file: TextIO = None,
- server_name: Optional[str] = None,
- session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
- supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
+ if configuration.is_client:
- if is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
+ assert (
+ configuration.certificate is not None
+ ), "SSL certificate is required for a server"
- assert certificate is not None, "SSL certificate is required for a server"
+ assert (
+ configuration.private_key is not None
+ ), "SSL private key is required for a server"
- assert private_key is not None, "SSL private key is required for a server"
loop = asyncio.get_event_loop()
- self.is_client = is_client
- if supported_versions is not None:
- self.supported_versions = supported_versions
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
+ # configuration
- # TLS configuration
- self._alpn_protocols = alpn_protocols
- self._certificate = certificate
- self._private_key = private_key
- self._secrets_log_file = secrets_log_file
- self._server_name = server_name
+ self._configuration = configuration
+ self._is_client = configuration.is_client
self._close_at: Optional[float] = None
self._close_exception: Optional[Exception] = None
self._closed = asyncio.Event()
self._connect_called = False
self._connected_waiter = loop</s>
===========changed ref 4===========
<s> secrets_log_file: TextIO = None,
- server_name: Optional[str] = None,
- session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
- supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
<s> None
self._closed = asyncio.Event()
self._connect_called = False
self._connected_waiter = loop.create_future()
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._crypto_buffers: Dict[tls.Epoch, Buffer] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
self._handshake_complete = False
self._handshake_confirmed = False
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
- self._local_idle_timeout = idle_timeout or 60.0 # seconds
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128</s>
|
aioquic.connection/QuicConnection.create_stream
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<8>:<add> stream_id = (int(is_unidirectional) << 1) | int(not self._is_client)
<del> stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
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> await self._parameters_available.wait()
<7>
<8> stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
<9> while stream_id in self._streams:
<10> stream_id += 4
<11>
<12> # determine limits
<13> if is_unidirectional:
<14> max_stream_data_local = 0
<15> max_stream_data_remote = self._remote_max_stream_data_uni
<16> max_streams = self._remote_max_streams_uni
<17> else:
<18> max_stream_data_local = self._local_max_stream_data_bidi_local
<19> max_stream_data_remote = self._remote_max_stream_data_bidi_remote
<20> max_streams = self._remote_max_streams_bidi
<21>
<22> # check max streams
<23> if stream_id // 4 >= max_streams:
<24> raise ValueError("Too many streams open")
<25>
<26> # create stream
<27> stream = self._streams[stream_id] = QuicStream(
<28> connection=self,
<29> stream_id=stream_id,
<30> max_stream_data_local=max_stream_data_local,
<31> max_stream_data_remote=max_stream_data_remote,
<32> )
<33>
<34> return stream.reader, stream.writer
<35>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
_send_soon(self) -> None
_send_soon() -> None
at: aioquic.connection.QuicConnection.__init__
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._loop = loop
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._streams: Dict[int, QuicStream] = {}
self._ping_pending = False
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._on_ping_delivery
self._ping_waiter = None
self._ping_pending = True
at: aioquic.connection.QuicConnection._write_application
self._ping_pending = False
at: aioquic.connection.QuicConnection.create_stream
stream_id += 4
stream_id = (int(is_unidirectional) << 1) | int(not self._is_client)
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.stream.QuicStream.__init__
self.reader = asyncio.StreamReader()
self.reader = None
self.writer = None
self.writer = asyncio.StreamWriter(self, None, self.reader, None)
===========unchanged ref 1===========
at: asyncio.events.AbstractEventLoop
create_future() -> Future[Any]
at: asyncio.tasks
shield(arg: _FutureT[_T], *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def connect(
self, addr: NetworkAddress, protocol_version: Optional[int] = None
) -> None:
"""
Initiate the TLS handshake.
This method can only be called for clients and a single time.
"""
assert (
+ self._is_client and not self._connect_called
- self.is_client and not self._connect_called
), "connect() can only be called for clients and a single time"
self._connect_called = True
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
if protocol_version is not None:
self._version = protocol_version
else:
+ self._version = max(self._configuration.supported_versions)
- self._version = max(self.supported_versions)
self._connect()
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
"""
A QUIC connection.
"""
- supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
-
===========changed ref 2===========
+ # module: aioquic.configuration
+
+
===========changed ref 3===========
+ # module: aioquic.configuration
+ @dataclass
+ class QuicConfiguration:
+ alpn_protocols: Optional[List[str]] = None
+ certificate: Any = None
+ idle_timeout: float = 60.0
+ is_client: bool = True
+ private_key: Any = None
+ secrets_log_file: TextIO = None
+ server_name: Optional[str] = None
+ session_ticket: Optional[tls.SessionTicket] = None
+ supported_versions: List[QuicProtocolVersion] = field(
+ default_factory=lambda: [
+ QuicProtocolVersion.DRAFT_19,
+ QuicProtocolVersion.DRAFT_20,
+ ]
+ )
+
===========changed ref 4===========
<s> None,
- secrets_log_file: TextIO = None,
- server_name: Optional[str] = None,
- session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
- supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
+ if configuration.is_client:
- if is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
+ assert (
+ configuration.certificate is not None
+ ), "SSL certificate is required for a server"
- assert certificate is not None, "SSL certificate is required for a server"
+ assert (
+ configuration.private_key is not None
+ ), "SSL private key is required for a server"
- assert private_key is not None, "SSL private key is required for a server"
loop = asyncio.get_event_loop()
- self.is_client = is_client
- if supported_versions is not None:
- self.supported_versions = supported_versions
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
+ # configuration
- # TLS configuration
- self._alpn_protocols = alpn_protocols
- self._certificate = certificate
- self._private_key = private_key
- self._secrets_log_file = secrets_log_file
- self._server_name = server_name
+ self._configuration = configuration
+ self._is_client = configuration.is_client
self._close_at: Optional[float] = None
self._close_exception: Optional[Exception] = None
self._closed = asyncio.Event()
self._connect_called = False
self._connected_waiter = loop</s>
|
aioquic.connection/QuicConnection._connect
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<3>:<add> assert self._is_client
<del> assert self.is_client
<5>:<add> self._close_at = self._loop.time() + self._configuration.idle_timeout
<del> self._close_at = self._loop.time() + self._local_idle_timeout
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _connect(self) -> None:
<0> """
<1> Start the client handshake.
<2> """
<3> assert self.is_client
<4>
<5> self._close_at = self._loop.time() + self._local_idle_timeout
<6> self._initialize(self._peer_cid)
<7>
<8> self.tls.handle_message(b"", self._crypto_buffers)
<9> self._push_crypto_data()
<10> self._send_pending()
<11>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection.__init__
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self._retire_connection_ids: List[int] = []
at: aioquic.connection.QuicConnection._consume_connection_id
self._peer_cid_seq = connection_id.sequence_number
at: aioquic.connection.QuicConnection.datagram_received
self._peer_cid_seq = 0
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def connect(
self, addr: NetworkAddress, protocol_version: Optional[int] = None
) -> None:
"""
Initiate the TLS handshake.
This method can only be called for clients and a single time.
"""
assert (
+ self._is_client and not self._connect_called
- self.is_client and not self._connect_called
), "connect() can only be called for clients and a single time"
self._connect_called = True
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
if protocol_version is not None:
self._version = protocol_version
else:
+ self._version = max(self._configuration.supported_versions)
- self._version = max(self.supported_versions)
self._connect()
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
"""
A QUIC connection.
"""
- supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
-
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
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.
"""
await self._parameters_available.wait()
+ stream_id = (int(is_unidirectional) << 1) | int(not self._is_client)
- stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
while stream_id in self._streams:
stream_id += 4
# determine limits
if is_unidirectional:
max_stream_data_local = 0
max_stream_data_remote = self._remote_max_stream_data_uni
max_streams = self._remote_max_streams_uni
else:
max_stream_data_local = self._local_max_stream_data_bidi_local
max_stream_data_remote = self._remote_max_stream_data_bidi_remote
max_streams = self._remote_max_streams_bidi
# check max streams
if stream_id // 4 >= max_streams:
raise ValueError("Too many streams open")
# create stream
stream = self._streams[stream_id] = QuicStream(
connection=self,
stream_id=stream_id,
max_stream_data_local=max_stream_data_local,
max_stream_data_remote=max_stream_data_remote,
)
return stream.reader, stream.writer
===========changed ref 3===========
+ # module: aioquic.configuration
+
+
===========changed ref 4===========
+ # module: aioquic.configuration
+ @dataclass
+ class QuicConfiguration:
+ alpn_protocols: Optional[List[str]] = None
+ certificate: Any = None
+ idle_timeout: float = 60.0
+ is_client: bool = True
+ private_key: Any = None
+ secrets_log_file: TextIO = None
+ server_name: Optional[str] = None
+ session_ticket: Optional[tls.SessionTicket] = None
+ supported_versions: List[QuicProtocolVersion] = field(
+ default_factory=lambda: [
+ QuicProtocolVersion.DRAFT_19,
+ QuicProtocolVersion.DRAFT_20,
+ ]
+ )
+
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
"""
Handle an incoming datagram.
"""
# stop handling packets when closing
if self._state in END_STATES:
return
data = cast(bytes, data)
buf = Buffer(data=data)
now = self._loop.time()
while not buf.eof():
start_off = buf.tell()
header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
# check destination CID matches
destination_cid_seq: Optional[int] = None
for connection_id in self._host_cids:
if header.destination_cid == connection_id.cid:
destination_cid_seq = connection_id.sequence_number
break
+ if self._is_client and destination_cid_seq is None:
- if self.is_client and destination_cid_seq is None:
return
# check protocol version
+ if self._is_client and header.version == QuicProtocolVersion.NEGOTIATION:
- if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:
# version negotiation
versions = []
while not buf.eof():
versions.append(buf.pull_uint32())
+ common = set(self._configuration.supported_versions).intersection(
- common = set(self.supported_versions).intersection(versions)
+ versions
+ )
if not common:
self._logger.error("Could not find a common protocol version")
self.connection_lost(
QuicConnectionError(
error_code=QuicErrorCode.INTERNAL_ERROR,
frame_type=None,
reason_phrase="Could not find a common protocol version",
)
)
return
self._version = QuicProtocolVersion(max(common))
self._version_negotiation_count += 1
self</s>
|
aioquic.connection/QuicConnection._get_or_create_stream
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<6>:<add> if stream_is_client_initiated(stream_id) == self._is_client:
<del> if stream_is_client_initiated(stream_id) == self.is_client:
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _get_or_create_stream(self, frame_type: int, stream_id: int) -> QuicStream:
<0> """
<1> Get or create a stream in response to a received frame.
<2> """
<3> stream = self._streams.get(stream_id, None)
<4> if stream is None:
<5> # check initiator
<6> if stream_is_client_initiated(stream_id) == self.is_client:
<7> raise QuicConnectionError(
<8> error_code=QuicErrorCode.STREAM_STATE_ERROR,
<9> frame_type=frame_type,
<10> reason_phrase="Wrong stream initiator",
<11> )
<12>
<13> # determine limits
<14> if stream_is_unidirectional(stream_id):
<15> max_stream_data_local = self._local_max_stream_data_uni
<16> max_stream_data_remote = 0
<17> max_streams = self._local_max_streams_uni
<18> else:
<19> max_stream_data_local = self._local_max_stream_data_bidi_remote
<20> max_stream_data_remote = self._remote_max_stream_data_bidi_local
<21> max_streams = self._local_max_streams_bidi
<22>
<23> # check max streams
<24> if stream_id // 4 >= max_streams:
<25> raise QuicConnectionError(
<26> error_code=QuicErrorCode.STREAM_LIMIT_ERROR,
<27> frame_type=frame_type,
<28> reason_phrase="Too many streams open",
<29> )
<30>
<31> # create stream
<32> self._logger.info("Stream %d created by peer" % stream_id)
<33> stream = self._streams[stream_id] = QuicStream(
<34> connection=self,
<35> stream_id=stream_id,
<36> max_stream_data_local=max_stream_data_local,
<37> max_stream_data_remote=max_stream_data_remote,
<38> )</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _get_or_create_stream(self, frame_type: int, stream_id: int) -> QuicStream:
# offset: 1
return stream
===========unchanged ref 0===========
at: aioquic.configuration.QuicConfiguration
alpn_protocols: Optional[List[str]] = None
certificate: Any = None
private_key: Any = None
at: aioquic.connection
stream_is_unidirectional(stream_id: int) -> bool
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
at: aioquic.connection.QuicConnection
_serialize_transport_parameters() -> bytes
_serialize_transport_parameters(self) -> bytes
at: aioquic.connection.QuicConnection.__init__
self._configuration = configuration
self._is_client = configuration.is_client
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._remote_max_stream_data_bidi_local = 0
self._streams: Dict[int, QuicStream] = {}
self._stream_handler = lambda r, w: None
self._stream_handler = stream_handler
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, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.stream.QuicStream.__init__
self.reader = asyncio.StreamReader()
self.reader = None
===========unchanged ref 1===========
self.writer = None
self.writer = asyncio.StreamWriter(self, None, self.reader, None)
at: aioquic.tls
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
Context(is_client: bool, logger: Optional[Union[logging.Logger, logging.LoggerAdapter]]=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] = []
at: logging.LoggerAdapter
logger: Logger
extra: Mapping[str, Any]
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _connect(self) -> None:
"""
Start the client handshake.
"""
+ assert self._is_client
- assert self.is_client
+ self._close_at = self._loop.time() + self._configuration.idle_timeout
- self._close_at = self._loop.time() + self._local_idle_timeout
self._initialize(self._peer_cid)
self.tls.handle_message(b"", self._crypto_buffers)
self._push_crypto_data()
self._send_pending()
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def connect(
self, addr: NetworkAddress, protocol_version: Optional[int] = None
) -> None:
"""
Initiate the TLS handshake.
This method can only be called for clients and a single time.
"""
assert (
+ self._is_client and not self._connect_called
- self.is_client and not self._connect_called
), "connect() can only be called for clients and a single time"
self._connect_called = True
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
if protocol_version is not None:
self._version = protocol_version
else:
+ self._version = max(self._configuration.supported_versions)
- self._version = max(self.supported_versions)
self._connect()
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
"""
A QUIC connection.
"""
- supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
-
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
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.
"""
await self._parameters_available.wait()
+ stream_id = (int(is_unidirectional) << 1) | int(not self._is_client)
- stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
while stream_id in self._streams:
stream_id += 4
# determine limits
if is_unidirectional:
max_stream_data_local = 0
max_stream_data_remote = self._remote_max_stream_data_uni
max_streams = self._remote_max_streams_uni
else:
max_stream_data_local = self._local_max_stream_data_bidi_local
max_stream_data_remote = self._remote_max_stream_data_bidi_remote
max_streams = self._remote_max_streams_bidi
# check max streams
if stream_id // 4 >= max_streams:
raise ValueError("Too many streams open")
# create stream
stream = self._streams[stream_id] = QuicStream(
connection=self,
stream_id=stream_id,
max_stream_data_local=max_stream_data_local,
max_stream_data_remote=max_stream_data_remote,
)
return stream.reader, stream.writer
===========changed ref 4===========
+ # module: aioquic.configuration
+
+
===========changed ref 5===========
+ # module: aioquic.configuration
+ @dataclass
+ class QuicConfiguration:
+ alpn_protocols: Optional[List[str]] = None
+ certificate: Any = None
+ idle_timeout: float = 60.0
+ is_client: bool = True
+ private_key: Any = None
+ secrets_log_file: TextIO = None
+ server_name: Optional[str] = None
+ session_ticket: Optional[tls.SessionTicket] = None
+ supported_versions: List[QuicProtocolVersion] = field(
+ default_factory=lambda: [
+ QuicProtocolVersion.DRAFT_19,
+ QuicProtocolVersion.DRAFT_20,
+ ]
+ )
+
|
aioquic.connection/QuicConnection._initialize
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<1>:<add> self.tls = tls.Context(is_client=self._is_client, logger=self._logger)
<del> self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
<2>:<add> self.tls.alpn_protocols = self._configuration.alpn_protocols
<del> self.tls.alpn_protocols = self._alpn_protocols
<3>:<add> self.tls.certificate = self._configuration.certificate
<del> self.tls.certificate = self._certificate
<4>:<add> self.tls.certificate_private_key = self._configuration.private_key
<del> self.tls.certificate_private_key = self._private_key
<11>:<add> self.tls.server_name = self._configuration.server_name
<del> self.tls.server_name = self._server_name
<14>:<add> session_ticket = self._configuration.session_ticket
<15>:<add> self._is_client
<del> self.is_client
<16>:<add> and session_ticket is not None
<del> and self._session_ticket is not None
<17>:<add> and session_ticket.is_valid
<del> and self._session_ticket.is_valid
<18>:<add> and session_ticket.server_name == self._configuration.server_name
<del> and self._session_ticket.server_name == self._server_name
<20>:<add> self.tls.session_ticket = self._configuration.session_ticket
<del> self.tls.session_ticket = self._session_ticket
<23>:<add> if session_ticket.max_early_data_size == 0xFFFFFFFF:
<del> if self._session_ticket.max_early_data_size == 0xFFFFFFFF:
<24>:<add> for ext_type, ext_data in session_ticket.other_extensions:
<del> for ext_type, ext_data in self._session_ticket.other_extensions:
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
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_transport_parameters(),
<9> )
<10> ]
<11> self.tls.server_name = self._server_name
<12>
<13> # TLS session resumption
<14> if (
<15> self.is_client
<16> and self._session_ticket is not None
<17> and self._session_ticket.is_valid
<18> and self._session_ticket.server_name == self._server_name
<19> ):
<20> self.tls.session_ticket = self._session_ticket
<21>
<22> # parse saved QUIC transport parameters - for 0-RTT
<23> if self._session_ticket.max_early_data_size == 0xFFFFFFFF:
<24> for ext_type, ext_data in self._session_ticket.other_extensions:
<25> if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
<26> self._parse_transport_parameters(
<27> ext_data, from_session_ticket=True
<28> )
<29> break
<30>
<31> # TLS callbacks
<32> if self._session_ticket_fetcher is not None:
<33> self.tls.get_session_ticket_cb = self._session_ticket_fetcher
<34> if self._session_ticket_handler is not None:
<35> self.tls.new_session_ticket_cb = self._session_ticket_handler
<36> self.tls.update_traffic_key_cb = self._update_traffic_key
<37>
<38> # packet spaces
<39> self._cryptos</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _initialize(self, peer_cid: bytes) -> None:
# offset: 1
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self._crypto_buffers = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
self._crypto_streams = {
tls.Epoch.INITIAL: QuicStream(),
tls.Epoch.HANDSHAKE: QuicStream(),
tls.Epoch.ONE_RTT: QuicStream(),
}
self._spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
self._cryptos[tls.Epoch.INITIAL].setup_initial(
cid=peer_cid, is_client=self.is_client
)
self._loss.spaces = list(self._spaces.values())
self._packet_number = 0
===========unchanged ref 0===========
at: aioquic._buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic._buffer.Buffer
pull_uint_var() -> int
at: aioquic.configuration.QuicConfiguration
server_name: Optional[str] = None
session_ticket: Optional[tls.SessionTicket] = None
at: aioquic.connection
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath, time: float)
at: aioquic.connection.QuicConnection
_parse_transport_parameters(self, data: bytes, from_session_ticket: bool=False) -> None
_parse_transport_parameters(data: bytes, from_session_ticket: bool=False) -> None
_update_traffic_key(direction: tls.Direction, epoch: tls.Epoch, cipher_suite: tls.CipherSuite, secret: bytes) -> None
at: aioquic.connection.QuicConnection.__init__
self._configuration = configuration
self._is_client = configuration.is_client
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._crypto_buffers: Dict[tls.Epoch, Buffer] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
self._loss = QuicPacketRecovery(send_probe=self._send_probe)
self._packet_number = 0
self._spaces: Dict[tls.Epoch, QuicPacketSpace] = {}
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self._is_client, logger=self._logger)
at: aioquic.connection.QuicConnection._send_pending
self._packet_number = builder.packet_number
at: aioquic.crypto
CryptoPair()
===========unchanged ref 1===========
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_ack_frame(buf: Buffer) -> Tuple[RangeSet, int]
at: aioquic.recovery
QuicPacketSpace()
at: aioquic.recovery.QuicPacketRecovery.__init__
self.spaces: List[QuicPacketSpace] = []
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.tls
Epoch()
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls.Context.__init__
self.session_ticket: Optional[SessionTicket] = None
self.server_name: Optional[str] = None
self.get_session_ticket_cb: Optional[SessionTicketFetcher] = None
self.new_session_ticket_cb: Optional[SessionTicketHandler] = None
self.update_traffic_key_cb: Callable[
[Direction, Epoch, CipherSuite, bytes], None
] = lambda d, e, c, s: None
at: aioquic.tls.SessionTicket
age_add: int
cipher_suite: CipherSuite
not_valid_after: datetime.datetime
not_valid_before: datetime.datetime
resumption_secret: bytes
server_name: str
ticket: bytes
max_early_data_size: Optional[int] = None
===========unchanged ref 2===========
other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _connect(self) -> None:
"""
Start the client handshake.
"""
+ assert self._is_client
- assert self.is_client
+ self._close_at = self._loop.time() + self._configuration.idle_timeout
- self._close_at = self._loop.time() + self._local_idle_timeout
self._initialize(self._peer_cid)
self.tls.handle_message(b"", self._crypto_buffers)
self._push_crypto_data()
self._send_pending()
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<11>:<add> self._is_client and self._state == QuicConnectionState.FIRSTFLIGHT
<del> self.is_client and self._state == QuicConnectionState.FIRSTFLIGHT
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
<0> network_path = self._network_paths[0]
<1>
<2> self._send_task = None
<3> if self._state in END_STATES:
<4> return
<5>
<6> # build datagrams
<7> builder = QuicPacketBuilder(
<8> host_cid=self.host_cid,
<9> packet_number=self._packet_number,
<10> pad_first_datagram=(
<11> self.is_client and self._state == QuicConnectionState.FIRSTFLIGHT
<12> ),
<13> peer_cid=self._peer_cid,
<14> peer_token=self._peer_token,
<15> spin_bit=self._spin_bit,
<16> version=self._version,
<17> )
<18> if self._close_pending:
<19> for epoch, packet_type in (
<20> (tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
<21> (tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
<22> (tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
<23> ):
<24> crypto = self._cryptos[epoch]
<25> if crypto.send.is_valid():
<26> builder.start_packet(packet_type, crypto)
<27> write_close_frame(builder, **self._close_pending)
<28> builder.end_packet()
<29> self._close_pending = None
<30> break
<31> self._close(is_initiator=True)
<32> else:
<33> # congestion control
<34> builder.max_flight_bytes = (
<35> self._loss.congestion_window - self._loss.bytes_in_flight
<36> )
<37> if not network_path.is_validated:
<38> # limit data on un-validated network paths
<39> builder.max_total_bytes = (
<40> network_path.bytes_received * 3 - network_path.bytes_sent
<41> )
<42>
<43> </s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
if not self._handshake_confirmed:
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch)
self._write_application(builder, network_path, self._loop.time())
except QuicPacketBuilderStop:
pass
datagrams, packets = builder.flush()
if datagrams:
self._packet_number = builder.packet_number
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
# register packets
now = self._loop.time()
sent_handshake = False
for packet in packets:
packet.sent_time = now
self._loss.on_packet_sent(
packet=packet, space=self._spaces[packet.epoch]
)
if packet.epoch == tls.Epoch.HANDSHAKE:
sent_handshake = True
# check if we can discard initial keys
if sent_handshake and self.is_client:
self._discard_epoch(tls.Epoch.INITIAL)
# arm timer
self._set_timer()
===========unchanged ref 0===========
at: aioquic.connection
write_close_frame(builder: QuicPacketBuilder, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None
QuicConnectionState()
at: aioquic.connection.QuicConnection
_close(is_initiator: bool) -> None
_send_pending() -> None
_write_application(builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float) -> None
_write_application(self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float) -> None
_write_handshake(builder: QuicPacketBuilder, epoch: tls.Epoch) -> None
at: aioquic.connection.QuicConnection.__init__
self._is_client = configuration.is_client
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._handshake_confirmed = False
self._loop = loop
self._loss = QuicPacketRecovery(send_probe=self._send_probe)
self._packet_number = 0
self._peer_cid = os.urandom(8)
self._peer_token = b""
self._spin_bit = False
self._state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
self._close_pending: Optional[Dict] = None
self._probe_pending = False
self._send_task: Optional[asyncio.Handle] = None
at: aioquic.connection.QuicConnection._consume_connection_id
self._peer_cid = connection_id.cid
at: aioquic.connection.QuicConnection._handle_ack_frame
self._handshake_confirmed = True
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._initialize
self._cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self._packet_number = 0
at: aioquic.connection.QuicConnection._send_pending
network_path = self._network_paths[0]
self._send_task = None
builder = QuicPacketBuilder(
host_cid=self.host_cid,
packet_number=self._packet_number,
pad_first_datagram=(
self._is_client and self._state == QuicConnectionState.FIRSTFLIGHT
),
peer_cid=self._peer_cid,
peer_token=self._peer_token,
spin_bit=self._spin_bit,
version=self._version,
)
at: aioquic.connection.QuicConnection._set_state
self._state = state
at: aioquic.connection.QuicConnection._write_application
self._probe_pending = False
at: aioquic.connection.QuicConnection.close
self._close_pending = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.connect
self._version = protocol_version
self._version = max(self._configuration.supported_versions)
at: aioquic.connection.QuicConnection.connection_made
self._transport = cast(asyncio.DatagramTransport, transport)
at: aioquic.connection.QuicConnection.datagram_received
self._version = QuicProtocolVersion(header.version)
self._version = QuicProtocolVersion(max(common))
self._peer_cid = header.source_cid
self._peer_token = header.token
===========unchanged ref 2===========
self._spin_bit = self._spin_bit_peer
self._spin_bit = not self._spin_bit_peer
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
bytes_received: int = 0
bytes_sent: int = 0
is_validated: bool = False
local_challenge: Optional[bytes] = None
remote_challenge: Optional[bytes] = None
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair.__init__
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
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
at: aioquic.packet_builder
QuicPacketBuilderStop(*args: object)
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> Tuple[List[bytes], List[QuicSentPacket]]
start_packet(packet_type: int, crypto: CryptoPair, is_probe=False) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.max_flight_bytes: Optional[int] = None
self.max_total_bytes: Optional[int] = None
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
|
aioquic.connection/QuicConnection._parse_transport_parameters
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<4>:<add> self._is_client
<del> self.is_client
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _parse_transport_parameters(
self, data: bytes, from_session_ticket: bool = False
) -> None:
<0> quic_transport_parameters = pull_quic_transport_parameters(Buffer(data=data))
<1>
<2> # validate remote parameters
<3> if (
<4> self.is_client
<5> and not from_session_ticket
<6> and (
<7> quic_transport_parameters.original_connection_id
<8> != self._original_connection_id
<9> )
<10> ):
<11> raise QuicConnectionError(
<12> error_code=QuicErrorCode.TRANSPORT_PARAMETER_ERROR,
<13> frame_type=QuicFrameType.CRYPTO,
<14> reason_phrase="original_connection_id does not match",
<15> )
<16>
<17> # store remote parameters
<18> if quic_transport_parameters.idle_timeout is not None:
<19> self._remote_idle_timeout = quic_transport_parameters.idle_timeout / 1000.0
<20> for param in ["ack_delay_exponent", "max_ack_delay"]:
<21> value = getattr(quic_transport_parameters, param)
<22> if value is not None:
<23> setattr(self._loss, param, value)
<24> for param in [
<25> "max_data",
<26> "max_stream_data_bidi_local",
<27> "max_stream_data_bidi_remote",
<28> "max_stream_data_uni",
<29> "max_streams_bidi",
<30> "max_streams_uni",
<31> ]:
<32> value = getattr(quic_transport_parameters, "initial_" + param)
<33> if value is not None:
<34> setattr(self, "_remote_" + param, value)
<35>
<36> # wakeup waiters
<37> if not self._parameters_available.is_set():
<38> self._parameters_available.set()
<39>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
at: aioquic.connection.QuicConnection.__init__
self._configuration = configuration
self._local_max_data = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._loss = QuicPacketRecovery(send_probe=self._send_probe)
self._original_connection_id = original_connection_id
self._parameters_available = asyncio.Event()
self._remote_idle_timeout = 0.0 # seconds
at: aioquic.connection.QuicConnection._parse_transport_parameters
quic_transport_parameters = pull_quic_transport_parameters(Buffer(data=data))
at: aioquic.connection.QuicConnection._write_connection_limits
self._local_max_data *= 2
at: aioquic.connection.QuicConnection.datagram_received
self._original_connection_id = self._peer_cid
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(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)
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
===========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(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
network_path = self._network_paths[0]
self._send_task = None
if self._state in END_STATES:
return
# build datagrams
builder = QuicPacketBuilder(
host_cid=self.host_cid,
packet_number=self._packet_number,
pad_first_datagram=(
+ self._is_client and self._state == QuicConnectionState.FIRSTFLIGHT
- self.is_client and self._state == QuicConnectionState.FIRSTFLIGHT
),
peer_cid=self._peer_cid,
peer_token=self._peer_token,
spin_bit=self._spin_bit,
version=self._version,
)
if self._close_pending:
for epoch, packet_type in (
(tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
(tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
(tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
):
crypto = self._cryptos[epoch]
if crypto.send.is_valid():
builder.start_packet(packet_type, crypto)
write_close_frame(builder, **self._close_pending)
builder.end_packet()
self._close_pending = None
break
self._close(is_initiator=True)
else:
# congestion control
builder.max_flight_bytes = (
self._loss.congestion_window - self._loss.bytes_in_flight
)
if not network_path.is_validated:
# limit data on un-validated network paths
builder.max_total_bytes = (
network_path.bytes_received * 3 - network_path.bytes_sent
)
try:
if not self._handshake_confirmed:
for epoch in [tls.</s>
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
<s>bytes_sent
)
try:
if not self._handshake_confirmed:
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch)
self._write_application(builder, network_path, self._loop.time())
except QuicPacketBuilderStop:
pass
datagrams, packets = builder.flush()
if datagrams:
self._packet_number = builder.packet_number
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
# register packets
now = self._loop.time()
sent_handshake = False
for packet in packets:
packet.sent_time = now
self._loss.on_packet_sent(
packet=packet, space=self._spaces[packet.epoch]
)
if packet.epoch == tls.Epoch.HANDSHAKE:
sent_handshake = True
# check if we can discard initial keys
+ if sent_handshake and self._is_client:
- if sent_handshake and self.is_client:
self._discard_epoch(tls.Epoch.INITIAL)
# arm timer
self._set_timer()
|
aioquic.connection/QuicConnection._serialize_transport_parameters
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<1>:<add> idle_timeout=int(self._configuration.idle_timeout * 1000),
<del> idle_timeout=int(self._local_idle_timeout * 1000),
<10>:<add> if not self._is_client:
<del> if not self.is_client:
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _serialize_transport_parameters(self) -> bytes:
<0> quic_transport_parameters = QuicTransportParameters(
<1> idle_timeout=int(self._local_idle_timeout * 1000),
<2> initial_max_data=self._local_max_data,
<3> initial_max_stream_data_bidi_local=self._local_max_stream_data_bidi_local,
<4> initial_max_stream_data_bidi_remote=self._local_max_stream_data_bidi_remote,
<5> initial_max_stream_data_uni=self._local_max_stream_data_uni,
<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 not self.is_client:
<11> quic_transport_parameters.original_connection_id = (
<12> self._original_connection_id
<13> )
<14>
<15> buf = Buffer(capacity=512)
<16> push_quic_transport_parameters(buf, quic_transport_parameters)
<17> return buf.data
<18>
|
===========unchanged ref 0===========
at: aioquic._buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionState()
END_STATES = frozenset([QuicConnectionState.CLOSING, QuicConnectionState.DRAINING])
at: aioquic.connection.QuicConnection.__init__
self._is_client = configuration.is_client
self._close_at: Optional[float] = None
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(send_probe=self._send_probe)
self._original_connection_id = original_connection_id
self._state = QuicConnectionState.FIRSTFLIGHT
at: aioquic.connection.QuicConnection._close
self._close_at = self._loop.time() + 3 * self._loss.get_probe_timeout()
at: aioquic.connection.QuicConnection._connect
self._close_at = self._loop.time() + self._configuration.idle_timeout
at: aioquic.connection.QuicConnection._serialize_transport_parameters
quic_transport_parameters = QuicTransportParameters(
idle_timeout=int(self._configuration.idle_timeout * 1000),
initial_max_data=self._local_max_data,
initial_max_stream_data_bidi_local=self._local_max_stream_data_bidi_local,
initial_max_stream_data_bidi_remote=self._local_max_stream_data_bidi_remote,
initial_max_stream_data_uni=self._local_max_stream_data_uni,
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._original_connection_id = self._peer_cid
self._close_at = now + self._configuration.idle_timeout
at: aioquic.packet
push_quic_transport_parameters(buf: Buffer, params: QuicTransportParameters) -> None
at: aioquic.packet.QuicTransportParameters
original_connection_id: Optional[bytes] = None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _parse_transport_parameters(
self, data: bytes, from_session_ticket: bool = False
) -> None:
quic_transport_parameters = pull_quic_transport_parameters(Buffer(data=data))
# validate remote parameters
if (
+ self._is_client
- self.is_client
and not from_session_ticket
and (
quic_transport_parameters.original_connection_id
!= self._original_connection_id
)
):
raise QuicConnectionError(
error_code=QuicErrorCode.TRANSPORT_PARAMETER_ERROR,
frame_type=QuicFrameType.CRYPTO,
reason_phrase="original_connection_id does not match",
)
# store remote parameters
if quic_transport_parameters.idle_timeout is not None:
self._remote_idle_timeout = quic_transport_parameters.idle_timeout / 1000.0
for param in ["ack_delay_exponent", "max_ack_delay"]:
value = getattr(quic_transport_parameters, param)
if value is not None:
setattr(self._loss, param, value)
for param in [
"max_data",
"max_stream_data_bidi_local",
"max_stream_data_bidi_remote",
"max_stream_data_uni",
"max_streams_bidi",
"max_streams_uni",
]:
value = getattr(quic_transport_parameters, "initial_" + param)
if value is not None:
setattr(self, "_remote_" + param, value)
# wakeup waiters
if not self._parameters_available.is_set():
self._parameters_available.set()
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
network_path = self._network_paths[0]
self._send_task = None
if self._state in END_STATES:
return
# build datagrams
builder = QuicPacketBuilder(
host_cid=self.host_cid,
packet_number=self._packet_number,
pad_first_datagram=(
+ self._is_client and self._state == QuicConnectionState.FIRSTFLIGHT
- self.is_client and self._state == QuicConnectionState.FIRSTFLIGHT
),
peer_cid=self._peer_cid,
peer_token=self._peer_token,
spin_bit=self._spin_bit,
version=self._version,
)
if self._close_pending:
for epoch, packet_type in (
(tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
(tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
(tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
):
crypto = self._cryptos[epoch]
if crypto.send.is_valid():
builder.start_packet(packet_type, crypto)
write_close_frame(builder, **self._close_pending)
builder.end_packet()
self._close_pending = None
break
self._close(is_initiator=True)
else:
# congestion control
builder.max_flight_bytes = (
self._loss.congestion_window - self._loss.bytes_in_flight
)
if not network_path.is_validated:
# limit data on un-validated network paths
builder.max_total_bytes = (
network_path.bytes_received * 3 - network_path.bytes_sent
)
try:
if not self._handshake_confirmed:
for epoch in [tls.</s>
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
<s>bytes_sent
)
try:
if not self._handshake_confirmed:
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch)
self._write_application(builder, network_path, self._loop.time())
except QuicPacketBuilderStop:
pass
datagrams, packets = builder.flush()
if datagrams:
self._packet_number = builder.packet_number
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
# register packets
now = self._loop.time()
sent_handshake = False
for packet in packets:
packet.sent_time = now
self._loss.on_packet_sent(
packet=packet, space=self._spaces[packet.epoch]
)
if packet.epoch == tls.Epoch.HANDSHAKE:
sent_handshake = True
# check if we can discard initial keys
+ if sent_handshake and self._is_client:
- if sent_handshake and self.is_client:
self._discard_epoch(tls.Epoch.INITIAL)
# arm timer
self._set_timer()
|
aioquic.connection/QuicConnection._stream_can_receive
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<2>:<add> ) != self._is_client or not stream_is_unidirectional(stream_id)
<del> ) != self.is_client or not stream_is_unidirectional(stream_id)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_receive(self, stream_id: int) -> bool:
<0> return stream_is_client_initiated(
<1> stream_id
<2> ) != self.is_client or not stream_is_unidirectional(stream_id)
<3>
|
===========unchanged ref 0===========
at: aioquic.tls
Direction()
Epoch()
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _serialize_transport_parameters(self) -> bytes:
quic_transport_parameters = QuicTransportParameters(
+ idle_timeout=int(self._configuration.idle_timeout * 1000),
- idle_timeout=int(self._local_idle_timeout * 1000),
initial_max_data=self._local_max_data,
initial_max_stream_data_bidi_local=self._local_max_stream_data_bidi_local,
initial_max_stream_data_bidi_remote=self._local_max_stream_data_bidi_remote,
initial_max_stream_data_uni=self._local_max_stream_data_uni,
initial_max_streams_bidi=self._local_max_streams_bidi,
initial_max_streams_uni=self._local_max_streams_uni,
ack_delay_exponent=10,
)
+ if not self._is_client:
- if not self.is_client:
quic_transport_parameters.original_connection_id = (
self._original_connection_id
)
buf = Buffer(capacity=512)
push_quic_transport_parameters(buf, quic_transport_parameters)
return buf.data
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _parse_transport_parameters(
self, data: bytes, from_session_ticket: bool = False
) -> None:
quic_transport_parameters = pull_quic_transport_parameters(Buffer(data=data))
# validate remote parameters
if (
+ self._is_client
- self.is_client
and not from_session_ticket
and (
quic_transport_parameters.original_connection_id
!= self._original_connection_id
)
):
raise QuicConnectionError(
error_code=QuicErrorCode.TRANSPORT_PARAMETER_ERROR,
frame_type=QuicFrameType.CRYPTO,
reason_phrase="original_connection_id does not match",
)
# store remote parameters
if quic_transport_parameters.idle_timeout is not None:
self._remote_idle_timeout = quic_transport_parameters.idle_timeout / 1000.0
for param in ["ack_delay_exponent", "max_ack_delay"]:
value = getattr(quic_transport_parameters, param)
if value is not None:
setattr(self._loss, param, value)
for param in [
"max_data",
"max_stream_data_bidi_local",
"max_stream_data_bidi_remote",
"max_stream_data_uni",
"max_streams_bidi",
"max_streams_uni",
]:
value = getattr(quic_transport_parameters, "initial_" + param)
if value is not None:
setattr(self, "_remote_" + param, value)
# wakeup waiters
if not self._parameters_available.is_set():
self._parameters_available.set()
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
network_path = self._network_paths[0]
self._send_task = None
if self._state in END_STATES:
return
# build datagrams
builder = QuicPacketBuilder(
host_cid=self.host_cid,
packet_number=self._packet_number,
pad_first_datagram=(
+ self._is_client and self._state == QuicConnectionState.FIRSTFLIGHT
- self.is_client and self._state == QuicConnectionState.FIRSTFLIGHT
),
peer_cid=self._peer_cid,
peer_token=self._peer_token,
spin_bit=self._spin_bit,
version=self._version,
)
if self._close_pending:
for epoch, packet_type in (
(tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
(tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
(tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
):
crypto = self._cryptos[epoch]
if crypto.send.is_valid():
builder.start_packet(packet_type, crypto)
write_close_frame(builder, **self._close_pending)
builder.end_packet()
self._close_pending = None
break
self._close(is_initiator=True)
else:
# congestion control
builder.max_flight_bytes = (
self._loss.congestion_window - self._loss.bytes_in_flight
)
if not network_path.is_validated:
# limit data on un-validated network paths
builder.max_total_bytes = (
network_path.bytes_received * 3 - network_path.bytes_sent
)
try:
if not self._handshake_confirmed:
for epoch in [tls.</s>
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
<s>bytes_sent
)
try:
if not self._handshake_confirmed:
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch)
self._write_application(builder, network_path, self._loop.time())
except QuicPacketBuilderStop:
pass
datagrams, packets = builder.flush()
if datagrams:
self._packet_number = builder.packet_number
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
# register packets
now = self._loop.time()
sent_handshake = False
for packet in packets:
packet.sent_time = now
self._loss.on_packet_sent(
packet=packet, space=self._spaces[packet.epoch]
)
if packet.epoch == tls.Epoch.HANDSHAKE:
sent_handshake = True
# check if we can discard initial keys
+ if sent_handshake and self._is_client:
- if sent_handshake and self.is_client:
self._discard_epoch(tls.Epoch.INITIAL)
# arm timer
self._set_timer()
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _connect(self) -> None:
"""
Start the client handshake.
"""
+ assert self._is_client
- assert self.is_client
+ self._close_at = self._loop.time() + self._configuration.idle_timeout
- self._close_at = self._loop.time() + self._local_idle_timeout
self._initialize(self._peer_cid)
self.tls.handle_message(b"", self._crypto_buffers)
self._push_crypto_data()
self._send_pending()
===========changed ref 5===========
+ # module: aioquic.configuration
+
+
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
"""
A QUIC connection.
"""
- supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
-
|
aioquic.connection/QuicConnection._stream_can_send
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<2>:<add> ) == self._is_client or not stream_is_unidirectional(stream_id)
<del> ) == self.is_client or not stream_is_unidirectional(stream_id)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_send(self, stream_id: int) -> bool:
<0> return stream_is_client_initiated(
<1> stream_id
<2> ) == self.is_client or not stream_is_unidirectional(stream_id)
<3>
|
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_receive(self, stream_id: int) -> bool:
return stream_is_client_initiated(
stream_id
+ ) != self._is_client or not stream_is_unidirectional(stream_id)
- ) != self.is_client or not stream_is_unidirectional(stream_id)
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _serialize_transport_parameters(self) -> bytes:
quic_transport_parameters = QuicTransportParameters(
+ idle_timeout=int(self._configuration.idle_timeout * 1000),
- idle_timeout=int(self._local_idle_timeout * 1000),
initial_max_data=self._local_max_data,
initial_max_stream_data_bidi_local=self._local_max_stream_data_bidi_local,
initial_max_stream_data_bidi_remote=self._local_max_stream_data_bidi_remote,
initial_max_stream_data_uni=self._local_max_stream_data_uni,
initial_max_streams_bidi=self._local_max_streams_bidi,
initial_max_streams_uni=self._local_max_streams_uni,
ack_delay_exponent=10,
)
+ if not self._is_client:
- if not self.is_client:
quic_transport_parameters.original_connection_id = (
self._original_connection_id
)
buf = Buffer(capacity=512)
push_quic_transport_parameters(buf, quic_transport_parameters)
return buf.data
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _parse_transport_parameters(
self, data: bytes, from_session_ticket: bool = False
) -> None:
quic_transport_parameters = pull_quic_transport_parameters(Buffer(data=data))
# validate remote parameters
if (
+ self._is_client
- self.is_client
and not from_session_ticket
and (
quic_transport_parameters.original_connection_id
!= self._original_connection_id
)
):
raise QuicConnectionError(
error_code=QuicErrorCode.TRANSPORT_PARAMETER_ERROR,
frame_type=QuicFrameType.CRYPTO,
reason_phrase="original_connection_id does not match",
)
# store remote parameters
if quic_transport_parameters.idle_timeout is not None:
self._remote_idle_timeout = quic_transport_parameters.idle_timeout / 1000.0
for param in ["ack_delay_exponent", "max_ack_delay"]:
value = getattr(quic_transport_parameters, param)
if value is not None:
setattr(self._loss, param, value)
for param in [
"max_data",
"max_stream_data_bidi_local",
"max_stream_data_bidi_remote",
"max_stream_data_uni",
"max_streams_bidi",
"max_streams_uni",
]:
value = getattr(quic_transport_parameters, "initial_" + param)
if value is not None:
setattr(self, "_remote_" + param, value)
# wakeup waiters
if not self._parameters_available.is_set():
self._parameters_available.set()
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
network_path = self._network_paths[0]
self._send_task = None
if self._state in END_STATES:
return
# build datagrams
builder = QuicPacketBuilder(
host_cid=self.host_cid,
packet_number=self._packet_number,
pad_first_datagram=(
+ self._is_client and self._state == QuicConnectionState.FIRSTFLIGHT
- self.is_client and self._state == QuicConnectionState.FIRSTFLIGHT
),
peer_cid=self._peer_cid,
peer_token=self._peer_token,
spin_bit=self._spin_bit,
version=self._version,
)
if self._close_pending:
for epoch, packet_type in (
(tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
(tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
(tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
):
crypto = self._cryptos[epoch]
if crypto.send.is_valid():
builder.start_packet(packet_type, crypto)
write_close_frame(builder, **self._close_pending)
builder.end_packet()
self._close_pending = None
break
self._close(is_initiator=True)
else:
# congestion control
builder.max_flight_bytes = (
self._loss.congestion_window - self._loss.bytes_in_flight
)
if not network_path.is_validated:
# limit data on un-validated network paths
builder.max_total_bytes = (
network_path.bytes_received * 3 - network_path.bytes_sent
)
try:
if not self._handshake_confirmed:
for epoch in [tls.</s>
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
<s>bytes_sent
)
try:
if not self._handshake_confirmed:
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch)
self._write_application(builder, network_path, self._loop.time())
except QuicPacketBuilderStop:
pass
datagrams, packets = builder.flush()
if datagrams:
self._packet_number = builder.packet_number
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
# register packets
now = self._loop.time()
sent_handshake = False
for packet in packets:
packet.sent_time = now
self._loss.on_packet_sent(
packet=packet, space=self._spaces[packet.epoch]
)
if packet.epoch == tls.Epoch.HANDSHAKE:
sent_handshake = True
# check if we can discard initial keys
+ if sent_handshake and self._is_client:
- if sent_handshake and self.is_client:
self._discard_epoch(tls.Epoch.INITIAL)
# arm timer
self._set_timer()
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _connect(self) -> None:
"""
Start the client handshake.
"""
+ assert self._is_client
- assert self.is_client
+ self._close_at = self._loop.time() + self._configuration.idle_timeout
- self._close_at = self._loop.time() + self._local_idle_timeout
self._initialize(self._peer_cid)
self.tls.handle_message(b"", self._crypto_buffers)
self._push_crypto_data()
self._send_pending()
===========changed ref 6===========
+ # module: aioquic.configuration
+
+
|
aioquic.connection/QuicConnection._update_traffic_key
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<4>:<add> secrets_log_file = self._configuration.secrets_log_file
<add> if secrets_log_file is not None:
<del> if self._secrets_log_file is not None:
<5>:<add> label_row = self._is_client == (direction == tls.Direction.DECRYPT)
<del> label_row = self.is_client == (direction == tls.Direction.DECRYPT)
<7>:<add> secrets_log_file.write(
<del> self._secrets_log_file.write(
<10>:<add> secrets_log_file.flush()
<del> self._secrets_log_file.flush()
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _update_traffic_key(
self,
direction: tls.Direction,
epoch: tls.Epoch,
cipher_suite: tls.CipherSuite,
secret: bytes,
) -> None:
<0> """
<1> Callback which is invoked by the TLS engine when new traffic keys are
<2> available.
<3> """
<4> if self._secrets_log_file is not None:
<5> label_row = self.is_client == (direction == tls.Direction.DECRYPT)
<6> label = SECRETS_LABELS[label_row][epoch.value]
<7> self._secrets_log_file.write(
<8> "%s %s %s\n" % (label, self.tls.client_random.hex(), secret.hex())
<9> )
<10> self._secrets_log_file.flush()
<11>
<12> crypto = self._cryptos[epoch]
<13> if direction == tls.Direction.ENCRYPT:
<14> crypto.send.setup(cipher_suite, secret)
<15> else:
<16> crypto.recv.setup(cipher_suite, secret)
<17>
|
===========unchanged ref 0===========
at: aioquic.connection
SECRETS_LABELS = [
[
None,
"QUIC_CLIENT_EARLY_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
[
None,
None,
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
],
]
QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, is_validated: bool=False, local_challenge: Optional[bytes]=None, remote_challenge: Optional[bytes]=None)
at: aioquic.connection.QuicConnection.__init__
self._configuration = configuration
self._is_client = configuration.is_client
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self._is_client, logger=self._logger)
self._cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self._crypto_streams = {
tls.Epoch.INITIAL: QuicStream(),
tls.Epoch.HANDSHAKE: QuicStream(),
tls.Epoch.ONE_RTT: QuicStream(),
}
at: aioquic.crypto.CryptoContext
setup(cipher_suite: CipherSuite, secret: bytes) -> None
at: aioquic.crypto.CryptoPair.__init__
self.recv = CryptoContext()
self.send = CryptoContext()
===========unchanged ref 1===========
at: aioquic.packet
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.tls
Direction()
Epoch()
at: aioquic.tls.Context.__init__
self.client_random = None
self.client_random = os.urandom(32)
at: aioquic.tls.Context._server_handle_hello
self.client_random = peer_hello.random
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
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_send(self, stream_id: int) -> bool:
return stream_is_client_initiated(
stream_id
+ ) == self._is_client or not stream_is_unidirectional(stream_id)
- ) == self.is_client or not stream_is_unidirectional(stream_id)
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_receive(self, stream_id: int) -> bool:
return stream_is_client_initiated(
stream_id
+ ) != self._is_client or not stream_is_unidirectional(stream_id)
- ) != self.is_client or not stream_is_unidirectional(stream_id)
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _serialize_transport_parameters(self) -> bytes:
quic_transport_parameters = QuicTransportParameters(
+ idle_timeout=int(self._configuration.idle_timeout * 1000),
- idle_timeout=int(self._local_idle_timeout * 1000),
initial_max_data=self._local_max_data,
initial_max_stream_data_bidi_local=self._local_max_stream_data_bidi_local,
initial_max_stream_data_bidi_remote=self._local_max_stream_data_bidi_remote,
initial_max_stream_data_uni=self._local_max_stream_data_uni,
initial_max_streams_bidi=self._local_max_streams_bidi,
initial_max_streams_uni=self._local_max_streams_uni,
ack_delay_exponent=10,
)
+ if not self._is_client:
- if not self.is_client:
quic_transport_parameters.original_connection_id = (
self._original_connection_id
)
buf = Buffer(capacity=512)
push_quic_transport_parameters(buf, quic_transport_parameters)
return buf.data
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _parse_transport_parameters(
self, data: bytes, from_session_ticket: bool = False
) -> None:
quic_transport_parameters = pull_quic_transport_parameters(Buffer(data=data))
# validate remote parameters
if (
+ self._is_client
- self.is_client
and not from_session_ticket
and (
quic_transport_parameters.original_connection_id
!= self._original_connection_id
)
):
raise QuicConnectionError(
error_code=QuicErrorCode.TRANSPORT_PARAMETER_ERROR,
frame_type=QuicFrameType.CRYPTO,
reason_phrase="original_connection_id does not match",
)
# store remote parameters
if quic_transport_parameters.idle_timeout is not None:
self._remote_idle_timeout = quic_transport_parameters.idle_timeout / 1000.0
for param in ["ack_delay_exponent", "max_ack_delay"]:
value = getattr(quic_transport_parameters, param)
if value is not None:
setattr(self._loss, param, value)
for param in [
"max_data",
"max_stream_data_bidi_local",
"max_stream_data_bidi_remote",
"max_stream_data_uni",
"max_streams_bidi",
"max_streams_uni",
]:
value = getattr(quic_transport_parameters, "initial_" + param)
if value is not None:
setattr(self, "_remote_" + param, value)
# wakeup waiters
if not self._parameters_available.is_set():
self._parameters_available.set()
|
aioquic.client/connect
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<s> port: int,
*,
alpn_protocols: Optional[List[str]] = None,
idle_timeout: Optional[float] = None,
protocol_version: Optional[int] = None,
secrets_log_file: Optional[TextIO] = None,
session_ticket: Optional[SessionTicket] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> AsyncGenerator[QuicConnection, None]:
<0> """
<1> Connect to a QUIC server at the given `host` and `port`.
<2>
<3> :meth:`connect()` returns an awaitable. Awaiting it yields a
<4> :class:`~aioquic.QuicConnection` which can be used to create streams.
<5>
<6> :func:`connect` also accepts the following optional arguments:
<7>
<8> * ``alpn_protocols`` is a list of ALPN protocols to offer in the
<9> ClientHello.
<10> * ``secrets_log_file`` is a file-like object in which to log traffic
<11> secrets. This is useful to analyze traffic captures with Wireshark.
<12> * ``session_ticket`` is a TLS session ticket which should be used for
<13> resumption.
<14> * ``session_ticket_handler`` is a callback which is invoked by the TLS
<15> engine when a new session ticket is received.
<16> * ``stream_handler`` is a callback which is invoked whenever a stream is
<17> created. It must accept two arguments: a :class:`asyncio.StreamReader`
<18> and a :class:`asyncio.StreamWriter`.
<19> """
<20> loop = asyncio.get_event_loop()
<21>
<22> # if host is not an IP address, pass it to enable SNI
<23> try:
<24> ipaddress.ip_address(host)
<25> server_name = None
<26> except ValueError:
<27> server_name = host
<28>
<29> # lookup remote address
<30> infos = await loop.getaddrinfo(host, port, type=socket.SOCK_DGRAM)
<31> addr = infos[0][4]</s>
|
===========below chunk 0===========
<s>
*,
alpn_protocols: Optional[List[str]] = None,
idle_timeout: Optional[float] = None,
protocol_version: Optional[int] = None,
secrets_log_file: Optional[TextIO] = None,
session_ticket: Optional[SessionTicket] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> AsyncGenerator[QuicConnection, None]:
# offset: 1
addr = ("::ffff:" + addr[0], addr[1], 0, 0)
# connect
_, protocol = await loop.create_datagram_endpoint(
lambda: QuicConnection(
alpn_protocols=alpn_protocols,
idle_timeout=idle_timeout,
is_client=True,
secrets_log_file=secrets_log_file,
server_name=server_name,
session_ticket=session_ticket,
session_ticket_handler=session_ticket_handler,
stream_handler=stream_handler,
),
local_addr=("::", 0),
)
protocol = cast(QuicConnection, protocol)
protocol.connect(addr, protocol_version=protocol_version)
await protocol.wait_connected()
try:
yield protocol
finally:
protocol.close()
await protocol.wait_closed()
===========unchanged ref 0===========
at: _asyncio
get_event_loop()
at: aioquic.compat
asynccontextmanager = _asynccontextmanager
asynccontextmanager = None
at: aioquic.configuration
QuicConfiguration(alpn_protocols: Optional[List[str]]=None, certificate: Any=None, idle_timeout: float=60.0, is_client: bool=True, private_key: Any=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, supported_versions: List[QuicProtocolVersion]=field(
default_factory=lambda: [
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
))
at: aioquic.configuration.QuicConfiguration
alpn_protocols: Optional[List[str]] = None
certificate: Any = None
idle_timeout: float = 60.0
is_client: bool = True
private_key: Any = None
secrets_log_file: TextIO = None
server_name: Optional[str] = None
session_ticket: Optional[tls.SessionTicket] = None
supported_versions: List[QuicProtocolVersion] = field(
default_factory=lambda: [
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
)
at: aioquic.connection
QuicStreamHandler = Callable[[asyncio.StreamReader, asyncio.StreamWriter], None]
QuicConnection(*, configuration: QuicConfiguration, original_connection_id: Optional[bytes]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
connect(addr: NetworkAddress, protocol_version: Optional[int]=None) -> None
===========unchanged ref 1===========
at: aioquic.tls
SessionTicket(age_add: int, cipher_suite: CipherSuite, not_valid_after: datetime.datetime, not_valid_before: datetime.datetime, resumption_secret: bytes, server_name: str, ticket: bytes, max_early_data_size: Optional[int]=None, other_extensions: List[Tuple[int, bytes]]=field(default_factory=list))
SessionTicketHandler = Callable[[SessionTicket], None]
at: asyncio.events
get_event_loop() -> AbstractEventLoop
at: asyncio.events.AbstractEventLoop
getaddrinfo(host: Optional[str], port: Union[str, int, None], *, family: int=..., type: int=..., proto: int=..., flags: int=...) -> List[Tuple[AddressFamily, SocketKind, int, str, Union[Tuple[str, int], Tuple[str, int, int, int]]]]
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: contextlib
asynccontextmanager(func: Callable[..., AsyncIterator[_T]]) -> Callable[..., AsyncContextManager[_T]]
at: ipaddress
ip_address(address: object) -> Any
at: socket
SOCK_DGRAM: SocketKind
at: typing
cast(typ: Type[_T], val: Any) -> _T
cast(typ: str, val: Any) -> Any
cast(typ: object, val: Any) -> Any
List = _alias(list, 1, inst=False, name='List')
AsyncGenerator = _alias(collections.abc.AsyncGenerator, 2)
TextIO()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
"""
A QUIC connection.
"""
- supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
-
===========changed ref 1===========
+ # module: aioquic.configuration
+ @dataclass
+ class QuicConfiguration:
+ alpn_protocols: Optional[List[str]] = None
+ certificate: Any = None
+ idle_timeout: float = 60.0
+ is_client: bool = True
+ private_key: Any = None
+ secrets_log_file: TextIO = None
+ server_name: Optional[str] = None
+ session_ticket: Optional[tls.SessionTicket] = None
+ supported_versions: List[QuicProtocolVersion] = field(
+ default_factory=lambda: [
+ QuicProtocolVersion.DRAFT_19,
+ QuicProtocolVersion.DRAFT_20,
+ ]
+ )
+
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def connect(
self, addr: NetworkAddress, protocol_version: Optional[int] = None
) -> None:
"""
Initiate the TLS handshake.
This method can only be called for clients and a single time.
"""
assert (
+ self._is_client and not self._connect_called
- self.is_client and not self._connect_called
), "connect() can only be called for clients and a single time"
self._connect_called = True
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
if protocol_version is not None:
self._version = protocol_version
else:
+ self._version = max(self._configuration.supported_versions)
- self._version = max(self.supported_versions)
self._connect()
===========changed ref 3===========
+ # module: aioquic.configuration
+
+
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_send(self, stream_id: int) -> bool:
return stream_is_client_initiated(
stream_id
+ ) == self._is_client or not stream_is_unidirectional(stream_id)
- ) == self.is_client or not stream_is_unidirectional(stream_id)
|
|
aioquic.server/QuicServer.__init__
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<0>:<del> self._alpn_protocols = alpn_protocols
<1>:<del> self._certificate = certificate
<2>:<add> self._configuration = configuration
<3>:<del> self._idle_timeout = idle_timeout
<4>:<del> self._private_key = private_key
<5>:<del> self._secrets_log_file = secrets_log_file
|
<s> None,
+ configuration: QuicConfiguration,
connection_handler: Optional[QuicConnectionHandler] = None,
- idle_timeout: Optional[float] = None,
- secrets_log_file: Optional[TextIO] = None,
session_ticket_fetcher: Optional[SessionTicketFetcher] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stateless_retry: bool = False,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
<0> self._alpn_protocols = alpn_protocols
<1> self._certificate = certificate
<2> self._connections: Dict[bytes, QuicConnection] = {}
<3> self._idle_timeout = idle_timeout
<4> self._private_key = private_key
<5> self._secrets_log_file = secrets_log_file
<6> self._session_ticket_fetcher = session_ticket_fetcher
<7> self._session_ticket_handler = session_ticket_handler
<8> self._transport: Optional[asyncio.DatagramTransport] = None
<9>
<10> if connection_handler is not None:
<11> self._connection_handler = connection_handler
<12> else:
<13> self._connection_handler = lambda c: None
<14>
<15> self._stream_handler = stream_handler
<16>
<17> if stateless_retry:
<18> self._retry_key = rsa.generate_private_key(
<19> public_exponent=65537, key_size=1024, backend=default_backend()
<20> )
<21> else:
<22> self._retry_key = None
<23>
|
===========unchanged ref 0===========
at: aioquic._buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.configuration
QuicConfiguration(alpn_protocols: Optional[List[str]]=None, certificate: Any=None, idle_timeout: float=60.0, is_client: bool=True, private_key: Any=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, supported_versions: List[QuicProtocolVersion]=field(
default_factory=lambda: [
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
))
at: aioquic.connection
NetworkAddress = Any
QuicStreamHandler = Callable[[asyncio.StreamReader, asyncio.StreamWriter], None]
QuicConnection(*, configuration: QuicConfiguration, original_connection_id: Optional[bytes]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.server
QuicConnectionHandler = Callable[[QuicConnection], None]
at: aioquic.tls
SessionTicketFetcher = Callable[[bytes], Optional[SessionTicket]]
SessionTicketHandler = Callable[[SessionTicket], None]
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: asyncio.transports
BaseTransport(extra: Optional[Mapping[Any, Any]]=...)
DatagramTransport(extra: Optional[Mapping[Any, Any]]=...)
===========unchanged ref 1===========
at: typing
cast(typ: Type[_T], val: Any) -> _T
cast(typ: str, val: Any) -> Any
cast(typ: object, val: Any) -> Any
Dict = _alias(dict, 2, inst=False, name='Dict')
Text = str
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
"""
A QUIC connection.
"""
- supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
-
===========changed ref 1===========
+ # module: aioquic.configuration
+ @dataclass
+ class QuicConfiguration:
+ alpn_protocols: Optional[List[str]] = None
+ certificate: Any = None
+ idle_timeout: float = 60.0
+ is_client: bool = True
+ private_key: Any = None
+ secrets_log_file: TextIO = None
+ server_name: Optional[str] = None
+ session_ticket: Optional[tls.SessionTicket] = None
+ supported_versions: List[QuicProtocolVersion] = field(
+ default_factory=lambda: [
+ QuicProtocolVersion.DRAFT_19,
+ QuicProtocolVersion.DRAFT_20,
+ ]
+ )
+
===========changed ref 2===========
+ # module: aioquic.configuration
+
+
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_send(self, stream_id: int) -> bool:
return stream_is_client_initiated(
stream_id
+ ) == self._is_client or not stream_is_unidirectional(stream_id)
- ) == self.is_client or not stream_is_unidirectional(stream_id)
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_receive(self, stream_id: int) -> bool:
return stream_is_client_initiated(
stream_id
+ ) != self._is_client or not stream_is_unidirectional(stream_id)
- ) != self.is_client or not stream_is_unidirectional(stream_id)
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _connect(self) -> None:
"""
Start the client handshake.
"""
+ assert self._is_client
- assert self.is_client
+ self._close_at = self._loop.time() + self._configuration.idle_timeout
- self._close_at = self._loop.time() + self._local_idle_timeout
self._initialize(self._peer_cid)
self.tls.handle_message(b"", self._crypto_buffers)
self._push_crypto_data()
self._send_pending()
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def connect(
self, addr: NetworkAddress, protocol_version: Optional[int] = None
) -> None:
"""
Initiate the TLS handshake.
This method can only be called for clients and a single time.
"""
assert (
+ self._is_client and not self._connect_called
- self.is_client and not self._connect_called
), "connect() can only be called for clients and a single time"
self._connect_called = True
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
if protocol_version is not None:
self._version = protocol_version
else:
+ self._version = max(self._configuration.supported_versions)
- self._version = max(self.supported_versions)
self._connect()
===========changed ref 7===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _update_traffic_key(
self,
direction: tls.Direction,
epoch: tls.Epoch,
cipher_suite: tls.CipherSuite,
secret: bytes,
) -> None:
"""
Callback which is invoked by the TLS engine when new traffic keys are
available.
"""
+ secrets_log_file = self._configuration.secrets_log_file
+ if secrets_log_file is not None:
- if self._secrets_log_file is not None:
+ label_row = self._is_client == (direction == tls.Direction.DECRYPT)
- label_row = self.is_client == (direction == tls.Direction.DECRYPT)
label = SECRETS_LABELS[label_row][epoch.value]
+ secrets_log_file.write(
- self._secrets_log_file.write(
"%s %s %s\n" % (label, self.tls.client_random.hex(), secret.hex())
)
+ secrets_log_file.flush()
- self._secrets_log_file.flush()
crypto = self._cryptos[epoch]
if direction == tls.Direction.ENCRYPT:
crypto.send.setup(cipher_suite, secret)
else:
crypto.recv.setup(cipher_suite, secret)
|
aioquic.server/QuicServer.datagram_received
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<7>:<add> and header.version not in self._configuration.supported_versions
<del> and header.version not in QuicConnection.supported_versions
<13>:<add> supported_versions=self._configuration.supported_versions,
<del> supported_versions=QuicConnection.supported_versions,
|
# module: aioquic.server
class QuicServer(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
<0> data = cast(bytes, data)
<1> buf = Buffer(data=data)
<2> header = pull_quic_header(buf, host_cid_length=8)
<3>
<4> # version negotiation
<5> if (
<6> header.version is not None
<7> and header.version not in QuicConnection.supported_versions
<8> ):
<9> self._transport.sendto(
<10> encode_quic_version_negotiation(
<11> source_cid=header.destination_cid,
<12> destination_cid=header.source_cid,
<13> supported_versions=QuicConnection.supported_versions,
<14> ),
<15> addr,
<16> )
<17> return
<18>
<19> connection = self._connections.get(header.destination_cid, None)
<20> original_connection_id: Optional[bytes] = None
<21> if connection is None and header.packet_type == PACKET_TYPE_INITIAL:
<22> # stateless retry
<23> if self._retry_key is not None:
<24> if not header.token:
<25> retry_message = encode_address(addr) + b"|" + header.destination_cid
<26> retry_token = self._retry_key.public_key().encrypt(
<27> retry_message,
<28> padding.OAEP(
<29> mgf=padding.MGF1(hashes.SHA256()),
<30> algorithm=hashes.SHA256(),
<31> label=None,
<32> ),
<33> )
<34> self._transport.sendto(
<35> encode_quic_retry(
<36> version=header.version,
<37> source_cid=os.urandom(8),
<38> destination_cid=header.source_cid,
<39> original_destination_cid=header.destination_cid,
<40> retry_token=retry_token,
<41> ),
<42> addr,
<43> )
<44> return
<45> else:</s>
|
===========below chunk 0===========
# module: aioquic.server
class QuicServer(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
# offset: 1
retry_message = self._retry_key.decrypt(
header.token,
padding.OAEP(
mgf=padding.MGF1(hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None,
),
)
encoded_addr, original_connection_id = retry_message.split(
b"|", maxsplit=1
)
if encoded_addr != encode_address(addr):
return
except ValueError:
return
# create new connection
connection = QuicConnection(
alpn_protocols=self._alpn_protocols,
certificate=self._certificate,
idle_timeout=self._idle_timeout,
is_client=False,
original_connection_id=original_connection_id,
private_key=self._private_key,
secrets_log_file=self._secrets_log_file,
session_ticket_fetcher=self._session_ticket_fetcher,
session_ticket_handler=self._session_ticket_handler,
stream_handler=self._stream_handler,
)
self._connections[header.destination_cid] = connection
def connection_id_issued(cid: bytes) -> None:
self._connections[cid] = connection
def connection_id_retired(cid: bytes) -> None:
del self._connections[cid]
connection._connection_id_issued_handler = connection_id_issued
connection._connection_id_retired_handler = connection_id_retired
connection.connection_made(self._transport)
self._connections[connection.host_cid] = connection
self._connection_handler(connection)
if connection is not None:
connection.datagram_received(data, addr)
===========unchanged ref 0===========
at: aioquic.configuration.QuicConfiguration
alpn_protocols: Optional[List[str]] = None
certificate: Any = None
idle_timeout: float = 60.0
is_client: bool = True
private_key: Any = None
secrets_log_file: TextIO = None
server_name: Optional[str] = None
session_ticket: Optional[tls.SessionTicket] = None
supported_versions: List[QuicProtocolVersion] = field(
default_factory=lambda: [
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
)
at: aioquic.connection
QuicStreamHandler = Callable[[asyncio.StreamReader, asyncio.StreamWriter], None]
QuicConnection(*, configuration: QuicConfiguration, original_connection_id: Optional[bytes]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
connection_made(transport: asyncio.BaseTransport) -> None
datagram_received(data: Union[bytes, Text], addr: NetworkAddress) -> None
at: aioquic.connection.QuicConnection.__init__
self.host_cid = self._host_cids[0].cid
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionIdHandler = lambda c: None
at: aioquic.connection.QuicConnection.datagram_received
self.host_cid = context.host_cid
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
encode_quic_retry(version: int, source_cid: bytes, destination_cid: bytes, original_destination_cid: bytes, retry_token: bytes) -> bytes
===========unchanged ref 1===========
encode_quic_version_negotiation(source_cid: bytes, destination_cid: bytes, supported_versions: List[QuicProtocolVersion]) -> bytes
at: aioquic.packet.QuicHeader
is_long_header: bool
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: aioquic.server
QuicConnectionHandler = Callable[[QuicConnection], None]
encode_address(addr: NetworkAddress) -> bytes
at: aioquic.server.QuicServer.__init__
self._configuration = configuration
self._connections: Dict[bytes, QuicConnection] = {}
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
self._transport: Optional[asyncio.DatagramTransport] = None
self._connection_handler = connection_handler
self._connection_handler = lambda c: None
self._stream_handler = stream_handler
self._retry_key = None
self._retry_key = rsa.generate_private_key(
public_exponent=65537, key_size=1024, backend=default_backend()
)
at: aioquic.server.QuicServer.connection_made
self._transport = cast(asyncio.DatagramTransport, transport)
at: aioquic.server.QuicServer.datagram_received
data = cast(bytes, data)
header = pull_quic_header(buf, host_cid_length=8)
at: asyncio.transports.DatagramTransport
__slots__ = ()
sendto(data: Any, addr: Optional[_Address]=...) -> None
at: os
urandom(size: int, /) -> bytes
at: typing
List = _alias(list, 1, inst=False, name='List')
===========unchanged ref 2===========
TextIO()
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(asyncio.DatagramProtocol):
"""
A QUIC connection.
"""
- supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
-
|
aioquic.server/serve
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<27>:<add> configuration = QuicConfiguration(
<add> alpn_protocols=alpn_protocols,
<add> certificate=certificate,
<add> is_client=False,
<add> private_key=private_key,
<add> secrets_log_file=secrets_log_file,
<add> )
<add>
<29>:<del> alpn_protocols=alpn
|
<s> *,
certificate: Any,
private_key: Any,
alpn_protocols: Optional[List[str]] = None,
connection_handler: QuicConnectionHandler = None,
stream_handler: QuicStreamHandler = None,
secrets_log_file: Optional[TextIO] = None,
session_ticket_fetcher: Optional[SessionTicketFetcher] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stateless_retry: bool = False,
) -> None:
<0> """
<1> Start a QUIC server at the given `host` and `port`.
<2>
<3> :func:`serve` requires a TLS certificate and private key, which can be
<4> specified using the following arguments:
<5>
<6> * ``certificate`` is the server's TLS certificate.
<7> See :func:`cryptography.x509.load_pem_x509_certificate`.
<8> * ``private_key`` is the server's private key.
<9> See :func:`cryptography.hazmat.primitives.serialization.load_pem_private_key`.
<10>
<11> :func:`serve` also accepts the following optional arguments:
<12>
<13> * ``connection_handler`` is a callback which is invoked whenever a
<14> connection is created. It must be a a function accepting a single
<15> argument: a :class:`~aioquic.QuicConnection`.
<16> * ``secrets_log_file`` is a file-like object in which to log traffic
<17> secrets. This is useful to analyze traffic captures with Wireshark.
<18> * ``stateless_retry`` specifies whether a stateless retry should be
<19> performed prior to handling new connections.
<20> * ``stream_handler`` is a callback which is invoked whenever a stream is
<21> created. It must accept two arguments: a :class:`asyncio.StreamReader`
<22> and a :class:`asyncio.StreamWriter`.
<23> """
<24>
<25> loop = asyncio.get_event_loop()
<26>
<27> _, protocol = await loop.create_datagram_endpoint(
<28> lambda: QuicServer(
<29> alpn_protocols=alpn</s>
|
===========below chunk 0===========
<s> certificate: Any,
private_key: Any,
alpn_protocols: Optional[List[str]] = None,
connection_handler: QuicConnectionHandler = None,
stream_handler: QuicStreamHandler = None,
secrets_log_file: Optional[TextIO] = None,
session_ticket_fetcher: Optional[SessionTicketFetcher] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stateless_retry: bool = False,
) -> None:
# offset: 1
certificate=certificate,
connection_handler=connection_handler,
private_key=private_key,
secrets_log_file=secrets_log_file,
session_ticket_fetcher=session_ticket_fetcher,
session_ticket_handler=session_ticket_handler,
stateless_retry=stateless_retry,
stream_handler=stream_handler,
),
local_addr=(host, port),
)
===========unchanged ref 0===========
at: _asyncio
get_event_loop()
at: aioquic.configuration
QuicConfiguration(alpn_protocols: Optional[List[str]]=None, certificate: Any=None, idle_timeout: float=60.0, is_client: bool=True, private_key: Any=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, supported_versions: List[QuicProtocolVersion]=field(
default_factory=lambda: [
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
))
at: aioquic.server
QuicServer(*, configuration: QuicConfiguration, connection_handler: Optional[QuicConnectionHandler]=None, session_ticket_fetcher: Optional[SessionTicketFetcher]=None, session_ticket_handler: Optional[SessionTicketHandler]=None, stateless_retry: bool=False, stream_handler: Optional[QuicStreamHandler]=None)
at: asyncio.events
get_event_loop() -> AbstractEventLoop
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
===========changed ref 0===========
+ # module: aioquic.configuration
+ @dataclass
+ class QuicConfiguration:
+ alpn_protocols: Optional[List[str]] = None
+ certificate: Any = None
+ idle_timeout: float = 60.0
+ is_client: bool = True
+ private_key: Any = None
+ secrets_log_file: TextIO = None
+ server_name: Optional[str] = None
+ session_ticket: Optional[tls.SessionTicket] = None
+ supported_versions: List[QuicProtocolVersion] = field(
+ default_factory=lambda: [
+ QuicProtocolVersion.DRAFT_19,
+ QuicProtocolVersion.DRAFT_20,
+ ]
+ )
+
===========changed ref 1===========
<s> None,
+ configuration: QuicConfiguration,
connection_handler: Optional[QuicConnectionHandler] = None,
- idle_timeout: Optional[float] = None,
- secrets_log_file: Optional[TextIO] = None,
session_ticket_fetcher: Optional[SessionTicketFetcher] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stateless_retry: bool = False,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
- self._alpn_protocols = alpn_protocols
- self._certificate = certificate
+ self._configuration = configuration
self._connections: Dict[bytes, QuicConnection] = {}
- self._idle_timeout = idle_timeout
- self._private_key = private_key
- self._secrets_log_file = secrets_log_file
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
self._transport: Optional[asyncio.DatagramTransport] = None
if connection_handler is not None:
self._connection_handler = connection_handler
else:
self._connection_handler = lambda c: None
self._stream_handler = stream_handler
if stateless_retry:
self._retry_key = rsa.generate_private_key(
public_exponent=65537, key_size=1024, backend=default_backend()
)
else:
self._retry_key = None
===========changed ref 2===========
# module: aioquic.server
class QuicServer(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
data = cast(bytes, data)
buf = Buffer(data=data)
header = pull_quic_header(buf, host_cid_length=8)
# version negotiation
if (
header.version is not None
+ and header.version not in self._configuration.supported_versions
- 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=self._configuration.supported_versions,
- supported_versions=QuicConnection.supported_versions,
),
addr,
)
return
connection = self._connections.get(header.destination_cid, None)
original_connection_id: Optional[bytes] = None
if connection is None and header.packet_type == PACKET_TYPE_INITIAL:
# stateless retry
if self._retry_key is not None:
if not header.token:
retry_message = encode_address(addr) + b"|" + header.destination_cid
retry_token = self._retry_key.public_key().encrypt(
retry_message,
padding.OAEP(
mgf=padding.MGF1(hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None,
),
)
self._transport.sendto(
encode_quic_retry(
version=header.version,
source_cid=os.urandom(8),
destination_cid=header.source_cid,
original_destination_cid=header.destination_cid,
retry_token=retry_token,
),
addr,
)
return
else:
try:
retry_message = self._retry</s>
|
tests.test_connection/create_standalone_client
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<0>:<add> client = QuicConnection(configuration=QuicConfiguration(is_client=True))
<del> client = QuicConnection(is_client=True)
|
# module: tests.test_connection
def create_standalone_client():
<0> client = QuicConnection(is_client=True)
<1> client_transport = FakeTransport(CLIENT_ADDR, loss=0)
<2>
<3> # kick-off handshake
<4> client.connection_made(client_transport)
<5> client.connect(SERVER_ADDR)
<6>
<7> return client, client_transport
<8>
|
===========unchanged ref 0===========
at: aioquic.configuration
QuicConfiguration(alpn_protocols: Optional[List[str]]=None, certificate: Any=None, idle_timeout: float=60.0, is_client: bool=True, private_key: Any=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, supported_versions: List[QuicProtocolVersion]=field(
default_factory=lambda: [
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
))
at: aioquic.configuration.QuicConfiguration
alpn_protocols: Optional[List[str]] = None
certificate: Any = None
idle_timeout: float = 60.0
is_client: bool = True
private_key: Any = None
secrets_log_file: TextIO = None
server_name: Optional[str] = None
session_ticket: Optional[tls.SessionTicket] = None
supported_versions: List[QuicProtocolVersion] = field(
default_factory=lambda: [
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
)
at: aioquic.connection
QuicConnection(*, configuration: QuicConfiguration, original_connection_id: Optional[bytes]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
connect(addr: NetworkAddress, protocol_version: Optional[int]=None) -> None
connection_made(transport: asyncio.BaseTransport) -> None
at: tests.test_connection
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
FakeTransport(local_addr, loss=0)
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
"""
A QUIC connection.
"""
- supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
-
===========changed ref 1===========
+ # module: aioquic.configuration
+ @dataclass
+ class QuicConfiguration:
+ alpn_protocols: Optional[List[str]] = None
+ certificate: Any = None
+ idle_timeout: float = 60.0
+ is_client: bool = True
+ private_key: Any = None
+ secrets_log_file: TextIO = None
+ server_name: Optional[str] = None
+ session_ticket: Optional[tls.SessionTicket] = None
+ supported_versions: List[QuicProtocolVersion] = field(
+ default_factory=lambda: [
+ QuicProtocolVersion.DRAFT_19,
+ QuicProtocolVersion.DRAFT_20,
+ ]
+ )
+
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def connect(
self, addr: NetworkAddress, protocol_version: Optional[int] = None
) -> None:
"""
Initiate the TLS handshake.
This method can only be called for clients and a single time.
"""
assert (
+ self._is_client and not self._connect_called
- self.is_client and not self._connect_called
), "connect() can only be called for clients and a single time"
self._connect_called = True
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
if protocol_version is not None:
self._version = protocol_version
else:
+ self._version = max(self._configuration.supported_versions)
- self._version = max(self.supported_versions)
self._connect()
===========changed ref 3===========
+ # module: aioquic.configuration
+
+
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_send(self, stream_id: int) -> bool:
return stream_is_client_initiated(
stream_id
+ ) == self._is_client or not stream_is_unidirectional(stream_id)
- ) == self.is_client or not stream_is_unidirectional(stream_id)
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_receive(self, stream_id: int) -> bool:
return stream_is_client_initiated(
stream_id
+ ) != self._is_client or not stream_is_unidirectional(stream_id)
- ) != self.is_client or not stream_is_unidirectional(stream_id)
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _connect(self) -> None:
"""
Start the client handshake.
"""
+ assert self._is_client
- assert self.is_client
+ self._close_at = self._loop.time() + self._configuration.idle_timeout
- self._close_at = self._loop.time() + self._local_idle_timeout
self._initialize(self._peer_cid)
self.tls.handle_message(b"", self._crypto_buffers)
self._push_crypto_data()
self._send_pending()
===========changed ref 7===========
<s> None,
+ configuration: QuicConfiguration,
connection_handler: Optional[QuicConnectionHandler] = None,
- idle_timeout: Optional[float] = None,
- secrets_log_file: Optional[TextIO] = None,
session_ticket_fetcher: Optional[SessionTicketFetcher] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stateless_retry: bool = False,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
- self._alpn_protocols = alpn_protocols
- self._certificate = certificate
+ self._configuration = configuration
self._connections: Dict[bytes, QuicConnection] = {}
- self._idle_timeout = idle_timeout
- self._private_key = private_key
- self._secrets_log_file = secrets_log_file
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
self._transport: Optional[asyncio.DatagramTransport] = None
if connection_handler is not None:
self._connection_handler = connection_handler
else:
self._connection_handler = lambda c: None
self._stream_handler = stream_handler
if stateless_retry:
self._retry_key = rsa.generate_private_key(
public_exponent=65537, key_size=1024, backend=default_backend()
)
else:
self._retry_key = None
|
tests.test_connection/client_and_server
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<0>:<add> client = QuicConnection(
<add> configuration=QuicConfiguration(is_client=True, **client_options)
<del> client = QuicConnection(is_client=True, **client_options)
<1>:<add> )
<4>:<add> configuration=QuicConfiguration(
<add> is_client=False,
<del> is_client=False,
<5>:<add> certificate=SERVER_CERTIFICATE,
<del> certificate=SERVER_CERTIFICATE,
<6>:<add> private_key=SERVER_PRIVATE_KEY,
<del> private_key=SERVER_PRIVATE_KEY,
<7>:<add> **server_options
<del> **server_options
<8>:<add> ),
<add> stream_handler=server_stream_handler,
|
# module: tests.test_connection
@contextlib.contextmanager
def client_and_server(
client_options={},
client_patch=lambda x: None,
server_options={},
server_patch=lambda x: None,
+ server_stream_handler=None,
transport_options={},
):
<0> client = QuicConnection(is_client=True, **client_options)
<1> client_patch(client)
<2>
<3> server = QuicConnection(
<4> is_client=False,
<5> certificate=SERVER_CERTIFICATE,
<6> private_key=SERVER_PRIVATE_KEY,
<7> **server_options
<8> )
<9> server_patch(server)
<10>
<11> # perform handshake
<12> create_transport(client, server, **transport_options)
<13>
<14> yield client, server
<15>
<16> # close
<17> client.close()
<18> server.close()
<19>
|
===========unchanged ref 0===========
at: aioquic.configuration
QuicConfiguration(alpn_protocols: Optional[List[str]]=None, certificate: Any=None, idle_timeout: float=60.0, is_client: bool=True, private_key: Any=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, supported_versions: List[QuicProtocolVersion]=field(
default_factory=lambda: [
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
))
at: aioquic.connection
QuicConnection(*, configuration: QuicConfiguration, original_connection_id: Optional[bytes]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: contextlib
contextmanager(func: Callable[..., Iterator[_T]]) -> Callable[..., _GeneratorContextManager[_T]]
at: tests.utils
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()
)
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
"""
A QUIC connection.
"""
- supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
-
===========changed ref 1===========
+ # module: aioquic.configuration
+ @dataclass
+ class QuicConfiguration:
+ alpn_protocols: Optional[List[str]] = None
+ certificate: Any = None
+ idle_timeout: float = 60.0
+ is_client: bool = True
+ private_key: Any = None
+ secrets_log_file: TextIO = None
+ server_name: Optional[str] = None
+ session_ticket: Optional[tls.SessionTicket] = None
+ supported_versions: List[QuicProtocolVersion] = field(
+ default_factory=lambda: [
+ QuicProtocolVersion.DRAFT_19,
+ QuicProtocolVersion.DRAFT_20,
+ ]
+ )
+
===========changed ref 2===========
# module: tests.test_connection
def create_standalone_client():
+ client = QuicConnection(configuration=QuicConfiguration(is_client=True))
- client = QuicConnection(is_client=True)
client_transport = FakeTransport(CLIENT_ADDR, loss=0)
# kick-off handshake
client.connection_made(client_transport)
client.connect(SERVER_ADDR)
return client, client_transport
===========changed ref 3===========
+ # module: aioquic.configuration
+
+
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_send(self, stream_id: int) -> bool:
return stream_is_client_initiated(
stream_id
+ ) == self._is_client or not stream_is_unidirectional(stream_id)
- ) == self.is_client or not stream_is_unidirectional(stream_id)
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_receive(self, stream_id: int) -> bool:
return stream_is_client_initiated(
stream_id
+ ) != self._is_client or not stream_is_unidirectional(stream_id)
- ) != self.is_client or not stream_is_unidirectional(stream_id)
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _connect(self) -> None:
"""
Start the client handshake.
"""
+ assert self._is_client
- assert self.is_client
+ self._close_at = self._loop.time() + self._configuration.idle_timeout
- self._close_at = self._loop.time() + self._local_idle_timeout
self._initialize(self._peer_cid)
self.tls.handle_message(b"", self._crypto_buffers)
self._push_crypto_data()
self._send_pending()
===========changed ref 7===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def connect(
self, addr: NetworkAddress, protocol_version: Optional[int] = None
) -> None:
"""
Initiate the TLS handshake.
This method can only be called for clients and a single time.
"""
assert (
+ self._is_client and not self._connect_called
- self.is_client and not self._connect_called
), "connect() can only be called for clients and a single time"
self._connect_called = True
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
if protocol_version is not None:
self._version = protocol_version
else:
+ self._version = max(self._configuration.supported_versions)
- self._version = max(self.supported_versions)
self._connect()
===========changed ref 8===========
<s> None,
+ configuration: QuicConfiguration,
connection_handler: Optional[QuicConnectionHandler] = None,
- idle_timeout: Optional[float] = None,
- secrets_log_file: Optional[TextIO] = None,
session_ticket_fetcher: Optional[SessionTicketFetcher] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stateless_retry: bool = False,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
- self._alpn_protocols = alpn_protocols
- self._certificate = certificate
+ self._configuration = configuration
self._connections: Dict[bytes, QuicConnection] = {}
- self._idle_timeout = idle_timeout
- self._private_key = private_key
- self._secrets_log_file = secrets_log_file
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
self._transport: Optional[asyncio.DatagramTransport] = None
if connection_handler is not None:
self._connection_handler = connection_handler
else:
self._connection_handler = lambda c: None
self._stream_handler = stream_handler
if stateless_retry:
self._retry_key = rsa.generate_private_key(
public_exponent=65537, key_size=1024, backend=default_backend()
)
else:
self._retry_key = None
|
tests.test_connection/QuicConnectionTest._test_connect_with_version
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<18>:<add> server_options={"supported_versions": server_versions},
<del> server_options={
<19>:<add> server_stream_handler=lambda reader, writer: asyncio.ensure_future(
<del> "stream_handler": lambda reader, writer: asyncio.ensure_future(
<20>:<add> serve_request(reader, writer)
<del> serve_request(reader, writer)
<21>:<del> ),
<22>:<del> "supported_versions": server_versions,
<23>:<add> ),
<del> },
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
<0> async def serve_request(reader, writer):
<1> # check request
<2> request = await reader.read(1024)
<3> self.assertEqual(request, b"ping")
<4>
<5> # send response
<6> writer.write(b"pong")
<7>
<8> # receives EOF
<9> request = await reader.read()
<10> self.assertEqual(request, b"")
<11>
<12> # sends EOF
<13> writer.write(b"done")
<14> writer.write_eof()
<15>
<16> with client_and_server(
<17> client_options={"supported_versions": client_versions},
<18> server_options={
<19> "stream_handler": lambda reader, writer: asyncio.ensure_future(
<20> serve_request(reader, writer)
<21> ),
<22> "supported_versions": server_versions,
<23> },
<24> ) as (client, server):
<25> run(asyncio.gather(client.wait_connected(), server.wait_connected()))
<26>
<27> # check each endpoint has available connection IDs for the peer
<28> self.assertEqual(
<29> sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<30> )
<31>
<32> # clients sends data over stream
<33> client_reader, client_writer = run(client.create_stream())
<34> client_writer.write(b"ping")
<35>
<36> # client receives pong
<37> self.assertEqual(run(client_reader.read(1024)), b"pong")
<38>
<39> # client writes EOF
<40> client_writer.write_eof()
<41>
<42> # client receives EOF
<43> self.assertEqual(run(client_reader.read()), b"done")
<44>
|
===========unchanged ref 0===========
at: asyncio.tasks
ensure_future(coro_or_future: _FutureT[_T], *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
===========unchanged ref 1===========
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: bool=...) -> Future[
Tuple[Union[_T1, BaseException], Union[_T2, BaseException], Union[_T3, BaseException], Union[_T4, BaseException]]
]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[Tuple[_T1, _T2, _T3, _T4]]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[Tuple[_T1, _T2]]
gather(coro_or_future1: _FutureT[Any], coro_or_future2: _FutureT[Any], coro_or_future3: _FutureT[Any], coro_or_future4: _FutureT[Any], coro_or_future5: _FutureT[Any], coro_or_future6: _FutureT[Any], *coros_or_futures: _FutureT[Any], loop: Optional[AbstractEventLoop]=..., return_exceptions: bool=...) -> Future[List[Any]]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[Tuple[_T1,</s>
===========unchanged ref 2===========
at: tests.test_connection
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, server_stream_handler=None, transport_options={})
at: tests.utils
run(coro)
at: unittest.case
TestCase(methodName: str=...)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
@contextlib.contextmanager
def client_and_server(
client_options={},
client_patch=lambda x: None,
server_options={},
server_patch=lambda x: None,
+ server_stream_handler=None,
transport_options={},
):
+ client = QuicConnection(
+ configuration=QuicConfiguration(is_client=True, **client_options)
- client = QuicConnection(is_client=True, **client_options)
+ )
client_patch(client)
server = QuicConnection(
+ configuration=QuicConfiguration(
+ is_client=False,
- is_client=False,
+ certificate=SERVER_CERTIFICATE,
- certificate=SERVER_CERTIFICATE,
+ private_key=SERVER_PRIVATE_KEY,
- private_key=SERVER_PRIVATE_KEY,
+ **server_options
- **server_options
+ ),
+ stream_handler=server_stream_handler,
)
server_patch(server)
# perform handshake
create_transport(client, server, **transport_options)
yield client, server
# close
client.close()
server.close()
===========changed ref 1===========
# module: tests.test_connection
def create_standalone_client():
+ client = QuicConnection(configuration=QuicConfiguration(is_client=True))
- client = QuicConnection(is_client=True)
client_transport = FakeTransport(CLIENT_ADDR, loss=0)
# kick-off handshake
client.connection_made(client_transport)
client.connect(SERVER_ADDR)
return client, client_transport
===========changed ref 2===========
+ # module: aioquic.configuration
+
+
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
"""
A QUIC connection.
"""
- supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
-
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_send(self, stream_id: int) -> bool:
return stream_is_client_initiated(
stream_id
+ ) == self._is_client or not stream_is_unidirectional(stream_id)
- ) == self.is_client or not stream_is_unidirectional(stream_id)
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_receive(self, stream_id: int) -> bool:
return stream_is_client_initiated(
stream_id
+ ) != self._is_client or not stream_is_unidirectional(stream_id)
- ) != self.is_client or not stream_is_unidirectional(stream_id)
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _connect(self) -> None:
"""
Start the client handshake.
"""
+ assert self._is_client
- assert self.is_client
+ self._close_at = self._loop.time() + self._configuration.idle_timeout
- self._close_at = self._loop.time() + self._local_idle_timeout
self._initialize(self._peer_cid)
self.tls.handle_message(b"", self._crypto_buffers)
self._push_crypto_data()
self._send_pending()
===========changed ref 7===========
+ # module: aioquic.configuration
+ @dataclass
+ class QuicConfiguration:
+ alpn_protocols: Optional[List[str]] = None
+ certificate: Any = None
+ idle_timeout: float = 60.0
+ is_client: bool = True
+ private_key: Any = None
+ secrets_log_file: TextIO = None
+ server_name: Optional[str] = None
+ session_ticket: Optional[tls.SessionTicket] = None
+ supported_versions: List[QuicProtocolVersion] = field(
+ default_factory=lambda: [
+ QuicProtocolVersion.DRAFT_19,
+ QuicProtocolVersion.DRAFT_20,
+ ]
+ )
+
===========changed ref 8===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def connect(
self, addr: NetworkAddress, protocol_version: Optional[int] = None
) -> None:
"""
Initiate the TLS handshake.
This method can only be called for clients and a single time.
"""
assert (
+ self._is_client and not self._connect_called
- self.is_client and not self._connect_called
), "connect() can only be called for clients and a single time"
self._connect_called = True
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
if protocol_version is not None:
self._version = protocol_version
else:
+ self._version = max(self._configuration.supported_versions)
- self._version = max(self.supported_versions)
self._connect()
|
tests.test_connection/QuicConnectionTest.test_error_received
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<0>:<add> client, _ = create_standalone_client()
<del> client = QuicConnection(is_client=True)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_error_received(self):
<0> client = QuicConnection(is_client=True)
<1> client.error_received(OSError("foo"))
<2>
|
===========unchanged ref 0===========
at: tests.test_connection
SERVER_ADDR = ("2.3.4.5", 4433)
===========changed ref 0===========
# module: tests.test_connection
def create_standalone_client():
+ client = QuicConnection(configuration=QuicConfiguration(is_client=True))
- client = QuicConnection(is_client=True)
client_transport = FakeTransport(CLIENT_ADDR, loss=0)
# kick-off handshake
client.connection_made(client_transport)
client.connect(SERVER_ADDR)
return client, client_transport
===========changed ref 1===========
# module: tests.test_connection
@contextlib.contextmanager
def client_and_server(
client_options={},
client_patch=lambda x: None,
server_options={},
server_patch=lambda x: None,
+ server_stream_handler=None,
transport_options={},
):
+ client = QuicConnection(
+ configuration=QuicConfiguration(is_client=True, **client_options)
- client = QuicConnection(is_client=True, **client_options)
+ )
client_patch(client)
server = QuicConnection(
+ configuration=QuicConfiguration(
+ is_client=False,
- is_client=False,
+ certificate=SERVER_CERTIFICATE,
- certificate=SERVER_CERTIFICATE,
+ private_key=SERVER_PRIVATE_KEY,
- private_key=SERVER_PRIVATE_KEY,
+ **server_options
- **server_options
+ ),
+ stream_handler=server_stream_handler,
)
server_patch(server)
# perform handshake
create_transport(client, server, **transport_options)
yield client, server
# close
client.close()
server.close()
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
async def serve_request(reader, writer):
# check request
request = await reader.read(1024)
self.assertEqual(request, b"ping")
# send response
writer.write(b"pong")
# receives EOF
request = await reader.read()
self.assertEqual(request, b"")
# sends EOF
writer.write(b"done")
writer.write_eof()
with client_and_server(
client_options={"supported_versions": client_versions},
+ server_options={"supported_versions": server_versions},
- server_options={
+ server_stream_handler=lambda reader, writer: asyncio.ensure_future(
- "stream_handler": lambda reader, writer: asyncio.ensure_future(
+ serve_request(reader, writer)
- serve_request(reader, writer)
- ),
- "supported_versions": server_versions,
+ ),
- },
) as (client, server):
run(asyncio.gather(client.wait_connected(), server.wait_connected()))
# check each endpoint has available connection IDs for the peer
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
# clients sends data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
# client receives pong
self.assertEqual(run(client_reader.read(1024)), b"pong")
# client writes EOF
client_writer.write_eof()
# client receives EOF
self.assertEqual(run(client_reader.read()), b"done")
===========changed ref 3===========
+ # module: aioquic.configuration
+
+
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
"""
A QUIC connection.
"""
- supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
-
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_send(self, stream_id: int) -> bool:
return stream_is_client_initiated(
stream_id
+ ) == self._is_client or not stream_is_unidirectional(stream_id)
- ) == self.is_client or not stream_is_unidirectional(stream_id)
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_receive(self, stream_id: int) -> bool:
return stream_is_client_initiated(
stream_id
+ ) != self._is_client or not stream_is_unidirectional(stream_id)
- ) != self.is_client or not stream_is_unidirectional(stream_id)
===========changed ref 7===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _connect(self) -> None:
"""
Start the client handshake.
"""
+ assert self._is_client
- assert self.is_client
+ self._close_at = self._loop.time() + self._configuration.idle_timeout
- self._close_at = self._loop.time() + self._local_idle_timeout
self._initialize(self._peer_cid)
self.tls.handle_message(b"", self._crypto_buffers)
self._push_crypto_data()
self._send_pending()
===========changed ref 8===========
+ # module: aioquic.configuration
+ @dataclass
+ class QuicConfiguration:
+ alpn_protocols: Optional[List[str]] = None
+ certificate: Any = None
+ idle_timeout: float = 60.0
+ is_client: bool = True
+ private_key: Any = None
+ secrets_log_file: TextIO = None
+ server_name: Optional[str] = None
+ session_ticket: Optional[tls.SessionTicket] = None
+ supported_versions: List[QuicProtocolVersion] = field(
+ default_factory=lambda: [
+ QuicProtocolVersion.DRAFT_19,
+ QuicProtocolVersion.DRAFT_20,
+ ]
+ )
+
===========changed ref 9===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def connect(
self, addr: NetworkAddress, protocol_version: Optional[int] = None
) -> None:
"""
Initiate the TLS handshake.
This method can only be called for clients and a single time.
"""
assert (
+ self._is_client and not self._connect_called
- self.is_client and not self._connect_called
), "connect() can only be called for clients and a single time"
self._connect_called = True
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
if protocol_version is not None:
self._version = protocol_version
else:
+ self._version = max(self._configuration.supported_versions)
- self._version = max(self.supported_versions)
self._connect()
|
tests.test_connection/QuicConnectionTest.test_with_packet_loss_during_app_data
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<16>:<del> server_options={
<17>:<add> server_stream_handler=lambda reader, writer: asyncio.ensure_future(
<del> "stream_handler": lambda reader, writer: asyncio.ensure_future(
<18>:<add> serve_request(reader, writer)
<del> serve_request(reader, writer)
<19>:<del> )
<20>:<add> )
<del> }
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_with_packet_loss_during_app_data(self):
<0> """
<1> This test ensures stream data is successfully sent and received
<2> in the presence of packet loss (randomized 25% in each direction).
<3>
<4> This tests *only* exercises loss in the 1-RTT epoch, no loss occurs
<5> during the handshake phase.
<6> """
<7> client_data = b"C" * 100000
<8> server_data = b"S" * 100000
<9>
<10> async def serve_request(reader, writer):
<11> self.assertEqual(await reader.read(), client_data)
<12> writer.write(server_data)
<13> writer.write_eof()
<14>
<15> with client_and_server(
<16> server_options={
<17> "stream_handler": lambda reader, writer: asyncio.ensure_future(
<18> serve_request(reader, writer)
<19> )
<20> }
<21> ) as (client, server):
<22> # complete handshake
<23> run(client.wait_connected())
<24>
<25> # cause packet loss in both directions
<26> client._transport.loss = 0.25
<27> server._transport.loss = 0.25
<28>
<29> # create stream and send data
<30> client_reader, client_writer = run(client.create_stream())
<31> client_writer.write(client_data)
<32> client_writer.write_eof()
<33>
<34> # check response
<35> self.assertEqual(run(client_reader.read()), server_data)
<36>
|
===========unchanged ref 0===========
at: asyncio.tasks
ensure_future(coro_or_future: _FutureT[_T], *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: tests.test_connection
SERVER_ADDR = ("2.3.4.5", 4433)
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, server_stream_handler=None, transport_options={})
at: tests.test_connection.FakeTransport.sendto
self.sent += 1
at: tests.test_connection.QuicConnectionTest.test_version_negotiation_ok
client, client_transport = create_standalone_client()
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
@contextlib.contextmanager
def client_and_server(
client_options={},
client_patch=lambda x: None,
server_options={},
server_patch=lambda x: None,
+ server_stream_handler=None,
transport_options={},
):
+ client = QuicConnection(
+ configuration=QuicConfiguration(is_client=True, **client_options)
- client = QuicConnection(is_client=True, **client_options)
+ )
client_patch(client)
server = QuicConnection(
+ configuration=QuicConfiguration(
+ is_client=False,
- is_client=False,
+ certificate=SERVER_CERTIFICATE,
- certificate=SERVER_CERTIFICATE,
+ private_key=SERVER_PRIVATE_KEY,
- private_key=SERVER_PRIVATE_KEY,
+ **server_options
- **server_options
+ ),
+ stream_handler=server_stream_handler,
)
server_patch(server)
# perform handshake
create_transport(client, server, **transport_options)
yield client, server
# close
client.close()
server.close()
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_error_received(self):
+ client, _ = create_standalone_client()
- client = QuicConnection(is_client=True)
client.error_received(OSError("foo"))
===========changed ref 2===========
# module: tests.test_connection
def create_standalone_client():
+ client = QuicConnection(configuration=QuicConfiguration(is_client=True))
- client = QuicConnection(is_client=True)
client_transport = FakeTransport(CLIENT_ADDR, loss=0)
# kick-off handshake
client.connection_made(client_transport)
client.connect(SERVER_ADDR)
return client, client_transport
===========changed ref 3===========
+ # module: aioquic.configuration
+
+
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
"""
A QUIC connection.
"""
- supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
-
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_send(self, stream_id: int) -> bool:
return stream_is_client_initiated(
stream_id
+ ) == self._is_client or not stream_is_unidirectional(stream_id)
- ) == self.is_client or not stream_is_unidirectional(stream_id)
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_receive(self, stream_id: int) -> bool:
return stream_is_client_initiated(
stream_id
+ ) != self._is_client or not stream_is_unidirectional(stream_id)
- ) != self.is_client or not stream_is_unidirectional(stream_id)
===========changed ref 7===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _connect(self) -> None:
"""
Start the client handshake.
"""
+ assert self._is_client
- assert self.is_client
+ self._close_at = self._loop.time() + self._configuration.idle_timeout
- self._close_at = self._loop.time() + self._local_idle_timeout
self._initialize(self._peer_cid)
self.tls.handle_message(b"", self._crypto_buffers)
self._push_crypto_data()
self._send_pending()
===========changed ref 8===========
+ # module: aioquic.configuration
+ @dataclass
+ class QuicConfiguration:
+ alpn_protocols: Optional[List[str]] = None
+ certificate: Any = None
+ idle_timeout: float = 60.0
+ is_client: bool = True
+ private_key: Any = None
+ secrets_log_file: TextIO = None
+ server_name: Optional[str] = None
+ session_ticket: Optional[tls.SessionTicket] = None
+ supported_versions: List[QuicProtocolVersion] = field(
+ default_factory=lambda: [
+ QuicProtocolVersion.DRAFT_19,
+ QuicProtocolVersion.DRAFT_20,
+ ]
+ )
+
===========changed ref 9===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
async def serve_request(reader, writer):
# check request
request = await reader.read(1024)
self.assertEqual(request, b"ping")
# send response
writer.write(b"pong")
# receives EOF
request = await reader.read()
self.assertEqual(request, b"")
# sends EOF
writer.write(b"done")
writer.write_eof()
with client_and_server(
client_options={"supported_versions": client_versions},
+ server_options={"supported_versions": server_versions},
- server_options={
+ server_stream_handler=lambda reader, writer: asyncio.ensure_future(
- "stream_handler": lambda reader, writer: asyncio.ensure_future(
+ serve_request(reader, writer)
- serve_request(reader, writer)
- ),
- "supported_versions": server_versions,
+ ),
- },
) as (client, server):
run(asyncio.gather(client.wait_connected(), server.wait_connected()))
# check each endpoint has available connection IDs for the peer
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
# clients sends data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
# client receives pong
self.assertEqual(run(client_reader.read(1024)), b"pong")
# client writes EOF
client_writer.write_eof()
# client receives EOF
self.assertEqual(run(client_reader.read()), b"done")
|
tests.test_connection/QuicConnectionTest.test_with_packet_loss_during_handshake
|
Modified
|
aiortc~aioquic
|
e886aedab7cf04177e48e76db6f0d09b67068ea7
|
[connection] add a QuicConfiguration object
|
<13>:<del> server_options={
<14>:<add> server_stream_handler=lambda reader, writer: asyncio.ensure_future(
<del> "stream_handler": lambda reader, writer: asyncio.ensure_future(
<15>:<add> serve_request(reader, writer)
<del> serve_request(reader, writer)
<16>:<del> )
<17>:<add> ),
<del> },
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_with_packet_loss_during_handshake(self):
<0> """
<1> This test ensures handshake success and stream data is successfully sent
<2> and received in the presence of packet loss (randomized 25% in each direction).
<3> """
<4> client_data = b"C" * 50000
<5> server_data = b"S" * 50000
<6>
<7> async def serve_request(reader, writer):
<8> self.assertEqual(await reader.read(), client_data)
<9> writer.write(server_data)
<10> writer.write_eof()
<11>
<12> with client_and_server(
<13> server_options={
<14> "stream_handler": lambda reader, writer: asyncio.ensure_future(
<15> serve_request(reader, writer)
<16> )
<17> },
<18> transport_options={"loss": 0.25},
<19> ) as (client, server):
<20> # complete handshake
<21> run(asyncio.gather(client.wait_connected(), server.wait_connected()))
<22>
<23> # create stream and send data
<24> client_reader, client_writer = run(client.create_stream())
<25> client_writer.write(client_data)
<26> client_writer.write_eof()
<27>
<28> # check response
<29> self.assertEqual(run(client_reader.read()), server_data)
<30>
|
===========unchanged ref 0===========
at: asyncio.tasks
ensure_future(coro_or_future: _FutureT[_T], *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
===========unchanged ref 1===========
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: bool=...) -> Future[
Tuple[Union[_T1, BaseException], Union[_T2, BaseException], Union[_T3, BaseException], Union[_T4, BaseException]]
]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[Tuple[_T1, _T2, _T3, _T4]]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[Tuple[_T1, _T2]]
gather(coro_or_future1: _FutureT[Any], coro_or_future2: _FutureT[Any], coro_or_future3: _FutureT[Any], coro_or_future4: _FutureT[Any], coro_or_future5: _FutureT[Any], coro_or_future6: _FutureT[Any], *coros_or_futures: _FutureT[Any], loop: Optional[AbstractEventLoop]=..., return_exceptions: bool=...) -> Future[List[Any]]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[Tuple[_T1,</s>
===========unchanged ref 2===========
at: tests.test_connection
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, server_stream_handler=None, transport_options={})
at: tests.test_connection.QuicConnectionTest.test_with_packet_loss_during_app_data
server_data = b"S" * 100000
client_reader, client_writer = run(client.create_stream())
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
@contextlib.contextmanager
def client_and_server(
client_options={},
client_patch=lambda x: None,
server_options={},
server_patch=lambda x: None,
+ server_stream_handler=None,
transport_options={},
):
+ client = QuicConnection(
+ configuration=QuicConfiguration(is_client=True, **client_options)
- client = QuicConnection(is_client=True, **client_options)
+ )
client_patch(client)
server = QuicConnection(
+ configuration=QuicConfiguration(
+ is_client=False,
- is_client=False,
+ certificate=SERVER_CERTIFICATE,
- certificate=SERVER_CERTIFICATE,
+ private_key=SERVER_PRIVATE_KEY,
- private_key=SERVER_PRIVATE_KEY,
+ **server_options
- **server_options
+ ),
+ stream_handler=server_stream_handler,
)
server_patch(server)
# perform handshake
create_transport(client, server, **transport_options)
yield client, server
# close
client.close()
server.close()
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_with_packet_loss_during_app_data(self):
"""
This test ensures stream data is successfully sent and received
in the presence of packet loss (randomized 25% in each direction).
This tests *only* exercises loss in the 1-RTT epoch, no loss occurs
during the handshake phase.
"""
client_data = b"C" * 100000
server_data = b"S" * 100000
async def serve_request(reader, writer):
self.assertEqual(await reader.read(), client_data)
writer.write(server_data)
writer.write_eof()
with client_and_server(
- server_options={
+ server_stream_handler=lambda reader, writer: asyncio.ensure_future(
- "stream_handler": lambda reader, writer: asyncio.ensure_future(
+ serve_request(reader, writer)
- serve_request(reader, writer)
- )
+ )
- }
) as (client, server):
# complete handshake
run(client.wait_connected())
# cause packet loss in both directions
client._transport.loss = 0.25
server._transport.loss = 0.25
# create stream and send data
client_reader, client_writer = run(client.create_stream())
client_writer.write(client_data)
client_writer.write_eof()
# check response
self.assertEqual(run(client_reader.read()), server_data)
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_error_received(self):
+ client, _ = create_standalone_client()
- client = QuicConnection(is_client=True)
client.error_received(OSError("foo"))
===========changed ref 3===========
# module: tests.test_connection
def create_standalone_client():
+ client = QuicConnection(configuration=QuicConfiguration(is_client=True))
- client = QuicConnection(is_client=True)
client_transport = FakeTransport(CLIENT_ADDR, loss=0)
# kick-off handshake
client.connection_made(client_transport)
client.connect(SERVER_ADDR)
return client, client_transport
===========changed ref 4===========
+ # module: aioquic.configuration
+
+
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
"""
A QUIC connection.
"""
- supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
-
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_send(self, stream_id: int) -> bool:
return stream_is_client_initiated(
stream_id
+ ) == self._is_client or not stream_is_unidirectional(stream_id)
- ) == self.is_client or not stream_is_unidirectional(stream_id)
===========changed ref 7===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _stream_can_receive(self, stream_id: int) -> bool:
return stream_is_client_initiated(
stream_id
+ ) != self._is_client or not stream_is_unidirectional(stream_id)
- ) != self.is_client or not stream_is_unidirectional(stream_id)
|
aioquic.stream/QuicStream.__init__
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<5>:<del>
<6>:<del> if stream_id is not None:
<7>:<del> self.reader = asyncio.StreamReader()
<8>:<del> self.writer = asyncio.StreamWriter(self, None, self.reader, None)
<9>:<del> else:
<10>:<del> self.reader = None
<11>:<del> self.writer = None
|
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
def __init__(
self,
stream_id: Optional[int] = None,
connection: Optional[Any] = None,
max_stream_data_local: int = 0,
max_stream_data_remote: int = 0,
) -> None:
<0> self._connection = connection
<1> self.max_stream_data_local = max_stream_data_local
<2> self.max_stream_data_local_sent = max_stream_data_local
<3> self.max_stream_data_remote = max_stream_data_remote
<4> self.send_buffer_is_empty = True
<5>
<6> if stream_id is not None:
<7> self.reader = asyncio.StreamReader()
<8> self.writer = asyncio.StreamWriter(self, None, self.reader, None)
<9> else:
<10> self.reader = None
<11> self.writer = None
<12>
<13> self._recv_buffer = bytearray()
<14> self._recv_buffer_fin: Optional[int] = None
<15> self._recv_buffer_start = 0 # the offset for the start of the buffer
<16> self._recv_highest = 0 # the highest offset ever seen
<17> self._recv_ranges = RangeSet()
<18>
<19> self._send_acked = RangeSet()
<20> self._send_buffer = bytearray()
<21> self._send_buffer_fin: Optional[int] = None
<22> self._send_buffer_start = 0 # the offset for the start of the buffer
<23> self._send_buffer_stop = 0 # the offset for the stop of the buffer
<24> self._send_highest = 0
<25> self._send_pending = RangeSet()
<26> self._send_pending_eof = False
<27>
<28> self.__stream_id = stream_id
<29>
|
===========unchanged ref 0===========
at: aioquic.rangeset
RangeSet(ranges: Iterable[range]=[])
at: aioquic.stream.QuicStream.add_frame
self._recv_highest = frame_end
self._recv_buffer += bytearray(gap)
self._recv_buffer_fin = frame_end
at: aioquic.stream.QuicStream.get_frame
self._send_pending_eof = False
self.send_buffer_is_empty = True
self._send_highest = stop
at: aioquic.stream.QuicStream.on_data_delivery
self.send_buffer_is_empty = False
self._send_buffer_start += size
self._send_pending_eof = True
at: aioquic.stream.QuicStream.pull_data
self._recv_buffer = self._recv_buffer[pos:]
self._recv_buffer_start = r.stop
at: aioquic.stream.QuicStream.write
self.send_buffer_is_empty = False
self._send_buffer += data
self._send_buffer_stop += size
at: aioquic.stream.QuicStream.write_eof
self.send_buffer_is_empty = False
self._send_buffer_fin = self._send_buffer_stop
self._send_pending_eof = True
|
aioquic.stream/QuicStream.add_frame
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<34>:<add> if self._connection:
<del> if self.reader:
<36>:<add> self._connection._events.append(
<add> events.StreamDataReceived(
<add> data=data,
<del> if data:
<37>:<del> self.reader.feed_data(data)
<38>:<add> end_stream=(self._recv_buffer_start == self._recv_buffer_fin),
<del> if self._recv_buffer_start == self._recv_buffer_fin:
<39>:<add> stream_id=self.__stream_id,
<add> )
<add> )
<del> self.reader.feed_eof()
|
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
# reader
def add_frame(self, frame: QuicStreamFrame) -> None:
<0> """
<1> Add a frame of received data.
<2> """
<3> pos = frame.offset - self._recv_buffer_start
<4> count = len(frame.data)
<5> frame_end = frame.offset + count
<6>
<7> # we should receive no more data beyond FIN!
<8> if self._recv_buffer_fin is not None and frame_end > self._recv_buffer_fin:
<9> raise Exception("Data received beyond FIN")
<10>
<11> if pos + count > 0:
<12> # frame has been partially consumed
<13> if pos < 0:
<14> count += pos
<15> frame.data = frame.data[-pos:]
<16> frame.offset -= pos
<17> pos = 0
<18>
<19> # marked received
<20> if count:
<21> self._recv_ranges.add(frame.offset, frame_end)
<22> if frame_end > self._recv_highest:
<23> self._recv_highest = frame_end
<24>
<25> # add data
<26> gap = pos - len(self._recv_buffer)
<27> if gap > 0:
<28> self._recv_buffer += bytearray(gap)
<29> self._recv_buffer[pos : pos + count] = frame.data
<30>
<31> if frame.fin:
<32> self._recv_buffer_fin = frame_end
<33>
<34> if self.reader:
<35> data = self.pull_data()
<36> if data:
<37> self.reader.feed_data(data)
<38> if self._recv_buffer_start == self._recv_buffer_fin:
<39> self.reader.feed_eof()
<40>
|
===========unchanged ref 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.__init__
self._connection = connection
self._recv_buffer = bytearray()
self._recv_buffer_fin: Optional[int] = None
self._recv_buffer_start = 0 # the offset for the start of the buffer
self._recv_highest = 0 # the highest offset ever seen
self._recv_ranges = RangeSet()
self.__stream_id = stream_id
at: aioquic.stream.QuicStream.add_frame
frame_end = frame.offset + count
at: aioquic.stream.QuicStream.pull_data
self._recv_buffer = self._recv_buffer[pos:]
self._recv_buffer_start = r.stop
===========changed ref 0===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
- def connection_lost(self, exc: Exception) -> None:
- if self.reader is not None:
- if exc is None:
- self.reader.feed_eof()
- else:
- self.reader.set_exception(exc)
-
===========changed ref 1===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
def __init__(
self,
stream_id: Optional[int] = None,
connection: Optional[Any] = None,
max_stream_data_local: int = 0,
max_stream_data_remote: int = 0,
) -> None:
self._connection = connection
self.max_stream_data_local = max_stream_data_local
self.max_stream_data_local_sent = max_stream_data_local
self.max_stream_data_remote = max_stream_data_remote
self.send_buffer_is_empty = True
-
- if stream_id is not None:
- self.reader = asyncio.StreamReader()
- self.writer = asyncio.StreamWriter(self, None, self.reader, None)
- else:
- self.reader = None
- self.writer = None
self._recv_buffer = bytearray()
self._recv_buffer_fin: Optional[int] = None
self._recv_buffer_start = 0 # the offset for the start of the buffer
self._recv_highest = 0 # the highest offset ever seen
self._recv_ranges = RangeSet()
self._send_acked = RangeSet()
self._send_buffer = bytearray()
self._send_buffer_fin: Optional[int] = None
self._send_buffer_start = 0 # the offset for the start of the buffer
self._send_buffer_stop = 0 # the offset for the stop of the buffer
self._send_highest = 0
self._send_pending = RangeSet()
self._send_pending_eof = False
self.__stream_id = stream_id
|
aioquic.stream/QuicStream.write
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<13>:<del> if self._connection is not None:
<14>:<del> self._connection._send_soon()
|
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
def write(self, data: bytes) -> None:
<0> """
<1> Write some data bytes to the QUIC stream.
<2> """
<3> assert self._send_buffer_fin is None, "cannot call write() after FIN"
<4> size = len(data)
<5>
<6> if size:
<7> self.send_buffer_is_empty = False
<8> self._send_pending.add(
<9> self._send_buffer_stop, self._send_buffer_stop + size
<10> )
<11> self._send_buffer += data
<12> self._send_buffer_stop += size
<13> if self._connection is not None:
<14> self._connection._send_soon()
<15>
|
===========changed ref 0===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
- # asyncio.Transport
-
- def can_write_eof(self) -> bool:
- return True
-
===========changed ref 1===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
- def get_extra_info(self, name: str, default: Any = None) -> Any:
- """
- Get information about the underlying QUIC stream.
- """
- if name == "connection":
- return self._connection
- elif name == "stream_id":
- return self.stream_id
-
===========changed ref 2===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
- def connection_lost(self, exc: Exception) -> None:
- if self.reader is not None:
- if exc is None:
- self.reader.feed_eof()
- else:
- self.reader.set_exception(exc)
-
===========changed ref 3===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
def __init__(
self,
stream_id: Optional[int] = None,
connection: Optional[Any] = None,
max_stream_data_local: int = 0,
max_stream_data_remote: int = 0,
) -> None:
self._connection = connection
self.max_stream_data_local = max_stream_data_local
self.max_stream_data_local_sent = max_stream_data_local
self.max_stream_data_remote = max_stream_data_remote
self.send_buffer_is_empty = True
-
- if stream_id is not None:
- self.reader = asyncio.StreamReader()
- self.writer = asyncio.StreamWriter(self, None, self.reader, None)
- else:
- self.reader = None
- self.writer = None
self._recv_buffer = bytearray()
self._recv_buffer_fin: Optional[int] = None
self._recv_buffer_start = 0 # the offset for the start of the buffer
self._recv_highest = 0 # the highest offset ever seen
self._recv_ranges = RangeSet()
self._send_acked = RangeSet()
self._send_buffer = bytearray()
self._send_buffer_fin: Optional[int] = None
self._send_buffer_start = 0 # the offset for the start of the buffer
self._send_buffer_stop = 0 # the offset for the stop of the buffer
self._send_highest = 0
self._send_pending = RangeSet()
self._send_pending_eof = False
self.__stream_id = stream_id
===========changed ref 4===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
# reader
def add_frame(self, frame: QuicStreamFrame) -> None:
"""
Add a frame of received data.
"""
pos = frame.offset - self._recv_buffer_start
count = len(frame.data)
frame_end = frame.offset + count
# we should receive no more data beyond FIN!
if self._recv_buffer_fin is not None and frame_end > self._recv_buffer_fin:
raise Exception("Data received beyond FIN")
if pos + count > 0:
# frame has been partially consumed
if pos < 0:
count += pos
frame.data = frame.data[-pos:]
frame.offset -= pos
pos = 0
# marked received
if count:
self._recv_ranges.add(frame.offset, frame_end)
if frame_end > self._recv_highest:
self._recv_highest = frame_end
# add data
gap = pos - len(self._recv_buffer)
if gap > 0:
self._recv_buffer += bytearray(gap)
self._recv_buffer[pos : pos + count] = frame.data
if frame.fin:
self._recv_buffer_fin = frame_end
+ if self._connection:
- if self.reader:
data = self.pull_data()
+ self._connection._events.append(
+ events.StreamDataReceived(
+ data=data,
- if data:
- self.reader.feed_data(data)
+ end_stream=(self._recv_buffer_start == self._recv_buffer_fin),
- if self._recv_buffer_start == self._recv_buffer_fin:
+ stream_id=self.__stream_id,
+ )
+ )
- self.reader.feed_eof()
|
aioquic.stream/QuicStream.write_eof
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<5>:<del> if self._connection is not None:
<6>:<del> self._connection._send_soon()
|
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
def write_eof(self) -> None:
<0> assert self._send_buffer_fin is None, "cannot call write_eof() after FIN"
<1>
<2> self.send_buffer_is_empty = False
<3> self._send_buffer_fin = self._send_buffer_stop
<4> self._send_pending_eof = True
<5> if self._connection is not None:
<6> self._connection._send_soon()
<7>
|
===========changed ref 0===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
- # asyncio.Transport
-
- def can_write_eof(self) -> bool:
- return True
-
===========changed ref 1===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
- def get_extra_info(self, name: str, default: Any = None) -> Any:
- """
- Get information about the underlying QUIC stream.
- """
- if name == "connection":
- return self._connection
- elif name == "stream_id":
- return self.stream_id
-
===========changed ref 2===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
def write(self, data: bytes) -> None:
"""
Write some data bytes to the QUIC stream.
"""
assert self._send_buffer_fin is None, "cannot call write() after FIN"
size = len(data)
if size:
self.send_buffer_is_empty = False
self._send_pending.add(
self._send_buffer_stop, self._send_buffer_stop + size
)
self._send_buffer += data
self._send_buffer_stop += size
- if self._connection is not None:
- self._connection._send_soon()
===========changed ref 3===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
- def connection_lost(self, exc: Exception) -> None:
- if self.reader is not None:
- if exc is None:
- self.reader.feed_eof()
- else:
- self.reader.set_exception(exc)
-
===========changed ref 4===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
def __init__(
self,
stream_id: Optional[int] = None,
connection: Optional[Any] = None,
max_stream_data_local: int = 0,
max_stream_data_remote: int = 0,
) -> None:
self._connection = connection
self.max_stream_data_local = max_stream_data_local
self.max_stream_data_local_sent = max_stream_data_local
self.max_stream_data_remote = max_stream_data_remote
self.send_buffer_is_empty = True
-
- if stream_id is not None:
- self.reader = asyncio.StreamReader()
- self.writer = asyncio.StreamWriter(self, None, self.reader, None)
- else:
- self.reader = None
- self.writer = None
self._recv_buffer = bytearray()
self._recv_buffer_fin: Optional[int] = None
self._recv_buffer_start = 0 # the offset for the start of the buffer
self._recv_highest = 0 # the highest offset ever seen
self._recv_ranges = RangeSet()
self._send_acked = RangeSet()
self._send_buffer = bytearray()
self._send_buffer_fin: Optional[int] = None
self._send_buffer_start = 0 # the offset for the start of the buffer
self._send_buffer_stop = 0 # the offset for the stop of the buffer
self._send_highest = 0
self._send_pending = RangeSet()
self._send_pending_eof = False
self.__stream_id = stream_id
===========changed ref 5===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
# reader
def add_frame(self, frame: QuicStreamFrame) -> None:
"""
Add a frame of received data.
"""
pos = frame.offset - self._recv_buffer_start
count = len(frame.data)
frame_end = frame.offset + count
# we should receive no more data beyond FIN!
if self._recv_buffer_fin is not None and frame_end > self._recv_buffer_fin:
raise Exception("Data received beyond FIN")
if pos + count > 0:
# frame has been partially consumed
if pos < 0:
count += pos
frame.data = frame.data[-pos:]
frame.offset -= pos
pos = 0
# marked received
if count:
self._recv_ranges.add(frame.offset, frame_end)
if frame_end > self._recv_highest:
self._recv_highest = frame_end
# add data
gap = pos - len(self._recv_buffer)
if gap > 0:
self._recv_buffer += bytearray(gap)
self._recv_buffer[pos : pos + count] = frame.data
if frame.fin:
self._recv_buffer_fin = frame_end
+ if self._connection:
- if self.reader:
data = self.pull_data()
+ self._connection._events.append(
+ events.StreamDataReceived(
+ data=data,
- if data:
- self.reader.feed_data(data)
+ end_stream=(self._recv_buffer_start == self._recv_buffer_fin),
- if self._recv_buffer_start == self._recv_buffer_fin:
+ stream_id=self.__stream_id,
+ )
+ )
- self.reader.feed_eof()
|
aioquic.connection/QuicConnection.close
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<4>:<add> self._close_event = events.ConnectionTerminated(
<add> error_code=error_code,
<add> frame_type=frame_type,
<add> reason_phrase=reason_phrase,
<add> )
<9>:<del> self._send_pending()
|
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def close(
self,
error_code: int = QuicErrorCode.NO_ERROR,
frame_type: Optional[int] = None,
reason_phrase: str = "",
) -> None:
<0> """
<1> Close the connection.
<2> """
<3> if self._state not in END_STATES:
<4> self._close_pending = {
<5> "error_code": error_code,
<6> "frame_type": frame_type,
<7> "reason_phrase": reason_phrase,
<8> }
<9> self._send_pending()
<10>
|
===========unchanged ref 0===========
at: aioquic.configuration.QuicConfiguration
alpn_protocols: Optional[List[str]] = None
certificate: Any = None
idle_timeout: float = 60.0
is_client: bool = True
private_key: Any = None
secrets_log_file: TextIO = None
server_name: Optional[str] = None
session_ticket: Optional[tls.SessionTicket] = None
supported_versions: List[QuicProtocolVersion] = field(
default_factory=lambda: [
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
)
at: aioquic.connection
QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, is_validated: bool=False, local_challenge: Optional[bytes]=None, remote_challenge: Optional[bytes]=None)
at: aioquic.connection.QuicConnection
_connect(now: float) -> None
at: aioquic.connection.QuicConnection.__init__
self._configuration = configuration
self._is_client = configuration.is_client
self._connect_called = False
self._network_paths: List[QuicNetworkPath] = []
self._version: Optional[int] = None
at: aioquic.connection.QuicConnection.receive_datagram
self._version = QuicProtocolVersion(header.version)
self._version = QuicProtocolVersion(max(common))
self._network_paths = [network_path]
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
bytes_received: int = 0
bytes_sent: int = 0
is_validated: bool = False
local_challenge: Optional[bytes] = None
remote_challenge: Optional[bytes] = None
===========changed ref 0===========
# module: aioquic.connection
- QuicConnectionIdHandler = Callable[[bytes], None]
- QuicStreamHandler = Callable[[asyncio.StreamReader, asyncio.StreamWriter], None]
-
END_STATES = frozenset([QuicConnectionState.CLOSING, QuicConnectionState.DRAINING])
===========changed ref 1===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
- # asyncio.Transport
-
- def can_write_eof(self) -> bool:
- return True
-
===========changed ref 2===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
- def connection_lost(self, exc: Exception) -> None:
- if self.reader is not None:
- if exc is None:
- self.reader.feed_eof()
- else:
- self.reader.set_exception(exc)
-
===========changed ref 3===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
- def get_extra_info(self, name: str, default: Any = None) -> Any:
- """
- Get information about the underlying QUIC stream.
- """
- if name == "connection":
- return self._connection
- elif name == "stream_id":
- return self.stream_id
-
===========changed ref 4===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
def write_eof(self) -> None:
assert self._send_buffer_fin is None, "cannot call write_eof() after FIN"
self.send_buffer_is_empty = False
self._send_buffer_fin = self._send_buffer_stop
self._send_pending_eof = True
- if self._connection is not None:
- self._connection._send_soon()
===========changed ref 5===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
def write(self, data: bytes) -> None:
"""
Write some data bytes to the QUIC stream.
"""
assert self._send_buffer_fin is None, "cannot call write() after FIN"
size = len(data)
if size:
self.send_buffer_is_empty = False
self._send_pending.add(
self._send_buffer_stop, self._send_buffer_stop + size
)
self._send_buffer += data
self._send_buffer_stop += size
- if self._connection is not None:
- self._connection._send_soon()
===========changed ref 6===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
def __init__(
self,
stream_id: Optional[int] = None,
connection: Optional[Any] = None,
max_stream_data_local: int = 0,
max_stream_data_remote: int = 0,
) -> None:
self._connection = connection
self.max_stream_data_local = max_stream_data_local
self.max_stream_data_local_sent = max_stream_data_local
self.max_stream_data_remote = max_stream_data_remote
self.send_buffer_is_empty = True
-
- if stream_id is not None:
- self.reader = asyncio.StreamReader()
- self.writer = asyncio.StreamWriter(self, None, self.reader, None)
- else:
- self.reader = None
- self.writer = None
self._recv_buffer = bytearray()
self._recv_buffer_fin: Optional[int] = None
self._recv_buffer_start = 0 # the offset for the start of the buffer
self._recv_highest = 0 # the highest offset ever seen
self._recv_ranges = RangeSet()
self._send_acked = RangeSet()
self._send_buffer = bytearray()
self._send_buffer_fin: Optional[int] = None
self._send_buffer_start = 0 # the offset for the start of the buffer
self._send_buffer_stop = 0 # the offset for the stop of the buffer
self._send_highest = 0
self._send_pending = RangeSet()
self._send_pending_eof = False
self.__stream_id = stream_id
|
aioquic.connection/QuicConnection.connect
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<4>:<add>
<add> After calling this method call :meth:`datagrams_to_send` to retrieve data
<add> which needs to be sent.
<15>:<add> self._connect(now=now)
<del> self._connect()
|
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def connect(
+ self, addr: NetworkAddress, now: float, protocol_version: Optional[int] = None
- self, addr: NetworkAddress, protocol_version: Optional[int] = None
) -> None:
<0> """
<1> Initiate the TLS handshake.
<2>
<3> This method can only be called for clients and a single time.
<4> """
<5> assert (
<6> self._is_client and not self._connect_called
<7> ), "connect() can only be called for clients and a single time"
<8> self._connect_called = True
<9>
<10> self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
<11> if protocol_version is not None:
<12> self._version = protocol_version
<13> else:
<14> self._version = max(self._configuration.supported_versions)
<15> self._connect()
<16>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection.__init__
self._is_client = configuration.is_client
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._streams: Dict[int, QuicStream] = {}
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
===========changed ref 0===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def close(
self,
error_code: int = QuicErrorCode.NO_ERROR,
frame_type: Optional[int] = None,
reason_phrase: str = "",
) -> None:
"""
Close the connection.
"""
if self._state not in END_STATES:
+ self._close_event = events.ConnectionTerminated(
+ error_code=error_code,
+ frame_type=frame_type,
+ reason_phrase=reason_phrase,
+ )
self._close_pending = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
- self._send_pending()
===========changed ref 1===========
# module: aioquic.connection
- QuicConnectionIdHandler = Callable[[bytes], None]
- QuicStreamHandler = Callable[[asyncio.StreamReader, asyncio.StreamWriter], None]
-
END_STATES = frozenset([QuicConnectionState.CLOSING, QuicConnectionState.DRAINING])
===========changed ref 2===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
- # asyncio.Transport
-
- def can_write_eof(self) -> bool:
- return True
-
===========changed ref 3===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
- def connection_lost(self, exc: Exception) -> None:
- if self.reader is not None:
- if exc is None:
- self.reader.feed_eof()
- else:
- self.reader.set_exception(exc)
-
===========changed ref 4===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
- def get_extra_info(self, name: str, default: Any = None) -> Any:
- """
- Get information about the underlying QUIC stream.
- """
- if name == "connection":
- return self._connection
- elif name == "stream_id":
- return self.stream_id
-
===========changed ref 5===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
def write_eof(self) -> None:
assert self._send_buffer_fin is None, "cannot call write_eof() after FIN"
self.send_buffer_is_empty = False
self._send_buffer_fin = self._send_buffer_stop
self._send_pending_eof = True
- if self._connection is not None:
- self._connection._send_soon()
===========changed ref 6===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
def write(self, data: bytes) -> None:
"""
Write some data bytes to the QUIC stream.
"""
assert self._send_buffer_fin is None, "cannot call write() after FIN"
size = len(data)
if size:
self.send_buffer_is_empty = False
self._send_pending.add(
self._send_buffer_stop, self._send_buffer_stop + size
)
self._send_buffer += data
self._send_buffer_stop += size
- if self._connection is not None:
- self._connection._send_soon()
===========changed ref 7===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
def __init__(
self,
stream_id: Optional[int] = None,
connection: Optional[Any] = None,
max_stream_data_local: int = 0,
max_stream_data_remote: int = 0,
) -> None:
self._connection = connection
self.max_stream_data_local = max_stream_data_local
self.max_stream_data_local_sent = max_stream_data_local
self.max_stream_data_remote = max_stream_data_remote
self.send_buffer_is_empty = True
-
- if stream_id is not None:
- self.reader = asyncio.StreamReader()
- self.writer = asyncio.StreamWriter(self, None, self.reader, None)
- else:
- self.reader = None
- self.writer = None
self._recv_buffer = bytearray()
self._recv_buffer_fin: Optional[int] = None
self._recv_buffer_start = 0 # the offset for the start of the buffer
self._recv_highest = 0 # the highest offset ever seen
self._recv_ranges = RangeSet()
self._send_acked = RangeSet()
self._send_buffer = bytearray()
self._send_buffer_fin: Optional[int] = None
self._send_buffer_start = 0 # the offset for the start of the buffer
self._send_buffer_stop = 0 # the offset for the stop of the buffer
self._send_highest = 0
self._send_pending = RangeSet()
self._send_pending_eof = False
self.__stream_id = stream_id
|
aioquic.connection/QuicConnection.create_stream
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<1>:<del> Create a QUIC stream and return a pair of (reader, writer) objects.
<2>:<del>
<3>:<del> The returned reader and writer objects are instances of :class:`asyncio.StreamReader`
<4>:<del> and :class:`asyncio.StreamWriter` classes.
<5>:<add> Create a QUIC stream and return it.
<6>:<del> await self._parameters_available.wait()
<7>:<del>
<8>:<add> if stream_id is None:
<add> stream_id = (int(is_unidirectional) << 1) | int(not self._is_client)
<del> stream_id = (int(is_unidirectional) << 1) | int(not self._is_client)
<9>:<add> while stream_id in self._streams:
<del> while stream_id in self._streams:
<10>:<add> stream_id += 4
<del> stream_id += 4
<33>:<add> return stream
<34>:<del> return stream.reader, stream.writer
|
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def create_stream(
- def create_stream(
+ self, is_unidirectional: bool = False, stream_id: Optional[int] = None
+ ) -> QuicStream:
- 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> await self._parameters_available.wait()
<7>
<8> stream_id = (int(is_unidirectional) << 1) | int(not self._is_client)
<9> while stream_id in self._streams:
<10> stream_id += 4
<11>
<12> # determine limits
<13> if is_unidirectional:
<14> max_stream_data_local = 0
<15> max_stream_data_remote = self._remote_max_stream_data_uni
<16> max_streams = self._remote_max_streams_uni
<17> else:
<18> max_stream_data_local = self._local_max_stream_data_bidi_local
<19> max_stream_data_remote = self._remote_max_stream_data_bidi_remote
<20> max_streams = self._remote_max_streams_bidi
<21>
<22> # check max streams
<23> if stream_id // 4 >= max_streams:
<24> raise ValueError("Too many streams open")
<25>
<26> # create stream
<27> stream = self._streams[stream_id] = QuicStream(
<28> connection=self,
<29> stream_id=stream_id,
<30> max_stream_data_local=max_stream_data_local,
<31> max_stream_data_remote=max_stream_data_remote,
<32> )
<33>
<34> return stream.reader, stream.writer
</s>
|
===========unchanged ref 0===========
at: aioquic.connection
NetworkAddress = Any
QuicConnectionState()
END_STATES = frozenset([QuicConnectionState.CLOSING, QuicConnectionState.DRAINING])
at: aioquic.connection.QuicConnection.__init__
self._is_client = configuration.is_client
self.host_cid = self._host_cids[0].cid
self._network_paths: List[QuicNetworkPath] = []
self._packet_number = 0
self._peer_cid = os.urandom(8)
self._peer_token = b""
self._spin_bit = False
self._state = QuicConnectionState.FIRSTFLIGHT
self._streams: Dict[int, QuicStream] = {}
self._version: Optional[int] = None
self._close_pending: Optional[Dict] = None
at: aioquic.connection.QuicConnection._consume_connection_id
self._peer_cid = connection_id.cid
at: aioquic.connection.QuicConnection._initialize
self._packet_number = 0
at: aioquic.connection.QuicConnection._set_state
self._state = state
at: aioquic.connection.QuicConnection.close
self._close_pending = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.connect
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
self._version = protocol_version
self._version = max(self._configuration.supported_versions)
at: aioquic.connection.QuicConnection.create_stream
stream_id += 4
stream_id = (int(is_unidirectional) << 1) | int(not self._is_client)
===========unchanged ref 1===========
max_stream_data_local = 0
max_stream_data_local = self._local_max_stream_data_bidi_local
max_stream_data_remote = self._remote_max_stream_data_bidi_remote
max_stream_data_remote = self._remote_max_stream_data_uni
at: aioquic.connection.QuicConnection.datagrams_to_send
self._close_pending = None
self._packet_number = builder.packet_number
at: aioquic.connection.QuicConnection.receive_datagram
self._version = QuicProtocolVersion(header.version)
self._version = QuicProtocolVersion(max(common))
self._peer_cid = header.source_cid
self._peer_token = header.token
self._network_paths = [network_path]
self._spin_bit = self._spin_bit_peer
self._spin_bit = not self._spin_bit_peer
self.host_cid = context.host_cid
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.tls
Epoch()
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
===========unchanged ref 2===========
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def close(
self,
error_code: int = QuicErrorCode.NO_ERROR,
frame_type: Optional[int] = None,
reason_phrase: str = "",
) -> None:
"""
Close the connection.
"""
if self._state not in END_STATES:
+ self._close_event = events.ConnectionTerminated(
+ error_code=error_code,
+ frame_type=frame_type,
+ reason_phrase=reason_phrase,
+ )
self._close_pending = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
- self._send_pending()
===========changed ref 1===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def connect(
+ self, addr: NetworkAddress, now: float, protocol_version: Optional[int] = None
- self, addr: NetworkAddress, protocol_version: Optional[int] = None
) -> None:
"""
Initiate the TLS handshake.
This method can only be called for clients and a single time.
+
+ After calling this method call :meth:`datagrams_to_send` to retrieve data
+ which needs to be sent.
"""
assert (
self._is_client and not self._connect_called
), "connect() can only be called for clients and a single time"
self._connect_called = True
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
if protocol_version is not None:
self._version = protocol_version
else:
self._version = max(self._configuration.supported_versions)
+ self._connect(now=now)
- self._connect()
===========changed ref 2===========
# module: aioquic.connection
- QuicConnectionIdHandler = Callable[[bytes], None]
- QuicStreamHandler = Callable[[asyncio.StreamReader, asyncio.StreamWriter], None]
-
END_STATES = frozenset([QuicConnectionState.CLOSING, QuicConnectionState.DRAINING])
===========changed ref 3===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
- # asyncio.Transport
-
- def can_write_eof(self) -> bool:
- return True
-
===========changed ref 4===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
- def connection_lost(self, exc: Exception) -> None:
- if self.reader is not None:
- if exc is None:
- self.reader.feed_eof()
- else:
- self.reader.set_exception(exc)
-
===========changed ref 5===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
- def get_extra_info(self, name: str, default: Any = None) -> Any:
- """
- Get information about the underlying QUIC stream.
- """
- if name == "connection":
- return self._connection
- elif name == "stream_id":
- return self.stream_id
-
===========changed ref 6===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
def write_eof(self) -> None:
assert self._send_buffer_fin is None, "cannot call write_eof() after FIN"
self.send_buffer_is_empty = False
self._send_buffer_fin = self._send_buffer_stop
self._send_pending_eof = True
- if self._connection is not None:
- self._connection._send_soon()
|
aioquic.connection/QuicConnection._close
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<3>:<add> self._close_at = now + 3 * self._loss.get_probe_timeout()
<del> self._close_at = self._loop.time() + 3 * self._loss.get_probe_timeout()
|
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _close(self, is_initiator: bool, now: float) -> None:
- def _close(self, is_initiator: bool) -> None:
<0> """
<1> Start the close procedure.
<2> """
<3> self._close_at = self._loop.time() + 3 * self._loss.get_probe_timeout()
<4> if is_initiator:
<5> self._set_state(QuicConnectionState.CLOSING)
<6> else:
<7> self._set_state(QuicConnectionState.DRAINING)
<8>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
_consume_connection_id() -> None
at: aioquic.connection.QuicConnection.__init__
self.host_cid = self._host_cids[0].cid
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
at: aioquic.connection.QuicConnection.receive_datagram
destination_cid_seq = connection_id.sequence_number
destination_cid_seq: Optional[int] = None
network_path = self._find_network_path(addr)
epoch = get_epoch(header.packet_type)
context = QuicReceiveContext(
epoch=epoch,
host_cid=header.destination_cid,
network_path=network_path,
time=now,
)
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
is_validated: bool = False
at: aioquic.connection.QuicReceiveContext
epoch: tls.Epoch
host_cid: bytes
network_path: QuicNetworkPath
time: float
at: aioquic.tls
Epoch()
at: logging.LoggerAdapter
logger: Logger
extra: Mapping[str, Any]
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def error_received(self, exc: Exception) -> None:
- self._logger.warning(exc)
-
===========changed ref 1===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def next_event(self) -> Optional[events.Event]:
+ """
+ Retrieve the next event from the event buffer.
+
+ Returns `None` if there are no buffered events.
+ """
+ try:
+ return self._events.popleft()
+ except IndexError:
+ return None
+
===========changed ref 2===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def connection_made(self, transport: asyncio.BaseTransport) -> None:
- self._transport = cast(asyncio.DatagramTransport, transport)
-
===========changed ref 3===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def wait_connected(self) -> None:
- """
- Wait for the TLS handshake to complete.
- """
- await asyncio.shield(self._connected_waiter)
-
===========changed ref 4===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def wait_closed(self) -> None:
- """
- Wait for the connection to be closed.
- """
- await self._closed.wait()
-
===========changed ref 5===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- # asyncio.DatagramProtocol
-
- def connection_lost(self, exc: Exception) -> None:
- self._logger.info("Connection closed")
- for epoch in self._spaces.keys():
- self._discard_epoch(epoch)
- for stream in self._streams.values():
- stream.connection_lost(exc)
- if not self._connected_waiter.done():
- self._connected_waiter.set_exception(exc or ConnectionError)
- self._closed.set()
-
===========changed ref 6===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def ping(self) -> None:
- """
- Pings the remote host and waits for the response.
- """
- assert self._ping_waiter is None, "already await a ping"
- self._ping_pending = True
- self._ping_waiter = self._loop.create_future()
- self._send_soon()
- await asyncio.shield(self._ping_waiter)
-
===========changed ref 7===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def handle_timer(self, now: float) -> None:
+ """
+ Handle the timer.
+
+ After calling this method call :meth:`datagrams_to_send` to retrieve data
+ which needs to be sent.
+ """
+ # idle timeout
+ if now >= self._close_at:
+ if self._close_event is None:
+ self._close_event = events.ConnectionTerminated(
+ error_code=QuicErrorCode.INTERNAL_ERROR,
+ frame_type=None,
+ reason_phrase="Idle timeout",
+ )
+ self._close_complete()
+ return
+
+ # loss detection timeout
+ if self._loss_at is not None and now >= self._loss_at:
+ self._logger.debug("Loss detection triggered")
+ self._loss.on_loss_detection_timeout(now=now)
+
===========changed ref 8===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def get_timer(self) -> Optional[float]:
+ """
+ Return the time at which the timer should fire or None if no timer is needed.
+ """
+ timer_at = self._close_at
+ if self._state not in END_STATES:
+ # ack timer
+ for space in self._loss.spaces:
+ if space.ack_at is not None and space.ack_at < timer_at:
+ timer_at = space.ack_at
+
+ # loss detection timer
+ self._loss_at = self._loss.get_loss_detection_time()
+ if self._loss_at is not None and self._loss_at < timer_at:
+ timer_at = self._loss_at
+ return timer_at
+
===========changed ref 9===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def close(
self,
error_code: int = QuicErrorCode.NO_ERROR,
frame_type: Optional[int] = None,
reason_phrase: str = "",
) -> None:
"""
Close the connection.
"""
if self._state not in END_STATES:
+ self._close_event = events.ConnectionTerminated(
+ error_code=error_code,
+ frame_type=frame_type,
+ reason_phrase=reason_phrase,
+ )
self._close_pending = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
- self._send_pending()
|
aioquic.connection/QuicConnection._connect
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<5>:<add> self._close_at = now + self._configuration.idle_timeout
<del> self._close_at = self._loop.time() + self._configuration.idle_timeout
<10>:<del> self._send_pending()
|
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _connect(self, now: float) -> None:
- def _connect(self) -> None:
<0> """
<1> Start the client handshake.
<2> """
<3> assert self._is_client
<4>
<5> self._close_at = self._loop.time() + self._configuration.idle_timeout
<6> self._initialize(self._peer_cid)
<7>
<8> self.tls.handle_message(b"", self._crypto_buffers)
<9> self._push_crypto_data()
<10> self._send_pending()
<11>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection.__init__
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._network_paths: List[QuicNetworkPath] = []
at: aioquic.connection.QuicConnection.connect
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
at: aioquic.connection.QuicConnection.receive_datagram
start_off = buf.tell()
network_path = self._find_network_path(addr)
self._network_paths = [network_path]
space = self._spaces[tls.Epoch.ONE_RTT]
space = self._spaces[epoch]
end_off = buf.tell() + header.rest_length
plain_header, plain_payload, packet_number = crypto.decrypt_packet(
data[start_off:end_off], encrypted_off, space.expected_packet_number
)
is_ack_eliciting, is_probing = self._payload_received(
context, plain_payload
)
at: aioquic.connection.QuicNetworkPath
bytes_received: int = 0
is_validated: bool = False
at: aioquic.recovery.QuicPacketSpace.__init__
self.largest_received_packet = 0
at: logging.LoggerAdapter
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:
- class QuicConnection(asyncio.DatagramProtocol):
- def error_received(self, exc: Exception) -> None:
- self._logger.warning(exc)
-
===========changed ref 1===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _close(self, is_initiator: bool, now: float) -> None:
- def _close(self, is_initiator: bool) -> None:
"""
Start the close procedure.
"""
+ self._close_at = now + 3 * self._loss.get_probe_timeout()
- self._close_at = self._loop.time() + 3 * self._loss.get_probe_timeout()
if is_initiator:
self._set_state(QuicConnectionState.CLOSING)
else:
self._set_state(QuicConnectionState.DRAINING)
===========changed ref 2===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def next_event(self) -> Optional[events.Event]:
+ """
+ Retrieve the next event from the event buffer.
+
+ Returns `None` if there are no buffered events.
+ """
+ try:
+ return self._events.popleft()
+ except IndexError:
+ return None
+
===========changed ref 3===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def connection_made(self, transport: asyncio.BaseTransport) -> None:
- self._transport = cast(asyncio.DatagramTransport, transport)
-
===========changed ref 4===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def wait_connected(self) -> None:
- """
- Wait for the TLS handshake to complete.
- """
- await asyncio.shield(self._connected_waiter)
-
===========changed ref 5===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def wait_closed(self) -> None:
- """
- Wait for the connection to be closed.
- """
- await self._closed.wait()
-
===========changed ref 6===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- # asyncio.DatagramProtocol
-
- def connection_lost(self, exc: Exception) -> None:
- self._logger.info("Connection closed")
- for epoch in self._spaces.keys():
- self._discard_epoch(epoch)
- for stream in self._streams.values():
- stream.connection_lost(exc)
- if not self._connected_waiter.done():
- self._connected_waiter.set_exception(exc or ConnectionError)
- self._closed.set()
-
===========changed ref 7===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def ping(self) -> None:
- """
- Pings the remote host and waits for the response.
- """
- assert self._ping_waiter is None, "already await a ping"
- self._ping_pending = True
- self._ping_waiter = self._loop.create_future()
- self._send_soon()
- await asyncio.shield(self._ping_waiter)
-
===========changed ref 8===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def handle_timer(self, now: float) -> None:
+ """
+ Handle the timer.
+
+ After calling this method call :meth:`datagrams_to_send` to retrieve data
+ which needs to be sent.
+ """
+ # idle timeout
+ if now >= self._close_at:
+ if self._close_event is None:
+ self._close_event = events.ConnectionTerminated(
+ error_code=QuicErrorCode.INTERNAL_ERROR,
+ frame_type=None,
+ reason_phrase="Idle timeout",
+ )
+ self._close_complete()
+ return
+
+ # loss detection timeout
+ if self._loss_at is not None and now >= self._loss_at:
+ self._logger.debug("Loss detection triggered")
+ self._loss.on_loss_detection_timeout(now=now)
+
===========changed ref 9===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def get_timer(self) -> Optional[float]:
+ """
+ Return the time at which the timer should fire or None if no timer is needed.
+ """
+ timer_at = self._close_at
+ if self._state not in END_STATES:
+ # ack timer
+ for space in self._loss.spaces:
+ if space.ack_at is not None and space.ack_at < timer_at:
+ timer_at = space.ack_at
+
+ # loss detection timer
+ self._loss_at = self._loss.get_loss_detection_time()
+ if self._loss_at is not None and self._loss_at < timer_at:
+ timer_at = self._loss_at
+ return timer_at
+
===========changed ref 10===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def close(
self,
error_code: int = QuicErrorCode.NO_ERROR,
frame_type: Optional[int] = None,
reason_phrase: str = "",
) -> None:
"""
Close the connection.
"""
if self._state not in END_STATES:
+ self._close_event = events.ConnectionTerminated(
+ error_code=error_code,
+ frame_type=frame_type,
+ reason_phrase=reason_phrase,
+ )
self._close_pending = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
- self._send_pending()
|
aioquic.connection/QuicConnection._get_or_create_stream
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _get_or_create_stream(self, frame_type: int, stream_id: int) -> QuicStream:
<0> """
<1> Get or create a stream in response to a received frame.
<2> """
<3> stream = self._streams.get(stream_id, None)
<4> if stream is None:
<5> # check initiator
<6> if stream_is_client_initiated(stream_id) == self._is_client:
<7> raise QuicConnectionError(
<8> error_code=QuicErrorCode.STREAM_STATE_ERROR,
<9> frame_type=frame_type,
<10> reason_phrase="Wrong stream initiator",
<11> )
<12>
<13> # determine limits
<14> if stream_is_unidirectional(stream_id):
<15> max_stream_data_local = self._local_max_stream_data_uni
<16> max_stream_data_remote = 0
<17> max_streams = self._local_max_streams_uni
<18> else:
<19> max_stream_data_local = self._local_max_stream_data_bidi_remote
<20> max_stream_data_remote = self._remote_max_stream_data_bidi_local
<21> max_streams = self._local_max_streams_bidi
<22>
<23> # check max streams
<24> if stream_id // 4 >= max_streams:
<25> raise QuicConnectionError(
<26> error_code=QuicErrorCode.STREAM_LIMIT_ERROR,
<27> frame_type=frame_type,
<28> reason_phrase="Too many streams open",
<29> )
<30>
<31> # create stream
<32> self._logger.info("Stream %d created by peer" % stream_id)
<33> stream = self._streams[stream_id] = QuicStream(
<34> connection=self,
<35> stream_id=stream_id,
<36> max_stream_data_local=max_stream_data_local,
<37> max_stream_data_remote=max_stream_</s>
|
===========below chunk 0===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _get_or_create_stream(self, frame_type: int, stream_id: int) -> QuicStream:
# offset: 1
)
self._stream_handler(stream.reader, stream.writer)
return stream
===========unchanged ref 0===========
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicConnectionState()
at: aioquic.connection.QuicConnection
_set_state(state: QuicConnectionState) -> None
_stream_can_receive(stream_id: int) -> bool
_stream_can_send(stream_id: int) -> bool
at: aioquic.connection.QuicConnection.__init__
self._close_at: Optional[float] = None
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(send_probe=self._send_probe)
self._spaces: Dict[tls.Epoch, QuicPacketSpace] = {}
at: aioquic.connection.QuicConnection._connect
self._close_at = now + self._configuration.idle_timeout
at: aioquic.connection.QuicConnection._initialize
self._spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.connection.QuicConnection.receive_datagram
self._close_at = now + self._configuration.idle_timeout
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.recovery.QuicPacketRecovery
get_probe_timeout() -> float
at: logging.LoggerAdapter
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:
- class QuicConnection(asyncio.DatagramProtocol):
+ def send_ping(self, uid: int) -> None:
+ """
+ Send a PING frame to the peer.
+ """
+ self._ping_pending.append(uid)
+
===========changed ref 1===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def error_received(self, exc: Exception) -> None:
- self._logger.warning(exc)
-
===========changed ref 2===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def send_stream_data(
+ self, stream_id: int, data: bytes, end_stream: bool = False
+ ) -> None:
+ """
+ Send data on the specific stream.
+
+ If `end_stream` is `True`, the FIN bit will be set.
+ """
+ try:
+ stream = self._streams[stream_id]
+ except KeyError:
+ self.create_stream(stream_id=stream_id)
+ stream = self._streams[stream_id]
+ stream.write(data)
+ if end_stream:
+ stream.write_eof()
+
===========changed ref 3===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _connect(self, now: float) -> None:
- def _connect(self) -> None:
"""
Start the client handshake.
"""
assert self._is_client
+ self._close_at = now + self._configuration.idle_timeout
- self._close_at = self._loop.time() + self._configuration.idle_timeout
self._initialize(self._peer_cid)
self.tls.handle_message(b"", self._crypto_buffers)
self._push_crypto_data()
- self._send_pending()
===========changed ref 4===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _close(self, is_initiator: bool, now: float) -> None:
- def _close(self, is_initiator: bool) -> None:
"""
Start the close procedure.
"""
+ self._close_at = now + 3 * self._loss.get_probe_timeout()
- self._close_at = self._loop.time() + 3 * self._loss.get_probe_timeout()
if is_initiator:
self._set_state(QuicConnectionState.CLOSING)
else:
self._set_state(QuicConnectionState.DRAINING)
===========changed ref 5===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def next_event(self) -> Optional[events.Event]:
+ """
+ Retrieve the next event from the event buffer.
+
+ Returns `None` if there are no buffered events.
+ """
+ try:
+ return self._events.popleft()
+ except IndexError:
+ return None
+
===========changed ref 6===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def connection_made(self, transport: asyncio.BaseTransport) -> None:
- self._transport = cast(asyncio.DatagramTransport, transport)
-
===========changed ref 7===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def wait_connected(self) -> None:
- """
- Wait for the TLS handshake to complete.
- """
- await asyncio.shield(self._connected_waiter)
-
===========changed ref 8===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def wait_closed(self) -> None:
- """
- Wait for the connection to be closed.
- """
- await self._closed.wait()
-
===========changed ref 9===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- # asyncio.DatagramProtocol
-
- def connection_lost(self, exc: Exception) -> None:
- self._logger.info("Connection closed")
- for epoch in self._spaces.keys():
- self._discard_epoch(epoch)
- for stream in self._streams.values():
- stream.connection_lost(exc)
- if not self._connected_waiter.done():
- self._connected_waiter.set_exception(exc or ConnectionError)
- self._closed.set()
-
===========changed ref 10===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def ping(self) -> None:
- """
- Pings the remote host and waits for the response.
- """
- assert self._ping_waiter is None, "already await a ping"
- self._ping_pending = True
- self._ping_waiter = self._loop.create_future()
- self._send_soon()
- await asyncio.shield(self._ping_waiter)
-
|
|
aioquic.connection/QuicConnection._handle_connection_close_frame
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<11>:<del> if error_code != QuicErrorCode.NO_ERROR:
<12>:<del> self._close_exception = QuicConnectionError(
<13>:<del> error_code=error_code,
<14>:<del> frame_type=frame_type,
<15>:<del> reason_phrase=reason_phrase,
<16>:<add> self._close_event = events.ConnectionTerminated(
<add> error_code=error_code, frame_type=frame_type, reason_phrase=reason_phrase
<add> )
<del> )
<17>:<add> self._close(is_initiator=False, now=context.time)
<18>:<del> self._close(is_initiator=False)
<19>:<del> self._set_timer()
<20>:<del>
|
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _handle_connection_close_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a CONNECTION_CLOSE frame.
<2> """
<3> if frame_type == QuicFrameType.TRANSPORT_CLOSE:
<4> error_code, frame_type, reason_phrase = pull_transport_close_frame(buf)
<5> else:
<6> error_code, reason_phrase = pull_application_close_frame(buf)
<7> frame_type = None
<8> self._logger.info(
<9> "Connection close code 0x%X, reason %s", error_code, reason_phrase
<10> )
<11> if error_code != QuicErrorCode.NO_ERROR:
<12> self._close_exception = QuicConnectionError(
<13> error_code=error_code,
<14> frame_type=frame_type,
<15> reason_phrase=reason_phrase,
<16> )
<17>
<18> self._close(is_initiator=False)
<19> self._set_timer()
<20>
|
===========unchanged ref 0===========
at: aioquic.configuration.QuicConfiguration
server_name: Optional[str] = None
session_ticket: Optional[tls.SessionTicket] = None
at: aioquic.connection.QuicConnection
_parse_transport_parameters(data: bytes, from_session_ticket: bool=False) -> None
_serialize_transport_parameters() -> bytes
_serialize_transport_parameters(self) -> bytes
at: aioquic.connection.QuicConnection.__init__
self._configuration = configuration
self._is_client = configuration.is_client
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self._is_client, logger=self._logger)
at: aioquic.tls
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls.Context.__init__
self.session_ticket: Optional[SessionTicket] = None
self.server_name: Optional[str] = None
at: aioquic.tls.SessionTicket
age_add: int
cipher_suite: CipherSuite
not_valid_after: datetime.datetime
not_valid_before: datetime.datetime
resumption_secret: bytes
server_name: str
ticket: bytes
max_early_data_size: Optional[int] = None
other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
===========changed ref 0===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _close_complete(self) -> None:
+ """
+ Finish the close procedure.
+ """
+ self._logger.info("Connection closed")
+ self._close_at = None
+ for epoch in self._spaces.keys():
+ self._discard_epoch(epoch)
+ self._events.append(self._close_event)
+
===========changed ref 1===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def send_ping(self, uid: int) -> None:
+ """
+ Send a PING frame to the peer.
+ """
+ self._ping_pending.append(uid)
+
===========changed ref 2===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def error_received(self, exc: Exception) -> None:
- self._logger.warning(exc)
-
===========changed ref 3===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def send_stream_data(
+ self, stream_id: int, data: bytes, end_stream: bool = False
+ ) -> None:
+ """
+ Send data on the specific stream.
+
+ If `end_stream` is `True`, the FIN bit will be set.
+ """
+ try:
+ stream = self._streams[stream_id]
+ except KeyError:
+ self.create_stream(stream_id=stream_id)
+ stream = self._streams[stream_id]
+ stream.write(data)
+ if end_stream:
+ stream.write_eof()
+
===========changed ref 4===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _connect(self, now: float) -> None:
- def _connect(self) -> None:
"""
Start the client handshake.
"""
assert self._is_client
+ self._close_at = now + self._configuration.idle_timeout
- self._close_at = self._loop.time() + self._configuration.idle_timeout
self._initialize(self._peer_cid)
self.tls.handle_message(b"", self._crypto_buffers)
self._push_crypto_data()
- self._send_pending()
===========changed ref 5===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _close(self, is_initiator: bool, now: float) -> None:
- def _close(self, is_initiator: bool) -> None:
"""
Start the close procedure.
"""
+ self._close_at = now + 3 * self._loss.get_probe_timeout()
- self._close_at = self._loop.time() + 3 * self._loss.get_probe_timeout()
if is_initiator:
self._set_state(QuicConnectionState.CLOSING)
else:
self._set_state(QuicConnectionState.DRAINING)
===========changed ref 6===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def next_event(self) -> Optional[events.Event]:
+ """
+ Retrieve the next event from the event buffer.
+
+ Returns `None` if there are no buffered events.
+ """
+ try:
+ return self._events.popleft()
+ except IndexError:
+ return None
+
===========changed ref 7===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def connection_made(self, transport: asyncio.BaseTransport) -> None:
- self._transport = cast(asyncio.DatagramTransport, transport)
-
===========changed ref 8===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def wait_connected(self) -> None:
- """
- Wait for the TLS handshake to complete.
- """
- await asyncio.shield(self._connected_waiter)
-
===========changed ref 9===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def wait_closed(self) -> None:
- """
- Wait for the connection to be closed.
- """
- await self._closed.wait()
-
===========changed ref 10===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- # asyncio.DatagramProtocol
-
- def connection_lost(self, exc: Exception) -> None:
- self._logger.info("Connection closed")
- for epoch in self._spaces.keys():
- self._discard_epoch(epoch)
- for stream in self._streams.values():
- stream.connection_lost(exc)
- if not self._connected_waiter.done():
- self._connected_waiter.set_exception(exc or ConnectionError)
- self._closed.set()
-
|
aioquic.connection/QuicConnection._handle_crypto_frame
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<40>:<del> # wakeup waiter
<41>:<del> self._connected_waiter.
|
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a CRYPTO frame.
<2> """
<3> stream = self._crypto_streams[context.epoch]
<4> stream.add_frame(pull_crypto_frame(buf))
<5> data = stream.pull_data()
<6> if data:
<7> # pass data to TLS layer
<8> try:
<9> self.tls.handle_message(data, self._crypto_buffers)
<10> self._push_crypto_data()
<11> except tls.Alert as exc:
<12> raise QuicConnectionError(
<13> error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),
<14> frame_type=QuicFrameType.CRYPTO,
<15> reason_phrase=str(exc),
<16> )
<17>
<18> # parse transport parameters
<19> if (
<20> not self._parameters_received
<21> and self.tls.received_extensions is not None
<22> ):
<23> for ext_type, ext_data in self.tls.received_extensions:
<24> if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
<25> self._parse_transport_parameters(ext_data)
<26> self._parameters_received = True
<27> break
<28> assert (
<29> self._parameters_received
<30> ), "No QUIC transport parameters received"
<31> self._logger.info("ALPN negotiated protocol %s", self.alpn_protocol)
<32>
<33> # update current epoch
<34> if not self._handshake_complete and self.tls.state in [
<35> tls.State.CLIENT_POST_HANDSHAKE,
<36> tls.State.SERVER_POST_HANDSHAKE,
<37> ]:
<38> self._handshake_complete = True
<39> self._replenish_connection_ids()
<40> # wakeup waiter
<41> self._connected_waiter.</s>
|
===========below chunk 0===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
# offset: 1
===========unchanged ref 0===========
at: aioquic._buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath, time: float)
at: aioquic.connection.QuicConnection
_update_traffic_key(direction: tls.Direction, epoch: tls.Epoch, cipher_suite: tls.CipherSuite, secret: bytes) -> None
at: aioquic.connection.QuicConnection.__init__
self._is_client = configuration.is_client
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._crypto_buffers: Dict[tls.Epoch, Buffer] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
self._loss = QuicPacketRecovery(send_probe=self._send_probe)
self._packet_number = 0
self._spaces: Dict[tls.Epoch, QuicPacketSpace] = {}
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self._is_client, logger=self._logger)
at: aioquic.connection.QuicConnection.datagrams_to_send
self._packet_number = builder.packet_number
at: aioquic.crypto
CryptoPair()
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_ack_frame(buf: Buffer) -> Tuple[RangeSet, int]
at: aioquic.recovery
QuicPacketSpace()
===========unchanged ref 1===========
at: aioquic.recovery.QuicPacketRecovery.__init__
self.spaces: List[QuicPacketSpace] = []
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.tls
Epoch()
at: aioquic.tls.Context.__init__
self.get_session_ticket_cb: Optional[SessionTicketFetcher] = None
self.new_session_ticket_cb: Optional[SessionTicketHandler] = None
self.update_traffic_key_cb: Callable[
[Direction, Epoch, CipherSuite, bytes], None
] = lambda d, e, c, s: None
===========changed ref 0===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _close_complete(self) -> None:
+ """
+ Finish the close procedure.
+ """
+ self._logger.info("Connection closed")
+ self._close_at = None
+ for epoch in self._spaces.keys():
+ self._discard_epoch(epoch)
+ self._events.append(self._close_event)
+
===========changed ref 1===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def send_ping(self, uid: int) -> None:
+ """
+ Send a PING frame to the peer.
+ """
+ self._ping_pending.append(uid)
+
===========changed ref 2===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def error_received(self, exc: Exception) -> None:
- self._logger.warning(exc)
-
===========changed ref 3===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _handle_connection_close_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a CONNECTION_CLOSE frame.
"""
if frame_type == QuicFrameType.TRANSPORT_CLOSE:
error_code, frame_type, reason_phrase = pull_transport_close_frame(buf)
else:
error_code, reason_phrase = pull_application_close_frame(buf)
frame_type = None
self._logger.info(
"Connection close code 0x%X, reason %s", error_code, reason_phrase
)
- if error_code != QuicErrorCode.NO_ERROR:
- self._close_exception = QuicConnectionError(
- error_code=error_code,
- frame_type=frame_type,
- reason_phrase=reason_phrase,
+ self._close_event = events.ConnectionTerminated(
+ error_code=error_code, frame_type=frame_type, reason_phrase=reason_phrase
+ )
- )
+ self._close(is_initiator=False, now=context.time)
- self._close(is_initiator=False)
- self._set_timer()
-
===========changed ref 4===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def send_stream_data(
+ self, stream_id: int, data: bytes, end_stream: bool = False
+ ) -> None:
+ """
+ Send data on the specific stream.
+
+ If `end_stream` is `True`, the FIN bit will be set.
+ """
+ try:
+ stream = self._streams[stream_id]
+ except KeyError:
+ self.create_stream(stream_id=stream_id)
+ stream = self._streams[stream_id]
+ stream.write(data)
+ if end_stream:
+ stream.write_eof()
+
===========changed ref 5===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _connect(self, now: float) -> None:
- def _connect(self) -> None:
"""
Start the client handshake.
"""
assert self._is_client
+ self._close_at = now + self._configuration.idle_timeout
- self._close_at = self._loop.time() + self._configuration.idle_timeout
self._initialize(self._peer_cid)
self.tls.handle_message(b"", self._crypto_buffers)
self._push_crypto_data()
- self._send_pending()
===========changed ref 6===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _close(self, is_initiator: bool, now: float) -> None:
- def _close(self, is_initiator: bool) -> None:
"""
Start the close procedure.
"""
+ self._close_at = now + 3 * self._loss.get_probe_timeout()
- self._close_at = self._loop.time() + 3 * self._loss.get_probe_timeout()
if is_initiator:
self._set_state(QuicConnectionState.CLOSING)
else:
self._set_state(QuicConnectionState.DRAINING)
|
aioquic.connection/QuicConnection._handle_reset_stream_frame
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<16>:<add> # stream = self._get_or_create_stream(frame_type, stream_id)
<del> stream = self._get_or_create_stream(frame_type, stream_id)
<17>:<add> self._events.append(events.StreamReset(stream_id=stream_id))
<del> stream.connection_lost(None)
|
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _handle_reset_stream_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a RESET_STREAM frame.
<2> """
<3> stream_id = buf.pull_uint_var()
<4> error_code = buf.pull_uint16()
<5> final_size = buf.pull_uint_var()
<6>
<7> # check stream direction
<8> self._assert_stream_can_receive(frame_type, stream_id)
<9>
<10> self._logger.info(
<11> "Stream %d reset by peer (error code %d, final size %d)",
<12> stream_id,
<13> error_code,
<14> final_size,
<15> )
<16> stream = self._get_or_create_stream(frame_type, stream_id)
<17> stream.connection_lost(None)
<18>
|
===========unchanged ref 0===========
at: aioquic._buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic._buffer.Buffer
pull_uint_var() -> int
at: aioquic.connection
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath, time: float)
at: aioquic.connection.QuicConnection.__init__
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
at: logging.LoggerAdapter
debug(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _close_complete(self) -> None:
+ """
+ Finish the close procedure.
+ """
+ self._logger.info("Connection closed")
+ self._close_at = None
+ for epoch in self._spaces.keys():
+ self._discard_epoch(epoch)
+ self._events.append(self._close_event)
+
===========changed ref 1===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def send_ping(self, uid: int) -> None:
+ """
+ Send a PING frame to the peer.
+ """
+ self._ping_pending.append(uid)
+
===========changed ref 2===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def error_received(self, exc: Exception) -> None:
- self._logger.warning(exc)
-
===========changed ref 3===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _handle_connection_close_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a CONNECTION_CLOSE frame.
"""
if frame_type == QuicFrameType.TRANSPORT_CLOSE:
error_code, frame_type, reason_phrase = pull_transport_close_frame(buf)
else:
error_code, reason_phrase = pull_application_close_frame(buf)
frame_type = None
self._logger.info(
"Connection close code 0x%X, reason %s", error_code, reason_phrase
)
- if error_code != QuicErrorCode.NO_ERROR:
- self._close_exception = QuicConnectionError(
- error_code=error_code,
- frame_type=frame_type,
- reason_phrase=reason_phrase,
+ self._close_event = events.ConnectionTerminated(
+ error_code=error_code, frame_type=frame_type, reason_phrase=reason_phrase
+ )
- )
+ self._close(is_initiator=False, now=context.time)
- self._close(is_initiator=False)
- self._set_timer()
-
===========changed ref 4===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def send_stream_data(
+ self, stream_id: int, data: bytes, end_stream: bool = False
+ ) -> None:
+ """
+ Send data on the specific stream.
+
+ If `end_stream` is `True`, the FIN bit will be set.
+ """
+ try:
+ stream = self._streams[stream_id]
+ except KeyError:
+ self.create_stream(stream_id=stream_id)
+ stream = self._streams[stream_id]
+ stream.write(data)
+ if end_stream:
+ stream.write_eof()
+
===========changed ref 5===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _connect(self, now: float) -> None:
- def _connect(self) -> None:
"""
Start the client handshake.
"""
assert self._is_client
+ self._close_at = now + self._configuration.idle_timeout
- self._close_at = self._loop.time() + self._configuration.idle_timeout
self._initialize(self._peer_cid)
self.tls.handle_message(b"", self._crypto_buffers)
self._push_crypto_data()
- self._send_pending()
===========changed ref 6===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _close(self, is_initiator: bool, now: float) -> None:
- def _close(self, is_initiator: bool) -> None:
"""
Start the close procedure.
"""
+ self._close_at = now + 3 * self._loss.get_probe_timeout()
- self._close_at = self._loop.time() + 3 * self._loss.get_probe_timeout()
if is_initiator:
self._set_state(QuicConnectionState.CLOSING)
else:
self._set_state(QuicConnectionState.DRAINING)
===========changed ref 7===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a CRYPTO frame.
"""
stream = self._crypto_streams[context.epoch]
stream.add_frame(pull_crypto_frame(buf))
data = stream.pull_data()
if data:
# pass data to TLS layer
try:
self.tls.handle_message(data, self._crypto_buffers)
self._push_crypto_data()
except tls.Alert as exc:
raise QuicConnectionError(
error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),
frame_type=QuicFrameType.CRYPTO,
reason_phrase=str(exc),
)
# parse transport parameters
if (
not self._parameters_received
and self.tls.received_extensions is not None
):
for ext_type, ext_data in self.tls.received_extensions:
if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
self._parse_transport_parameters(ext_data)
self._parameters_received = True
break
assert (
self._parameters_received
), "No QUIC transport parameters received"
self._logger.info("ALPN negotiated protocol %s", self.alpn_protocol)
# update current epoch
if not self._handshake_complete and self.tls.state in [
tls.State.CLIENT_POST_HANDSHAKE,
tls.State.SERVER_POST_HANDSHAKE,
]:
self._handshake_complete = True
self._replenish_connection_ids()
- # wakeup waiter
- self._connected_waiter.set_result(None)
+ self._events.append(events.HandshakeCompleted())
===========changed ref 8===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def next_event(self) -> Optional[events.Event]:
+ """
+ Retrieve the next event from the event buffer.
+
+ Returns `None` if there are no buffered events.
+ """
+ try:
+ return self._events.popleft()
+ except IndexError:
+ return None
+
|
aioquic.connection/QuicConnection._handle_retire_connection_id_frame
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<15>:<add> self._events.append(
<add> events.ConnectionIdRetired(connection_id=connection_id.cid)
<add> )
<del> self._connection_id_retired_handler(connection_id.cid)
|
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _handle_retire_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a RETIRE_CONNECTION_ID frame.
<2> """
<3> sequence_number = buf.pull_uint_var()
<4>
<5> # find the connection ID by sequence number
<6> for index, connection_id in enumerate(self._host_cids):
<7> if connection_id.sequence_number == sequence_number:
<8> if connection_id.cid == context.host_cid:
<9> raise QuicConnectionError(
<10> error_code=QuicErrorCode.PROTOCOL_VIOLATION,
<11> frame_type=frame_type,
<12> reason_phrase="Cannot retire current connection ID",
<13> )
<14> del self._host_cids[index]
<15> self._connection_id_retired_handler(connection_id.cid)
<16> break
<17>
<18> # issue a new connection ID
<19> self._replenish_connection_ids()
<20>
|
===========unchanged ref 0===========
at: aioquic._buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
dump_cid(cid: bytes) -> str
QuicConnectionId(cid: bytes, sequence_number: int, stateless_reset_token: bytes=b"", was_sent: bool=False)
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath, time: float)
at: aioquic.connection.QuicConnection.__init__
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._peer_cid_available: List[QuicConnectionId] = []
at: aioquic.connection.QuicConnectionId
cid: bytes
sequence_number: int
stateless_reset_token: bytes = b""
was_sent: bool = False
at: aioquic.packet
pull_new_connection_id_frame(buf: Buffer) -> Tuple[int, bytes, bytes]
at: logging.LoggerAdapter
debug(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _handle_reset_stream_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RESET_STREAM frame.
"""
stream_id = buf.pull_uint_var()
error_code = buf.pull_uint16()
final_size = buf.pull_uint_var()
# check stream direction
self._assert_stream_can_receive(frame_type, stream_id)
self._logger.info(
"Stream %d reset by peer (error code %d, final size %d)",
stream_id,
error_code,
final_size,
)
+ # stream = self._get_or_create_stream(frame_type, stream_id)
- stream = self._get_or_create_stream(frame_type, stream_id)
+ self._events.append(events.StreamReset(stream_id=stream_id))
- stream.connection_lost(None)
===========changed ref 1===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _close_complete(self) -> None:
+ """
+ Finish the close procedure.
+ """
+ self._logger.info("Connection closed")
+ self._close_at = None
+ for epoch in self._spaces.keys():
+ self._discard_epoch(epoch)
+ self._events.append(self._close_event)
+
===========changed ref 2===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def send_ping(self, uid: int) -> None:
+ """
+ Send a PING frame to the peer.
+ """
+ self._ping_pending.append(uid)
+
===========changed ref 3===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def error_received(self, exc: Exception) -> None:
- self._logger.warning(exc)
-
===========changed ref 4===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _handle_connection_close_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a CONNECTION_CLOSE frame.
"""
if frame_type == QuicFrameType.TRANSPORT_CLOSE:
error_code, frame_type, reason_phrase = pull_transport_close_frame(buf)
else:
error_code, reason_phrase = pull_application_close_frame(buf)
frame_type = None
self._logger.info(
"Connection close code 0x%X, reason %s", error_code, reason_phrase
)
- if error_code != QuicErrorCode.NO_ERROR:
- self._close_exception = QuicConnectionError(
- error_code=error_code,
- frame_type=frame_type,
- reason_phrase=reason_phrase,
+ self._close_event = events.ConnectionTerminated(
+ error_code=error_code, frame_type=frame_type, reason_phrase=reason_phrase
+ )
- )
+ self._close(is_initiator=False, now=context.time)
- self._close(is_initiator=False)
- self._set_timer()
-
===========changed ref 5===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def send_stream_data(
+ self, stream_id: int, data: bytes, end_stream: bool = False
+ ) -> None:
+ """
+ Send data on the specific stream.
+
+ If `end_stream` is `True`, the FIN bit will be set.
+ """
+ try:
+ stream = self._streams[stream_id]
+ except KeyError:
+ self.create_stream(stream_id=stream_id)
+ stream = self._streams[stream_id]
+ stream.write(data)
+ if end_stream:
+ stream.write_eof()
+
===========changed ref 6===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _connect(self, now: float) -> None:
- def _connect(self) -> None:
"""
Start the client handshake.
"""
assert self._is_client
+ self._close_at = now + self._configuration.idle_timeout
- self._close_at = self._loop.time() + self._configuration.idle_timeout
self._initialize(self._peer_cid)
self.tls.handle_message(b"", self._crypto_buffers)
self._push_crypto_data()
- self._send_pending()
===========changed ref 7===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _close(self, is_initiator: bool, now: float) -> None:
- def _close(self, is_initiator: bool) -> None:
"""
Start the close procedure.
"""
+ self._close_at = now + 3 * self._loss.get_probe_timeout()
- self._close_at = self._loop.time() + 3 * self._loss.get_probe_timeout()
if is_initiator:
self._set_state(QuicConnectionState.CLOSING)
else:
self._set_state(QuicConnectionState.DRAINING)
|
aioquic.connection/QuicConnection._on_ping_delivery
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<1>:<add> Callback when a PING frame is acknowledged or lost.
<del> Callback when a PING frame is is acknowledged or lost.
<5>:<del> waiter = self._ping_waiter
<6>:<del> self._ping_waiter = None
<7>:<del> waiter.set_result(None)
<8>:<add> for uid in uids:
<add> self._events.append(events.PongReceived(uid=uid))
<9>:<add> self._ping_pending.extend(uids)
<del> self._ping_pending = True
|
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _on_ping_delivery(
+ self, delivery: QuicDeliveryState, uids: Sequence[int]
+ ) -> None:
- def _on_ping_delivery(self, delivery: QuicDeliveryState) -> None:
<0> """
<1> Callback when a PING frame is is acknowledged or lost.
<2> """
<3> if delivery == QuicDeliveryState.ACKED:
<4> self._logger.info("Received PING response")
<5> waiter = self._ping_waiter
<6> self._ping_waiter = None
<7> waiter.set_result(None)
<8> else:
<9> self._ping_pending = True
<10>
|
===========unchanged ref 0===========
at: aioquic._buffer.Buffer
pull_uint_var() -> int
===========changed ref 0===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _handle_retire_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RETIRE_CONNECTION_ID frame.
"""
sequence_number = buf.pull_uint_var()
# find the connection ID by sequence number
for index, connection_id in enumerate(self._host_cids):
if connection_id.sequence_number == sequence_number:
if connection_id.cid == context.host_cid:
raise QuicConnectionError(
error_code=QuicErrorCode.PROTOCOL_VIOLATION,
frame_type=frame_type,
reason_phrase="Cannot retire current connection ID",
)
del self._host_cids[index]
+ self._events.append(
+ events.ConnectionIdRetired(connection_id=connection_id.cid)
+ )
- self._connection_id_retired_handler(connection_id.cid)
break
# issue a new connection ID
self._replenish_connection_ids()
===========changed ref 1===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _handle_reset_stream_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RESET_STREAM frame.
"""
stream_id = buf.pull_uint_var()
error_code = buf.pull_uint16()
final_size = buf.pull_uint_var()
# check stream direction
self._assert_stream_can_receive(frame_type, stream_id)
self._logger.info(
"Stream %d reset by peer (error code %d, final size %d)",
stream_id,
error_code,
final_size,
)
+ # stream = self._get_or_create_stream(frame_type, stream_id)
- stream = self._get_or_create_stream(frame_type, stream_id)
+ self._events.append(events.StreamReset(stream_id=stream_id))
- stream.connection_lost(None)
===========changed ref 2===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _close_complete(self) -> None:
+ """
+ Finish the close procedure.
+ """
+ self._logger.info("Connection closed")
+ self._close_at = None
+ for epoch in self._spaces.keys():
+ self._discard_epoch(epoch)
+ self._events.append(self._close_event)
+
===========changed ref 3===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def send_ping(self, uid: int) -> None:
+ """
+ Send a PING frame to the peer.
+ """
+ self._ping_pending.append(uid)
+
===========changed ref 4===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def error_received(self, exc: Exception) -> None:
- self._logger.warning(exc)
-
===========changed ref 5===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _handle_connection_close_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a CONNECTION_CLOSE frame.
"""
if frame_type == QuicFrameType.TRANSPORT_CLOSE:
error_code, frame_type, reason_phrase = pull_transport_close_frame(buf)
else:
error_code, reason_phrase = pull_application_close_frame(buf)
frame_type = None
self._logger.info(
"Connection close code 0x%X, reason %s", error_code, reason_phrase
)
- if error_code != QuicErrorCode.NO_ERROR:
- self._close_exception = QuicConnectionError(
- error_code=error_code,
- frame_type=frame_type,
- reason_phrase=reason_phrase,
+ self._close_event = events.ConnectionTerminated(
+ error_code=error_code, frame_type=frame_type, reason_phrase=reason_phrase
+ )
- )
+ self._close(is_initiator=False, now=context.time)
- self._close(is_initiator=False)
- self._set_timer()
-
===========changed ref 6===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def send_stream_data(
+ self, stream_id: int, data: bytes, end_stream: bool = False
+ ) -> None:
+ """
+ Send data on the specific stream.
+
+ If `end_stream` is `True`, the FIN bit will be set.
+ """
+ try:
+ stream = self._streams[stream_id]
+ except KeyError:
+ self.create_stream(stream_id=stream_id)
+ stream = self._streams[stream_id]
+ stream.write(data)
+ if end_stream:
+ stream.write_eof()
+
===========changed ref 7===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _connect(self, now: float) -> None:
- def _connect(self) -> None:
"""
Start the client handshake.
"""
assert self._is_client
+ self._close_at = now + self._configuration.idle_timeout
- self._close_at = self._loop.time() + self._configuration.idle_timeout
self._initialize(self._peer_cid)
self.tls.handle_message(b"", self._crypto_buffers)
self._push_crypto_data()
- self._send_pending()
===========changed ref 8===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _close(self, is_initiator: bool, now: float) -> None:
- def _close(self, is_initiator: bool) -> None:
"""
Start the close procedure.
"""
+ self._close_at = now + 3 * self._loss.get_probe_timeout()
- self._close_at = self._loop.time() + 3 * self._loss.get_probe_timeout()
if is_initiator:
self._set_state(QuicConnectionState.CLOSING)
else:
self._set_state(QuicConnectionState.DRAINING)
|
aioquic.connection/QuicConnection._parse_transport_parameters
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<36>:<del> # wakeup waiters
<37>:<del> if not self._parameters_available.is_set():
<38>:<del> self._parameters_available.set()
<39>:<del>
|
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _parse_transport_parameters(
self, data: bytes, from_session_ticket: bool = False
) -> None:
<0> quic_transport_parameters = pull_quic_transport_parameters(Buffer(data=data))
<1>
<2> # validate remote parameters
<3> if (
<4> self._is_client
<5> and not from_session_ticket
<6> and (
<7> quic_transport_parameters.original_connection_id
<8> != self._original_connection_id
<9> )
<10> ):
<11> raise QuicConnectionError(
<12> error_code=QuicErrorCode.TRANSPORT_PARAMETER_ERROR,
<13> frame_type=QuicFrameType.CRYPTO,
<14> reason_phrase="original_connection_id does not match",
<15> )
<16>
<17> # store remote parameters
<18> if quic_transport_parameters.idle_timeout is not None:
<19> self._remote_idle_timeout = quic_transport_parameters.idle_timeout / 1000.0
<20> for param in ["ack_delay_exponent", "max_ack_delay"]:
<21> value = getattr(quic_transport_parameters, param)
<22> if value is not None:
<23> setattr(self._loss, param, value)
<24> for param in [
<25> "max_data",
<26> "max_stream_data_bidi_local",
<27> "max_stream_data_bidi_remote",
<28> "max_stream_data_uni",
<29> "max_streams_bidi",
<30> "max_streams_uni",
<31> ]:
<32> value = getattr(quic_transport_parameters, "initial_" + param)
<33> if value is not None:
<34> setattr(self, "_remote_" + param, value)
<35>
<36> # wakeup waiters
<37> if not self._parameters_available.is_set():
<38> self._parameters_available.set()
<39>
|
===========unchanged ref 0===========
at: aioquic._buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.configuration.QuicConfiguration
idle_timeout: float = 60.0
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
at: aioquic.connection.QuicConnection.__init__
self._configuration = configuration
self._is_client = configuration.is_client
self._local_max_data = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._loss = QuicPacketRecovery(send_probe=self._send_probe)
self._original_connection_id = original_connection_id
self._remote_idle_timeout = 0.0 # seconds
at: aioquic.connection.QuicConnection._parse_transport_parameters
quic_transport_parameters = pull_quic_transport_parameters(Buffer(data=data))
at: aioquic.connection.QuicConnection._write_connection_limits
self._local_max_data *= 2
at: aioquic.connection.QuicConnection.receive_datagram
self._original_connection_id = self._peer_cid
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(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)
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
===========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:
- class QuicConnection(asyncio.DatagramProtocol):
- def _send_soon(self) -> None:
- if self._send_task is None:
- self._send_task = self._loop.call_soon(self._send_pending)
-
===========changed ref 1===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def _on_timeout(self) -> None:
- now = self._loop.time() + K_GRANULARITY
- self._timer = None
- self._timer_at = None
-
- # idle timeout
- if now >= self._close_at:
- self.connection_lost(self._close_exception)
- return
-
- # loss detection timeout
- if self._loss_at is not None and now >= self._loss_at:
- self._logger.debug("Loss detection triggered")
- self._loss.on_loss_detection_timeout(now=now)
- self._send_pending()
-
===========changed ref 2===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def _on_ping_delivery(
+ self, delivery: QuicDeliveryState, uids: Sequence[int]
+ ) -> None:
- def _on_ping_delivery(self, delivery: QuicDeliveryState) -> None:
"""
+ Callback when a PING frame is acknowledged or lost.
- Callback when a PING frame is is acknowledged or lost.
"""
if delivery == QuicDeliveryState.ACKED:
self._logger.info("Received PING response")
- waiter = self._ping_waiter
- self._ping_waiter = None
- waiter.set_result(None)
+ for uid in uids:
+ self._events.append(events.PongReceived(uid=uid))
else:
+ self._ping_pending.extend(uids)
- self._ping_pending = True
===========changed ref 3===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _handle_retire_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RETIRE_CONNECTION_ID frame.
"""
sequence_number = buf.pull_uint_var()
# find the connection ID by sequence number
for index, connection_id in enumerate(self._host_cids):
if connection_id.sequence_number == sequence_number:
if connection_id.cid == context.host_cid:
raise QuicConnectionError(
error_code=QuicErrorCode.PROTOCOL_VIOLATION,
frame_type=frame_type,
reason_phrase="Cannot retire current connection ID",
)
del self._host_cids[index]
+ self._events.append(
+ events.ConnectionIdRetired(connection_id=connection_id.cid)
+ )
- self._connection_id_retired_handler(connection_id.cid)
break
# issue a new connection ID
self._replenish_connection_ids()
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
<0> crypto_stream: Optional[QuicStream] = None
<1> if self._cryptos[tls.Epoch.ONE_RTT].send.is_valid():
<2> crypto = self._cryptos[tls.Epoch.ONE_RTT]
<3> crypto_stream = self._crypto_streams[tls.Epoch.ONE_RTT]
<4> packet_type = PACKET_TYPE_ONE_RTT
<5> elif self._cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
<6> crypto = self._cryptos[tls.Epoch.ZERO_RTT]
<7> packet_type = PACKET_TYPE_ZERO_RTT
<8> else:
<9> return
<10> space = self._spaces[tls.Epoch.ONE_RTT]
<11>
<12> buf = builder.buffer
<13>
<14> while True:
<15> # write header
<16> builder.start_packet(packet_type, crypto, is_probe=self._probe_pending)
<17>
<18> if self._handshake_complete:
<19> # ACK
<20> if space.ack_at is not None and space.ack_at <= now:
<21> builder.start_frame(
<22> QuicFrameType.ACK,
<23> self._on_ack_delivery,
<24> (space, space.largest_received_packet),
<25> )
<26> push_ack_frame(buf, space.ack_queue, 0)
<27> space.ack_at = None
<28>
<29> # PATH CHALLENGE
<30> if (
<31> not network_path.is_validated
<32> and network_path.local_challenge is None
<33> ):
<34> self._logger.info(
<35> "Network path %s sending challenge", network_path.addr
<36> )
<37> network_path.local_challenge = os.urandom(8)
<38> builder</s>
|
===========below chunk 0===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
# offset: 1
buf.push_bytes(network_path.local_challenge)
# PATH RESPONSE
if network_path.remote_challenge is not None:
builder.start_frame(QuicFrameType.PATH_RESPONSE)
buf.push_bytes(network_path.remote_challenge)
network_path.remote_challenge = None
# NEW_CONNECTION_ID
for connection_id in self._host_cids:
if not connection_id.was_sent:
builder.start_frame(
QuicFrameType.NEW_CONNECTION_ID,
self._on_new_connection_id_delivery,
(connection_id,),
)
push_new_connection_id_frame(
buf,
connection_id.sequence_number,
connection_id.cid,
connection_id.stateless_reset_token,
)
connection_id.was_sent = True
self._connection_id_issued_handler(connection_id.cid)
# RETIRE_CONNECTION_ID
while self._retire_connection_ids:
sequence_number = self._retire_connection_ids.pop(0)
builder.start_frame(
QuicFrameType.RETIRE_CONNECTION_ID,
self._on_retire_connection_id_delivery,
(sequence_number,),
)
buf.push_uint_var(sequence_number)
# connection-level limits
self._write_connection_limits(builder=builder, space=space)
# stream-level limits
for stream in self._streams.values():
self._write_stream_limits(builder=builder, space=space, stream=stream)
# PING (user-request)
if self._ping_pending:
self._logger.info</s>
===========below chunk 1===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath, now: float
) -> None:
# offset: 2
<s>=stream)
# PING (user-request)
if self._ping_pending:
self._logger.info("Sending PING in packet %d", builder.packet_number)
builder.start_frame(QuicFrameType.PING, self._on_ping_delivery)
self._ping_pending = False
# PING (probe)
if self._probe_pending:
self._logger.info("Sending probe")
builder.start_frame(QuicFrameType.PING)
self._probe_pending = False
# CRYPTO
if crypto_stream is not None and not crypto_stream.send_buffer_is_empty:
write_crypto_frame(builder=builder, space=space, stream=crypto_stream)
for stream in self._streams.values():
# STREAM
if not stream.send_buffer_is_empty:
self._remote_max_data_used += write_stream_frame(
builder=builder,
space=space,
stream=stream,
max_offset=min(
stream._send_highest
+ self._remote_max_data
- self._remote_max_data_used,
stream.max_stream_data_remote,
),
)
if not builder.end_packet():
break
===========unchanged ref 0===========
at: aioquic._buffer.Buffer
push_bytes(value: bytes) -> None
push_uint_var(value: int) -> None
at: aioquic.connection
write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
write_stream_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream, max_offset: int) -> int
at: aioquic.connection.QuicConnection
_on_new_connection_id_delivery(delivery: QuicDeliveryState, connection_id: QuicConnectionId) -> None
_on_ping_delivery(delivery: QuicDeliveryState, uids: Sequence[int]) -> None
_on_retire_connection_id_delivery(delivery: QuicDeliveryState, sequence_number: int) -> None
_write_stream_limits(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
at: aioquic.connection.QuicConnection.__init__
self._cryptos: Dict[tls.Epoch, CryptoPair] = {}
self._crypto_streams: Dict[tls.Epoch, QuicStream] = {}
self._events: Deque[events.Event] = deque()
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._remote_max_data = 0
self._remote_max_data_used = 0
self._spaces: Dict[tls.Epoch, QuicPacketSpace] = {}
self._streams: Dict[int, QuicStream] = {}
self._ping_pending: List[int] = []
self._probe_pending = False
===========unchanged ref 1===========
self._retire_connection_ids: List[int] = []
at: aioquic.connection.QuicConnection._handle_max_data_frame
self._remote_max_data = max_data
at: aioquic.connection.QuicConnection._initialize
self._cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self._crypto_streams = {
tls.Epoch.INITIAL: QuicStream(),
tls.Epoch.HANDSHAKE: QuicStream(),
tls.Epoch.ONE_RTT: QuicStream(),
}
self._spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.connection.QuicConnection._send_probe
self._probe_pending = True
at: aioquic.connection.QuicConnection._write_application
crypto_stream: Optional[QuicStream] = None
crypto_stream = self._crypto_streams[tls.Epoch.ONE_RTT]
space = self._spaces[tls.Epoch.ONE_RTT]
buf = builder.buffer
at: aioquic.connection.QuicConnectionId
cid: bytes
sequence_number: int
stateless_reset_token: bytes = b""
was_sent: bool = False
at: aioquic.connection.QuicNetworkPath
local_challenge: Optional[bytes] = None
remote_challenge: Optional[bytes] = None
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
|
|
tests.test_connection/create_standalone_client
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<1>:<del> client_transport = FakeTransport(CLIENT_ADDR, loss=0)
<4>:<del> client.connection_made(client_transport)
<5>:<add> client.connect(SERVER_ADDR, now=time.time())
<del> client.connect(SERVER_ADDR)
<6>:<add> self.assertEqual(len(client.datagrams_to_send(now=time.time())), 1)
<7>:<add> return client
<del> return client, client_transport
|
# module: tests.test_connection
+ def create_standalone_client(self):
- def create_standalone_client():
<0> client = QuicConnection(configuration=QuicConfiguration(is_client=True))
<1> client_transport = FakeTransport(CLIENT_ADDR, loss=0)
<2>
<3> # kick-off handshake
<4> client.connection_made(client_transport)
<5> client.connect(SERVER_ADDR)
<6>
<7> return client, client_transport
<8>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, configuration: QuicConfiguration, original_connection_id: Optional[bytes]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None)
at: contextlib
contextmanager(func: Callable[..., Iterator[_T]]) -> Callable[..., _GeneratorContextManager[_T]]
===========changed ref 0===========
# module: tests.test_connection
- class FakeTransport:
- sent = 0
- target = None
-
===========changed ref 1===========
# module: tests.test_connection
+ def consume_events(connection):
+ while True:
+ event = connection.next_event()
+ if event is None:
+ break
+
===========changed ref 2===========
# module: tests.test_connection
- class FakeTransport:
- def __init__(self, local_addr, loss=0):
- self.local_addr = local_addr
- self.loop = asyncio.get_event_loop()
- self.loss = loss
-
===========changed ref 3===========
# module: tests.test_connection
- class FakeTransport:
- def sendto(self, data, addr):
- self.sent += 1
- if self.target is not None and random.random() >= self.loss:
- self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
-
===========changed ref 4===========
# module: tests.test_connection
- RTT = 0.005
-
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
===========changed ref 5===========
+ # module: aioquic.asyncio
+
+
===========changed ref 6===========
+ # module: aioquic.asyncio.server
+
+
===========changed ref 7===========
+ # module: aioquic.asyncio.client
+
+
===========changed ref 8===========
+ # module: aioquic.asyncio.protocol
+
+
===========changed ref 9===========
+ # module: aioquic.asyncio.protocol
+ class QuicStreamAdapter(asyncio.Transport):
+ def can_write_eof(self) -> bool:
+ return True
+
===========changed ref 10===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
- # asyncio.Transport
-
- def can_write_eof(self) -> bool:
- return True
-
===========changed ref 11===========
+ # module: aioquic.asyncio.client
+ __all__ = ["connect"]
+
===========changed ref 12===========
+ # module: aioquic.asyncio.server
+ class QuicServer(asyncio.DatagramProtocol):
+ def _connection_id_issued(self, cid: bytes, protocol: QuicConnectionProtocol):
+ self._protocols[cid] = protocol
+
===========changed ref 13===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def error_received(self, exc: Exception) -> None:
- self._logger.warning(exc)
-
===========changed ref 14===========
+ # module: aioquic.asyncio.compat
+ class _AsyncGeneratorContextManager(ContextDecorator):
+ def __aenter__(self):
+ return await self.gen.__anext__()
+
===========changed ref 15===========
+ # module: aioquic.asyncio.protocol
+ class QuicConnectionProtocol(asyncio.DatagramProtocol):
+ def close(self) -> None:
+ self._connection.close()
+ self._send_pending()
+
===========changed ref 16===========
+ # module: aioquic.asyncio.server
+ class QuicServer(asyncio.DatagramProtocol):
+ def connection_made(self, transport: asyncio.BaseTransport) -> None:
+ self._transport = cast(asyncio.DatagramTransport, transport)
+
===========changed ref 17===========
+ # module: aioquic.asyncio.protocol
+ class QuicStreamAdapter(asyncio.Transport):
+ def __init__(self, protocol: QuicConnectionProtocol, stream_id: int):
+ self.protocol = protocol
+ self.stream_id = stream_id
+
===========changed ref 18===========
+ # module: aioquic.asyncio.compat
+ if asynccontextmanager is None:
+ asynccontextmanager = _asynccontextmanager
+
===========changed ref 19===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def connection_made(self, transport: asyncio.BaseTransport) -> None:
- self._transport = cast(asyncio.DatagramTransport, transport)
-
===========changed ref 20===========
+ # module: aioquic.asyncio.server
+ class QuicServer(asyncio.DatagramProtocol):
+ def _connection_id_retired(
+ self, cid: bytes, protocol: QuicConnectionProtocol
+ ) -> None:
+ assert self._protocols[cid] == protocol
+ del self._protocols[cid]
+
===========changed ref 21===========
+ # module: aioquic.asyncio.compat
+ try:
+ from contextlib import asynccontextmanager
+ except ImportError:
+ asynccontextmanager = None
+
===========changed ref 22===========
+ # module: aioquic.asyncio.server
+ __all__ = ["serve"]
+
+ QuicConnectionHandler = Callable[[QuicConnectionProtocol], None]
+
===========changed ref 23===========
+ # module: aioquic.asyncio.protocol
+ class QuicConnectionProtocol(asyncio.DatagramProtocol):
+ def wait_closed(self) -> None:
+ """
+ Wait for the connection to be closed.
+ """
+ await self._closed.wait()
+
===========changed ref 24===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def send_ping(self, uid: int) -> None:
+ """
+ Send a PING frame to the peer.
+ """
+ self._ping_pending.append(uid)
+
===========changed ref 25===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def wait_closed(self) -> None:
- """
- Wait for the connection to be closed.
- """
- await self._closed.wait()
-
===========changed ref 26===========
+ # module: aioquic.asyncio.protocol
+ class QuicConnectionProtocol(asyncio.DatagramProtocol):
+ def wait_connected(self) -> None:
+ """
+ Wait for the TLS handshake to complete.
+ """
+ await asyncio.shield(self._connected_waiter)
+
===========changed ref 27===========
+ # module: aioquic.asyncio.protocol
+ QuicConnectionIdHandler = Callable[[bytes], None]
+ QuicStreamHandler = Callable[[asyncio.StreamReader, asyncio.StreamWriter], None]
+
===========changed ref 28===========
+ # module: aioquic.asyncio.protocol
+ class QuicStreamAdapter(asyncio.Transport):
+ def write(self, data):
+ self.protocol._connection.send_stream_data(self.stream_id, data)
+ self.protocol._send_soon()
+
===========changed ref 29===========
+ # module: aioquic.asyncio.server
+ def encode_address(addr: NetworkAddress) -> bytes:
+ return ipaddress.ip_address(addr[0]).packed + bytes([addr[1] >> 8, addr[1] & 0xFF])
+
===========changed ref 30===========
+ # module: aioquic.asyncio.protocol
+ class QuicConnectionProtocol(asyncio.DatagramProtocol):
+ def _send_soon(self) -> None:
+ if self._send_task is None:
+ self._send_task = self._loop.call_soon(self._send_pending)
+
===========changed ref 31===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def wait_connected(self) -> None:
- """
- Wait for the TLS handshake to complete.
- """
- await asyncio.shield(self._connected_waiter)
-
===========changed ref 32===========
+ # module: aioquic.asyncio.protocol
+ class QuicConnectionProtocol(asyncio.DatagramProtocol):
+ def request_key_update(self) -> None:
+ """
+ Request an update of the encryption keys.
+ """
+ self._connection.request_key_update()
+ self._send_pending()
+
|
tests.test_connection/client_and_server
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<3>:<add> client._ack_delay = 0
<11>:<add> )
<del> ),
<12>:<del> stream_handler=server_stream_handler,
<14>:<add> server._ack_delay = 0
<17>:<add> client.connect(SERVER_ADDR, now=time.time())
<add> for i in range(4):
<add> tick(client, server)
<del> create_transport(client, server, **transport_options)
|
# module: tests.test_connection
@contextlib.contextmanager
def client_and_server(
client_options={},
client_patch=lambda x: None,
server_options={},
server_patch=lambda x: None,
- server_stream_handler=None,
transport_options={},
):
<0> client = QuicConnection(
<1> configuration=QuicConfiguration(is_client=True, **client_options)
<2> )
<3> client_patch(client)
<4>
<5> server = QuicConnection(
<6> configuration=QuicConfiguration(
<7> is_client=False,
<8> certificate=SERVER_CERTIFICATE,
<9> private_key=SERVER_PRIVATE_KEY,
<10> **server_options
<11> ),
<12> stream_handler=server_stream_handler,
<13> )
<14> server_patch(server)
<15>
<16> # perform handshake
<17> create_transport(client, server, **transport_options)
<18>
<19> yield client, server
<20>
<21> # close
<22> client.close()
<23> server.close()
<24>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
close(error_code: int=QuicErrorCode.NO_ERROR, frame_type: Optional[int]=None, reason_phrase: str="") -> None
datagrams_to_send(now: float) -> List[Tuple[bytes, NetworkAddress]]
receive_datagram(data: bytes, addr: NetworkAddress, now: float) -> None
at: tests.test_connection
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
at: tests.test_connection.client_and_server
client = QuicConnection(
configuration=QuicConfiguration(is_client=True, **client_options)
)
server = QuicConnection(
configuration=QuicConfiguration(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
**server_options
)
)
at: time
time() -> float
at: unittest.case
TestCase(methodName: str=...)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertIsNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
def close(
self,
error_code: int = QuicErrorCode.NO_ERROR,
frame_type: Optional[int] = None,
reason_phrase: str = "",
) -> None:
"""
Close the connection.
"""
if self._state not in END_STATES:
+ self._close_event = events.ConnectionTerminated(
+ error_code=error_code,
+ frame_type=frame_type,
+ reason_phrase=reason_phrase,
+ )
self._close_pending = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
- self._send_pending()
===========changed ref 1===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def datagrams_to_send(self, now: float) -> List[Tuple[bytes, NetworkAddress]]:
+ """
+ Return (data, addr) tuples of datagrams which need to be sent.
+ """
+ network_path = self._network_paths[0]
+
+ if self._state in END_STATES:
+ return []
+
+ # build datagrams
+ builder = QuicPacketBuilder(
+ host_cid=self.host_cid,
+ packet_number=self._packet_number,
+ pad_first_datagram=(
+ self._is_client and self._state == QuicConnectionState.FIRSTFLIGHT
+ ),
+ peer_cid=self._peer_cid,
+ peer_token=self._peer_token,
+ spin_bit=self._spin_bit,
+ version=self._version,
+ )
+ if self._close_pending:
+ for epoch, packet_type in (
+ (tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
+ (tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
+ (tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
+ ):
+ crypto = self._cryptos[epoch]
+ if crypto.send.is_valid():
+ builder.start_packet(packet_type, crypto)
+ write_close_frame(builder, **self._close_pending)
+ builder.end_packet()
+ self._close_pending = None
+ break
+ self._close(is_initiator=True, now=now)
+ else:
+ # congestion control
+ builder.max_flight_bytes = (
+ self._loss.congestion_window - self._loss.bytes_in_flight
+ )
+ if not network_path.is_validated:
+ # limit data</s>
===========changed ref 2===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
+ def datagrams_to_send(self, now: float) -> List[Tuple[bytes, NetworkAddress]]:
# offset: 1
<s>.bytes_in_flight
+ )
+ if not network_path.is_validated:
+ # limit data on un-validated network paths
+ builder.max_total_bytes = (
+ network_path.bytes_received * 3 - network_path.bytes_sent
+ )
+
+ try:
+ if not self._handshake_confirmed:
+ for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
+ self._write_handshake(builder, epoch)
+ self._write_application(builder, network_path, now)
+ except QuicPacketBuilderStop:
+ pass
+
+ datagrams, packets = builder.flush()
+
+ if datagrams:
+ self._packet_number = builder.packet_number
+
+ # register packets
+ sent_handshake = False
+ for packet in packets:
+ packet.sent_time = now
+ self._loss.on_packet_sent(
+ packet=packet, space=self._spaces[packet.epoch]
+ )
+ if packet.epoch == tls.Epoch.HANDSHAKE:
+ sent_handshake = True
+
+ # check if we can discard initial keys
+ if sent_handshake and self._is_client:
+ self._discard_epoch(tls.Epoch.INITIAL)
+
+ # return datagrams to send and the destination network address
+ ret = []
+ for datagram in datagrams:
+ network_path.bytes_sent += len(datagram)
+ ret.append((datagram, network_path.addr))
+ return ret
+
===========changed ref 3===========
# module: tests.test_connection
- class FakeTransport:
- sent = 0
- target = None
-
===========changed ref 4===========
# module: tests.test_connection
+ def consume_events(connection):
+ while True:
+ event = connection.next_event()
+ if event is None:
+ break
+
===========changed ref 5===========
# module: tests.test_connection
- class FakeTransport:
- def __init__(self, local_addr, loss=0):
- self.local_addr = local_addr
- self.loop = asyncio.get_event_loop()
- self.loss = loss
-
===========changed ref 6===========
# module: tests.test_connection
- class FakeTransport:
- def sendto(self, data, addr):
- self.sent += 1
- if self.target is not None and random.random() >= self.loss:
- self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
-
===========changed ref 7===========
# module: tests.test_connection
- RTT = 0.005
-
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
|
tests.test_connection/QuicConnectionTest._test_connect_with_version
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<0>:<del> async def serve_request(reader, writer):
<1>:<del> # check request
<2>:<del> request = await reader.read(1024)
<3>:<del> self.assertEqual(request, b"ping")
<4>:<del>
<5>:<del> # send response
<6>:<del> writer.write(b"pong")
<7>:<del>
<8>:<del> # receives EOF
<9>:<del> request = await reader.read()
<10>:<del> self.assertEqual(request, b"")
<11>:<del>
<12>:<del> # sends EOF
<13>:<del> writer.write(b"done")
<14>:<del> writer.write_eof()
<15>:<del>
<19>:<del> server_stream_handler=lambda reader, writer: asyncio.ensure_future(
<20>:<del> serve_request(reader, writer)
<21>:<del> ),
<23>:<add> # check handshake completed
<add> self.assertEqual(type(client.next_event()), events.HandshakeCompleted)
<add> for i in range(7):
<add> self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
<add> self.assertIsNone(client.next_event())
<add>
<add> self.assertEqual(type(server.next_event()), events.HandshakeCompleted)
<add> for i in range(7):
<add> self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
<add> self.assertIsNone(server.next_event())
<del> run(asyncio.gather(client.wait_connected(), server.wait_connected()))
<29>:<add> self.assertEqual(
<add> sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<add> )
<30>:<add> # client closes the connection
<add> client.
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
<0> async def serve_request(reader, writer):
<1> # check request
<2> request = await reader.read(1024)
<3> self.assertEqual(request, b"ping")
<4>
<5> # send response
<6> writer.write(b"pong")
<7>
<8> # receives EOF
<9> request = await reader.read()
<10> self.assertEqual(request, b"")
<11>
<12> # sends EOF
<13> writer.write(b"done")
<14> writer.write_eof()
<15>
<16> with client_and_server(
<17> client_options={"supported_versions": client_versions},
<18> server_options={"supported_versions": server_versions},
<19> server_stream_handler=lambda reader, writer: asyncio.ensure_future(
<20> serve_request(reader, writer)
<21> ),
<22> ) as (client, server):
<23> run(asyncio.gather(client.wait_connected(), server.wait_connected()))
<24>
<25> # check each endpoint has available connection IDs for the peer
<26> self.assertEqual(
<27> sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<28> )
<29>
<30> # clients sends data over stream
<31> client_reader, client_writer = run(client.create_stream())
<32> client_writer.write(b"ping")
<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>
<40> # client receives EOF
<41> self.assertEqual(run(client_reader.read()), b"done")
<42>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: io
StringIO(initial_value: Optional[str]=..., newline: Optional[str]=...)
at: tests.test_connection
sequence_numbers(connection_ids)
tick(client, server)
at: tests.test_connection.QuicConnectionTest
_test_connect_with_version(self, client_versions, server_versions)
_test_connect_with_version(client_versions, server_versions)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertIsNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
+ def tick(client, server):
+ for data, addr in client.datagrams_to_send(now=time.time()):
+ server.receive_datagram(data, CLIENT_ADDR, now=time.time())
+
+ for data, addr in server.datagrams_to_send(now=time.time()):
+ client.receive_datagram(data, SERVER_ADDR, now=time.time())
+
===========changed ref 1===========
# module: tests.test_connection
- class FakeTransport:
- sent = 0
- target = None
-
===========changed ref 2===========
# module: tests.test_connection
+ def consume_events(connection):
+ while True:
+ event = connection.next_event()
+ if event is None:
+ break
+
===========changed ref 3===========
# module: tests.test_connection
- class FakeTransport:
- def __init__(self, local_addr, loss=0):
- self.local_addr = local_addr
- self.loop = asyncio.get_event_loop()
- self.loss = loss
-
===========changed ref 4===========
# module: tests.test_connection
- class FakeTransport:
- def sendto(self, data, addr):
- self.sent += 1
- if self.target is not None and random.random() >= self.loss:
- self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
-
===========changed ref 5===========
# module: tests.test_connection
- RTT = 0.005
-
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
===========changed ref 6===========
# module: tests.test_connection
- def create_transport(client, server, loss=0):
- client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
- client_transport.target = server
-
- server_transport = FakeTransport(SERVER_ADDR, loss=loss)
- server_transport.target = client
-
- # kick-off handshake
- server.connection_made(server_transport)
- client.connection_made(client_transport)
- client.connect(SERVER_ADDR)
- run(asyncio.sleep(0))
-
- return client_transport, server_transport
-
===========changed ref 7===========
# module: tests.test_connection
+ def create_standalone_client(self):
- def create_standalone_client():
client = QuicConnection(configuration=QuicConfiguration(is_client=True))
- client_transport = FakeTransport(CLIENT_ADDR, loss=0)
# kick-off handshake
- client.connection_made(client_transport)
+ client.connect(SERVER_ADDR, now=time.time())
- client.connect(SERVER_ADDR)
+ self.assertEqual(len(client.datagrams_to_send(now=time.time())), 1)
+ return client
- return client, client_transport
===========changed ref 8===========
# module: tests.test_connection
@contextlib.contextmanager
def client_and_server(
client_options={},
client_patch=lambda x: None,
server_options={},
server_patch=lambda x: None,
- server_stream_handler=None,
transport_options={},
):
client = QuicConnection(
configuration=QuicConfiguration(is_client=True, **client_options)
)
+ client._ack_delay = 0
client_patch(client)
server = QuicConnection(
configuration=QuicConfiguration(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
**server_options
+ )
- ),
- stream_handler=server_stream_handler,
)
+ server._ack_delay = 0
server_patch(server)
# perform handshake
+ client.connect(SERVER_ADDR, now=time.time())
+ for i in range(4):
+ tick(client, server)
- create_transport(client, server, **transport_options)
yield client, server
# close
client.close()
server.close()
===========changed ref 9===========
+ # module: aioquic.asyncio
+
+
===========changed ref 10===========
+ # module: aioquic.asyncio.server
+
+
===========changed ref 11===========
+ # module: aioquic.asyncio.client
+
+
===========changed ref 12===========
+ # module: aioquic.asyncio.protocol
+
+
===========changed ref 13===========
+ # module: aioquic.asyncio.protocol
+ class QuicStreamAdapter(asyncio.Transport):
+ def can_write_eof(self) -> bool:
+ return True
+
===========changed ref 14===========
# module: aioquic.stream
+ class QuicStream:
- class QuicStream(asyncio.Transport):
- # asyncio.Transport
-
- def can_write_eof(self) -> bool:
- return True
-
===========changed ref 15===========
+ # module: aioquic.asyncio.client
+ __all__ = ["connect"]
+
===========changed ref 16===========
+ # module: aioquic.asyncio.server
+ class QuicServer(asyncio.DatagramProtocol):
+ def _connection_id_issued(self, cid: bytes, protocol: QuicConnectionProtocol):
+ self._protocols[cid] = protocol
+
===========changed ref 17===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def error_received(self, exc: Exception) -> None:
- self._logger.warning(exc)
-
===========changed ref 18===========
+ # module: aioquic.asyncio.compat
+ class _AsyncGeneratorContextManager(ContextDecorator):
+ def __aenter__(self):
+ return await self.gen.__anext__()
+
===========changed ref 19===========
+ # module: aioquic.asyncio.protocol
+ class QuicConnectionProtocol(asyncio.DatagramProtocol):
+ def close(self) -> None:
+ self._connection.close()
+ self._send_pending()
+
===========changed ref 20===========
+ # module: aioquic.asyncio.server
+ class QuicServer(asyncio.DatagramProtocol):
+ def connection_made(self, transport: asyncio.BaseTransport) -> None:
+ self._transport = cast(asyncio.DatagramTransport, transport)
+
===========changed ref 21===========
+ # module: aioquic.asyncio.protocol
+ class QuicStreamAdapter(asyncio.Transport):
+ def __init__(self, protocol: QuicConnectionProtocol, stream_id: int):
+ self.protocol = protocol
+ self.stream_id = stream_id
+
===========changed ref 22===========
+ # module: aioquic.asyncio.compat
+ if asynccontextmanager is None:
+ asynccontextmanager = _asynccontextmanager
+
===========changed ref 23===========
# module: aioquic.connection
+ class QuicConnection:
- class QuicConnection(asyncio.DatagramProtocol):
- def connection_made(self, transport: asyncio.BaseTransport) -> None:
- self._transport = cast(asyncio.DatagramTransport, transport)
-
|
tests.test_connection/QuicConnectionTest.test_connect_with_log
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<6>:<del> run(client.wait_connected())
<7>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
<0> client_log_file = io.StringIO()
<1> server_log_file = io.StringIO()
<2> with client_and_server(
<3> client_options={"secrets_log_file": client_log_file},
<4> server_options={"secrets_log_file": server_log_file},
<5> ) as (client, server):
<6> run(client.wait_connected())
<7>
<8> # check secrets were logged
<9> client_log = client_log_file.getvalue()
<10> server_log = server_log_file.getvalue()
<11> self.assertEqual(client_log, server_log)
<12> labels = []
<13> for line in client_log.splitlines():
<14> labels.append(line.split()[0])
<15> self.assertEqual(
<16> labels,
<17> [
<18> "QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
<19> "QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
<20> "QUIC_SERVER_TRAFFIC_SECRET_0",
<21> "QUIC_CLIENT_TRAFFIC_SECRET_0",
<22> ],
<23> )
<24>
|
===========unchanged ref 0===========
at: tests.test_connection
CLIENT_ADDR = ("1.2.3.4", 1234)
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
sequence_numbers(connection_ids)
at: tests.test_connection.QuicConnectionTest.test_connect_with_log
labels = []
at: time
time() -> float
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
@contextlib.contextmanager
def client_and_server(
client_options={},
client_patch=lambda x: None,
server_options={},
server_patch=lambda x: None,
- server_stream_handler=None,
transport_options={},
):
client = QuicConnection(
configuration=QuicConfiguration(is_client=True, **client_options)
)
+ client._ack_delay = 0
client_patch(client)
server = QuicConnection(
configuration=QuicConfiguration(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
**server_options
+ )
- ),
- stream_handler=server_stream_handler,
)
+ server._ack_delay = 0
server_patch(server)
# perform handshake
+ client.connect(SERVER_ADDR, now=time.time())
+ for i in range(4):
+ tick(client, server)
- create_transport(client, server, **transport_options)
yield client, server
# close
client.close()
server.close()
===========changed ref 1===========
# module: tests.test_connection
- class FakeTransport:
- sent = 0
- target = None
-
===========changed ref 2===========
# module: tests.test_connection
+ def consume_events(connection):
+ while True:
+ event = connection.next_event()
+ if event is None:
+ break
+
===========changed ref 3===========
# module: tests.test_connection
+ def tick(client, server):
+ for data, addr in client.datagrams_to_send(now=time.time()):
+ server.receive_datagram(data, CLIENT_ADDR, now=time.time())
+
+ for data, addr in server.datagrams_to_send(now=time.time()):
+ client.receive_datagram(data, SERVER_ADDR, now=time.time())
+
===========changed ref 4===========
# module: tests.test_connection
- class FakeTransport:
- def __init__(self, local_addr, loss=0):
- self.local_addr = local_addr
- self.loop = asyncio.get_event_loop()
- self.loss = loss
-
===========changed ref 5===========
# module: tests.test_connection
- class FakeTransport:
- def sendto(self, data, addr):
- self.sent += 1
- if self.target is not None and random.random() >= self.loss:
- self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
-
===========changed ref 6===========
# module: tests.test_connection
- RTT = 0.005
-
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
===========changed ref 7===========
# module: tests.test_connection
- def create_transport(client, server, loss=0):
- client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
- client_transport.target = server
-
- server_transport = FakeTransport(SERVER_ADDR, loss=loss)
- server_transport.target = client
-
- # kick-off handshake
- server.connection_made(server_transport)
- client.connection_made(client_transport)
- client.connect(SERVER_ADDR)
- run(asyncio.sleep(0))
-
- return client_transport, server_transport
-
===========changed ref 8===========
# module: tests.test_connection
+ def create_standalone_client(self):
- def create_standalone_client():
client = QuicConnection(configuration=QuicConfiguration(is_client=True))
- client_transport = FakeTransport(CLIENT_ADDR, loss=0)
# kick-off handshake
- client.connection_made(client_transport)
+ client.connect(SERVER_ADDR, now=time.time())
- client.connect(SERVER_ADDR)
+ self.assertEqual(len(client.datagrams_to_send(now=time.time())), 1)
+ return client
- return client, client_transport
===========changed ref 9===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
- async def serve_request(reader, writer):
- # check request
- request = await reader.read(1024)
- self.assertEqual(request, b"ping")
-
- # send response
- writer.write(b"pong")
-
- # receives EOF
- request = await reader.read()
- self.assertEqual(request, b"")
-
- # sends EOF
- writer.write(b"done")
- writer.write_eof()
-
with client_and_server(
client_options={"supported_versions": client_versions},
server_options={"supported_versions": server_versions},
- server_stream_handler=lambda reader, writer: asyncio.ensure_future(
- serve_request(reader, writer)
- ),
) as (client, server):
+ # check handshake completed
+ self.assertEqual(type(client.next_event()), events.HandshakeCompleted)
+ for i in range(7):
+ self.assertEqual(type(client.next_event()), events.ConnectionIdIssued)
+ self.assertIsNone(client.next_event())
+
+ self.assertEqual(type(server.next_event()), events.HandshakeCompleted)
+ for i in range(7):
+ self.assertEqual(type(server.next_event()), events.ConnectionIdIssued)
+ self.assertIsNone(server.next_event())
- run(asyncio.gather(client.wait_connected(), server.wait_connected()))
# check each endpoint has available connection IDs for the peer
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
+ self.assertEqual(
+ sequence_numbers(server._peer_cid_available), [1, 2, 3, 4,</s>
|
tests.test_connection/QuicConnectionTest.test_consume_connection_id
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<1>:<del> run(client.wait_connected())
<6>:<add> # the client changes connection ID
<del> # change connection ID
<8>:<add> for data, addr in client.datagrams_to_send(now=time.time()):
<add> server.receive_datagram(data, CLIENT_ADDR, now=time.time())
<del> client._send_pending()
<13>:<del> # wait one RTT
<14>:<del> run(asyncio.sleep(RTT))
<15>:<del>
<17>:<add> for data, addr in server.datagrams_to_send(now=time.time()):
<add> client.receive_datagram(data, SERVER_ADDR, now=time.time())
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_consume_connection_id(self):
<0> with client_and_server() as (client, server):
<1> run(client.wait_connected())
<2> self.assertEqual(
<3> sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<4> )
<5>
<6> # change connection ID
<7> client._consume_connection_id()
<8> client._send_pending()
<9> self.assertEqual(
<10> sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
<11> )
<12>
<13> # wait one RTT
<14> run(asyncio.sleep(RTT))
<15>
<16> # the server provides a new connection ID
<17> self.assertEqual(
<18> sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
<19> )
<20>
|
===========unchanged ref 0===========
at: aioquic.tls
Epoch()
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: tests.test_connection
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
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
at: unittest.case._AssertRaisesContext.__exit__
self.exception = exc_value.with_traceback(None)
===========changed ref 0===========
# module: tests.test_connection
@contextlib.contextmanager
def client_and_server(
client_options={},
client_patch=lambda x: None,
server_options={},
server_patch=lambda x: None,
- server_stream_handler=None,
transport_options={},
):
client = QuicConnection(
configuration=QuicConfiguration(is_client=True, **client_options)
)
+ client._ack_delay = 0
client_patch(client)
server = QuicConnection(
configuration=QuicConfiguration(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
**server_options
+ )
- ),
- stream_handler=server_stream_handler,
)
+ server._ack_delay = 0
server_patch(server)
# perform handshake
+ client.connect(SERVER_ADDR, now=time.time())
+ for i in range(4):
+ tick(client, server)
- create_transport(client, server, **transport_options)
yield client, server
# close
client.close()
server.close()
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
- def test_connection_lost(self):
- with client_and_server() as (client, server):
- run(client.wait_connected())
-
- # send data over stream
- client_reader, client_writer = run(client.create_stream())
- client_writer.write(b"ping")
- run(asyncio.sleep(0))
-
- # break connection
- client.connection_lost(None)
- self.assertEqual(run(client_reader.read()), b"")
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
- def test_connection_lost_with_exception(self):
- with client_and_server() as (client, server):
- run(client.wait_connected())
-
- # send data over stream
- client_reader, client_writer = run(client.create_stream())
- client_writer.write(b"ping")
- run(asyncio.sleep(0))
-
- # break connection
- exc = Exception("some error")
- client.connection_lost(exc)
- with self.assertRaises(Exception) as cm:
- run(client_reader.read())
- self.assertEqual(cm.exception, exc)
-
===========changed ref 3===========
# module: tests.test_connection
- class FakeTransport:
- sent = 0
- target = None
-
===========changed ref 4===========
# module: tests.test_connection
+ def consume_events(connection):
+ while True:
+ event = connection.next_event()
+ if event is None:
+ break
+
===========changed ref 5===========
# module: tests.test_connection
+ def tick(client, server):
+ for data, addr in client.datagrams_to_send(now=time.time()):
+ server.receive_datagram(data, CLIENT_ADDR, now=time.time())
+
+ for data, addr in server.datagrams_to_send(now=time.time()):
+ client.receive_datagram(data, SERVER_ADDR, now=time.time())
+
===========changed ref 6===========
# module: tests.test_connection
- class FakeTransport:
- def __init__(self, local_addr, loss=0):
- self.local_addr = local_addr
- self.loop = asyncio.get_event_loop()
- self.loss = loss
-
===========changed ref 7===========
# module: tests.test_connection
- class FakeTransport:
- def sendto(self, data, addr):
- self.sent += 1
- if self.target is not None and random.random() >= self.loss:
- self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
-
===========changed ref 8===========
# module: tests.test_connection
- RTT = 0.005
-
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
===========changed ref 9===========
# module: tests.test_connection
- def create_transport(client, server, loss=0):
- client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
- client_transport.target = server
-
- server_transport = FakeTransport(SERVER_ADDR, loss=loss)
- server_transport.target = client
-
- # kick-off handshake
- server.connection_made(server_transport)
- client.connection_made(client_transport)
- client.connect(SERVER_ADDR)
- run(asyncio.sleep(0))
-
- return client_transport, server_transport
-
===========changed ref 10===========
# module: tests.test_connection
+ def create_standalone_client(self):
- def create_standalone_client():
client = QuicConnection(configuration=QuicConfiguration(is_client=True))
- client_transport = FakeTransport(CLIENT_ADDR, loss=0)
# kick-off handshake
- client.connection_made(client_transport)
+ client.connect(SERVER_ADDR, now=time.time())
- client.connect(SERVER_ADDR)
+ self.assertEqual(len(client.datagrams_to_send(now=time.time())), 1)
+ return client
- return client, client_transport
===========changed ref 11===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
client_log_file = io.StringIO()
server_log_file = io.StringIO()
with client_and_server(
client_options={"secrets_log_file": client_log_file},
server_options={"secrets_log_file": server_log_file},
) as (client, server):
- run(client.wait_connected())
-
# check secrets were logged
client_log = client_log_file.getvalue()
server_log = server_log_file.getvalue()
self.assertEqual(client_log, server_log)
labels = []
for line in client_log.splitlines():
labels.append(line.split()[0])
self.assertEqual(
labels,
[
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
)
|
tests.test_connection/QuicConnectionTest.test_create_stream
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<2>:<add> stream = client.create_stream()
<del> reader, writer = run(client.create_stream())
<3>:<add> self.assertEqual(stream.stream_id, 0)
<del> self.assertEqual(writer.get_extra_info("stream_id"), 0)
<4>:<del> self.assertIsNotNone(writer.get_extra_info("connection"))
<6>:<add> stream = client.create_stream()
<del> reader, writer = run(client.create_stream())
<7>:<add> self.assertEqual(stream.stream_id, 4)
<del> self.assertEqual(writer.get_extra_info("stream_id"), 4)
<9>:<add> stream = client.create_stream(is_unidirectional=True)
<del> reader, writer = run(client.create_stream(is_unidirectional=True))
<10>:<add> self.assertEqual(stream.stream_id, 2)
<del> self.assertEqual(writer.get_extra_info("stream_id"), 2)
<12>:<add> stream = client.create_stream(is_unidirectional=True)
<del> reader, writer = run(client.create_stream(is_unidirectional=True))
<13>:<add> self.assertEqual(stream.stream_id, 6)
<del> self.assertEqual(writer.get_extra_info("stream_id"), 6)
<16>:<add> stream = server.create_stream()
<del> reader, writer = run(server.create_stream())
<17>:<add> self.assertEqual(stream.stream_id, 1)
<del> self.assertEqual(writer.get_extra_info("stream_id"), 1)
<19>:<add> stream = server.create_stream()
<del> reader, writer = run(server.create_stream())
<20>:<add> self.assertEqual(stream.stream_id, 5)
<del> self.assertEqual(writer.get_extra_info("stream_id"), 5)
<22>:<add> stream = server.create_stream(is_unidirectional=True)
<del> reader, writer = run(server.create_stream(is_unidirectional=True))
<23>:<add> self.assertEqual(stream.stream_id, 3)
<del> self.assertEqual(writer.get_extra_info("stream_id"), 3)
<25>:<add>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream(self):
<0> with client_and_server() as (client, server):
<1> # client
<2> reader, writer = run(client.create_stream())
<3> self.assertEqual(writer.get_extra_info("stream_id"), 0)
<4> self.assertIsNotNone(writer.get_extra_info("connection"))
<5>
<6> reader, writer = run(client.create_stream())
<7> self.assertEqual(writer.get_extra_info("stream_id"), 4)
<8>
<9> reader, writer = run(client.create_stream(is_unidirectional=True))
<10> self.assertEqual(writer.get_extra_info("stream_id"), 2)
<11>
<12> reader, writer = run(client.create_stream(is_unidirectional=True))
<13> self.assertEqual(writer.get_extra_info("stream_id"), 6)
<14>
<15> # server
<16> reader, writer = run(server.create_stream())
<17> self.assertEqual(writer.get_extra_info("stream_id"), 1)
<18>
<19> reader, writer = run(server.create_stream())
<20> self.assertEqual(writer.get_extra_info("stream_id"), 5)
<21>
<22> reader, writer = run(server.create_stream(is_unidirectional=True))
<23> self.assertEqual(writer.get_extra_info("stream_id"), 3)
<24>
<25> reader, writer = run(server.create_stream(is_unidirectional=True))
<26> self.assertEqual(writer.get_extra_info("stream_id"), 7)
<27>
|
===========unchanged ref 0===========
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
TLS_VERSION_1_3_DRAFT_28 = 0x7F1C
at: tests.test_connection
SERVER_ADDR = ("2.3.4.5", 4433)
create_standalone_client(self)
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
at: time
time() -> float
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
+ def create_standalone_client(self):
- def create_standalone_client():
client = QuicConnection(configuration=QuicConfiguration(is_client=True))
- client_transport = FakeTransport(CLIENT_ADDR, loss=0)
# kick-off handshake
- client.connection_made(client_transport)
+ client.connect(SERVER_ADDR, now=time.time())
- client.connect(SERVER_ADDR)
+ self.assertEqual(len(client.datagrams_to_send(now=time.time())), 1)
+ return client
- return client, client_transport
===========changed ref 1===========
# module: tests.test_connection
@contextlib.contextmanager
def client_and_server(
client_options={},
client_patch=lambda x: None,
server_options={},
server_patch=lambda x: None,
- server_stream_handler=None,
transport_options={},
):
client = QuicConnection(
configuration=QuicConfiguration(is_client=True, **client_options)
)
+ client._ack_delay = 0
client_patch(client)
server = QuicConnection(
configuration=QuicConfiguration(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
**server_options
+ )
- ),
- stream_handler=server_stream_handler,
)
+ server._ack_delay = 0
server_patch(server)
# perform handshake
+ client.connect(SERVER_ADDR, now=time.time())
+ for i in range(4):
+ tick(client, server)
- create_transport(client, server, **transport_options)
yield client, server
# close
client.close()
server.close()
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
- def test_connection_lost(self):
- with client_and_server() as (client, server):
- run(client.wait_connected())
-
- # send data over stream
- client_reader, client_writer = run(client.create_stream())
- client_writer.write(b"ping")
- run(asyncio.sleep(0))
-
- # break connection
- client.connection_lost(None)
- self.assertEqual(run(client_reader.read()), b"")
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
- def test_connection_lost_with_exception(self):
- with client_and_server() as (client, server):
- run(client.wait_connected())
-
- # send data over stream
- client_reader, client_writer = run(client.create_stream())
- client_writer.write(b"ping")
- run(asyncio.sleep(0))
-
- # break connection
- exc = Exception("some error")
- client.connection_lost(exc)
- with self.assertRaises(Exception) as cm:
- run(client_reader.read())
- self.assertEqual(cm.exception, exc)
-
===========changed ref 4===========
# module: tests.test_connection
- class FakeTransport:
- sent = 0
- target = None
-
===========changed ref 5===========
# module: tests.test_connection
+ def consume_events(connection):
+ while True:
+ event = connection.next_event()
+ if event is None:
+ break
+
===========changed ref 6===========
# module: tests.test_connection
+ def tick(client, server):
+ for data, addr in client.datagrams_to_send(now=time.time()):
+ server.receive_datagram(data, CLIENT_ADDR, now=time.time())
+
+ for data, addr in server.datagrams_to_send(now=time.time()):
+ client.receive_datagram(data, SERVER_ADDR, now=time.time())
+
===========changed ref 7===========
# module: tests.test_connection
- class FakeTransport:
- def __init__(self, local_addr, loss=0):
- self.local_addr = local_addr
- self.loop = asyncio.get_event_loop()
- self.loss = loss
-
===========changed ref 8===========
# module: tests.test_connection
- class FakeTransport:
- def sendto(self, data, addr):
- self.sent += 1
- if self.target is not None and random.random() >= self.loss:
- self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
-
===========changed ref 9===========
# module: tests.test_connection
- RTT = 0.005
-
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
===========changed ref 10===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_consume_connection_id(self):
with client_and_server() as (client, server):
- run(client.wait_connected())
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
+ # the client changes connection ID
- # change connection ID
client._consume_connection_id()
+ for data, addr in client.datagrams_to_send(now=time.time()):
+ server.receive_datagram(data, CLIENT_ADDR, now=time.time())
- client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
)
- # wait one RTT
- run(asyncio.sleep(RTT))
-
# the server provides a new connection ID
+ for data, addr in server.datagrams_to_send(now=time.time()):
+ client.receive_datagram(data, SERVER_ADDR, now=time.time())
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
)
===========changed ref 11===========
# module: tests.test_connection
- def create_transport(client, server, loss=0):
- client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
- client_transport.target = server
-
- server_transport = FakeTransport(SERVER_ADDR, loss=loss)
- server_transport.target = client
-
- # kick-off handshake
- server.connection_made(server_transport)
- client.connection_made(client_transport)
- client.connect(SERVER_ADDR)
- run(asyncio.sleep(0))
-
- return client_transport, server_transport
-
|
tests.test_connection/QuicConnectionTest.test_create_stream_over_max_streams
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<1>:<del> run(client.wait_connected())
<2>:<del>
<5>:<add> client.send_stream_data(i * 4, b"")
<del> client_reader, client_writer = run(client.create_stream())
<9>:<add> client.send_stream_data(128 * 4, b"")
<del> client_reader, client_writer = run(client.create_stream())
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
<0> with client_and_server() as (client, server):
<1> run(client.wait_connected())
<2>
<3> # create streams
<4> for i in range(128):
<5> client_reader, client_writer = run(client.create_stream())
<6>
<7> # create one too many
<8> with self.assertRaises(ValueError) as cm:
<9> client_reader, client_writer = run(client.create_stream())
<10> self.assertEqual(str(cm.exception), "Too many streams open")
<11>
|
===========unchanged ref 0===========
at: aioquic._buffer.Buffer
push_bytes(value: bytes) -> None
at: aioquic.connection.QuicConnection.__init__
self.host_cid = self._host_cids[0].cid
self._peer_cid = os.urandom(8)
at: aioquic.connection.QuicConnection._consume_connection_id
self._peer_cid = connection_id.cid
at: aioquic.connection.QuicConnection.receive_datagram
self._peer_cid = header.source_cid
self.host_cid = context.host_cid
at: aioquic.crypto
CryptoPair()
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> Tuple[List[bytes], List[QuicSentPacket]]
start_packet(packet_type: int, crypto: CryptoPair, is_probe=False) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: tests.test_connection
SERVER_ADDR = ("2.3.4.5", 4433)
at: tests.test_connection.QuicConnectionTest.test_receive_datagram_wrong_version
client = create_standalone_client(self)
builder = QuicPacketBuilder(
host_cid=client._peer_cid,
peer_cid=client.host_cid,
version=0xFF000011, # DRAFT_16
)
at: time
time() -> float
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
- def test_connection_lost(self):
- with client_and_server() as (client, server):
- run(client.wait_connected())
-
- # send data over stream
- client_reader, client_writer = run(client.create_stream())
- client_writer.write(b"ping")
- run(asyncio.sleep(0))
-
- # break connection
- client.connection_lost(None)
- self.assertEqual(run(client_reader.read()), b"")
-
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
- def test_connection_lost_with_exception(self):
- with client_and_server() as (client, server):
- run(client.wait_connected())
-
- # send data over stream
- client_reader, client_writer = run(client.create_stream())
- client_writer.write(b"ping")
- run(asyncio.sleep(0))
-
- # break connection
- exc = Exception("some error")
- client.connection_lost(exc)
- with self.assertRaises(Exception) as cm:
- run(client_reader.read())
- self.assertEqual(cm.exception, exc)
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_receive_datagram_wrong_version(self):
+ client = create_standalone_client(self)
+
+ builder = QuicPacketBuilder(
+ host_cid=client._peer_cid,
+ peer_cid=client.host_cid,
+ version=0xFF000011, # DRAFT_16
+ )
+ crypto = CryptoPair()
+ crypto.setup_initial(client.host_cid, is_client=False)
+ builder.start_packet(PACKET_TYPE_INITIAL, crypto)
+ builder.buffer.push_bytes(bytes(1200))
+ builder.end_packet()
+
+ for datagram in builder.flush()[0]:
+ client.receive_datagram(datagram, SERVER_ADDR, now=time.time())
+ self.assertEqual(len(client.datagrams_to_send(now=time.time())), 0)
+
===========changed ref 3===========
# module: tests.test_connection
- class FakeTransport:
- sent = 0
- target = None
-
===========changed ref 4===========
# module: tests.test_connection
+ def consume_events(connection):
+ while True:
+ event = connection.next_event()
+ if event is None:
+ break
+
===========changed ref 5===========
# module: tests.test_connection
+ def tick(client, server):
+ for data, addr in client.datagrams_to_send(now=time.time()):
+ server.receive_datagram(data, CLIENT_ADDR, now=time.time())
+
+ for data, addr in server.datagrams_to_send(now=time.time()):
+ client.receive_datagram(data, SERVER_ADDR, now=time.time())
+
===========changed ref 6===========
# module: tests.test_connection
- class FakeTransport:
- def __init__(self, local_addr, loss=0):
- self.local_addr = local_addr
- self.loop = asyncio.get_event_loop()
- self.loss = loss
-
===========changed ref 7===========
# module: tests.test_connection
- class FakeTransport:
- def sendto(self, data, addr):
- self.sent += 1
- if self.target is not None and random.random() >= self.loss:
- self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
-
===========changed ref 8===========
# module: tests.test_connection
- RTT = 0.005
-
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
===========changed ref 9===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_consume_connection_id(self):
with client_and_server() as (client, server):
- run(client.wait_connected())
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
+ # the client changes connection ID
- # change connection ID
client._consume_connection_id()
+ for data, addr in client.datagrams_to_send(now=time.time()):
+ server.receive_datagram(data, CLIENT_ADDR, now=time.time())
- client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
)
- # wait one RTT
- run(asyncio.sleep(RTT))
-
# the server provides a new connection ID
+ for data, addr in server.datagrams_to_send(now=time.time()):
+ client.receive_datagram(data, SERVER_ADDR, now=time.time())
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
)
===========changed ref 10===========
# module: tests.test_connection
- def create_transport(client, server, loss=0):
- client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
- client_transport.target = server
-
- server_transport = FakeTransport(SERVER_ADDR, loss=loss)
- server_transport.target = client
-
- # kick-off handshake
- server.connection_made(server_transport)
- client.connection_made(client_transport)
- client.connect(SERVER_ADDR)
- run(asyncio.sleep(0))
-
- return client_transport, server_transport
-
|
tests.test_connection/QuicConnectionTest.test_decryption_error
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<1>:<del> run(client.wait_connected())
<2>:<del>
<8>:<add> # server sends close
<del> # close
<10>:<add> for data, addr in server.datagrams_to_send(now=time.time()):
<add> client.receive_datagram(data, SERVER_ADDR, now=time.time())
<del> run(server.wait_closed())
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
<0> with client_and_server() as (client, server):
<1> run(client.wait_connected())
<2>
<3> # mess with encryption key
<4> server._cryptos[tls.Epoch.ONE_RTT].send.setup(
<5> tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
<6> )
<7>
<8> # close
<9> server.close(error_code=QuicErrorCode.NO_ERROR)
<10> run(server.wait_closed())
<11>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
encode_quic_retry(version: int, source_cid: bytes, destination_cid: bytes, original_destination_cid: bytes, retry_token: bytes) -> bytes
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_connection
create_standalone_client(self)
===========changed ref 0===========
# module: tests.test_connection
+ def create_standalone_client(self):
- def create_standalone_client():
client = QuicConnection(configuration=QuicConfiguration(is_client=True))
- client_transport = FakeTransport(CLIENT_ADDR, loss=0)
# kick-off handshake
- client.connection_made(client_transport)
+ client.connect(SERVER_ADDR, now=time.time())
- client.connect(SERVER_ADDR)
+ self.assertEqual(len(client.datagrams_to_send(now=time.time())), 1)
+ return client
- return client, client_transport
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
with client_and_server() as (client, server):
- run(client.wait_connected())
-
# create streams
for i in range(128):
+ client.send_stream_data(i * 4, b"")
- client_reader, client_writer = run(client.create_stream())
# create one too many
with self.assertRaises(ValueError) as cm:
+ client.send_stream_data(128 * 4, b"")
- client_reader, client_writer = run(client.create_stream())
self.assertEqual(str(cm.exception), "Too many streams open")
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_receive_datagram_wrong_version(self):
+ client = create_standalone_client(self)
+
+ builder = QuicPacketBuilder(
+ host_cid=client._peer_cid,
+ peer_cid=client.host_cid,
+ version=0xFF000011, # DRAFT_16
+ )
+ crypto = CryptoPair()
+ crypto.setup_initial(client.host_cid, is_client=False)
+ builder.start_packet(PACKET_TYPE_INITIAL, crypto)
+ builder.buffer.push_bytes(bytes(1200))
+ builder.end_packet()
+
+ for datagram in builder.flush()[0]:
+ client.receive_datagram(datagram, SERVER_ADDR, now=time.time())
+ self.assertEqual(len(client.datagrams_to_send(now=time.time())), 0)
+
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
- def test_connection_lost(self):
- with client_and_server() as (client, server):
- run(client.wait_connected())
-
- # send data over stream
- client_reader, client_writer = run(client.create_stream())
- client_writer.write(b"ping")
- run(asyncio.sleep(0))
-
- # break connection
- client.connection_lost(None)
- self.assertEqual(run(client_reader.read()), b"")
-
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
- def test_connection_lost_with_exception(self):
- with client_and_server() as (client, server):
- run(client.wait_connected())
-
- # send data over stream
- client_reader, client_writer = run(client.create_stream())
- client_writer.write(b"ping")
- run(asyncio.sleep(0))
-
- # break connection
- exc = Exception("some error")
- client.connection_lost(exc)
- with self.assertRaises(Exception) as cm:
- run(client_reader.read())
- self.assertEqual(cm.exception, exc)
-
===========changed ref 5===========
# module: tests.test_connection
- class FakeTransport:
- sent = 0
- target = None
-
===========changed ref 6===========
# module: tests.test_connection
+ def consume_events(connection):
+ while True:
+ event = connection.next_event()
+ if event is None:
+ break
+
===========changed ref 7===========
# module: tests.test_connection
+ def tick(client, server):
+ for data, addr in client.datagrams_to_send(now=time.time()):
+ server.receive_datagram(data, CLIENT_ADDR, now=time.time())
+
+ for data, addr in server.datagrams_to_send(now=time.time()):
+ client.receive_datagram(data, SERVER_ADDR, now=time.time())
+
===========changed ref 8===========
# module: tests.test_connection
- class FakeTransport:
- def __init__(self, local_addr, loss=0):
- self.local_addr = local_addr
- self.loop = asyncio.get_event_loop()
- self.loss = loss
-
===========changed ref 9===========
# module: tests.test_connection
- class FakeTransport:
- def sendto(self, data, addr):
- self.sent += 1
- if self.target is not None and random.random() >= self.loss:
- self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
-
===========changed ref 10===========
# module: tests.test_connection
- RTT = 0.005
-
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
===========changed ref 11===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_consume_connection_id(self):
with client_and_server() as (client, server):
- run(client.wait_connected())
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
+ # the client changes connection ID
- # change connection ID
client._consume_connection_id()
+ for data, addr in client.datagrams_to_send(now=time.time()):
+ server.receive_datagram(data, CLIENT_ADDR, now=time.time())
- client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
)
- # wait one RTT
- run(asyncio.sleep(RTT))
-
# the server provides a new connection ID
+ for data, addr in server.datagrams_to_send(now=time.time()):
+ client.receive_datagram(data, SERVER_ADDR, now=time.time())
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
)
===========changed ref 12===========
# module: tests.test_connection
- def create_transport(client, server, loss=0):
- client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
- client_transport.target = server
-
- server_transport = FakeTransport(SERVER_ADDR, loss=loss)
- server_transport.target = client
-
- # kick-off handshake
- server.connection_made(server_transport)
- client.connection_made(client_transport)
- client.connect(SERVER_ADDR)
- run(asyncio.sleep(0))
-
- return client_transport, server_transport
-
|
tests.test_connection/QuicConnectionTest.test_tls_error
|
Modified
|
aiortc~aioquic
|
6b20cde81e13e54c558bdac21103f68ebae6e39c
|
[connection] move asyncio code out of QuicConnection (see #4)
|
<11>:<del> with self.assertRaises(QuicConnectionError) as cm:
<12>:<del> run(asyncio.gather(client.wait_connected(), server.wait_connected()))
<13>:<del> self.assertEqual(cm.exception.error_code, 326)
<14>:<del> self.assertEqual(cm.exception.frame_type, QuicFrameType.CRYPTO)
<15>:<del> self.assertEqual(
<16>:<del> cm.exception.reason_phrase, "No supported protocol version"
<17>:<del> )
<18>:<add> timer_at = server.get_timer()
<add> server.handle_timer(timer_at)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_tls_error(self):
<0> def patch(client):
<1> real_initialize = client._initialize
<2>
<3> def patched_initialize(peer_cid: bytes):
<4> real_initialize(peer_cid)
<5> client.tls._supported_versions = [tls.TLS_VERSION_1_3_DRAFT_28]
<6>
<7> client._initialize = patched_initialize
<8>
<9> # handshake fails
<10> with client_and_server(client_patch=patch) as (client, server):
<11> with self.assertRaises(QuicConnectionError) as cm:
<12> run(asyncio.gather(client.wait_connected(), server.wait_connected()))
<13> self.assertEqual(cm.exception.error_code, 326)
<14> self.assertEqual(cm.exception.frame_type, QuicFrameType.CRYPTO)
<15> self.assertEqual(
<16> cm.exception.reason_phrase, "No supported protocol version"
<17> )
<18>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
encode_quic_retry(version: int, source_cid: bytes, destination_cid: bytes, original_destination_cid: bytes, retry_token: bytes) -> bytes
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_connection
SERVER_ADDR = ("2.3.4.5", 4433)
create_standalone_client(self)
at: tests.test_connection.QuicConnectionTest.test_receive_datagram_retry
client = create_standalone_client(self)
at: time
time() -> float
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
+ def create_standalone_client(self):
- def create_standalone_client():
client = QuicConnection(configuration=QuicConfiguration(is_client=True))
- client_transport = FakeTransport(CLIENT_ADDR, loss=0)
# kick-off handshake
- client.connection_made(client_transport)
+ client.connect(SERVER_ADDR, now=time.time())
- client.connect(SERVER_ADDR)
+ self.assertEqual(len(client.datagrams_to_send(now=time.time())), 1)
+ return client
- return client, client_transport
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_receive_datagram_retry(self):
+ client = create_standalone_client(self)
+
+ client.receive_datagram(
+ encode_quic_retry(
+ version=QuicProtocolVersion.DRAFT_20,
+ source_cid=binascii.unhexlify("85abb547bf28be97"),
+ destination_cid=client.host_cid,
+ original_destination_cid=client._peer_cid,
+ retry_token=bytes(16),
+ ),
+ SERVER_ADDR,
+ now=time.time(),
+ )
+ self.assertEqual(len(client.datagrams_to_send(now=time.time())), 1)
+
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
with client_and_server() as (client, server):
- run(client.wait_connected())
-
# mess with encryption key
server._cryptos[tls.Epoch.ONE_RTT].send.setup(
tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
)
+ # server sends close
- # close
server.close(error_code=QuicErrorCode.NO_ERROR)
+ for data, addr in server.datagrams_to_send(now=time.time()):
+ client.receive_datagram(data, SERVER_ADDR, now=time.time())
- run(server.wait_closed())
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
with client_and_server() as (client, server):
- run(client.wait_connected())
-
# create streams
for i in range(128):
+ client.send_stream_data(i * 4, b"")
- client_reader, client_writer = run(client.create_stream())
# create one too many
with self.assertRaises(ValueError) as cm:
+ client.send_stream_data(128 * 4, b"")
- client_reader, client_writer = run(client.create_stream())
self.assertEqual(str(cm.exception), "Too many streams open")
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_receive_datagram_wrong_version(self):
+ client = create_standalone_client(self)
+
+ builder = QuicPacketBuilder(
+ host_cid=client._peer_cid,
+ peer_cid=client.host_cid,
+ version=0xFF000011, # DRAFT_16
+ )
+ crypto = CryptoPair()
+ crypto.setup_initial(client.host_cid, is_client=False)
+ builder.start_packet(PACKET_TYPE_INITIAL, crypto)
+ builder.buffer.push_bytes(bytes(1200))
+ builder.end_packet()
+
+ for datagram in builder.flush()[0]:
+ client.receive_datagram(datagram, SERVER_ADDR, now=time.time())
+ self.assertEqual(len(client.datagrams_to_send(now=time.time())), 0)
+
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
- def test_connection_lost(self):
- with client_and_server() as (client, server):
- run(client.wait_connected())
-
- # send data over stream
- client_reader, client_writer = run(client.create_stream())
- client_writer.write(b"ping")
- run(asyncio.sleep(0))
-
- # break connection
- client.connection_lost(None)
- self.assertEqual(run(client_reader.read()), b"")
-
===========changed ref 6===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
- def test_connection_lost_with_exception(self):
- with client_and_server() as (client, server):
- run(client.wait_connected())
-
- # send data over stream
- client_reader, client_writer = run(client.create_stream())
- client_writer.write(b"ping")
- run(asyncio.sleep(0))
-
- # break connection
- exc = Exception("some error")
- client.connection_lost(exc)
- with self.assertRaises(Exception) as cm:
- run(client_reader.read())
- self.assertEqual(cm.exception, exc)
-
===========changed ref 7===========
# module: tests.test_connection
- class FakeTransport:
- sent = 0
- target = None
-
===========changed ref 8===========
# module: tests.test_connection
+ def consume_events(connection):
+ while True:
+ event = connection.next_event()
+ if event is None:
+ break
+
===========changed ref 9===========
# module: tests.test_connection
+ def tick(client, server):
+ for data, addr in client.datagrams_to_send(now=time.time()):
+ server.receive_datagram(data, CLIENT_ADDR, now=time.time())
+
+ for data, addr in server.datagrams_to_send(now=time.time()):
+ client.receive_datagram(data, SERVER_ADDR, now=time.time())
+
===========changed ref 10===========
# module: tests.test_connection
- class FakeTransport:
- def __init__(self, local_addr, loss=0):
- self.local_addr = local_addr
- self.loop = asyncio.get_event_loop()
- self.loss = loss
-
===========changed ref 11===========
# module: tests.test_connection
- class FakeTransport:
- def sendto(self, data, addr):
- self.sent += 1
- if self.target is not None and random.random() >= self.loss:
- self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
-
===========changed ref 12===========
# module: tests.test_connection
- RTT = 0.005
-
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.