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.tls/Context._client_handle_finished
|
Modified
|
aiortc~aioquic
|
677b31fdb890dc9de8bfe4114e262a24d788913f
|
[tls] raise AlertDecryptError where appropriate
|
<4>:<add> if finished.verify_data != expected_verify_data:
<del> assert finished.verify_data == expected_verify_data
<5>:<add> raise AlertDecryptError
|
# module: aioquic.tls
class Context:
def _client_handle_finished(self, input_buf: Buffer, output_buf: Buffer) -> None:
<0> finished = pull_finished(input_buf)
<1>
<2> # check verify data
<3> expected_verify_data = self.key_schedule.finished_verify_data(self._dec_key)
<4> assert finished.verify_data == expected_verify_data
<5> self.key_schedule.update_hash(input_buf.data)
<6>
<7> # prepare traffic keys
<8> assert self.key_schedule.generation == 2
<9> self.key_schedule.extract(None)
<10> self._setup_traffic_protection(
<11> Direction.DECRYPT, Epoch.ONE_RTT, b"s ap traffic"
<12> )
<13> next_enc_key = self.key_schedule.derive_secret(b"c ap traffic")
<14>
<15> # send finished
<16> with push_message(self.key_schedule, output_buf):
<17> push_finished(
<18> output_buf,
<19> Finished(
<20> verify_data=self.key_schedule.finished_verify_data(self._enc_key)
<21> ),
<22> )
<23>
<24> # commit traffic key
<25> self._enc_key = next_enc_key
<26> self.update_traffic_key_cb(
<27> Direction.ENCRYPT,
<28> Epoch.ONE_RTT,
<29> self.key_schedule.cipher_suite,
<30> self._enc_key,
<31> )
<32>
<33> self._set_state(State.CLIENT_POST_HANDSHAKE)
<34>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.tls
AlertDecryptError(*args: object)
Direction()
Epoch()
State()
Finished(verify_data: bytes=b"")
pull_finished(buf: Buffer) -> Finished
push_finished(buf: Buffer, finished: Finished) -> None
push_message(key_schedule: Union[KeySchedule, KeyScheduleProxy], buf: Buffer) -> Generator
at: aioquic.tls.Context
_setup_traffic_protection(direction: Direction, epoch: Epoch, label: bytes) -> None
_set_state(state: State) -> None
at: aioquic.tls.Context.__init__
self.key_schedule: Optional[KeySchedule] = None
self._enc_key: Optional[bytes] = None
self._dec_key: Optional[bytes] = None
at: aioquic.tls.Context._client_handle_finished
self._enc_key = next_enc_key
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self._key_schedule_psk
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
at: aioquic.tls.Context._server_handle_finished
self._dec_key = self._next_dec_key
at: aioquic.tls.Context._server_handle_hello
self.key_schedule = KeySchedule(cipher_suite)
at: aioquic.tls.Context._setup_traffic_protection
self._enc_key = key
self._dec_key = key
at: aioquic.tls.Finished
verify_data: bytes = b""
at: aioquic.tls.KeySchedule
finished_verify_data(secret: bytes) -> bytes
derive_secret(label: bytes) -> bytes
===========unchanged ref 1===========
extract(key_material: Optional[bytes]=None) -> None
update_hash(data: bytes) -> None
at: aioquic.tls.KeySchedule.__init__
self.generation = 0
at: aioquic.tls.KeySchedule.extract
self.generation += 1
===========changed ref 0===========
# module: aioquic.tls
+ class AlertDecryptError(Alert):
+ description = AlertDescription.decrypt_error
+
===========changed ref 1===========
# module: aioquic.tls
class Context:
def _client_handle_certificate_verify(self, input_buf: Buffer) -> None:
verify = pull_certificate_verify(input_buf)
assert verify.algorithm in self._signature_algorithms
# check signature
+ try:
+ self._peer_certificate.public_key().verify(
- self._peer_certificate.public_key().verify(
+ verify.signature,
- verify.signature,
+ self.key_schedule.certificate_verify_data(
- self.key_schedule.certificate_verify_data(
+ b"TLS 1.3, server CertificateVerify"
- b"TLS 1.3, server CertificateVerify"
+ ),
- ),
+ *signature_algorithm_params(verify.algorithm),
- *signature_algorithm_params(verify.algorithm),
+ )
- )
+ except InvalidSignature:
+ raise AlertDecryptError
self.key_schedule.update_hash(input_buf.data)
self._set_state(State.CLIENT_EXPECT_FINISHED)
|
aioquic.tls/Context._server_handle_finished
|
Modified
|
aiortc~aioquic
|
677b31fdb890dc9de8bfe4114e262a24d788913f
|
[tls] raise AlertDecryptError where appropriate
|
<4>:<add> if finished.verify_data != expected_verify_data:
<del> assert finished.verify_data == expected_verify_data
<5>:<add> raise AlertDecryptError
|
# module: aioquic.tls
class Context:
def _server_handle_finished(self, input_buf: Buffer, output_buf: Buffer) -> None:
<0> finished = pull_finished(input_buf)
<1>
<2> # check verify data
<3> expected_verify_data = self.key_schedule.finished_verify_data(self._dec_key)
<4> assert finished.verify_data == expected_verify_data
<5>
<6> # commit traffic key
<7> self._dec_key = self._next_dec_key
<8> self._next_dec_key = None
<9> self.update_traffic_key_cb(
<10> Direction.DECRYPT,
<11> Epoch.ONE_RTT,
<12> self.key_schedule.cipher_suite,
<13> self._dec_key,
<14> )
<15>
<16> self.key_schedule.update_hash(input_buf.data)
<17>
<18> self._set_state(State.SERVER_POST_HANDSHAKE)
<19>
<20> # create a new session ticket
<21> if self.new_session_ticket_cb is not None:
<22> new_session_ticket = NewSessionTicket(
<23> ticket_lifetime=86400,
<24> ticket_age_add=struct.unpack("I", os.urandom(4))[0],
<25> ticket_nonce=b"",
<26> ticket=os.urandom(64),
<27> max_early_data_size=0xFFFFFFFF,
<28> )
<29>
<30> # notify application
<31> ticket = self._build_session_ticket(new_session_ticket)
<32> self.new_session_ticket_cb(ticket)
<33>
<34> # send messsage
<35> push_new_session_ticket(output_buf, new_session_ticket)
<36>
|
===========unchanged ref 0===========
at: _struct
unpack(format, buffer, /)
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.tls
AlertDecryptError(*args: object)
Direction()
Epoch()
State()
NewSessionTicket(ticket_lifetime: int=0, ticket_age_add: int=0, ticket_nonce: bytes=b"", ticket: bytes=b"", max_early_data_size: Optional[int]=None)
pull_finished(buf: Buffer) -> Finished
at: aioquic.tls.Context
_setup_traffic_protection(direction: Direction, epoch: Epoch, label: bytes) -> None
_set_state(state: State) -> None
at: aioquic.tls.Context.__init__
self.key_schedule: Optional[KeySchedule] = 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
self._dec_key: Optional[bytes] = None
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self._key_schedule_psk
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
at: aioquic.tls.Context._server_handle_hello
self.key_schedule = KeySchedule(cipher_suite)
at: aioquic.tls.Context._setup_traffic_protection
self._dec_key = key
at: aioquic.tls.Finished
verify_data: bytes = b""
at: aioquic.tls.KeySchedule
finished_verify_data(secret: bytes) -> bytes
derive_secret(label: bytes) -> bytes
extract(key_material: Optional[bytes]=None) -> None
===========unchanged ref 1===========
update_hash(data: bytes) -> None
at: aioquic.tls.KeySchedule.__init__
self.cipher_suite = cipher_suite
self.generation = 0
at: aioquic.tls.KeySchedule.extract
self.generation += 1
at: aioquic.tls.NewSessionTicket
ticket_lifetime: int = 0
ticket_age_add: int = 0
ticket_nonce: bytes = b""
ticket: bytes = b""
max_early_data_size: Optional[int] = None
at: os
urandom(size: int, /) -> bytes
===========changed ref 0===========
# module: aioquic.tls
+ class AlertDecryptError(Alert):
+ description = AlertDescription.decrypt_error
+
===========changed ref 1===========
# module: aioquic.tls
class Context:
def _client_handle_certificate_verify(self, input_buf: Buffer) -> None:
verify = pull_certificate_verify(input_buf)
assert verify.algorithm in self._signature_algorithms
# check signature
+ try:
+ self._peer_certificate.public_key().verify(
- self._peer_certificate.public_key().verify(
+ verify.signature,
- verify.signature,
+ self.key_schedule.certificate_verify_data(
- self.key_schedule.certificate_verify_data(
+ b"TLS 1.3, server CertificateVerify"
- b"TLS 1.3, server CertificateVerify"
+ ),
- ),
+ *signature_algorithm_params(verify.algorithm),
- *signature_algorithm_params(verify.algorithm),
+ )
- )
+ except InvalidSignature:
+ raise AlertDecryptError
self.key_schedule.update_hash(input_buf.data)
self._set_state(State.CLIENT_EXPECT_FINISHED)
===========changed ref 2===========
# module: aioquic.tls
class Context:
def _client_handle_finished(self, input_buf: Buffer, output_buf: Buffer) -> None:
finished = pull_finished(input_buf)
# check verify data
expected_verify_data = self.key_schedule.finished_verify_data(self._dec_key)
+ if finished.verify_data != expected_verify_data:
- assert finished.verify_data == expected_verify_data
+ raise AlertDecryptError
self.key_schedule.update_hash(input_buf.data)
# prepare traffic keys
assert self.key_schedule.generation == 2
self.key_schedule.extract(None)
self._setup_traffic_protection(
Direction.DECRYPT, Epoch.ONE_RTT, b"s ap traffic"
)
next_enc_key = self.key_schedule.derive_secret(b"c ap traffic")
# send finished
with push_message(self.key_schedule, output_buf):
push_finished(
output_buf,
Finished(
verify_data=self.key_schedule.finished_verify_data(self._enc_key)
),
)
# commit traffic key
self._enc_key = next_enc_key
self.update_traffic_key_cb(
Direction.ENCRYPT,
Epoch.ONE_RTT,
self.key_schedule.cipher_suite,
self._enc_key,
)
self._set_state(State.CLIENT_POST_HANDSHAKE)
|
aioquic.tls/Context.__init__
|
Modified
|
aiortc~aioquic
|
57012f7d8894010b9a27e9fc5826a810e3dcd12f
|
[tls] send New Session Ticket as soon as possible
|
# module: aioquic.tls
class Context:
def __init__(
self,
is_client: bool,
logger: Optional[Union[logging.Logger, logging.LoggerAdapter]] = None,
):
<0> self.alpn_negotiated: Optional[str] = None
<1> self.alpn_protocols: Optional[List[str]] = None
<2> self.certificate: Optional[x509.Certificate] = None
<3> self.certificate_private_key: Optional[
<4> Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
<5> ] = None
<6> self.early_data_accepted = False
<7> self.handshake_extensions: List[Extension] = []
<8> self.key_schedule: Optional[KeySchedule] = None
<9> self.received_extensions: Optional[List[Extension]] = None
<10> self.session_ticket: Optional[SessionTicket] = None
<11> self.server_name: Optional[str] = None
<12>
<13> # callbacks
<14> self.get_session_ticket_cb: Optional[SessionTicketFetcher] = None
<15> self.new_session_ticket_cb: Optional[SessionTicketHandler] = None
<16> self.update_traffic_key_cb: Callable[
<17> [Direction, Epoch, CipherSuite, bytes], None
<18> ] = lambda d, e, c, s: None
<19>
<20> # supported parameters
<21> self._cipher_suites = [
<22> CipherSuite.AES_256_GCM_SHA384,
<23> CipherSuite.AES_128_GCM_SHA256,
<24> CipherSuite.CHACHA20_POLY1305_SHA256,
<25> ]
<26> self._compression_methods = [CompressionMethod.NULL]
<27> self._key_exchange_modes = [KeyExchangeMode.PSK_DHE_KE]
<28> self._signature_algorithms = [
<29> SignatureAlgorithm.RSA_PSS_RSAE_SHA256,
<30> SignatureAlgorithm.ECDSA_SECP256R1_SHA256,
<31> SignatureAlgorithm.RSA_PKCS1_SHA256,</s>
|
===========below chunk 0===========
# module: aioquic.tls
class Context:
def __init__(
self,
is_client: bool,
logger: Optional[Union[logging.Logger, logging.LoggerAdapter]] = None,
):
# offset: 1
]
self._supported_groups = [Group.SECP256R1]
self._supported_versions = [TLS_VERSION_1_3]
# state
self._key_schedule_psk: Optional[KeySchedule] = None
self._key_schedule_proxy: Optional[KeyScheduleProxy] = None
self._peer_certificate: Optional[x509.Certificate] = None
self._receive_buffer = b""
self._session_resumed = False
self._enc_key: Optional[bytes] = None
self._dec_key: Optional[bytes] = None
self.__logger = logger
self._ec_private_key: Optional[ec.EllipticCurvePrivateKey] = None
self._x25519_private_key: Optional[x25519.X25519PrivateKey] = None
if is_client:
self.client_random = os.urandom(32)
self.session_id = os.urandom(32)
self.state = State.CLIENT_HANDSHAKE_START
else:
self.client_random = None
self.session_id = None
self.state = State.SERVER_EXPECT_CLIENT_HELLO
===========unchanged ref 0===========
at: aioquic.tls
TLS_VERSION_1_3 = 0x0304
Direction()
Epoch()
State()
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
CompressionMethod(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
CompressionMethod(x: Union[str, bytes, bytearray], base: int)
Group(x: Union[str, bytes, bytearray], base: int)
Group(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
KeyExchangeMode(x: Union[str, bytes, bytearray], base: int)
KeyExchangeMode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
SignatureAlgorithm(x: Union[str, bytes, bytearray], base: int)
SignatureAlgorithm(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
Extension = Tuple[int, bytes]
NewSessionTicket(ticket_lifetime: int=0, ticket_age_add: int=0, ticket_nonce: bytes=b"", ticket: bytes=b"", max_early_data_size: Optional[int]=None)
KeySchedule(cipher_suite: CipherSuite)
KeyScheduleProxy(cipher_suites: List[CipherSuite])
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))
SessionTicketFetcher = Callable[[bytes], Optional[SessionTicket]]
SessionTicketHandler = Callable[[SessionTicket], None]
===========unchanged ref 1===========
at: aioquic.tls.Context._client_handle_certificate
self._peer_certificate = x509.load_der_x509_certificate(
certificate.certificates[0][0], backend=default_backend()
)
at: aioquic.tls.Context._client_handle_encrypted_extensions
self.alpn_negotiated = encrypted_extensions.alpn_protocol
self.early_data_accepted = encrypted_extensions.early_data
self.received_extensions = encrypted_extensions.other_extensions
at: aioquic.tls.Context._client_handle_finished
self._enc_key = next_enc_key
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self._key_schedule_psk
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
self._session_resumed = True
self._key_schedule_psk = None
self._key_schedule_proxy = None
at: aioquic.tls.Context._client_send_hello
self._ec_private_key = ec.generate_private_key(
GROUP_TO_CURVE[Group.SECP256R1](), default_backend()
)
self._x25519_private_key = x25519.X25519PrivateKey.generate()
self._key_schedule_psk = KeySchedule(self.session_ticket.cipher_suite)
self._key_schedule_proxy = KeyScheduleProxy(hello.cipher_suites)
at: aioquic.tls.Context._server_handle_finished
self._dec_key = self._next_dec_key
at: aioquic.tls.Context._server_handle_hello
self.alpn_negotiated = negotiate(
self.alpn_protocols,
peer_hello.alpn_protocols,
AlertHandshakeFailure("No common ALPN protocols"),
)
self.client_random = peer_hello.random
===========unchanged ref 2===========
self.session_id = peer_hello.session_id
self.received_extensions = peer_hello.other_extensions
self.key_schedule = KeySchedule(cipher_suite)
self._session_resumed = True
self.early_data_accepted = True
self._x25519_private_key = x25519.X25519PrivateKey.generate()
self._ec_private_key = ec.generate_private_key(
GROUP_TO_CURVE[key_share[0]](), default_backend()
)
self._new_session_ticket = NewSessionTicket(
ticket_lifetime=86400,
ticket_age_add=struct.unpack("I", os.urandom(4))[0],
ticket_nonce=b"",
ticket=os.urandom(64),
max_early_data_size=0xFFFFFFFF,
)
at: aioquic.tls.Context._set_state
self.state = state
at: aioquic.tls.Context._setup_traffic_protection
self._enc_key = key
self._dec_key = key
at: aioquic.tls.Context.handle_message
self._receive_buffer += input_data
self._receive_buffer = self._receive_buffer[message_length:]
at: logging
Logger(name: str, level: _Level=...)
LoggerAdapter(logger: Logger, extra: Mapping[str, Any])
at: os
urandom(size: int, /) -> bytes
at: typing
Callable = _CallableType(collections.abc.Callable, 2)
List = _alias(list, 1, inst=False, name='List')
|
|
aioquic.tls/Context.handle_message
|
Modified
|
aiortc~aioquic
|
57012f7d8894010b9a27e9fc5826a810e3dcd12f
|
[tls] send New Session Ticket as soon as possible
|
# module: aioquic.tls
class Context:
def handle_message(
self, input_data: bytes, output_buf: Dict[Epoch, Buffer]
) -> None:
<0> if self.state == State.CLIENT_HANDSHAKE_START:
<1> self._client_send_hello(output_buf[Epoch.INITIAL])
<2> return
<3>
<4> self._receive_buffer += input_data
<5> while len(self._receive_buffer) >= 4:
<6> # determine message length
<7> message_type = self._receive_buffer[0]
<8> message_length = 0
<9> for b in self._receive_buffer[1:4]:
<10> message_length = (message_length << 8) | b
<11> message_length += 4
<12>
<13> # check message is complete
<14> if len(self._receive_buffer) < message_length:
<15> break
<16> message = self._receive_buffer[:message_length]
<17> self._receive_buffer = self._receive_buffer[message_length:]
<18>
<19> input_buf = Buffer(data=message)
<20>
<21> # client states
<22>
<23> if self.state == State.CLIENT_EXPECT_SERVER_HELLO:
<24> if message_type == HandshakeType.SERVER_HELLO:
<25> self._client_handle_hello(input_buf, output_buf[Epoch.INITIAL])
<26> else:
<27> raise AlertUnexpectedMessage
<28> elif self.state == State.CLIENT_EXPECT_ENCRYPTED_EXTENSIONS:
<29> if message_type == HandshakeType.ENCRYPTED_EXTENSIONS:
<30> self._client_handle_encrypted_extensions(input_buf)
<31> else:
<32> raise AlertUnexpectedMessage
<33> elif self.state == State.CLIENT_EXPECT_CERTIFICATE_REQUEST_OR_CERTIFICATE:
<34> if message_type == HandshakeType.CERTIFICATE:
<35> self._client_handle_certificate(input_buf)
<36> else:
<37> # FIXME: handle certificate request
<38> raise AlertUnexpectedMessage
<39> elif self.state == State.CLIENT_EXPECT_CERTIFICATE</s>
|
===========below chunk 0===========
# module: aioquic.tls
class Context:
def handle_message(
self, input_data: bytes, output_buf: Dict[Epoch, Buffer]
) -> None:
# offset: 1
if message_type == HandshakeType.CERTIFICATE_VERIFY:
self._client_handle_certificate_verify(input_buf)
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_EXPECT_FINISHED:
if message_type == HandshakeType.FINISHED:
self._client_handle_finished(input_buf, output_buf[Epoch.HANDSHAKE])
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_POST_HANDSHAKE:
if message_type == HandshakeType.NEW_SESSION_TICKET:
self._client_handle_new_session_ticket(input_buf)
else:
raise AlertUnexpectedMessage
# server states
elif self.state == State.SERVER_EXPECT_CLIENT_HELLO:
if message_type == HandshakeType.CLIENT_HELLO:
self._server_handle_hello(
input_buf,
output_buf[Epoch.INITIAL],
output_buf[Epoch.HANDSHAKE],
)
else:
raise AlertUnexpectedMessage
elif self.state == State.SERVER_EXPECT_FINISHED:
if message_type == HandshakeType.FINISHED:
self._server_handle_finished(input_buf, output_buf[Epoch.ONE_RTT])
else:
raise AlertUnexpectedMessage
elif self.state == State.SERVER_POST_HANDSHAKE:
raise AlertUnexpectedMessage
# should not happen
else:
raise Exception("unhandled state")
assert input_buf.eof()
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.tls
AlertUnexpectedMessage(*args: object)
Epoch()
State()
HandshakeType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
HandshakeType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.tls.Context
_client_send_hello(output_buf: Buffer) -> None
_client_handle_hello(input_buf: Buffer, output_buf: Buffer) -> None
_client_handle_encrypted_extensions(input_buf: Buffer) -> None
_client_handle_certificate(input_buf: Buffer) -> None
_client_handle_certificate_verify(input_buf: Buffer) -> None
_client_handle_finished(input_buf: Buffer, output_buf: Buffer) -> None
_client_handle_new_session_ticket(input_buf: Buffer) -> None
_server_handle_hello(input_buf: Buffer, initial_buf: Buffer, handshake_buf: Buffer, onertt_buf: Buffer) -> None
_server_handle_finished(input_buf: Buffer, output_buf: Buffer) -> None
_server_handle_finished(self, input_buf: Buffer, output_buf: Buffer) -> None
at: aioquic.tls.Context.__init__
self._receive_buffer = b""
self.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: aioquic.tls.Context._set_state
self.state = state
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: aioquic.tls
class Context:
def __init__(
self,
is_client: bool,
logger: Optional[Union[logging.Logger, logging.LoggerAdapter]] = None,
):
self.alpn_negotiated: Optional[str] = None
self.alpn_protocols: Optional[List[str]] = None
self.certificate: Optional[x509.Certificate] = None
self.certificate_private_key: Optional[
Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
] = None
self.early_data_accepted = False
self.handshake_extensions: List[Extension] = []
self.key_schedule: Optional[KeySchedule] = None
self.received_extensions: Optional[List[Extension]] = None
self.session_ticket: Optional[SessionTicket] = None
self.server_name: Optional[str] = None
# callbacks
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
# supported parameters
self._cipher_suites = [
CipherSuite.AES_256_GCM_SHA384,
CipherSuite.AES_128_GCM_SHA256,
CipherSuite.CHACHA20_POLY1305_SHA256,
]
self._compression_methods = [CompressionMethod.NULL]
self._key_exchange_modes = [KeyExchangeMode.PSK_DHE_KE]
self._signature_algorithms = [
SignatureAlgorithm.RSA_PSS_RSAE_SHA256,
SignatureAlgorithm.ECDSA_SECP256R1_SHA256,
SignatureAlgorithm.RSA_PKCS1_SHA256,
SignatureAlgorithm.RSA_PKCS1_SHA1,
]
self._supported_groups = [Group.SECP256R1</s>
===========changed ref 1===========
# module: aioquic.tls
class Context:
def __init__(
self,
is_client: bool,
logger: Optional[Union[logging.Logger, logging.LoggerAdapter]] = None,
):
# offset: 1
<s> SignatureAlgorithm.RSA_PKCS1_SHA1,
]
self._supported_groups = [Group.SECP256R1]
self._supported_versions = [TLS_VERSION_1_3]
# state
self._key_schedule_psk: Optional[KeySchedule] = None
self._key_schedule_proxy: Optional[KeyScheduleProxy] = None
+ self._new_session_ticket: Optional[NewSessionTicket] = None
self._peer_certificate: Optional[x509.Certificate] = None
self._receive_buffer = b""
self._session_resumed = False
self._enc_key: Optional[bytes] = None
self._dec_key: Optional[bytes] = None
self.__logger = logger
self._ec_private_key: Optional[ec.EllipticCurvePrivateKey] = None
self._x25519_private_key: Optional[x25519.X25519PrivateKey] = None
if is_client:
self.client_random = os.urandom(32)
self.session_id = os.urandom(32)
self.state = State.CLIENT_HANDSHAKE_START
else:
self.client_random = None
self.session_id = None
self.state = State.SERVER_EXPECT_CLIENT_HELLO
|
|
aioquic.tls/Context._server_handle_finished
|
Modified
|
aiortc~aioquic
|
57012f7d8894010b9a27e9fc5826a810e3dcd12f
|
[tls] send New Session Ticket as soon as possible
|
<3>:<del> expected_verify_data = self.key_schedule.finished_verify_data(self._dec_key)
<4>:<add> if finished.verify_data != self._expected_verify_data:
<del> if finished.verify_data != expected_verify_data:
<17>:<del> self.key_schedule.update_hash(input_buf.data)
<18>:<del>
<21>:<del> # create a new session ticket
<22>:<del> if self.new_session_ticket_cb is not None:
<23>:<del> new_session_ticket = NewSessionTicket(
<24>:<del> ticket_lifetime=86400,
<25>:<del> ticket_age_add=struct.unpack("I", os.urandom(4))[0],
<26>:<del> ticket_nonce=b"",
<27>:<del> ticket=os.urandom(64),
<28>:<del> max_early_data_size=0xFFFFFFFF,
<29>:<del> )
<30>:<del>
<31>:<del> # notify application
<32>:<del> ticket = self._build_session_ticket(new_session_ticket)
<33>:<del> self.new_session_ticket_cb(ticket)
<34>:<del>
<35>:<del> # send messsage
<36>:<del> push_new_session_ticket(output_buf, new_session_ticket)
<37>:<del>
|
# module: aioquic.tls
class Context:
def _server_handle_finished(self, input_buf: Buffer, output_buf: Buffer) -> None:
<0> finished = pull_finished(input_buf)
<1>
<2> # check verify data
<3> expected_verify_data = self.key_schedule.finished_verify_data(self._dec_key)
<4> if finished.verify_data != expected_verify_data:
<5> raise AlertDecryptError
<6>
<7> # commit traffic key
<8> self._dec_key = self._next_dec_key
<9> self._next_dec_key = None
<10> self.update_traffic_key_cb(
<11> Direction.DECRYPT,
<12> Epoch.ONE_RTT,
<13> self.key_schedule.cipher_suite,
<14> self._dec_key,
<15> )
<16>
<17> self.key_schedule.update_hash(input_buf.data)
<18>
<19> self._set_state(State.SERVER_POST_HANDSHAKE)
<20>
<21> # create a new session ticket
<22> if self.new_session_ticket_cb is not None:
<23> new_session_ticket = NewSessionTicket(
<24> ticket_lifetime=86400,
<25> ticket_age_add=struct.unpack("I", os.urandom(4))[0],
<26> ticket_nonce=b"",
<27> ticket=os.urandom(64),
<28> max_early_data_size=0xFFFFFFFF,
<29> )
<30>
<31> # notify application
<32> ticket = self._build_session_ticket(new_session_ticket)
<33> self.new_session_ticket_cb(ticket)
<34>
<35> # send messsage
<36> push_new_session_ticket(output_buf, new_session_ticket)
<37>
|
===========unchanged ref 0===========
at: _struct
unpack(format, buffer, /)
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.tls
AlertDecryptError(*args: object)
Direction()
Epoch()
State()
NewSessionTicket(ticket_lifetime: int=0, ticket_age_add: int=0, ticket_nonce: bytes=b"", ticket: bytes=b"", max_early_data_size: Optional[int]=None)
push_new_session_ticket(buf: Buffer, new_session_ticket: NewSessionTicket) -> None
Finished(verify_data: bytes=b"")
pull_finished(buf: Buffer) -> Finished
push_finished(buf: Buffer, finished: Finished) -> None
at: aioquic.tls.Context
_build_session_ticket(new_session_ticket: NewSessionTicket) -> SessionTicket
_set_state(state: State) -> None
at: aioquic.tls.Context.__init__
self.key_schedule: Optional[KeySchedule] = None
self.new_session_ticket_cb: Optional[SessionTicketHandler] = None
self._new_session_ticket: Optional[NewSessionTicket] = None
self._dec_key: Optional[bytes] = None
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self._key_schedule_psk
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
at: aioquic.tls.Context._server_handle_finished
self._dec_key = self._next_dec_key
self._next_dec_key = None
at: aioquic.tls.Context._server_handle_hello
self.key_schedule = KeySchedule(cipher_suite)
at: aioquic.tls.Context._setup_traffic_protection
self._dec_key = key
===========unchanged ref 1===========
at: aioquic.tls.Finished
verify_data: bytes = b""
at: aioquic.tls.KeySchedule
finished_verify_data(secret: bytes) -> bytes
derive_secret(label: bytes) -> bytes
update_hash(data: bytes) -> None
at: aioquic.tls.NewSessionTicket
ticket_lifetime: int = 0
ticket_age_add: int = 0
ticket_nonce: bytes = b""
ticket: bytes = b""
max_early_data_size: Optional[int] = None
at: os
urandom(size: int, /) -> bytes
===========changed ref 0===========
# module: aioquic.tls
class Context:
def handle_message(
self, input_data: bytes, output_buf: Dict[Epoch, Buffer]
) -> None:
if self.state == State.CLIENT_HANDSHAKE_START:
self._client_send_hello(output_buf[Epoch.INITIAL])
return
self._receive_buffer += input_data
while len(self._receive_buffer) >= 4:
# determine message length
message_type = self._receive_buffer[0]
message_length = 0
for b in self._receive_buffer[1:4]:
message_length = (message_length << 8) | b
message_length += 4
# check message is complete
if len(self._receive_buffer) < message_length:
break
message = self._receive_buffer[:message_length]
self._receive_buffer = self._receive_buffer[message_length:]
input_buf = Buffer(data=message)
# client states
if self.state == State.CLIENT_EXPECT_SERVER_HELLO:
if message_type == HandshakeType.SERVER_HELLO:
self._client_handle_hello(input_buf, output_buf[Epoch.INITIAL])
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_EXPECT_ENCRYPTED_EXTENSIONS:
if message_type == HandshakeType.ENCRYPTED_EXTENSIONS:
self._client_handle_encrypted_extensions(input_buf)
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_EXPECT_CERTIFICATE_REQUEST_OR_CERTIFICATE:
if message_type == HandshakeType.CERTIFICATE:
self._client_handle_certificate(input_buf)
else:
# FIXME: handle certificate request
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_EXPECT_CERTIFICATE_VERIFY:
if message_type == HandshakeType.CERTIFICATE_VERIFY:
self._client_handle_certificate_verify(input_buf)
else:
</s>
===========changed ref 1===========
# module: aioquic.tls
class Context:
def handle_message(
self, input_data: bytes, output_buf: Dict[Epoch, Buffer]
) -> None:
# offset: 1
<s> HandshakeType.CERTIFICATE_VERIFY:
self._client_handle_certificate_verify(input_buf)
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_EXPECT_FINISHED:
if message_type == HandshakeType.FINISHED:
self._client_handle_finished(input_buf, output_buf[Epoch.HANDSHAKE])
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_POST_HANDSHAKE:
if message_type == HandshakeType.NEW_SESSION_TICKET:
self._client_handle_new_session_ticket(input_buf)
else:
raise AlertUnexpectedMessage
# server states
elif self.state == State.SERVER_EXPECT_CLIENT_HELLO:
if message_type == HandshakeType.CLIENT_HELLO:
self._server_handle_hello(
input_buf,
output_buf[Epoch.INITIAL],
output_buf[Epoch.HANDSHAKE],
+ output_buf[Epoch.ONE_RTT],
)
else:
raise AlertUnexpectedMessage
elif self.state == State.SERVER_EXPECT_FINISHED:
if message_type == HandshakeType.FINISHED:
self._server_handle_finished(input_buf, output_buf[Epoch.ONE_RTT])
else:
raise AlertUnexpectedMessage
elif self.state == State.SERVER_POST_HANDSHAKE:
raise AlertUnexpectedMessage
# should not happen
else:
raise Exception("unhandled state")
assert input_buf.eof()
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
57012f7d8894010b9a27e9fc5826a810e3dcd12f
|
[tls] send New Session Ticket as soon as possible
|
<0>:<add> crypto_stream_id: Optional[tls.Epoch] = None
<2>:<add> crypto_stream_id = tls.Epoch.ONE_RTT
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
<0> if self.cryptos[tls.Epoch.ONE_RTT].send.is_valid():
<1> crypto = self.cryptos[tls.Epoch.ONE_RTT]
<2> packet_type = PACKET_TYPE_ONE_RTT
<3> elif self.cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
<4> crypto = self.cryptos[tls.Epoch.ZERO_RTT]
<5> packet_type = PACKET_TYPE_ZERO_RTT
<6> else:
<7> return
<8> space = self.spaces[tls.Epoch.ONE_RTT]
<9> is_one_rtt = self.__epoch == tls.Epoch.ONE_RTT
<10>
<11> buf = builder.buffer
<12> while True:
<13> # write header
<14> builder.start_packet(packet_type, crypto)
<15>
<16> if is_one_rtt:
<17> # ACK
<18> if space.ack_required and space.ack_queue:
<19> push_uint_var(buf, QuicFrameType.ACK)
<20> packet.push_ack_frame(buf, space.ack_queue, 0)
<21> space.ack_required = False
<22>
<23> # PATH CHALLENGE
<24> if (
<25> not network_path.is_validated
<26> and network_path.local_challenge is None
<27> ):
<28> self._logger.info(
<29> "Network path %s sending challenge", network_path.addr
<30> )
<31> network_path.local_challenge = os.urandom(8)
<32> push_uint_var(buf, QuicFrameType.PATH_CHALLENGE)
<33> push_bytes(buf, network_path.local_challenge)
<34>
<35> # PATH RESPONSE
<36> if network_path.remote_challenge is not None:
<37> push_uint_var(buf, QuicFrame</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 1
push_bytes(buf, 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:
push_uint_var(buf, QuicFrameType.NEW_CONNECTION_ID)
packet.push_new_connection_id_frame(
buf,
connection_id.sequence_number,
connection_id.cid,
connection_id.stateless_reset_token,
)
connection_id.was_sent = True
space.expect_ack(builder.packet_number, lambda: None)
self._connection_id_issued_handler(connection_id.cid)
# RETIRE_CONNECTION_ID
while self._retire_connection_ids:
push_uint_var(buf, QuicFrameType.RETIRE_CONNECTION_ID)
push_uint_var(buf, self._retire_connection_ids.pop(0))
space.expect_ack(builder.packet_number, lambda: None)
# PING
if self._ping_pending:
self._logger.info("Sending PING in packet %d", builder.packet_number)
push_uint_var(buf, QuicFrameType.PING)
space.expect_ack(builder.packet_number, self._on_ping_delivery)
self._ping_pending = False
for stream_id, stream in self.streams.items():
# CRYPTO
if is_one_rtt and stream_id == tls.Epoch.ONE_RTT:
frame_overhead = 3 + quic_uint_length(stream.next_send_offset)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 2
<s>)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:
push_uint_var(buf, QuicFrameType.CRYPTO)
with packet.push_crypto_frame(buf, frame.offset):
push_bytes(buf, frame.data)
space.expect_ack(
builder.packet_number,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
# STREAM
elif isinstance(stream_id, int):
# the frame data size is constrained by our peer's MAX_DATA and
# the space available in the current packet
frame_overhead = (
3
+ quic_uint_length(stream_id)
+ (
quic_uint_length(stream.next_send_offset)
if stream.next_send_offset
else 0
)
)
previous_send_highest = stream._send_highest
frame = stream.get_frame(
min(
builder.remaining_space - frame_overhead,
self._remote_max_data - self._remote_max_data_used,
)
)
if frame is not None:
flags = QuicStreamFlag.LEN
if frame.offset:
flags |= QuicStreamFlag.OFF
if frame.fin:
flags |= QuicStreamFlag.FIN
push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)
with push_stream_frame(buf, stream_id, frame.offset):
push_bytes(buf, frame.data)
self._remote_max_data_used +=</s>
===========below chunk 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 3
<s> stream._send_highest - previous_send_highest
)
space.expect_ack(
builder.packet_number,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
if not builder.end_packet():
break
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
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
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_on_ping_delivery() -> None
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__epoch = tls.Epoch.INITIAL
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._ping_pending = False
self._remote_max_data = 0
self._remote_max_data_used = 0
self._retire_connection_ids: List[int] = []
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._handle_max_data_frame
self._remote_max_data = max_data
|
tests.test_tls/ContextTest._handshake
|
Modified
|
aiortc~aioquic
|
57012f7d8894010b9a27e9fc5826a810e3dcd12f
|
[tls] send New Session Ticket as soon as possible
|
<10>:<add> # send server hello, encrypted extensions, certificate, certificate verify, finished, (session ticket)
<del> # send server hello, encrypted extensions, certificate, certificate verify, finished
<16>:<add> self.assertLessEqual(len(client_input), 2316)
<del> self.assertLessEqual(len(client_input), 2239)
<17>:<add>
<19>:<add> # handle server hello, encrypted extensions, certificate, certificate verify, finished, (session ticket)
<del> # handle server hello, encrypted extensions, certificate, certificate verify, finished
<28>:<del> # send new_session_ticket
<32>:<del> if create_ticket:
<33>:<del> self.assertEqual(len(client_input), 89)
<34>:<del> reset_buffers(server_buf)
<35>:<del>
<36>:<del> # handle new
|
# module: tests.test_tls
class ContextTest(TestCase):
def _handshake(self, client, server):
<0> # send client hello
<1> client_buf = create_buffers()
<2> client.handle_message(b"", client_buf)
<3> self.assertEqual(client.state, State.CLIENT_EXPECT_SERVER_HELLO)
<4> server_input = merge_buffers(client_buf)
<5> self.assertGreaterEqual(len(server_input), 219)
<6> self.assertLessEqual(len(server_input), 264)
<7> reset_buffers(client_buf)
<8>
<9> # handle client hello
<10> # send server hello, encrypted extensions, certificate, certificate verify, finished
<11> server_buf = create_buffers()
<12> server.handle_message(server_input, server_buf)
<13> self.assertEqual(server.state, State.SERVER_EXPECT_FINISHED)
<14> client_input = merge_buffers(server_buf)
<15> self.assertGreaterEqual(len(client_input), 2194)
<16> self.assertLessEqual(len(client_input), 2239)
<17> reset_buffers(server_buf)
<18>
<19> # handle server hello, encrypted extensions, certificate, certificate verify, finished
<20> # send finished
<21> client.handle_message(client_input, client_buf)
<22> self.assertEqual(client.state, State.CLIENT_POST_HANDSHAKE)
<23> server_input = merge_buffers(client_buf)
<24> self.assertEqual(len(server_input), 52)
<25> reset_buffers(client_buf)
<26>
<27> # handle finished
<28> # send new_session_ticket
<29> server.handle_message(server_input, server_buf)
<30> self.assertEqual(server.state, State.SERVER_POST_HANDSHAKE)
<31> client_input = merge_buffers(server_buf)
<32> if create_ticket:
<33> self.assertEqual(len(client_input), 89)
<34> reset_buffers(server_buf)
<35>
<36> # handle new</s>
|
===========below chunk 0===========
# module: tests.test_tls
class ContextTest(TestCase):
def _handshake(self, client, server):
# offset: 1
client.handle_message(client_input, client_buf)
self.assertEqual(client.state, State.CLIENT_POST_HANDSHAKE)
server_input = merge_buffers(client_buf)
self.assertEqual(len(server_input), 0)
else:
self.assertEqual(len(client_input), 0)
# check keys match
self.assertEqual(client._dec_key, server._enc_key)
self.assertEqual(client._enc_key, server._dec_key)
# check cipher suite
self.assertEqual(
client.key_schedule.cipher_suite, tls.CipherSuite.AES_256_GCM_SHA384
)
self.assertEqual(
server.key_schedule.cipher_suite, tls.CipherSuite.AES_256_GCM_SHA384
)
===========unchanged ref 0===========
at: aioquic.tls
State()
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls.Context
handle_message(input_data: bytes, output_buf: Dict[Epoch, Buffer]) -> None
at: aioquic.tls.Context.__init__
self.alpn_negotiated: Optional[str] = None
self.key_schedule: Optional[KeySchedule] = None
self._enc_key: Optional[bytes] = None
self._dec_key: Optional[bytes] = None
self.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: aioquic.tls.Context._client_handle_encrypted_extensions
self.alpn_negotiated = encrypted_extensions.alpn_protocol
at: aioquic.tls.Context._client_handle_finished
self._enc_key = next_enc_key
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self._key_schedule_psk
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
at: aioquic.tls.Context._server_handle_finished
self._dec_key = self._next_dec_key
at: aioquic.tls.Context._server_handle_hello
self.alpn_negotiated = negotiate(
self.alpn_protocols,
peer_hello.alpn_protocols,
AlertHandshakeFailure("No common ALPN protocols"),
)
self.key_schedule = KeySchedule(cipher_suite)
at: aioquic.tls.Context._set_state
self.state = state
at: aioquic.tls.Context._setup_traffic_protection
self._enc_key = key
self._dec_key = key
===========unchanged ref 1===========
at: aioquic.tls.KeySchedule.__init__
self.cipher_suite = cipher_suite
at: tests.test_tls
create_buffers()
merge_buffers(buffers)
reset_buffers(buffers)
at: tests.test_tls.ContextTest
create_client()
create_server()
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertGreaterEqual(a: Any, b: Any, msg: Any=...) -> None
assertLessEqual(a: Any, b: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.tls
class Context:
def handle_message(
self, input_data: bytes, output_buf: Dict[Epoch, Buffer]
) -> None:
if self.state == State.CLIENT_HANDSHAKE_START:
self._client_send_hello(output_buf[Epoch.INITIAL])
return
self._receive_buffer += input_data
while len(self._receive_buffer) >= 4:
# determine message length
message_type = self._receive_buffer[0]
message_length = 0
for b in self._receive_buffer[1:4]:
message_length = (message_length << 8) | b
message_length += 4
# check message is complete
if len(self._receive_buffer) < message_length:
break
message = self._receive_buffer[:message_length]
self._receive_buffer = self._receive_buffer[message_length:]
input_buf = Buffer(data=message)
# client states
if self.state == State.CLIENT_EXPECT_SERVER_HELLO:
if message_type == HandshakeType.SERVER_HELLO:
self._client_handle_hello(input_buf, output_buf[Epoch.INITIAL])
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_EXPECT_ENCRYPTED_EXTENSIONS:
if message_type == HandshakeType.ENCRYPTED_EXTENSIONS:
self._client_handle_encrypted_extensions(input_buf)
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_EXPECT_CERTIFICATE_REQUEST_OR_CERTIFICATE:
if message_type == HandshakeType.CERTIFICATE:
self._client_handle_certificate(input_buf)
else:
# FIXME: handle certificate request
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_EXPECT_CERTIFICATE_VERIFY:
if message_type == HandshakeType.CERTIFICATE_VERIFY:
self._client_handle_certificate_verify(input_buf)
else:
</s>
===========changed ref 1===========
# module: aioquic.tls
class Context:
def handle_message(
self, input_data: bytes, output_buf: Dict[Epoch, Buffer]
) -> None:
# offset: 1
<s> HandshakeType.CERTIFICATE_VERIFY:
self._client_handle_certificate_verify(input_buf)
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_EXPECT_FINISHED:
if message_type == HandshakeType.FINISHED:
self._client_handle_finished(input_buf, output_buf[Epoch.HANDSHAKE])
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_POST_HANDSHAKE:
if message_type == HandshakeType.NEW_SESSION_TICKET:
self._client_handle_new_session_ticket(input_buf)
else:
raise AlertUnexpectedMessage
# server states
elif self.state == State.SERVER_EXPECT_CLIENT_HELLO:
if message_type == HandshakeType.CLIENT_HELLO:
self._server_handle_hello(
input_buf,
output_buf[Epoch.INITIAL],
output_buf[Epoch.HANDSHAKE],
+ output_buf[Epoch.ONE_RTT],
)
else:
raise AlertUnexpectedMessage
elif self.state == State.SERVER_EXPECT_FINISHED:
if message_type == HandshakeType.FINISHED:
self._server_handle_finished(input_buf, output_buf[Epoch.ONE_RTT])
else:
raise AlertUnexpectedMessage
elif self.state == State.SERVER_POST_HANDSHAKE:
raise AlertUnexpectedMessage
# should not happen
else:
raise Exception("unhandled state")
assert input_buf.eof()
|
tests.test_tls/ContextTest.test_handshake
|
Modified
|
aiortc~aioquic
|
57012f7d8894010b9a27e9fc5826a810e3dcd12f
|
[tls] send New Session Ticket as soon as possible
|
<3>:<add> self._handshake(client, server)
<del> self._handshake(client, server, create_ticket=False)
|
# module: tests.test_tls
class ContextTest(TestCase):
def test_handshake(self):
<0> client = self.create_client()
<1> server = self.create_server()
<2>
<3> self._handshake(client, server, create_ticket=False)
<4>
<5> # check ALPN matches
<6> self.assertEqual(client.alpn_negotiated, None)
<7> self.assertEqual(server.alpn_negotiated, None)
<8>
|
===========unchanged ref 0===========
at: tests.test_tls.ContextTest
create_client()
create_server()
_handshake(client, server)
_handshake(self, client, server)
===========changed ref 0===========
# module: tests.test_tls
class ContextTest(TestCase):
def _handshake(self, client, server):
# send client hello
client_buf = create_buffers()
client.handle_message(b"", client_buf)
self.assertEqual(client.state, State.CLIENT_EXPECT_SERVER_HELLO)
server_input = merge_buffers(client_buf)
self.assertGreaterEqual(len(server_input), 219)
self.assertLessEqual(len(server_input), 264)
reset_buffers(client_buf)
# handle client hello
+ # send server hello, encrypted extensions, certificate, certificate verify, finished, (session ticket)
- # send server hello, encrypted extensions, certificate, certificate verify, finished
server_buf = create_buffers()
server.handle_message(server_input, server_buf)
self.assertEqual(server.state, State.SERVER_EXPECT_FINISHED)
client_input = merge_buffers(server_buf)
self.assertGreaterEqual(len(client_input), 2194)
+ self.assertLessEqual(len(client_input), 2316)
- self.assertLessEqual(len(client_input), 2239)
+
reset_buffers(server_buf)
+ # handle server hello, encrypted extensions, certificate, certificate verify, finished, (session ticket)
- # handle server hello, encrypted extensions, certificate, certificate verify, finished
# send finished
client.handle_message(client_input, client_buf)
self.assertEqual(client.state, State.CLIENT_POST_HANDSHAKE)
server_input = merge_buffers(client_buf)
self.assertEqual(len(server_input), 52)
reset_buffers(client_buf)
# handle finished
- # send new_session_ticket
server.handle_message(server_input, server_buf)
self.assertEqual(server.state, State.SERVER_POST_HANDSHAKE)
client_input = merge_buffers(server_buf)
- if create_ticket</s>
===========changed ref 1===========
# module: tests.test_tls
class ContextTest(TestCase):
def _handshake(self, client, server):
# offset: 1
<s>.SERVER_POST_HANDSHAKE)
client_input = merge_buffers(server_buf)
- if create_ticket:
- self.assertEqual(len(client_input), 89)
- reset_buffers(server_buf)
-
- # handle new_session_ticket
- client.handle_message(client_input, client_buf)
- self.assertEqual(client.state, State.CLIENT_POST_HANDSHAKE)
- server_input = merge_buffers(client_buf)
- self.assertEqual(len(server_input), 0)
- else:
+ self.assertEqual(len(client_input), 0)
- self.assertEqual(len(client_input), 0)
# check keys match
self.assertEqual(client._dec_key, server._enc_key)
self.assertEqual(client._enc_key, server._dec_key)
# check cipher suite
self.assertEqual(
client.key_schedule.cipher_suite, tls.CipherSuite.AES_256_GCM_SHA384
)
self.assertEqual(
server.key_schedule.cipher_suite, tls.CipherSuite.AES_256_GCM_SHA384
)
===========changed ref 2===========
# module: aioquic.tls
class Context:
def _server_handle_finished(self, input_buf: Buffer, output_buf: Buffer) -> None:
finished = pull_finished(input_buf)
# check verify data
- expected_verify_data = self.key_schedule.finished_verify_data(self._dec_key)
+ if finished.verify_data != self._expected_verify_data:
- if finished.verify_data != expected_verify_data:
raise AlertDecryptError
# commit traffic key
self._dec_key = self._next_dec_key
self._next_dec_key = None
self.update_traffic_key_cb(
Direction.DECRYPT,
Epoch.ONE_RTT,
self.key_schedule.cipher_suite,
self._dec_key,
)
- self.key_schedule.update_hash(input_buf.data)
-
self._set_state(State.SERVER_POST_HANDSHAKE)
- # create a new session ticket
- if self.new_session_ticket_cb is not None:
- new_session_ticket = NewSessionTicket(
- ticket_lifetime=86400,
- ticket_age_add=struct.unpack("I", os.urandom(4))[0],
- ticket_nonce=b"",
- ticket=os.urandom(64),
- max_early_data_size=0xFFFFFFFF,
- )
-
- # notify application
- ticket = self._build_session_ticket(new_session_ticket)
- self.new_session_ticket_cb(ticket)
-
- # send messsage
- push_new_session_ticket(output_buf, new_session_ticket)
-
===========changed ref 3===========
# module: aioquic.tls
class Context:
def __init__(
self,
is_client: bool,
logger: Optional[Union[logging.Logger, logging.LoggerAdapter]] = None,
):
self.alpn_negotiated: Optional[str] = None
self.alpn_protocols: Optional[List[str]] = None
self.certificate: Optional[x509.Certificate] = None
self.certificate_private_key: Optional[
Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
] = None
self.early_data_accepted = False
self.handshake_extensions: List[Extension] = []
self.key_schedule: Optional[KeySchedule] = None
self.received_extensions: Optional[List[Extension]] = None
self.session_ticket: Optional[SessionTicket] = None
self.server_name: Optional[str] = None
# callbacks
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
# supported parameters
self._cipher_suites = [
CipherSuite.AES_256_GCM_SHA384,
CipherSuite.AES_128_GCM_SHA256,
CipherSuite.CHACHA20_POLY1305_SHA256,
]
self._compression_methods = [CompressionMethod.NULL]
self._key_exchange_modes = [KeyExchangeMode.PSK_DHE_KE]
self._signature_algorithms = [
SignatureAlgorithm.RSA_PSS_RSAE_SHA256,
SignatureAlgorithm.ECDSA_SECP256R1_SHA256,
SignatureAlgorithm.RSA_PKCS1_SHA256,
SignatureAlgorithm.RSA_PKCS1_SHA1,
]
self._supported_groups = [Group.SECP256R1</s>
|
tests.test_tls/ContextTest.test_handshake_with_alpn
|
Modified
|
aiortc~aioquic
|
57012f7d8894010b9a27e9fc5826a810e3dcd12f
|
[tls] send New Session Ticket as soon as possible
|
<6>:<add> self._handshake(client, server)
<del> self._handshake(client, server, create_ticket=False)
|
# module: tests.test_tls
class ContextTest(TestCase):
def test_handshake_with_alpn(self):
<0> client = self.create_client()
<1> client.alpn_protocols = ["hq-20"]
<2>
<3> server = self.create_server()
<4> server.alpn_protocols = ["hq-20", "h3-20"]
<5>
<6> self._handshake(client, server, create_ticket=False)
<7>
<8> # check ALPN matches
<9> self.assertEqual(client.alpn_negotiated, "hq-20")
<10> self.assertEqual(server.alpn_negotiated, "hq-20")
<11>
|
===========unchanged ref 0===========
at: tests.test_tls
create_buffers()
at: tests.test_tls.ContextTest
create_client()
create_server()
at: tests.test_tls.ContextTest.test_handshake_with_alpn
client = self.create_client()
server = self.create_server()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_tls
class ContextTest(TestCase):
def test_handshake(self):
client = self.create_client()
server = self.create_server()
+ self._handshake(client, server)
- self._handshake(client, server, create_ticket=False)
# check ALPN matches
self.assertEqual(client.alpn_negotiated, None)
self.assertEqual(server.alpn_negotiated, None)
===========changed ref 1===========
# module: tests.test_tls
class ContextTest(TestCase):
def _handshake(self, client, server):
# send client hello
client_buf = create_buffers()
client.handle_message(b"", client_buf)
self.assertEqual(client.state, State.CLIENT_EXPECT_SERVER_HELLO)
server_input = merge_buffers(client_buf)
self.assertGreaterEqual(len(server_input), 219)
self.assertLessEqual(len(server_input), 264)
reset_buffers(client_buf)
# handle client hello
+ # send server hello, encrypted extensions, certificate, certificate verify, finished, (session ticket)
- # send server hello, encrypted extensions, certificate, certificate verify, finished
server_buf = create_buffers()
server.handle_message(server_input, server_buf)
self.assertEqual(server.state, State.SERVER_EXPECT_FINISHED)
client_input = merge_buffers(server_buf)
self.assertGreaterEqual(len(client_input), 2194)
+ self.assertLessEqual(len(client_input), 2316)
- self.assertLessEqual(len(client_input), 2239)
+
reset_buffers(server_buf)
+ # handle server hello, encrypted extensions, certificate, certificate verify, finished, (session ticket)
- # handle server hello, encrypted extensions, certificate, certificate verify, finished
# send finished
client.handle_message(client_input, client_buf)
self.assertEqual(client.state, State.CLIENT_POST_HANDSHAKE)
server_input = merge_buffers(client_buf)
self.assertEqual(len(server_input), 52)
reset_buffers(client_buf)
# handle finished
- # send new_session_ticket
server.handle_message(server_input, server_buf)
self.assertEqual(server.state, State.SERVER_POST_HANDSHAKE)
client_input = merge_buffers(server_buf)
- if create_ticket</s>
===========changed ref 2===========
# module: tests.test_tls
class ContextTest(TestCase):
def _handshake(self, client, server):
# offset: 1
<s>.SERVER_POST_HANDSHAKE)
client_input = merge_buffers(server_buf)
- if create_ticket:
- self.assertEqual(len(client_input), 89)
- reset_buffers(server_buf)
-
- # handle new_session_ticket
- client.handle_message(client_input, client_buf)
- self.assertEqual(client.state, State.CLIENT_POST_HANDSHAKE)
- server_input = merge_buffers(client_buf)
- self.assertEqual(len(server_input), 0)
- else:
+ self.assertEqual(len(client_input), 0)
- self.assertEqual(len(client_input), 0)
# check keys match
self.assertEqual(client._dec_key, server._enc_key)
self.assertEqual(client._enc_key, server._dec_key)
# check cipher suite
self.assertEqual(
client.key_schedule.cipher_suite, tls.CipherSuite.AES_256_GCM_SHA384
)
self.assertEqual(
server.key_schedule.cipher_suite, tls.CipherSuite.AES_256_GCM_SHA384
)
===========changed ref 3===========
# module: aioquic.tls
class Context:
def _server_handle_finished(self, input_buf: Buffer, output_buf: Buffer) -> None:
finished = pull_finished(input_buf)
# check verify data
- expected_verify_data = self.key_schedule.finished_verify_data(self._dec_key)
+ if finished.verify_data != self._expected_verify_data:
- if finished.verify_data != expected_verify_data:
raise AlertDecryptError
# commit traffic key
self._dec_key = self._next_dec_key
self._next_dec_key = None
self.update_traffic_key_cb(
Direction.DECRYPT,
Epoch.ONE_RTT,
self.key_schedule.cipher_suite,
self._dec_key,
)
- self.key_schedule.update_hash(input_buf.data)
-
self._set_state(State.SERVER_POST_HANDSHAKE)
- # create a new session ticket
- if self.new_session_ticket_cb is not None:
- new_session_ticket = NewSessionTicket(
- ticket_lifetime=86400,
- ticket_age_add=struct.unpack("I", os.urandom(4))[0],
- ticket_nonce=b"",
- ticket=os.urandom(64),
- max_early_data_size=0xFFFFFFFF,
- )
-
- # notify application
- ticket = self._build_session_ticket(new_session_ticket)
- self.new_session_ticket_cb(ticket)
-
- # send messsage
- push_new_session_ticket(output_buf, new_session_ticket)
-
|
tests.test_tls/ContextTest.test_handshake_with_rsa_pkcs1_sha256_signature
|
Modified
|
aiortc~aioquic
|
57012f7d8894010b9a27e9fc5826a810e3dcd12f
|
[tls] send New Session Ticket as soon as possible
|
<4>:<add> self._handshake(client, server)
<del> self._handshake(client, server, create_ticket=False)
|
# module: tests.test_tls
class ContextTest(TestCase):
def test_handshake_with_rsa_pkcs1_sha256_signature(self):
<0> client = self.create_client()
<1> client._signature_algorithms = [tls.SignatureAlgorithm.RSA_PKCS1_SHA256]
<2> server = self.create_server()
<3>
<4> self._handshake(client, server, create_ticket=False)
<5>
|
===========unchanged ref 0===========
at: tests.test_tls.ContextTest
create_server()
_handshake(client, server)
_handshake(self, client, server)
at: tests.test_tls.ContextTest.test_handshake_with_x25519
client = self.create_client()
===========changed ref 0===========
# module: tests.test_tls
class ContextTest(TestCase):
def _handshake(self, client, server):
# send client hello
client_buf = create_buffers()
client.handle_message(b"", client_buf)
self.assertEqual(client.state, State.CLIENT_EXPECT_SERVER_HELLO)
server_input = merge_buffers(client_buf)
self.assertGreaterEqual(len(server_input), 219)
self.assertLessEqual(len(server_input), 264)
reset_buffers(client_buf)
# handle client hello
+ # send server hello, encrypted extensions, certificate, certificate verify, finished, (session ticket)
- # send server hello, encrypted extensions, certificate, certificate verify, finished
server_buf = create_buffers()
server.handle_message(server_input, server_buf)
self.assertEqual(server.state, State.SERVER_EXPECT_FINISHED)
client_input = merge_buffers(server_buf)
self.assertGreaterEqual(len(client_input), 2194)
+ self.assertLessEqual(len(client_input), 2316)
- self.assertLessEqual(len(client_input), 2239)
+
reset_buffers(server_buf)
+ # handle server hello, encrypted extensions, certificate, certificate verify, finished, (session ticket)
- # handle server hello, encrypted extensions, certificate, certificate verify, finished
# send finished
client.handle_message(client_input, client_buf)
self.assertEqual(client.state, State.CLIENT_POST_HANDSHAKE)
server_input = merge_buffers(client_buf)
self.assertEqual(len(server_input), 52)
reset_buffers(client_buf)
# handle finished
- # send new_session_ticket
server.handle_message(server_input, server_buf)
self.assertEqual(server.state, State.SERVER_POST_HANDSHAKE)
client_input = merge_buffers(server_buf)
- if create_ticket</s>
===========changed ref 1===========
# module: tests.test_tls
class ContextTest(TestCase):
def _handshake(self, client, server):
# offset: 1
<s>.SERVER_POST_HANDSHAKE)
client_input = merge_buffers(server_buf)
- if create_ticket:
- self.assertEqual(len(client_input), 89)
- reset_buffers(server_buf)
-
- # handle new_session_ticket
- client.handle_message(client_input, client_buf)
- self.assertEqual(client.state, State.CLIENT_POST_HANDSHAKE)
- server_input = merge_buffers(client_buf)
- self.assertEqual(len(server_input), 0)
- else:
+ self.assertEqual(len(client_input), 0)
- self.assertEqual(len(client_input), 0)
# check keys match
self.assertEqual(client._dec_key, server._enc_key)
self.assertEqual(client._enc_key, server._dec_key)
# check cipher suite
self.assertEqual(
client.key_schedule.cipher_suite, tls.CipherSuite.AES_256_GCM_SHA384
)
self.assertEqual(
server.key_schedule.cipher_suite, tls.CipherSuite.AES_256_GCM_SHA384
)
===========changed ref 2===========
# module: tests.test_tls
class ContextTest(TestCase):
def test_handshake(self):
client = self.create_client()
server = self.create_server()
+ self._handshake(client, server)
- self._handshake(client, server, create_ticket=False)
# check ALPN matches
self.assertEqual(client.alpn_negotiated, None)
self.assertEqual(server.alpn_negotiated, None)
===========changed ref 3===========
# module: tests.test_tls
class ContextTest(TestCase):
def test_handshake_with_alpn(self):
client = self.create_client()
client.alpn_protocols = ["hq-20"]
server = self.create_server()
server.alpn_protocols = ["hq-20", "h3-20"]
+ self._handshake(client, server)
- self._handshake(client, server, create_ticket=False)
# check ALPN matches
self.assertEqual(client.alpn_negotiated, "hq-20")
self.assertEqual(server.alpn_negotiated, "hq-20")
===========changed ref 4===========
# module: aioquic.tls
class Context:
def _server_handle_finished(self, input_buf: Buffer, output_buf: Buffer) -> None:
finished = pull_finished(input_buf)
# check verify data
- expected_verify_data = self.key_schedule.finished_verify_data(self._dec_key)
+ if finished.verify_data != self._expected_verify_data:
- if finished.verify_data != expected_verify_data:
raise AlertDecryptError
# commit traffic key
self._dec_key = self._next_dec_key
self._next_dec_key = None
self.update_traffic_key_cb(
Direction.DECRYPT,
Epoch.ONE_RTT,
self.key_schedule.cipher_suite,
self._dec_key,
)
- self.key_schedule.update_hash(input_buf.data)
-
self._set_state(State.SERVER_POST_HANDSHAKE)
- # create a new session ticket
- if self.new_session_ticket_cb is not None:
- new_session_ticket = NewSessionTicket(
- ticket_lifetime=86400,
- ticket_age_add=struct.unpack("I", os.urandom(4))[0],
- ticket_nonce=b"",
- ticket=os.urandom(64),
- max_early_data_size=0xFFFFFFFF,
- )
-
- # notify application
- ticket = self._build_session_ticket(new_session_ticket)
- self.new_session_ticket_cb(ticket)
-
- # send messsage
- push_new_session_ticket(output_buf, new_session_ticket)
-
|
tests.test_tls/ContextTest.test_handshake_with_x25519
|
Modified
|
aiortc~aioquic
|
57012f7d8894010b9a27e9fc5826a810e3dcd12f
|
[tls] send New Session Ticket as soon as possible
|
<4>:<add> self._handshake(client, server)
<del> self._handshake(client, server, create_ticket=False)
|
# module: tests.test_tls
class ContextTest(TestCase):
def test_handshake_with_x25519(self):
<0> client = self.create_client()
<1> client._supported_groups = [tls.Group.X25519]
<2> server = self.create_server()
<3>
<4> self._handshake(client, server, create_ticket=False)
<5>
|
===========unchanged ref 0===========
at: tests.test_tls.ContextTest.test_session_ticket
client_tickets = []
server_tickets = []
===========changed ref 0===========
# module: tests.test_tls
class ContextTest(TestCase):
def test_handshake_with_rsa_pkcs1_sha256_signature(self):
client = self.create_client()
client._signature_algorithms = [tls.SignatureAlgorithm.RSA_PKCS1_SHA256]
server = self.create_server()
+ self._handshake(client, server)
- self._handshake(client, server, create_ticket=False)
===========changed ref 1===========
# module: tests.test_tls
class ContextTest(TestCase):
def test_handshake(self):
client = self.create_client()
server = self.create_server()
+ self._handshake(client, server)
- self._handshake(client, server, create_ticket=False)
# check ALPN matches
self.assertEqual(client.alpn_negotiated, None)
self.assertEqual(server.alpn_negotiated, None)
===========changed ref 2===========
# module: tests.test_tls
class ContextTest(TestCase):
def test_handshake_with_alpn(self):
client = self.create_client()
client.alpn_protocols = ["hq-20"]
server = self.create_server()
server.alpn_protocols = ["hq-20", "h3-20"]
+ self._handshake(client, server)
- self._handshake(client, server, create_ticket=False)
# check ALPN matches
self.assertEqual(client.alpn_negotiated, "hq-20")
self.assertEqual(server.alpn_negotiated, "hq-20")
===========changed ref 3===========
# module: tests.test_tls
class ContextTest(TestCase):
def _handshake(self, client, server):
# send client hello
client_buf = create_buffers()
client.handle_message(b"", client_buf)
self.assertEqual(client.state, State.CLIENT_EXPECT_SERVER_HELLO)
server_input = merge_buffers(client_buf)
self.assertGreaterEqual(len(server_input), 219)
self.assertLessEqual(len(server_input), 264)
reset_buffers(client_buf)
# handle client hello
+ # send server hello, encrypted extensions, certificate, certificate verify, finished, (session ticket)
- # send server hello, encrypted extensions, certificate, certificate verify, finished
server_buf = create_buffers()
server.handle_message(server_input, server_buf)
self.assertEqual(server.state, State.SERVER_EXPECT_FINISHED)
client_input = merge_buffers(server_buf)
self.assertGreaterEqual(len(client_input), 2194)
+ self.assertLessEqual(len(client_input), 2316)
- self.assertLessEqual(len(client_input), 2239)
+
reset_buffers(server_buf)
+ # handle server hello, encrypted extensions, certificate, certificate verify, finished, (session ticket)
- # handle server hello, encrypted extensions, certificate, certificate verify, finished
# send finished
client.handle_message(client_input, client_buf)
self.assertEqual(client.state, State.CLIENT_POST_HANDSHAKE)
server_input = merge_buffers(client_buf)
self.assertEqual(len(server_input), 52)
reset_buffers(client_buf)
# handle finished
- # send new_session_ticket
server.handle_message(server_input, server_buf)
self.assertEqual(server.state, State.SERVER_POST_HANDSHAKE)
client_input = merge_buffers(server_buf)
- if create_ticket</s>
===========changed ref 4===========
# module: tests.test_tls
class ContextTest(TestCase):
def _handshake(self, client, server):
# offset: 1
<s>.SERVER_POST_HANDSHAKE)
client_input = merge_buffers(server_buf)
- if create_ticket:
- self.assertEqual(len(client_input), 89)
- reset_buffers(server_buf)
-
- # handle new_session_ticket
- client.handle_message(client_input, client_buf)
- self.assertEqual(client.state, State.CLIENT_POST_HANDSHAKE)
- server_input = merge_buffers(client_buf)
- self.assertEqual(len(server_input), 0)
- else:
+ self.assertEqual(len(client_input), 0)
- self.assertEqual(len(client_input), 0)
# check keys match
self.assertEqual(client._dec_key, server._enc_key)
self.assertEqual(client._enc_key, server._dec_key)
# check cipher suite
self.assertEqual(
client.key_schedule.cipher_suite, tls.CipherSuite.AES_256_GCM_SHA384
)
self.assertEqual(
server.key_schedule.cipher_suite, tls.CipherSuite.AES_256_GCM_SHA384
)
===========changed ref 5===========
# module: aioquic.tls
class Context:
def _server_handle_finished(self, input_buf: Buffer, output_buf: Buffer) -> None:
finished = pull_finished(input_buf)
# check verify data
- expected_verify_data = self.key_schedule.finished_verify_data(self._dec_key)
+ if finished.verify_data != self._expected_verify_data:
- if finished.verify_data != expected_verify_data:
raise AlertDecryptError
# commit traffic key
self._dec_key = self._next_dec_key
self._next_dec_key = None
self.update_traffic_key_cb(
Direction.DECRYPT,
Epoch.ONE_RTT,
self.key_schedule.cipher_suite,
self._dec_key,
)
- self.key_schedule.update_hash(input_buf.data)
-
self._set_state(State.SERVER_POST_HANDSHAKE)
- # create a new session ticket
- if self.new_session_ticket_cb is not None:
- new_session_ticket = NewSessionTicket(
- ticket_lifetime=86400,
- ticket_age_add=struct.unpack("I", os.urandom(4))[0],
- ticket_nonce=b"",
- ticket=os.urandom(64),
- max_early_data_size=0xFFFFFFFF,
- )
-
- # notify application
- ticket = self._build_session_ticket(new_session_ticket)
- self.new_session_ticket_cb(ticket)
-
- # send messsage
- push_new_session_ticket(output_buf, new_session_ticket)
-
|
tests.test_tls/ContextTest.test_session_ticket
|
Modified
|
aiortc~aioquic
|
57012f7d8894010b9a27e9fc5826a810e3dcd12f
|
[tls] send New Session Ticket as soon as possible
|
<22>:<add> self._handshake(client, server)
<del> self._handshake(client, server, create_ticket=True)
|
# module: tests.test_tls
class ContextTest(TestCase):
def test_session_ticket(self):
<0> client_tickets = []
<1> server_tickets = []
<2>
<3> def client_new_ticket(ticket):
<4> client_tickets.append(ticket)
<5>
<6> def server_get_ticket(label):
<7> for t in server_tickets:
<8> if t.ticket == label:
<9> return t
<10> return None
<11>
<12> def server_new_ticket(ticket):
<13> server_tickets.append(ticket)
<14>
<15> def first_handshake():
<16> client = self.create_client()
<17> client.new_session_ticket_cb = client_new_ticket
<18>
<19> server = self.create_server()
<20> server.new_session_ticket_cb = server_new_ticket
<21>
<22> self._handshake(client, server, create_ticket=True)
<23>
<24> # check session resumption was not used
<25> self.assertFalse(client.session_resumed)
<26> self.assertFalse(server.session_resumed)
<27>
<28> # check tickets match
<29> self.assertEqual(len(client_tickets), 1)
<30> self.assertEqual(len(server_tickets), 1)
<31> self.assertEqual(client_tickets[0].ticket, server_tickets[0].ticket)
<32> self.assertEqual(
<33> client_tickets[0].resumption_secret, server_tickets[0].resumption_secret
<34> )
<35>
<36> def second_handshake():
<37> client = self.create_client()
<38> client.session_ticket = client_tickets[0]
<39>
<40> server = self.create_server()
<41> server.get_session_ticket_cb = server_get_ticket
<42>
<43> # send client hello with pre_shared_key
<44> client_buf = create_buffers()
<45> client.handle_message(b"", client_buf)
<46> self.assertEqual(client.state, State</s>
|
===========below chunk 0===========
# module: tests.test_tls
class ContextTest(TestCase):
def test_session_ticket(self):
# offset: 1
server_input = merge_buffers(client_buf)
self.assertEqual(len(server_input), 383)
reset_buffers(client_buf)
# handle client hello
# send server hello, encrypted extensions, finished
server_buf = create_buffers()
server.handle_message(server_input, server_buf)
self.assertEqual(server.state, State.SERVER_EXPECT_FINISHED)
client_input = merge_buffers(server_buf)
self.assertEqual(len(client_input), 307)
reset_buffers(server_buf)
# handle server hello, encrypted extensions, certificate, certificate verify, finished
# send finished
client.handle_message(client_input, client_buf)
self.assertEqual(client.state, State.CLIENT_POST_HANDSHAKE)
server_input = merge_buffers(client_buf)
self.assertEqual(len(server_input), 52)
reset_buffers(client_buf)
# handle finished
# send new_session_ticket
server.handle_message(server_input, server_buf)
self.assertEqual(server.state, State.SERVER_POST_HANDSHAKE)
client_input = merge_buffers(server_buf)
self.assertEqual(len(client_input), 0)
reset_buffers(server_buf)
# check keys match
self.assertEqual(client._dec_key, server._enc_key)
self.assertEqual(client._enc_key, server._dec_key)
# check session resumption was used
self.assertTrue(client.session_resumed)
self.assertTrue(server.session_resumed)
def second_handshake_bad_binder():
client = self.create_client()
client.session_ticket = client_tickets[0]
server = self.create_server()
server.get_session_ticket</s>
===========below chunk 1===========
# module: tests.test_tls
class ContextTest(TestCase):
def test_session_ticket(self):
# offset: 2
<s>_ticket = client_tickets[0]
server = self.create_server()
server.get_session_ticket_cb = server_get_ticket
# send client hello with pre_shared_key
client_buf = create_buffers()
client.handle_message(b"", client_buf)
self.assertEqual(client.state, State.CLIENT_EXPECT_SERVER_HELLO)
server_input = merge_buffers(client_buf)
self.assertEqual(len(server_input), 383)
reset_buffers(client_buf)
# tamper with binder
server_input = server_input[:-4] + bytes(4)
# handle client hello
# send server hello, encrypted extensions, finished
server_buf = create_buffers()
with self.assertRaises(tls.AlertHandshakeFailure) as cm:
server.handle_message(server_input, server_buf)
self.assertEqual(str(cm.exception), "PSK validation failed")
def second_handshake_bad_pre_shared_key():
client = self.create_client()
client.session_ticket = client_tickets[0]
server = self.create_server()
server.get_session_ticket_cb = server_get_ticket
# send client hello with pre_shared_key
client_buf = create_buffers()
client.handle_message(b"", client_buf)
self.assertEqual(client.state, State.CLIENT_EXPECT_SERVER_HELLO)
server_input = merge_buffers(client_buf)
self.assertEqual(len(server_input), 383)
reset_buffers(client_buf)
# handle client hello
# send server hello, encrypted extensions, finished
server_buf = create</s>
===========below chunk 2===========
# module: tests.test_tls
class ContextTest(TestCase):
def test_session_ticket(self):
# offset: 3
<s>()
server.handle_message(server_input, server_buf)
self.assertEqual(server.state, State.SERVER_EXPECT_FINISHED)
# tamper with pre_share_key index
buf = server_buf[tls.Epoch.INITIAL]
buf._data[buf.tell() - 1] = 1
client_input = merge_buffers(server_buf)
self.assertEqual(len(client_input), 307)
reset_buffers(server_buf)
# handle server hello and bomb
with self.assertRaises(tls.AlertIllegalParameter):
client.handle_message(client_input, client_buf)
first_handshake()
second_handshake()
second_handshake_bad_binder()
second_handshake_bad_pre_shared_key()
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.buffer.Buffer
eof() -> bool
tell() -> int
at: aioquic.buffer.Buffer.__init__
self._data = bytearray(capacity)
self._data = bytearray(data)
at: aioquic.tls
AlertHandshakeFailure(*args: object)
AlertIllegalParameter(*args: object)
Epoch()
State()
pull_client_hello(buf: Buffer) -> ClientHello
at: tests.test_tls
create_buffers()
merge_buffers(buffers)
reset_buffers(buffers)
at: tests.test_tls.ContextTest
create_client()
create_server()
_handshake(client, server)
_handshake(self, client, server)
at: tests.test_tls.ContextTest.test_session_ticket
client_tickets = []
server_tickets = []
client_new_ticket(ticket)
server_get_ticket(label)
at: tests.utils
load(name)
at: unittest.case
TestCase(methodName: str=...)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]
assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None
at: unittest.case._AssertRaisesContext.__exit__
self.exception = exc_value.with_traceback(None)
|
aioquic.stream/QuicStream.on_data_delivery
|
Modified
|
aiortc~aioquic
|
f204c07d805cba5fdbdc3240db5208fb06073216
|
[connection] rework delivery handlers to accept a delivery state
|
<4>:<add> if delivery == QuicDeliveryState.ACKED:
<add> self._send_acked.add(start, stop)
<del> self._send_acked.add(start, stop)
<5>:<add> first_range = self._send_acked[0]
<del> first_range = self._send_acked[0]
<6>:<add> if first_range.start == self._send_buffer_start:
<del> if first_range.start == self._send_buffer_start:
<7>:<add> size = first_range.stop - first_range.start
<del> size = first_range.stop - first_range.start
<8>:<add> self._send_acked.shift()
<del> self._send_acked.shift()
<9>:<add> self._send_buffer_start += size
<del> self._send_buffer_start += size
<10>:<add> del self._send_buffer[:size]
<del> del self._send_buffer[:size]
<11>:<add> else:
<add> self._send_pending.add(start, stop)
|
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def on_data_delivery(
+ self, delivery: QuicDeliveryState, start: int, stop: int
+ ) -> None:
- def on_data_delivery(self, start: int, stop: int) -> None:
<0> """
<1> Callback when sent data is ACK'd.
<2> """
<3> if stop - start:
<4> self._send_acked.add(start, stop)
<5> first_range = self._send_acked[0]
<6> if first_range.start == self._send_buffer_start:
<7> size = first_range.stop - first_range.start
<8> self._send_acked.shift()
<9> self._send_buffer_start += size
<10> del self._send_buffer[:size]
<11>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicDeliveryState()
at: aioquic.rangeset.RangeSet
add(start: int, stop: Optional[int]=None) -> None
at: aioquic.stream.QuicStream.__init__
self._send_acked = RangeSet()
self._send_buffer_start = 0 # the offset for the start of the buffer
at: aioquic.stream.QuicStream.on_data_delivery
self._send_buffer_start += size
===========changed ref 0===========
# module: aioquic.packet
+ class QuicDeliveryState(Enum):
+ ACKED = 0
+ LOST = 1
+ EXPIRED = 2
+
|
aioquic.connection/QuicConnection._handle_ack_frame
|
Modified
|
aiortc~aioquic
|
f204c07d805cba5fdbdc3240db5208fb06073216
|
[connection] rework delivery handlers to accept a delivery state
|
<15>:<add> handler(QuicDeliveryState.ACKED, *args)
<del> handler(*args)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle an ACK frame.
<2> """
<3> rangeset, _ = packet.pull_ack_frame(buf)
<4> if frame_type == QuicFrameType.ACK_ECN:
<5> pull_uint_var(buf)
<6> pull_uint_var(buf)
<7> pull_uint_var(buf)
<8>
<9> # trigger callbacks
<10> handlers = self.spaces[context.epoch].delivery_handlers
<11> for packet_range in rangeset:
<12> for packet_number in packet_range:
<13> if packet_number in handlers:
<14> for handler, args in handlers[packet_number]:
<15> handler(*args)
<16> del handlers[packet_number]
<17>
|
===========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)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
at: aioquic.connection.QuicConnection._initialize
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.connection.QuicPacketSpace.__init__
self.delivery_handlers: Dict[int, List[Tuple[QuicDeliveryHandler, Any]]] = {}
at: aioquic.connection.QuicReceiveContext
epoch: tls.Epoch
host_cid: bytes
network_path: QuicNetworkPath
at: aioquic.packet
QuicDeliveryState()
pull_uint_var(buf: Buffer) -> int
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_ack_frame(buf: Buffer) -> Tuple[RangeSet, int]
===========changed ref 0===========
# module: aioquic.packet
+ class QuicDeliveryState(Enum):
+ ACKED = 0
+ LOST = 1
+ EXPIRED = 2
+
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def on_data_delivery(
+ self, delivery: QuicDeliveryState, start: int, stop: int
+ ) -> None:
- def on_data_delivery(self, start: int, stop: int) -> None:
"""
Callback when sent data is ACK'd.
"""
if stop - start:
+ if delivery == QuicDeliveryState.ACKED:
+ self._send_acked.add(start, stop)
- self._send_acked.add(start, stop)
+ first_range = self._send_acked[0]
- first_range = self._send_acked[0]
+ if first_range.start == self._send_buffer_start:
- if first_range.start == self._send_buffer_start:
+ size = first_range.stop - first_range.start
- size = first_range.stop - first_range.start
+ self._send_acked.shift()
- self._send_acked.shift()
+ self._send_buffer_start += size
- self._send_buffer_start += size
+ del self._send_buffer[:size]
- del self._send_buffer[:size]
+ else:
+ self._send_pending.add(start, stop)
|
aioquic.connection/QuicConnection._on_ping_delivery
|
Modified
|
aiortc~aioquic
|
f204c07d805cba5fdbdc3240db5208fb06073216
|
[connection] rework delivery handlers to accept a delivery state
|
<1>:<add> Callback when a PING frame is is acknowledged or lost.
<del> Callback when a PING is ACK'd.
<3>:<add> if delivery == QuicDeliveryState.ACKED:
<add> self._logger.info("Received PING response")
<del> self._logger.info("Received PING response")
<4>:<add> waiter = self._ping_waiter
<del> waiter = self._ping_waiter
<5>:<add> self._ping_waiter = None
<del> self._ping_waiter = None
<6>:<add> waiter.set_result(None)
<del> waiter.set_result(None)
<7>:<add> else:
<add> self._ping_pending = True
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _on_ping_delivery(self, delivery: QuicDeliveryState) -> None:
- def _on_ping_delivery(self) -> None:
<0> """
<1> Callback when a PING is ACK'd.
<2> """
<3> self._logger.info("Received PING response")
<4> waiter = self._ping_waiter
<5> self._ping_waiter = None
<6> waiter.set_result(None)
<7>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnectionId(cid: bytes, sequence_number: int, stateless_reset_token: bytes=b"", was_sent: bool=False)
at: aioquic.packet
QuicDeliveryState()
===========changed ref 0===========
# module: aioquic.packet
+ class QuicDeliveryState(Enum):
+ ACKED = 0
+ LOST = 1
+ EXPIRED = 2
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle an ACK frame.
"""
rangeset, _ = packet.pull_ack_frame(buf)
if frame_type == QuicFrameType.ACK_ECN:
pull_uint_var(buf)
pull_uint_var(buf)
pull_uint_var(buf)
# trigger callbacks
handlers = self.spaces[context.epoch].delivery_handlers
for packet_range in rangeset:
for packet_number in packet_range:
if packet_number in handlers:
for handler, args in handlers[packet_number]:
+ handler(QuicDeliveryState.ACKED, *args)
- handler(*args)
del handlers[packet_number]
===========changed ref 2===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def on_data_delivery(
+ self, delivery: QuicDeliveryState, start: int, stop: int
+ ) -> None:
- def on_data_delivery(self, start: int, stop: int) -> None:
"""
Callback when sent data is ACK'd.
"""
if stop - start:
+ if delivery == QuicDeliveryState.ACKED:
+ self._send_acked.add(start, stop)
- self._send_acked.add(start, stop)
+ first_range = self._send_acked[0]
- first_range = self._send_acked[0]
+ if first_range.start == self._send_buffer_start:
- if first_range.start == self._send_buffer_start:
+ size = first_range.stop - first_range.start
- size = first_range.stop - first_range.start
+ self._send_acked.shift()
- self._send_acked.shift()
+ self._send_buffer_start += size
- self._send_buffer_start += size
+ del self._send_buffer[:size]
- del self._send_buffer[:size]
+ else:
+ self._send_pending.add(start, stop)
|
aioquic.stream/QuicStream.__init__
|
Modified
|
aiortc~aioquic
|
d6323152645b40ff3575ac3b7cec7a50683749e4
|
[stream] correctly reschedule lost frame with FIN bit
|
<19>:<del> self._send_complete = False
<20>:<del> self._send_eof = False
<21>:<add> self._send_buffer_fin: Optional[int] = None
<23>:<add> self._send_pending_eof = False
|
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
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_remote = max_stream_data_remote
<3>
<4> if stream_id is not None:
<5> self.reader = asyncio.StreamReader()
<6> self.writer = asyncio.StreamWriter(self, None, self.reader, None)
<7> else:
<8> self.reader = None
<9> self.writer = None
<10>
<11> self._recv_buffer = bytearray()
<12> self._recv_fin = False
<13> self._recv_highest = 0 # the highest offset ever seen
<14> self._recv_start = 0 # the offset for the start of the buffer
<15> self._recv_ranges = RangeSet()
<16>
<17> self._send_acked = RangeSet()
<18> self._send_buffer = bytearray()
<19> self._send_complete = False
<20> self._send_eof = False
<21> self._send_highest = 0
<22> self._send_pending = RangeSet()
<23> self._send_buffer_start = 0 # the offset for the start of the buffer
<24> self._send_buffer_stop = 0 # the offset for the stop of the buffer
<25>
<26> self.__stream_id = stream_id
<27>
|
===========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_fin = True
at: aioquic.stream.QuicStream.get_frame
self._send_pending_eof = False
self._send_highest = send.stop
at: aioquic.stream.QuicStream.on_data_delivery
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_start = r.stop
at: aioquic.stream.QuicStream.write
self._send_buffer += data
self._send_buffer_stop += size
at: aioquic.stream.QuicStream.write_eof
self._send_buffer_fin = self._send_buffer_stop
self._send_pending_eof = True
at: asyncio.streams
StreamWriter(transport: transports.BaseTransport, protocol: protocols.BaseProtocol, reader: Optional[StreamReader], loop: events.AbstractEventLoop)
StreamReader(limit: int=..., loop: Optional[events.AbstractEventLoop]=...)
at: asyncio.transports.BaseTransport
__slots__ = ('_extra',)
__init__(self, extra: Optional[Mapping[Any, Any]]=...) -> None
|
aioquic.stream/QuicStream.get_frame
|
Modified
|
aiortc~aioquic
|
d6323152645b40ff3575ac3b7cec7a50683749e4
|
[stream] correctly reschedule lost frame with FIN bit
|
<4>:<add> if not (self._send_pending or self._send_pending_eof):
<del> if self._send_complete or not (self._send_eof or self._send_pending):
<9>:<add> self._send_pending_eof = False
<del> self._send_complete = True
<38>:<add> if self._send_buffer_fin == send.stop:
<del> if self._send_eof and not self._send_pending:
<40>:<add> self._send_pending_eof = False
<del> self._send_complete = True
|
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
<0> """
<1> Get a frame of data to send.
<2> """
<3> # check there is something to send
<4> if self._send_complete or not (self._send_eof or self._send_pending):
<5> return None
<6>
<7> # FIN only
<8> if not self._send_pending:
<9> self._send_complete = True
<10> return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
<11>
<12> # apply flow control
<13> r = self._send_pending[0]
<14> size = min(size, r.stop - r.start)
<15> if self.stream_id is not None:
<16> size = min(size, self.max_stream_data_remote - r.start)
<17> if size <= 0:
<18> return None
<19>
<20> # create frame
<21> send = range(r.start, r.start + size)
<22> frame = QuicStreamFrame(
<23> data=self._send_buffer[
<24> send.start
<25> - self._send_buffer_start : send.start
<26> + size
<27> - self._send_buffer_start
<28> ],
<29> offset=send.start,
<30> )
<31> self._send_pending.subtract(send.start, send.stop)
<32>
<33> # track the highest offset ever sent
<34> if send.stop > self._send_highest:
<35> self._send_highest = send.stop
<36>
<37> # if the buffer is empty and EOF was written, set the FIN bit
<38> if self._send_eof and not self._send_pending:
<39> frame.fin = True
<40> self._send_complete = True
<41>
<42> return frame
<43>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.rangeset.RangeSet
subtract(start: int, stop: int) -> None
at: aioquic.stream.QuicStream.__init__
self.max_stream_data_remote = max_stream_data_remote
self._send_buffer = bytearray()
self._send_buffer_fin: Optional[int] = None
self._send_highest = 0
self._send_pending = RangeSet()
self._send_pending_eof = False
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
at: aioquic.stream.QuicStream.on_data_delivery
self._send_buffer_start += size
self._send_pending_eof = True
at: aioquic.stream.QuicStream.write
self._send_buffer += data
self._send_buffer_stop += size
at: aioquic.stream.QuicStream.write_eof
self._send_buffer_fin = self._send_buffer_stop
self._send_pending_eof = True
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
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_remote = max_stream_data_remote
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_fin = False
self._recv_highest = 0 # the highest offset ever seen
self._recv_start = 0 # the offset for the start of the buffer
self._recv_ranges = RangeSet()
self._send_acked = RangeSet()
self._send_buffer = bytearray()
- self._send_complete = False
- self._send_eof = False
+ self._send_buffer_fin: Optional[int] = None
self._send_highest = 0
self._send_pending = RangeSet()
+ self._send_pending_eof = False
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.__stream_id = stream_id
|
aioquic.stream/QuicStream.on_data_delivery
|
Modified
|
aiortc~aioquic
|
d6323152645b40ff3575ac3b7cec7a50683749e4
|
[stream] correctly reschedule lost frame with FIN bit
|
<14>:<add> if stop == self._send_buffer_fin:
<add> self._send_pending_eof = True
|
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def on_data_delivery(
self, delivery: QuicDeliveryState, start: int, stop: int
) -> None:
<0> """
<1> Callback when sent data is ACK'd.
<2> """
<3> if stop - start:
<4> if delivery == QuicDeliveryState.ACKED:
<5> self._send_acked.add(start, stop)
<6> first_range = self._send_acked[0]
<7> if first_range.start == self._send_buffer_start:
<8> size = first_range.stop - first_range.start
<9> self._send_acked.shift()
<10> self._send_buffer_start += size
<11> del self._send_buffer[:size]
<12> else:
<13> self._send_pending.add(start, stop)
<14>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicDeliveryState()
at: aioquic.rangeset.RangeSet
add(start: int, stop: Optional[int]=None) -> None
shift() -> range
at: aioquic.stream.QuicStream.__init__
self._send_acked = RangeSet()
self._send_buffer = bytearray()
self._send_pending = RangeSet()
self._send_buffer_start = 0 # the offset for the start of the buffer
at: aioquic.stream.QuicStream.write
self._send_buffer += data
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
+ if not (self._send_pending or self._send_pending_eof):
- if self._send_complete or not (self._send_eof or self._send_pending):
return None
# FIN only
if not self._send_pending:
+ self._send_pending_eof = False
- self._send_complete = True
return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
# apply flow control
r = self._send_pending[0]
size = min(size, r.stop - r.start)
if self.stream_id is not None:
size = min(size, self.max_stream_data_remote - r.start)
if size <= 0:
return None
# create frame
send = range(r.start, r.start + size)
frame = QuicStreamFrame(
data=self._send_buffer[
send.start
- self._send_buffer_start : send.start
+ size
- self._send_buffer_start
],
offset=send.start,
)
self._send_pending.subtract(send.start, send.stop)
# track the highest offset ever sent
if send.stop > self._send_highest:
self._send_highest = send.stop
# if the buffer is empty and EOF was written, set the FIN bit
+ if self._send_buffer_fin == send.stop:
- if self._send_eof and not self._send_pending:
frame.fin = True
+ self._send_pending_eof = False
- self._send_complete = True
return frame
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
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_remote = max_stream_data_remote
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_fin = False
self._recv_highest = 0 # the highest offset ever seen
self._recv_start = 0 # the offset for the start of the buffer
self._recv_ranges = RangeSet()
self._send_acked = RangeSet()
self._send_buffer = bytearray()
- self._send_complete = False
- self._send_eof = False
+ self._send_buffer_fin: Optional[int] = None
self._send_highest = 0
self._send_pending = RangeSet()
+ self._send_pending_eof = False
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.__stream_id = stream_id
|
aioquic.stream/QuicStream.write
|
Modified
|
aiortc~aioquic
|
d6323152645b40ff3575ac3b7cec7a50683749e4
|
[stream] correctly reschedule lost frame with FIN bit
|
<0>:<add> assert self._send_buffer_fin is None, "cannot call write() after FIN"
<del> assert not self._send_complete, "cannot call write() after completion"
|
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def write(self, data: bytes) -> None:
<0> assert not self._send_complete, "cannot call write() after completion"
<1> size = len(data)
<2>
<3> if size:
<4> self._send_pending.add(
<5> self._send_buffer_stop, self._send_buffer_stop + size
<6> )
<7> self._send_buffer += data
<8> self._send_buffer_stop += size
<9> if self._connection is not None:
<10> self._connection._send_soon()
<11>
|
===========unchanged ref 0===========
at: aioquic.rangeset.RangeSet
add(start: int, stop: Optional[int]=None) -> None
at: aioquic.stream.QuicStream.__init__
self._send_buffer = bytearray()
self._send_buffer_fin: Optional[int] = None
self._send_pending = RangeSet()
self._send_buffer_stop = 0 # the offset for the stop of the buffer
at: aioquic.stream.QuicStream.write_eof
self._send_buffer_fin = self._send_buffer_stop
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def on_data_delivery(
self, delivery: QuicDeliveryState, start: int, stop: int
) -> None:
"""
Callback when sent data is ACK'd.
"""
if stop - start:
if delivery == QuicDeliveryState.ACKED:
self._send_acked.add(start, stop)
first_range = self._send_acked[0]
if first_range.start == self._send_buffer_start:
size = first_range.stop - first_range.start
self._send_acked.shift()
self._send_buffer_start += size
del self._send_buffer[:size]
else:
self._send_pending.add(start, stop)
+ if stop == self._send_buffer_fin:
+ self._send_pending_eof = True
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
+ if not (self._send_pending or self._send_pending_eof):
- if self._send_complete or not (self._send_eof or self._send_pending):
return None
# FIN only
if not self._send_pending:
+ self._send_pending_eof = False
- self._send_complete = True
return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
# apply flow control
r = self._send_pending[0]
size = min(size, r.stop - r.start)
if self.stream_id is not None:
size = min(size, self.max_stream_data_remote - r.start)
if size <= 0:
return None
# create frame
send = range(r.start, r.start + size)
frame = QuicStreamFrame(
data=self._send_buffer[
send.start
- self._send_buffer_start : send.start
+ size
- self._send_buffer_start
],
offset=send.start,
)
self._send_pending.subtract(send.start, send.stop)
# track the highest offset ever sent
if send.stop > self._send_highest:
self._send_highest = send.stop
# if the buffer is empty and EOF was written, set the FIN bit
+ if self._send_buffer_fin == send.stop:
- if self._send_eof and not self._send_pending:
frame.fin = True
+ self._send_pending_eof = False
- self._send_complete = True
return frame
===========changed ref 2===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
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_remote = max_stream_data_remote
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_fin = False
self._recv_highest = 0 # the highest offset ever seen
self._recv_start = 0 # the offset for the start of the buffer
self._recv_ranges = RangeSet()
self._send_acked = RangeSet()
self._send_buffer = bytearray()
- self._send_complete = False
- self._send_eof = False
+ self._send_buffer_fin: Optional[int] = None
self._send_highest = 0
self._send_pending = RangeSet()
+ self._send_pending_eof = False
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.__stream_id = stream_id
|
aioquic.stream/QuicStream.write_eof
|
Modified
|
aiortc~aioquic
|
d6323152645b40ff3575ac3b7cec7a50683749e4
|
[stream] correctly reschedule lost frame with FIN bit
|
<0>:<add> assert self._send_buffer_fin is None, "cannot call write_eof() after FIN"
<del> assert not self._send_complete, "cannot call write_eof() after completion"
<2>:<add> self._send_buffer_fin = self._send_buffer_stop
<add> self._send_pending_eof = True
<del> self._send_eof = True
|
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def write_eof(self) -> None:
<0> assert not self._send_complete, "cannot call write_eof() after completion"
<1>
<2> self._send_eof = True
<3> if self._connection is not None:
<4> self._connection._send_soon()
<5>
|
===========unchanged ref 0===========
at: aioquic.stream.QuicStream.__init__
self._connection = connection
self._send_buffer_fin: Optional[int] = None
self._send_buffer_stop = 0 # the offset for the stop of the buffer
at: aioquic.stream.QuicStream.write
self._send_buffer_stop += size
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def write(self, data: bytes) -> None:
+ assert self._send_buffer_fin is None, "cannot call write() after FIN"
- assert not self._send_complete, "cannot call write() after completion"
size = len(data)
if size:
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 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def on_data_delivery(
self, delivery: QuicDeliveryState, start: int, stop: int
) -> None:
"""
Callback when sent data is ACK'd.
"""
if stop - start:
if delivery == QuicDeliveryState.ACKED:
self._send_acked.add(start, stop)
first_range = self._send_acked[0]
if first_range.start == self._send_buffer_start:
size = first_range.stop - first_range.start
self._send_acked.shift()
self._send_buffer_start += size
del self._send_buffer[:size]
else:
self._send_pending.add(start, stop)
+ if stop == self._send_buffer_fin:
+ self._send_pending_eof = True
===========changed ref 2===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
+ if not (self._send_pending or self._send_pending_eof):
- if self._send_complete or not (self._send_eof or self._send_pending):
return None
# FIN only
if not self._send_pending:
+ self._send_pending_eof = False
- self._send_complete = True
return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
# apply flow control
r = self._send_pending[0]
size = min(size, r.stop - r.start)
if self.stream_id is not None:
size = min(size, self.max_stream_data_remote - r.start)
if size <= 0:
return None
# create frame
send = range(r.start, r.start + size)
frame = QuicStreamFrame(
data=self._send_buffer[
send.start
- self._send_buffer_start : send.start
+ size
- self._send_buffer_start
],
offset=send.start,
)
self._send_pending.subtract(send.start, send.stop)
# track the highest offset ever sent
if send.stop > self._send_highest:
self._send_highest = send.stop
# if the buffer is empty and EOF was written, set the FIN bit
+ if self._send_buffer_fin == send.stop:
- if self._send_eof and not self._send_pending:
frame.fin = True
+ self._send_pending_eof = False
- self._send_complete = True
return frame
===========changed ref 3===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
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_remote = max_stream_data_remote
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_fin = False
self._recv_highest = 0 # the highest offset ever seen
self._recv_start = 0 # the offset for the start of the buffer
self._recv_ranges = RangeSet()
self._send_acked = RangeSet()
self._send_buffer = bytearray()
- self._send_complete = False
- self._send_eof = False
+ self._send_buffer_fin: Optional[int] = None
self._send_highest = 0
self._send_pending = RangeSet()
+ self._send_pending_eof = False
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.__stream_id = stream_id
|
tests.test_stream/QuicStreamTest.test_send_data_lost
|
Modified
|
aiortc~aioquic
|
d6323152645b40ff3575ac3b7cec7a50683749e4
|
[stream] correctly reschedule lost frame with FIN bit
|
<7>:<add> # write data and EOF
<del> # write data
<9>:<add> stream.write_eof()
<19>:<add> stream.get_frame(8), QuicStreamFrame(data=b"89012345", fin=True, offset=8)
<del> stream.get_frame(8), QuicStreamFrame(data=b"89012345", fin=False, offset=8)
|
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data_lost(self):
<0> stream = QuicStream(stream_id=0, max_stream_data_remote=512)
<1>
<2> # nothing to send yet
<3> self.assertFalse(stream.is_blocked())
<4> frame = stream.get_frame(8)
<5> self.assertIsNone(frame)
<6>
<7> # write data
<8> stream.write(b"0123456789012345")
<9> self.assertEqual(list(stream._send_pending), [range(0, 16)])
<10>
<11> # send a chunk
<12> self.assertEqual(
<13> stream.get_frame(8), QuicStreamFrame(data=b"01234567", fin=False, offset=0)
<14> )
<15> self.assertEqual(list(stream._send_pending), [range(8, 16)])
<16>
<17> # send another chunk
<18> self.assertEqual(
<19> stream.get_frame(8), QuicStreamFrame(data=b"89012345", fin=False, offset=8)
<20> )
<21> self.assertEqual(list(stream._send_pending), [])
<22>
<23> # nothing more to send
<24> self.assertIsNone(stream.get_frame(8))
<25> self.assertEqual(list(stream._send_pending), [])
<26>
<27> # a chunk gets lost
<28> stream.on_data_delivery(QuicDeliveryState.LOST, 0, 8)
<29> self.assertEqual(list(stream._send_pending), [range(0, 8)])
<30>
<31> # send chunk again
<32> self.assertEqual(
<33> stream.get_frame(8), QuicStreamFrame(data=b"01234567", fin=False, offset=0)
<34> )
<35> self.assertEqual(list(stream._send_pending), [])
<36>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicDeliveryState()
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.stream
QuicStream(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
get_frame(size: int) -> Optional[QuicStreamFrame]
is_blocked() -> bool
on_data_delivery(delivery: QuicDeliveryState, start: int, stop: int) -> None
write(data: bytes) -> None
write_eof() -> None
at: aioquic.stream.QuicStream.__init__
self._send_pending = RangeSet()
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
assertIsNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def write_eof(self) -> None:
+ assert self._send_buffer_fin is None, "cannot call write_eof() after FIN"
- assert not self._send_complete, "cannot call write_eof() after completion"
+ self._send_buffer_fin = self._send_buffer_stop
+ self._send_pending_eof = True
- self._send_eof = True
if self._connection is not None:
self._connection._send_soon()
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def write(self, data: bytes) -> None:
+ assert self._send_buffer_fin is None, "cannot call write() after FIN"
- assert not self._send_complete, "cannot call write() after completion"
size = len(data)
if size:
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 2===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def on_data_delivery(
self, delivery: QuicDeliveryState, start: int, stop: int
) -> None:
"""
Callback when sent data is ACK'd.
"""
if stop - start:
if delivery == QuicDeliveryState.ACKED:
self._send_acked.add(start, stop)
first_range = self._send_acked[0]
if first_range.start == self._send_buffer_start:
size = first_range.stop - first_range.start
self._send_acked.shift()
self._send_buffer_start += size
del self._send_buffer[:size]
else:
self._send_pending.add(start, stop)
+ if stop == self._send_buffer_fin:
+ self._send_pending_eof = True
===========changed ref 3===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
+ if not (self._send_pending or self._send_pending_eof):
- if self._send_complete or not (self._send_eof or self._send_pending):
return None
# FIN only
if not self._send_pending:
+ self._send_pending_eof = False
- self._send_complete = True
return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
# apply flow control
r = self._send_pending[0]
size = min(size, r.stop - r.start)
if self.stream_id is not None:
size = min(size, self.max_stream_data_remote - r.start)
if size <= 0:
return None
# create frame
send = range(r.start, r.start + size)
frame = QuicStreamFrame(
data=self._send_buffer[
send.start
- self._send_buffer_start : send.start
+ size
- self._send_buffer_start
],
offset=send.start,
)
self._send_pending.subtract(send.start, send.stop)
# track the highest offset ever sent
if send.stop > self._send_highest:
self._send_highest = send.stop
# if the buffer is empty and EOF was written, set the FIN bit
+ if self._send_buffer_fin == send.stop:
- if self._send_eof and not self._send_pending:
frame.fin = True
+ self._send_pending_eof = False
- self._send_complete = True
return frame
===========changed ref 4===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
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_remote = max_stream_data_remote
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_fin = False
self._recv_highest = 0 # the highest offset ever seen
self._recv_start = 0 # the offset for the start of the buffer
self._recv_ranges = RangeSet()
self._send_acked = RangeSet()
self._send_buffer = bytearray()
- self._send_complete = False
- self._send_eof = False
+ self._send_buffer_fin: Optional[int] = None
self._send_highest = 0
self._send_pending = RangeSet()
+ self._send_pending_eof = False
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.__stream_id = stream_id
|
aioquic.connection/QuicPacketSpace.__init__
|
Modified
|
aiortc~aioquic
|
be5c99a46784c5469876bbc98102abdf4ccd5963
|
[connection] add initial RTT estimation
|
<3>:<add>
<add> # sent packets
<4>:<add> self.timestamps: Dict[int, float] = {}
|
# module: aioquic.connection
class QuicPacketSpace:
def __init__(self) -> None:
<0> self.ack_queue = RangeSet()
<1> self.ack_required = False
<2> self.expected_packet_number = 0
<3> self.delivery_handlers: Dict[int, List[Tuple[QuicDeliveryHandler, Any]]] = {}
<4>
|
===========unchanged ref 0===========
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
logger = logging.getLogger("quic")
EPOCH_SHORTCUTS = {
"I": tls.Epoch.INITIAL,
"Z": tls.Epoch.ZERO_RTT,
"H": tls.Epoch.HANDSHAKE,
"O": tls.Epoch.ONE_RTT,
}
+ K_PACKET_THRESHOLD = 3
+ K_INITIAL_RTT = 0.5 # seconds
+ K_GRANULARITY = 0.001 # seconds
+ K_TIME_THRESHOLD = 9 / 8
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",
],
]
STREAM_FLAGS = 0x07
NetworkAddress = Any
|
aioquic.connection/QuicPacketSpace.expect_ack
|
Modified
|
aiortc~aioquic
|
be5c99a46784c5469876bbc98102abdf4ccd5963
|
[connection] add initial RTT estimation
|
<3>:<add> self.timestamps[packet_number] = time.time()
|
# module: aioquic.connection
class QuicPacketSpace:
def expect_ack(
self, packet_number: int, handler: QuicDeliveryHandler, args: Sequence[Any] = []
) -> None:
<0> if packet_number not in self.delivery_handlers:
<1> self.delivery_handlers[packet_number] = []
<2> self.delivery_handlers[packet_number].append((handler, args))
<3>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicDeliveryHandler = Callable[..., None]
at: aioquic.rangeset
RangeSet(ranges: Iterable[range]=[])
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: aioquic.connection
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
self.expected_packet_number = 0
+
+ # sent packets
self.delivery_handlers: Dict[int, List[Tuple[QuicDeliveryHandler, Any]]] = {}
+ self.timestamps: Dict[int, float] = {}
===========changed ref 1===========
# module: aioquic.connection
logger = logging.getLogger("quic")
EPOCH_SHORTCUTS = {
"I": tls.Epoch.INITIAL,
"Z": tls.Epoch.ZERO_RTT,
"H": tls.Epoch.HANDSHAKE,
"O": tls.Epoch.ONE_RTT,
}
+ K_PACKET_THRESHOLD = 3
+ K_INITIAL_RTT = 0.5 # seconds
+ K_GRANULARITY = 0.001 # seconds
+ K_TIME_THRESHOLD = 9 / 8
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",
],
]
STREAM_FLAGS = 0x07
NetworkAddress = Any
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
be5c99a46784c5469876bbc98102abdf4ccd5963
|
[connection] add initial RTT estimation
|
<28>:<add> self._highest_acked_by_peer = -1
|
<s>[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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
<0> if is_client:
<1> assert (
<2> original_connection_id is None
<3> ), "Cannot set original_connection_id for a client"
<4> else:
<5> assert certificate is not None, "SSL certificate is required for a server"
<6> assert private_key is not None, "SSL private key is required for a server"
<7>
<8> self.alpn_protocols = alpn_protocols
<9> self.certificate = certificate
<10> self.is_client = is_client
<11> self.peer_cid = os.urandom(8)
<12> self._peer_cid_seq: Optional[int] = None
<13> self._peer_cid_available: List[QuicConnectionId] = []
<14> self.peer_token = b""
<15> self.private_key = private_key
<16> self.secrets_log_file = secrets_log_file
<17> self.server_name = server_name
<18> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<19>
<20> # counters for debugging
<21> self._stateless_retry_count = 0
<22> self._version_negotiation_count = 0
<23>
<24> self._loop = asyncio.get_event_loop()
<25> self.__close: Optional[Dict] = None
<26> self.__connected = asyncio.Event()
<27> self.__epoch = tls.Epoch.INITIAL
<28> self._host_cids = [
<29> QuicConnectionId(
<30> cid=os.urandom(8),
<31> sequence_number=0,
<32> stateless_reset</s>
|
===========below chunk 0===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = 1048576
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = 1048576
self._local_max_stream_data_bidi_remote = 1048576
self._local_max_stream_data_uni = 1048576
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._parameters_received = False
self._ping_pending = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._probe_timeout = 0.1 # seconds
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max</s>
===========below chunk 1===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s>_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# things to send
self._retire_connection_ids: List[int] = []
# callbacks
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionIdHandler = lambda c: None
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
if stream_handler is not None:
self._stream_handler = stream_handler
else:
self._stream_handler = lambda r, w: None
# frame handlers
self.__frame_handlers = [
(self._handle_padding_frame, EPOCHS("IZHO")),
(self._handle_padding_frame, EPOCH</s>
===========below chunk 2===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 3
<s>ZO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_reset_stream_frame, EPOCHS("ZO")),
(self._handle_stop_sending_frame, EPOCHS("ZO")),
(self._handle_crypto_frame, EPOCHS("IHO")),
(self._handle_new_token_frame, EPOCHS("O")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_max_data_frame, EPOCHS("ZO")),
(self._handle_max_stream_data_frame, EPOCHS("ZO")),
(self._handle_max_streams_bidi_frame, EPOCHS("ZO")),
(self._handle</s>
===========below chunk 3===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 4
<s>_streams_uni_frame, EPOCHS("ZO")),
(self._handle_data_blocked_frame, EPOCHS("ZO")),
(self._handle_stream_data_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_new_connection_id_frame, EPOCHS("ZO")),
(self._handle_retire_connection_id_frame, EPOCHS("O")),
(self._handle_path_challenge_frame, EPOCHS("ZO")),
(self._handle_path_response_frame, EPOCHS("O")),
(self._handle_connection_close_frame, EPOCHS("IZHO")),
(self._handle_connection_close_frame, EPOCHS("ZO")),
]
|
aioquic.connection/QuicConnection._handle_ack_frame
|
Modified
|
aiortc~aioquic
|
be5c99a46784c5469876bbc98102abdf4ccd5963
|
[connection] add initial RTT estimation
|
<3>:<add> ack_time = time.time()
<add>
<add> rangeset, ack_delay = packet.pull_ack_frame(buf)
<del> rangeset, _ = packet.pull_ack_frame(buf)
<10>:<add> is_ack_eliciting = False
<add> largest_pn_is_newly_acked = False
<add> largest_pn_send_time = None
<11>:<add> timestamps = self.spaces[context.epoch].timestamps
<13>:<add> largest_pn_is_newly_acked = False
<14>:<add> # newly ack'd
<17>:<add> is_ack_eliciting = True
<add> largest_pn_is_newly_acked = True
<add> largest_pn_send_time = timestamps.pop(packet_number)
<add> if packet_number > self._highest_acked_by_peer:
<add> self._highest_acked_by_peer = packet_number
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle an ACK frame.
<2> """
<3> rangeset, _ = packet.pull_ack_frame(buf)
<4> if frame_type == QuicFrameType.ACK_ECN:
<5> pull_uint_var(buf)
<6> pull_uint_var(buf)
<7> pull_uint_var(buf)
<8>
<9> # trigger callbacks
<10> handlers = self.spaces[context.epoch].delivery_handlers
<11> for packet_range in rangeset:
<12> for packet_number in packet_range:
<13> if packet_number in handlers:
<14> for handler, args in handlers[packet_number]:
<15> handler(QuicDeliveryState.ACKED, *args)
<16> del handlers[packet_number]
<17>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
_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._session_ticket = session_ticket
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.crypto
CryptoPair()
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.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
other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _check_packet_loss(self) -> None:
+ """
+ Check whether any packets should be declared lost.
+ """
+ packet_threshold = self._highest_acked_by_peer - K_GRANULARITY
+ rtt = (
+ max(self._rtt_latest, self._rtt_smoothed)
+ if self._rtt_latest is not None
+ else K_INITIAL_RTT
+ )
+ time_threshold = time.time() - K_TIME_THRESHOLD * rtt
+
+ for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE, tls.Epoch.ONE_RTT]:
+ handlers = self.spaces[epoch].delivery_handlers
+ timestamps = self.spaces[epoch].timestamps
+ for packet_number, timestamp in list(timestamps.items()):
+ if packet_number <= packet_threshold or (
+ packet_number < self._highest_acked_by_peer
+ and timestamp < time_threshold
+ ):
+ self._logger.info("Packet %d was lost", packet_number)
+ for handler, args in handlers[packet_number]:
+ handler(QuicDeliveryState.LOST, *args)
+ del handlers[packet_number]
+ del timestamps[packet_number]
+ else:
+ break
+
===========changed ref 1===========
# module: aioquic.connection
class QuicPacketSpace:
def expect_ack(
self, packet_number: int, handler: QuicDeliveryHandler, args: Sequence[Any] = []
) -> None:
if packet_number not in self.delivery_handlers:
self.delivery_handlers[packet_number] = []
self.delivery_handlers[packet_number].append((handler, args))
+ self.timestamps[packet_number] = time.time()
===========changed ref 2===========
# module: aioquic.connection
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
self.expected_packet_number = 0
+
+ # sent packets
self.delivery_handlers: Dict[int, List[Tuple[QuicDeliveryHandler, Any]]] = {}
+ self.timestamps: Dict[int, float] = {}
===========changed ref 3===========
# module: aioquic.connection
logger = logging.getLogger("quic")
EPOCH_SHORTCUTS = {
"I": tls.Epoch.INITIAL,
"Z": tls.Epoch.ZERO_RTT,
"H": tls.Epoch.HANDSHAKE,
"O": tls.Epoch.ONE_RTT,
}
+ K_PACKET_THRESHOLD = 3
+ K_INITIAL_RTT = 0.5 # seconds
+ K_GRANULARITY = 0.001 # seconds
+ K_TIME_THRESHOLD = 9 / 8
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",
],
]
STREAM_FLAGS = 0x07
NetworkAddress = Any
===========changed ref 4===========
<s>[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,
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"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.peer_cid = os.urandom(8)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
+ self._highest_acked_by_peer = -1
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=</s>
|
aioquic.connection/QuicConnection._on_retire_connection_id_delivery
|
Modified
|
aiortc~aioquic
|
be5c99a46784c5469876bbc98102abdf4ccd5963
|
[connection] add initial RTT estimation
|
<4>:<add> self._retire_connection_ids.append(sequence_number)
<del> self._retire_connection_ids.add(sequence_number)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _on_retire_connection_id_delivery(
self, delivery: QuicDeliveryState, sequence_number: int
) -> None:
<0> """
<1> Callback when a RETIRE_CONNECTION_ID frame is is acknowledged or lost.
<2> """
<3> if delivery != QuicDeliveryState.ACKED:
<4> self._retire_connection_ids.add(sequence_number)
<5>
|
===========unchanged ref 0===========
at: aioquic.buffer
pull_bytes(buf: Buffer, length: int) -> bytes
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.connection.QuicConnection._handle_stream_frame
flags = frame_type & STREAM_FLAGS
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle an ACK frame.
"""
+ ack_time = time.time()
+
+ rangeset, ack_delay = packet.pull_ack_frame(buf)
- rangeset, _ = packet.pull_ack_frame(buf)
if frame_type == QuicFrameType.ACK_ECN:
pull_uint_var(buf)
pull_uint_var(buf)
pull_uint_var(buf)
# trigger callbacks
+ is_ack_eliciting = False
+ largest_pn_is_newly_acked = False
+ largest_pn_send_time = None
handlers = self.spaces[context.epoch].delivery_handlers
+ timestamps = self.spaces[context.epoch].timestamps
for packet_range in rangeset:
for packet_number in packet_range:
+ largest_pn_is_newly_acked = False
if packet_number in handlers:
+ # newly ack'd
for handler, args in handlers[packet_number]:
handler(QuicDeliveryState.ACKED, *args)
del handlers[packet_number]
+ is_ack_eliciting = True
+ largest_pn_is_newly_acked = True
+ largest_pn_send_time = timestamps.pop(packet_number)
+ if packet_number > self._highest_acked_by_peer:
+ self._highest_acked_by_peer = packet_number
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _check_packet_loss(self) -> None:
+ """
+ Check whether any packets should be declared lost.
+ """
+ packet_threshold = self._highest_acked_by_peer - K_GRANULARITY
+ rtt = (
+ max(self._rtt_latest, self._rtt_smoothed)
+ if self._rtt_latest is not None
+ else K_INITIAL_RTT
+ )
+ time_threshold = time.time() - K_TIME_THRESHOLD * rtt
+
+ for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE, tls.Epoch.ONE_RTT]:
+ handlers = self.spaces[epoch].delivery_handlers
+ timestamps = self.spaces[epoch].timestamps
+ for packet_number, timestamp in list(timestamps.items()):
+ if packet_number <= packet_threshold or (
+ packet_number < self._highest_acked_by_peer
+ and timestamp < time_threshold
+ ):
+ self._logger.info("Packet %d was lost", packet_number)
+ for handler, args in handlers[packet_number]:
+ handler(QuicDeliveryState.LOST, *args)
+ del handlers[packet_number]
+ del timestamps[packet_number]
+ else:
+ break
+
===========changed ref 2===========
# module: aioquic.connection
class QuicPacketSpace:
def expect_ack(
self, packet_number: int, handler: QuicDeliveryHandler, args: Sequence[Any] = []
) -> None:
if packet_number not in self.delivery_handlers:
self.delivery_handlers[packet_number] = []
self.delivery_handlers[packet_number].append((handler, args))
+ self.timestamps[packet_number] = time.time()
===========changed ref 3===========
# module: aioquic.connection
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
self.expected_packet_number = 0
+
+ # sent packets
self.delivery_handlers: Dict[int, List[Tuple[QuicDeliveryHandler, Any]]] = {}
+ self.timestamps: Dict[int, float] = {}
===========changed ref 4===========
# module: aioquic.connection
logger = logging.getLogger("quic")
EPOCH_SHORTCUTS = {
"I": tls.Epoch.INITIAL,
"Z": tls.Epoch.ZERO_RTT,
"H": tls.Epoch.HANDSHAKE,
"O": tls.Epoch.ONE_RTT,
}
+ K_PACKET_THRESHOLD = 3
+ K_INITIAL_RTT = 0.5 # seconds
+ K_GRANULARITY = 0.001 # seconds
+ K_TIME_THRESHOLD = 9 / 8
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",
],
]
STREAM_FLAGS = 0x07
NetworkAddress = Any
===========changed ref 5===========
<s>[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,
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"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.peer_cid = os.urandom(8)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
+ self._highest_acked_by_peer = -1
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=</s>
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
3d9fe79f36cd886d54f7a6857e85af92bc3a6700
|
[connection] ensure parameters are available before creating stream
|
<s>[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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
<0> if is_client:
<1> assert (
<2> original_connection_id is None
<3> ), "Cannot set original_connection_id for a client"
<4> else:
<5> assert certificate is not None, "SSL certificate is required for a server"
<6> assert private_key is not None, "SSL private key is required for a server"
<7>
<8> self.alpn_protocols = alpn_protocols
<9> self.certificate = certificate
<10> self.is_client = is_client
<11> self.peer_cid = os.urandom(8)
<12> self._peer_cid_seq: Optional[int] = None
<13> self._peer_cid_available: List[QuicConnectionId] = []
<14> self.peer_token = b""
<15> self.private_key = private_key
<16> self.secrets_log_file = secrets_log_file
<17> self.server_name = server_name
<18> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<19>
<20> # counters for debugging
<21> self._stateless_retry_count = 0
<22> self._version_negotiation_count = 0
<23>
<24> self._loop = asyncio.get_event_loop()
<25> self.__close: Optional[Dict] = None
<26> self.__connected = asyncio.Event()
<27> self.__epoch = tls.Epoch.INITIAL
<28> self._highest_acked_by_peer = -1
<29> self._host_cids = [
<30> QuicConnectionId(
<31> cid=os.urandom(8</s>
|
===========below chunk 0===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
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 = 60000 # milliseconds
self._local_max_data = 1048576
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = 1048576
self._local_max_stream_data_bidi_remote = 1048576
self._local_max_stream_data_uni = 1048576
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._parameters_received = False
self._ping_pending = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._probe_timeout = 0.1 # seconds
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote =</s>
===========below chunk 1===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s>_max_stream_data_bidi_local = 0
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._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# things to send
self._retire_connection_ids: List[int] = []
# RTT estimation (seconds)
self._rtt_latest: Optional[float] = None
self._rtt_min: Optional[float] = None
self._rtt_smoothed: Optional[float] = None
self._rtt_var: Optional[float] = None
# callbacks
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionIdHandler = lambda c: None
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket</s>
===========below chunk 2===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 3
<s> = session_ticket_handler
if stream_handler is not None:
self._stream_handler = stream_handler
else:
self._stream_handler = lambda r, w: None
# frame handlers
self.__frame_handlers = [
(self._handle_padding_frame, EPOCHS("IZHO")),
(self._handle_padding_frame, EPOCHS("ZO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_reset_stream_frame, EPOCHS("ZO")),
(self._handle_stop_sending_frame, EPOCHS("ZO")),
(self._handle_crypto_frame, EPOCHS("IHO")),
(self._handle_new_token_frame, EPOCHS("O")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO</s>
===========below chunk 3===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 4
<s>
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_max_data_frame, EPOCHS("ZO")),
(self._handle_max_stream_data_frame, EPOCHS("ZO")),
(self._handle_max_streams_bidi_frame, EPOCHS("ZO")),
(self._handle_max_streams_uni_frame, EPOCHS("ZO")),
(self._handle_data_blocked_frame, EPOCHS("ZO")),
(self._handle_stream_data_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_new_connection_id_frame, EPOCHS("ZO")),
(self._handle_retire_connection_id_frame, EPOCHS("O")),
(self._handle_path_challenge_frame, EPOCHS("ZO")),
(self._handle_path_response_frame, EPOCHS("O")),
(self._handle_connection_close_frame, EPOCHS("IZHO")),
(self._handle_connection_close_frame, EPOCHS("ZO")),
]
|
|
aioquic.connection/QuicConnection.create_stream
|
Modified
|
aiortc~aioquic
|
3d9fe79f36cd886d54f7a6857e85af92bc3a6700
|
[connection] ensure parameters are available before creating stream
|
<6>:<add> await self._parameters_available.wait()
<add>
|
# 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> stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
<7> while stream_id in self.streams:
<8> stream_id += 4
<9>
<10> # determine limits
<11> if is_unidirectional:
<12> max_stream_data_local = 0
<13> max_stream_data_remote = self._remote_max_stream_data_uni
<14> max_streams = self._remote_max_streams_uni
<15> else:
<16> max_stream_data_local = self._local_max_stream_data_bidi_local
<17> max_stream_data_remote = self._remote_max_stream_data_bidi_remote
<18> max_streams = self._remote_max_streams_bidi
<19>
<20> # check max streams
<21> if stream_id // 4 >= max_streams:
<22> raise ValueError("Too many streams open")
<23>
<24> # create stream
<25> stream = self.streams[stream_id] = QuicStream(
<26> connection=self,
<27> stream_id=stream_id,
<28> max_stream_data_local=max_stream_data_local,
<29> max_stream_data_remote=max_stream_data_remote,
<30> )
<31>
<32> return stream.reader, stream.writer
<33>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self._local_max_stream_data_bidi_local = 1048576
self._parameters_available = asyncio.Event()
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
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.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
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===========
<s>[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,
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"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.peer_cid = os.urandom(8)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self._highest_acked_by_peer = -1
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True</s>
===========changed ref 1===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
<s> 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 = 60000 # milliseconds
self._local_max_data = 1048576
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = 1048576
self._local_max_stream_data_bidi_remote = 1048576
self._local_max_stream_data_uni = 1048576
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
+ self._parameters_available = asyncio.Event()
self._parameters_received = False
self._ping_pending = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._probe_timeout = 0.1 # seconds
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
</s>
===========changed ref 2===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s>remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
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._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# things to send
self._retire_connection_ids: List[int] = []
# RTT estimation (seconds)
self._rtt_latest: Optional[float] = None
self._rtt_min: Optional[float] = None
self._rtt_smoothed: Optional[float] = None
self._rtt_var: Optional[float] = None
# callbacks
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionIdHandler = lambda c: None
self._session_ticket_fetcher</s>
|
aioquic.connection/QuicConnection._handle_crypto_frame
|
Modified
|
aiortc~aioquic
|
3d9fe79f36cd886d54f7a6857e85af92bc3a6700
|
[connection] ensure parameters are available before creating stream
|
<25>:<add> self._parameters_received = True
<26>:<add> assert (
<add> self._parameters_received
<del> self._parameters_received = True
<27>:<add> ), "No QUIC transport parameters received"
<add> self._logger.info("ALPN negotiated protocol %s", self.alpn_protocol)
|
# module: aioquic.connection
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.streams[context.epoch]
<4> stream.add_frame(packet.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.send_buffer)
<10> except tls.Alert as exc:
<11> raise QuicConnectionError(
<12> error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),
<13> frame_type=QuicFrameType.CRYPTO,
<14> reason_phrase=str(exc),
<15> )
<16>
<17> # parse transport parameters
<18> if (
<19> not self._parameters_received
<20> and self.tls.received_extensions is not None
<21> ):
<22> for ext_type, ext_data in self.tls.received_extensions:
<23> if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
<24> self._parse_transport_parameters(ext_data)
<25> break
<26> self._parameters_received = True
<27>
<28> # update current epoch
<29> if self.__epoch == tls.Epoch.HANDSHAKE and self.tls.state in [
<30> tls.State.CLIENT_POST_HANDSHAKE,
<31> tls.State.SERVER_POST_HANDSHAKE,
<32> ]:
<33> self._replenish_connection_ids()
<34> self.__epoch = tls.Epoch.ONE_RTT
<35> # wakeup waiter
<36> if not self.__connected.is_set():
<37> self.__connected.set()
<38> elif self.__epoch == tls.Epoch.INITIAL:
<39> self.__epoch = tls.Epoch.HANDSHAKE
<40>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath)
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
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__epoch = tls.Epoch.INITIAL
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._parameters_received = False
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
self.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
at: aioquic.connection.QuicReceiveContext
epoch: tls.Epoch
host_cid: bytes
network_path: QuicNetworkPath
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
===========unchanged ref 1===========
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_crypto_frame(buf: Buffer) -> QuicStreamFrame
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
pull_data() -> bytes
at: aioquic.tls
Alert(*args: object)
Epoch()
State()
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls.Alert
description: AlertDescription
at: aioquic.tls.Context
handle_message(input_data: bytes, output_buf: Dict[Epoch, Buffer]) -> None
at: aioquic.tls.Context.__init__
self.received_extensions: Optional[List[Extension]] = None
self.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: aioquic.tls.Context._client_handle_encrypted_extensions
self.received_extensions = encrypted_extensions.other_extensions
at: aioquic.tls.Context._server_handle_hello
self.received_extensions = peer_hello.other_extensions
at: aioquic.tls.Context._set_state
self.state = state
at: 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 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)
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 1===========
<s>[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,
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"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.peer_cid = os.urandom(8)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self._highest_acked_by_peer = -1
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True</s>
|
aioquic.connection/QuicConnection._parse_transport_parameters
|
Modified
|
aiortc~aioquic
|
3d9fe79f36cd886d54f7a6857e85af92bc3a6700
|
[connection] ensure parameters are available before creating stream
|
<32>:<add> # wakeup waiters
<add> if not self._parameters_available.is_set():
<add> self._parameters_available.set()
<del> self._logger.info("ALPN negotiated protocol %s", self.alpn_protocol)
|
# 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
<20> for param in [
<21> "max_data",
<22> "max_stream_data_bidi_local",
<23> "max_stream_data_bidi_remote",
<24> "max_stream_data_uni",
<25> "max_streams_bidi",
<26> "max_streams_uni",
<27> ]:
<28> value = getattr(quic_transport_parameters, "initial_" + param)
<29> if value is not None:
<30> setattr(self, "_remote_" + param, value)
<31>
<32> self._logger.info("ALPN negotiated protocol %s", self.alpn_protocol)
<33>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
at: aioquic.connection.QuicConnection
_send_pending() -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self._loop = asyncio.get_event_loop()
self._original_connection_id = original_connection_id
self._remote_idle_timeout = 0 # milliseconds
self.__send_pending_task: Optional[asyncio.Handle] = None
at: aioquic.connection.QuicConnection._send_pending
network_path = self._network_paths[0]
at: aioquic.connection.QuicConnection.datagram_received
self._original_connection_id = self.peer_cid
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.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
pull_quic_transport_parameters(buf: Buffer) -> QuicTransportParameters
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
===========unchanged ref 1===========
supported_versions: List[QuicProtocolVersion] = field(default_factory=list)
original_connection_id: Optional[bytes] = None
idle_timeout: Optional[int] = None
stateless_reset_token: Optional[bytes] = None
max_packet_size: Optional[int] = None
initial_max_data: Optional[int] = None
initial_max_stream_data_bidi_local: Optional[int] = None
initial_max_stream_data_bidi_remote: Optional[int] = None
initial_max_stream_data_uni: Optional[int] = None
initial_max_streams_bidi: Optional[int] = None
initial_max_streams_uni: Optional[int] = None
ack_delay_exponent: Optional[int] = None
max_ack_delay: Optional[int] = None
disable_migration: Optional[bool] = False
preferred_address: Optional[bytes] = None
at: asyncio.events.AbstractEventLoop
call_soon(callback: Callable[..., Any], *args: Any) -> Handle
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a CRYPTO frame.
"""
stream = self.streams[context.epoch]
stream.add_frame(packet.pull_crypto_frame(buf))
data = stream.pull_data()
if data:
# pass data to TLS layer
try:
self.tls.handle_message(data, self.send_buffer)
except tls.Alert as exc:
raise QuicConnectionError(
error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),
frame_type=QuicFrameType.CRYPTO,
reason_phrase=str(exc),
)
# 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
- self._parameters_received = True
+ ), "No QUIC transport parameters received"
+ self._logger.info("ALPN negotiated protocol %s", self.alpn_protocol)
# update current epoch
if self.__epoch == tls.Epoch.HANDSHAKE and self.tls.state in [
tls.State.CLIENT_POST_HANDSHAKE,
tls.State.SERVER_POST_HANDSHAKE,
]:
self._replenish_connection_ids()
self.__epoch = tls.Epoch.ONE_RTT
# wakeup waiter
if not self.__connected.is_set():
self.__connected.set()
elif self.__epoch == tls.Epoch.INITIAL:
self.__epoch = tls.Epoch.HANDSHAKE
===========changed ref 1===========
# 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)
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
|
aioquic.packet_builder/QuicPacketBuilder.__init__
|
Modified
|
aiortc~aioquic
|
89540022e09e27a41c5118255ceea925ef9a3b5a
|
[connection] take ack delay into account when estimating RTT
|
<7>:<add> self._ack_eliciting = False
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
packet_number: int = 0,
peer_token: bytes = b"",
spin_bit: bool = False,
):
<0> self._host_cid = host_cid
<1> self._peer_cid = peer_cid
<2> self._peer_token = peer_token
<3> self._spin_bit = spin_bit
<4> self._version = version
<5>
<6> # assembled datagrams
<7> self._datagrams: List[bytes] = []
<8>
<9> # current packet
<10> self._crypto: Optional[CryptoPair] = None
<11> self._header_size = 0
<12> self._packet_number = packet_number
<13> self._packet_start = 0
<14> self._packet_type = 0
<15>
<16> self.buffer = Buffer(PACKET_MAX_SIZE)
<17>
|
===========unchanged ref 0===========
at: aioquic.crypto
CryptoPair()
at: aioquic.packet_builder.QuicPacketBuilder.end_packet
self._packet_number += 1
self._crypto = None
at: aioquic.packet_builder.QuicPacketBuilder.flush
self._datagrams = []
at: aioquic.packet_builder.QuicPacketBuilder.start_frame
self._ack_eliciting = True
at: aioquic.packet_builder.QuicPacketBuilder.start_packet
self._packet_start = buf.tell()
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
at: typing
List = _alias(list, 1, inst=False, name='List')
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
89540022e09e27a41c5118255ceea925ef9a3b5a
|
[connection] take ack delay into account when estimating RTT
|
<28>:<del> self._highest_acked_by_peer = -1
|
<s>[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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
<0> if is_client:
<1> assert (
<2> original_connection_id is None
<3> ), "Cannot set original_connection_id for a client"
<4> else:
<5> assert certificate is not None, "SSL certificate is required for a server"
<6> assert private_key is not None, "SSL private key is required for a server"
<7>
<8> self.alpn_protocols = alpn_protocols
<9> self.certificate = certificate
<10> self.is_client = is_client
<11> self.peer_cid = os.urandom(8)
<12> self._peer_cid_seq: Optional[int] = None
<13> self._peer_cid_available: List[QuicConnectionId] = []
<14> self.peer_token = b""
<15> self.private_key = private_key
<16> self.secrets_log_file = secrets_log_file
<17> self.server_name = server_name
<18> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<19>
<20> # counters for debugging
<21> self._stateless_retry_count = 0
<22> self._version_negotiation_count = 0
<23>
<24> self._loop = asyncio.get_event_loop()
<25> self.__close: Optional[Dict] = None
<26> self.__connected = asyncio.Event()
<27> self.__epoch = tls.Epoch.INITIAL
<28> self._highest_acked_by_peer = -1
<29> self._host_cids = [
<30> QuicConnectionId(
<31> cid=os.urandom(8</s>
|
===========below chunk 0===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
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 = 60000 # milliseconds
self._local_max_data = 1048576
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = 1048576
self._local_max_stream_data_bidi_remote = 1048576
self._local_max_stream_data_uni = 1048576
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._parameters_available = asyncio.Event()
self._parameters_received = False
self._ping_pending = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._probe_timeout = 0.1 # seconds
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote</s>
===========below chunk 1===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s>max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
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._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# things to send
self._retire_connection_ids: List[int] = []
# RTT estimation (seconds)
self._rtt_latest: Optional[float] = None
self._rtt_min: Optional[float] = None
self._rtt_smoothed: Optional[float] = None
self._rtt_var: Optional[float] = None
# callbacks
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionIdHandler = lambda c: None
self._session_ticket_fetcher = session</s>
===========below chunk 2===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 3
<s>_fetcher
self._session_ticket_handler = session_ticket_handler
if stream_handler is not None:
self._stream_handler = stream_handler
else:
self._stream_handler = lambda r, w: None
# frame handlers
self.__frame_handlers = [
(self._handle_padding_frame, EPOCHS("IZHO")),
(self._handle_padding_frame, EPOCHS("ZO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_reset_stream_frame, EPOCHS("ZO")),
(self._handle_stop_sending_frame, EPOCHS("ZO")),
(self._handle_crypto_frame, EPOCHS("IHO")),
(self._handle_new_token_frame, EPOCHS("O")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._</s>
===========below chunk 3===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 4
<s>stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_max_data_frame, EPOCHS("ZO")),
(self._handle_max_stream_data_frame, EPOCHS("ZO")),
(self._handle_max_streams_bidi_frame, EPOCHS("ZO")),
(self._handle_max_streams_uni_frame, EPOCHS("ZO")),
(self._handle_data_blocked_frame, EPOCHS("ZO")),
(self._handle_stream_data_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_new_connection_id_frame, EPOCHS("ZO")),
(self._handle_retire_connection_id_frame, EPOCHS("O")),
(self._handle_path_challenge_frame, EPOCHS("ZO")),
(self._handle_path_response_frame, EPOCHS("O")),
(self._handle_connection_close_frame, EPOCHS("IZHO")),
(self._handle_connection_close_frame, EPOCHS("ZO")),
]
|
aioquic.connection/QuicConnection._handle_ack_frame
|
Modified
|
aiortc~aioquic
|
89540022e09e27a41c5118255ceea925ef9a3b5a
|
[connection] take ack delay into account when estimating RTT
|
<4>:<add> space = self.spaces[context.epoch]
<5>:<add> rangeset, ack_delay_encoded = packet.pull_ack_frame(buf)
<del> rangeset, ack_delay = packet.pull_ack_frame(buf)
<12>:<del> is_ack_eliciting = False
<13>:<add> largest_newly_acked = None
<del> largest_pn_is_newly_acked = False
<14>:<add> largest_send_time = None
<del> largest_pn_send_time = None
<15>:<add> handlers = space.delivery_handlers
<del> handlers = self.spaces[context.epoch].delivery_handlers
<16>:<add> timestamps = space.timestamps
<del> timestamps = self.spaces[context.epoch].timestamps
<19>:<del> largest_pn_is_newly_acked = False
<25>:<del> is_ack_eliciting = True
<26>:<add> largest_newly_acked = packet_number
<del> largest_pn_is_newly_acked = True
<27>:<add> largest_send_time = timestamps.pop(packet_number)
<del> largest_pn_send_time = timestamps.pop(packet_number)
<28>:<del> if packet_number > self._highest_acked_by_peer:
<29>:<del> self._highest_acked_by_peer = packet_number
<32>:<add> if largest_newly_acked is not None:
<add> self._loss.ack_received(
<add> largest_newly_acked=largest_newly_acked,
<del> if is_ack_eliciting and largest_pn_is_newly_acked:
<33>:<add> latest_rtt=ack_time - largest_send_time,
<del> latest_rtt = ack_time - largest_pn_send_time
<34>:<del> if self._rtt_min is None or latest_rtt < self._rtt_min:
<35>:<del> self._rtt_min = latest_rtt
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle an ACK frame.
<2> """
<3> ack_time = time.time()
<4>
<5> rangeset, ack_delay = packet.pull_ack_frame(buf)
<6> if frame_type == QuicFrameType.ACK_ECN:
<7> pull_uint_var(buf)
<8> pull_uint_var(buf)
<9> pull_uint_var(buf)
<10>
<11> # trigger callbacks
<12> is_ack_eliciting = False
<13> largest_pn_is_newly_acked = False
<14> largest_pn_send_time = None
<15> handlers = self.spaces[context.epoch].delivery_handlers
<16> timestamps = self.spaces[context.epoch].timestamps
<17> for packet_range in rangeset:
<18> for packet_number in packet_range:
<19> largest_pn_is_newly_acked = False
<20> if packet_number in handlers:
<21> # newly ack'd
<22> for handler, args in handlers[packet_number]:
<23> handler(QuicDeliveryState.ACKED, *args)
<24> del handlers[packet_number]
<25> is_ack_eliciting = True
<26> largest_pn_is_newly_acked = True
<27> largest_pn_send_time = timestamps.pop(packet_number)
<28> if packet_number > self._highest_acked_by_peer:
<29> self._highest_acked_by_peer = packet_number
<30>
<31> # update RTT estimate
<32> if is_ack_eliciting and largest_pn_is_newly_acked:
<33> latest_rtt = ack_time - largest_pn_send_time
<34> if self._rtt_min is None or latest_rtt < self._rtt_min:
<35> self._rtt_min = latest_rtt</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
# offset: 1
if self._rtt_latest is None:
self._rtt_var = latest_rtt / 2
self._rtt_smoothed = latest_rtt
else:
self._rtt_var = 3 / 4 * self._rtt_var + 1 / 4 * abs(
self._rtt_min - latest_rtt
)
self._rtt_smoothed = 7 / 8 * self._rtt_smoothed + 1 / 8 * latest_rtt
self._rtt_latest = latest_rtt
# check for loss
self._check_packet_loss()
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicPacketSpace()
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath)
at: aioquic.connection.QuicConnection
_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.is_client = is_client
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self._session_ticket = session_ticket
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()
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, 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]=...)
===========unchanged ref 1===========
at: aioquic.tls.Context.__init__
self.session_ticket: Optional[SessionTicket] = 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
other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
- def _check_packet_loss(self) -> None:
- """
- Check whether any packets should be declared lost.
- """
- packet_threshold = self._highest_acked_by_peer - K_GRANULARITY
- rtt = (
- max(self._rtt_latest, self._rtt_smoothed)
- if self._rtt_latest is not None
- else K_INITIAL_RTT
- )
- time_threshold = time.time() - K_TIME_THRESHOLD * rtt
-
- for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE, tls.Epoch.ONE_RTT]:
- handlers = self.spaces[epoch].delivery_handlers
- timestamps = self.spaces[epoch].timestamps
- for packet_number, timestamp in list(timestamps.items()):
- if packet_number <= packet_threshold or (
- packet_number < self._highest_acked_by_peer
- and timestamp < time_threshold
- ):
- self._logger.info("Packet %d was lost", packet_number)
- for handler, args in handlers[packet_number]:
- handler(QuicDeliveryState.LOST, *args)
- del handlers[packet_number]
- del timestamps[packet_number]
- else:
- break
-
===========changed ref 1===========
# module: aioquic.connection
+ class QuicPacketLoss:
+ def get_probe_timeout(self) -> float:
+ if not self._rtt_initialized:
+ return 0.5
+ return (
+ self._rtt_smoothed
+ + max(4 * self._rtt_variance, K_GRANULARITY)
+ + self.max_ack_delay / 1000
+ )
+
===========changed ref 2===========
# module: aioquic.connection
+ class QuicPacketLoss:
+ def __init__(self) -> None:
+ self.ack_delay_exponent = 3
+ self.max_ack_delay = 25 # ms
+
+ self._highest_acked_pn = -1
+ self._rtt_initialized = False
+ self._rtt_latest = 0.0
+ self._rtt_min = math.inf
+ self._rtt_smoothed = 0.0
+ self._rtt_variance = 0.0
+
===========changed ref 3===========
# module: aioquic.connection
+ class QuicPacketLoss:
+ def detect_loss(self, space: QuicPacketSpace) -> None:
+ """
+ Check whether any packets should be declared lost.
+ """
+ packet_threshold = self._highest_acked_pn - K_GRANULARITY
+ rtt = (
+ max(self._rtt_latest, self._rtt_smoothed)
+ if self._rtt_initialized
+ else K_INITIAL_RTT
+ )
+ time_threshold = time.time() - K_TIME_THRESHOLD * rtt
+
+ handlers = space.delivery_handlers
+ timestamps = space.timestamps
+ for packet_number, timestamp in list(timestamps.items()):
+ if packet_number <= packet_threshold or (
+ packet_number < self._highest_acked_pn and timestamp < time_threshold
+ ):
+ for handler, args in handlers[packet_number]:
+ handler(QuicDeliveryState.LOST, *args)
+ del handlers[packet_number]
+ del timestamps[packet_number]
+ else:
+ break
+
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
89540022e09e27a41c5118255ceea925ef9a3b5a
|
[connection] take ack delay into account when estimating RTT
|
<30>:<add> # update state
<add> if builder.ack_eliciting:
<add> self._loss.get_probe_timeout()
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
<0> network_path = self._network_paths[0]
<1>
<2> # build datagrams
<3> builder = QuicPacketBuilder(
<4> host_cid=self.host_cid,
<5> packet_number=self.packet_number,
<6> peer_cid=self.peer_cid,
<7> peer_token=self.peer_token,
<8> spin_bit=self._spin_bit,
<9> version=self._version,
<10> )
<11>
<12> if self.__close:
<13> for epoch, packet_type in (
<14> (tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
<15> (tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
<16> (tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
<17> ):
<18> crypto = self.cryptos[epoch]
<19> if crypto.send.is_valid():
<20> builder.start_packet(packet_type, crypto)
<21> push_close(builder.buffer, **self.__close)
<22> builder.end_packet()
<23> self.__close = None
<24> break
<25> else:
<26> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<27> self._write_handshake(builder, epoch)
<28> self._write_application(builder, network_path)
<29>
<30> self.packet_number = builder.packet_number
<31>
<32> # send datagrams
<33> for datagram in builder.flush():
<34> self._transport.sendto(datagram, network_path.addr)
<35> network_path.bytes_sent += len(datagram)
<36> self.__send_pending_task = None
<37>
|
===========unchanged ref 0===========
at: aioquic.buffer.Buffer
seek(pos: int) -> None
at: aioquic.connection
QuicConnectionId(cid: bytes, sequence_number: int, stateless_reset_token: bytes=b"", was_sent: bool=False)
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self._host_cid_seq = 1
at: aioquic.connection.QuicConnection._initialize
self.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
at: aioquic.connection.QuicConnection._payload_received
frame_type = pull_uint_var(buf)
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.stream.QuicStream
write(data: bytes) -> None
at: os
urandom(size: int, /) -> bytes
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
- def _check_packet_loss(self) -> None:
- """
- Check whether any packets should be declared lost.
- """
- packet_threshold = self._highest_acked_by_peer - K_GRANULARITY
- rtt = (
- max(self._rtt_latest, self._rtt_smoothed)
- if self._rtt_latest is not None
- else K_INITIAL_RTT
- )
- time_threshold = time.time() - K_TIME_THRESHOLD * rtt
-
- for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE, tls.Epoch.ONE_RTT]:
- handlers = self.spaces[epoch].delivery_handlers
- timestamps = self.spaces[epoch].timestamps
- for packet_number, timestamp in list(timestamps.items()):
- if packet_number <= packet_threshold or (
- packet_number < self._highest_acked_by_peer
- and timestamp < time_threshold
- ):
- self._logger.info("Packet %d was lost", packet_number)
- for handler, args in handlers[packet_number]:
- handler(QuicDeliveryState.LOST, *args)
- del handlers[packet_number]
- del timestamps[packet_number]
- else:
- break
-
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ @property
+ def ack_eliciting(self) -> bool:
+ """
+ Returns True if an ack-eliciting frame was written.
+ """
+ return self._ack_eliciting
+
===========changed ref 2===========
# module: aioquic.connection
+ class QuicPacketLoss:
+ def get_probe_timeout(self) -> float:
+ if not self._rtt_initialized:
+ return 0.5
+ return (
+ self._rtt_smoothed
+ + max(4 * self._rtt_variance, K_GRANULARITY)
+ + self.max_ack_delay / 1000
+ )
+
===========changed ref 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def start_frame(self, frame_type: int) -> None:
+ """
+ Starts a new frame.
+ """
+ push_uint_var(self.buffer, frame_type)
+ if not self._ack_eliciting and frame_type not in [
+ QuicFrameType.ACK,
+ QuicFrameType.ACK_ECN,
+ QuicFrameType.PADDING,
+ ]:
+ self._ack_eliciting = True
+
===========changed ref 4===========
# module: aioquic.connection
+ class QuicPacketLoss:
+ def __init__(self) -> None:
+ self.ack_delay_exponent = 3
+ self.max_ack_delay = 25 # ms
+
+ self._highest_acked_pn = -1
+ self._rtt_initialized = False
+ self._rtt_latest = 0.0
+ self._rtt_min = math.inf
+ self._rtt_smoothed = 0.0
+ self._rtt_variance = 0.0
+
===========changed ref 5===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
host_cid: bytes,
peer_cid: bytes,
version: int,
packet_number: int = 0,
peer_token: bytes = b"",
spin_bit: bool = False,
):
self._host_cid = host_cid
self._peer_cid = peer_cid
self._peer_token = peer_token
self._spin_bit = spin_bit
self._version = version
# assembled datagrams
+ self._ack_eliciting = False
self._datagrams: List[bytes] = []
# current packet
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
===========changed ref 6===========
# module: aioquic.connection
+ class QuicPacketLoss:
+ def detect_loss(self, space: QuicPacketSpace) -> None:
+ """
+ Check whether any packets should be declared lost.
+ """
+ packet_threshold = self._highest_acked_pn - K_GRANULARITY
+ rtt = (
+ max(self._rtt_latest, self._rtt_smoothed)
+ if self._rtt_initialized
+ else K_INITIAL_RTT
+ )
+ time_threshold = time.time() - K_TIME_THRESHOLD * rtt
+
+ handlers = space.delivery_handlers
+ timestamps = space.timestamps
+ for packet_number, timestamp in list(timestamps.items()):
+ if packet_number <= packet_threshold or (
+ packet_number < self._highest_acked_pn and timestamp < time_threshold
+ ):
+ for handler, args in handlers[packet_number]:
+ handler(QuicDeliveryState.LOST, *args)
+ del handlers[packet_number]
+ del timestamps[packet_number]
+ else:
+ break
+
|
aioquic.connection/QuicConnection._parse_transport_parameters
|
Modified
|
aiortc~aioquic
|
89540022e09e27a41c5118255ceea925ef9a3b5a
|
[connection] take ack delay into account when estimating RTT
|
<20>:<add> for param in ["ack_delay_exponent", "max_ack_delay"]:
<add> value = getattr(quic_transport_parameters, param)
<add> if value is not None:
<add> setattr(self._loss, param, value)
|
# 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
<20> for param in [
<21> "max_data",
<22> "max_stream_data_bidi_local",
<23> "max_stream_data_bidi_remote",
<24> "max_stream_data_uni",
<25> "max_streams_bidi",
<26> "max_streams_uni",
<27> ]:
<28> value = getattr(quic_transport_parameters, "initial_" + param)
<29> if value is not None:
<30> setattr(self, "_remote_" + param, value)
<31>
<32> # wakeup waiters
<33> if not self._parameters_available.is_set():
<34> self._parameters_available.set()
<35>
|
===========unchanged ref 0===========
at: aioquic.connection
push_close(buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None
at: aioquic.connection.QuicConnection
_write_application(builder: QuicPacketBuilder, network_path: QuicNetworkPath) -> None
_write_handshake(builder: QuicPacketBuilder, epoch: tls.Epoch) -> None
at: aioquic.connection.QuicConnection.__init__
self.peer_cid = os.urandom(8)
self.peer_token = b""
self.__close: Optional[Dict] = None
self.host_cid = self._host_cids[0].cid
self._spin_bit = False
self.__send_pending_task: Optional[asyncio.Handle] = None
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
self._loss = QuicPacketLoss()
at: aioquic.connection.QuicConnection._consume_connection_id
self.peer_cid = connection_id.cid
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]
builder = QuicPacketBuilder(
host_cid=self.host_cid,
packet_number=self.packet_number,
peer_cid=self.peer_cid,
peer_token=self.peer_token,
spin_bit=self._spin_bit,
version=self._version,
)
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._send_soon
self.__send_pending_task = self._loop.call_soon(self._send_pending)
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.connect
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._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
remote_challenge: Optional[bytes] = None
at: aioquic.connection.QuicPacketLoss
get_probe_timeout(self) -> float
get_probe_timeout() -> float
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 2===========
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> List[bytes]
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()
at: asyncio.transports.DatagramTransport
__slots__ = ()
sendto(data: Any, addr: Optional[_Address]=...) -> None
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ @property
+ def ack_eliciting(self) -> bool:
+ """
+ Returns True if an ack-eliciting frame was written.
+ """
+ return self._ack_eliciting
+
===========changed ref 1===========
# module: aioquic.connection
+ class QuicPacketLoss:
+ def get_probe_timeout(self) -> float:
+ if not self._rtt_initialized:
+ return 0.5
+ return (
+ self._rtt_smoothed
+ + max(4 * self._rtt_variance, K_GRANULARITY)
+ + self.max_ack_delay / 1000
+ )
+
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
network_path = self._network_paths[0]
# build datagrams
builder = QuicPacketBuilder(
host_cid=self.host_cid,
packet_number=self.packet_number,
peer_cid=self.peer_cid,
peer_token=self.peer_token,
spin_bit=self._spin_bit,
version=self._version,
)
if self.__close:
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)
push_close(builder.buffer, **self.__close)
builder.end_packet()
self.__close = None
break
else:
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch)
self._write_application(builder, network_path)
+ # update state
+ if builder.ack_eliciting:
+ self._loss.get_probe_timeout()
self.packet_number = builder.packet_number
# send datagrams
for datagram in builder.flush():
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
self.__send_pending_task = None
|
aioquic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
89540022e09e27a41c5118255ceea925ef9a3b5a
|
[connection] take ack delay into account when estimating RTT
|
<16>:<add> builder.start_frame(QuicFrameType.ACK)
<del> push_uint_var(buf, QuicFrameType.ACK)
<25>:<add> builder.start_frame(QuicFrameType.CRYPTO)
<del> push_uint_var(buf, QuicFrameType.CRYPTO)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
<0> crypto = self.cryptos[epoch]
<1> space = self.spaces[epoch]
<2> if not crypto.send.is_valid():
<3> return
<4>
<5> buf = builder.buffer
<6>
<7> while True:
<8> if epoch == tls.Epoch.INITIAL:
<9> packet_type = PACKET_TYPE_INITIAL
<10> else:
<11> packet_type = PACKET_TYPE_HANDSHAKE
<12> builder.start_packet(packet_type, crypto)
<13>
<14> # ACK
<15> if space.ack_required and space.ack_queue:
<16> push_uint_var(buf, QuicFrameType.ACK)
<17> packet.push_ack_frame(buf, space.ack_queue, 0)
<18> space.ack_required = False
<19>
<20> # CRYPTO
<21> stream = self.streams[epoch]
<22> frame_overhead = 3 + quic_uint_length(stream.next_send_offset)
<23> frame = stream.get_frame(builder.remaining_space - frame_overhead)
<24> if frame is not None:
<25> push_uint_var(buf, QuicFrameType.CRYPTO)
<26> with packet.push_crypto_frame(buf, frame.offset):
<27> push_bytes(buf, frame.data)
<28> space.expect_ack(
<29> builder.packet_number,
<30> stream.on_data_delivery,
<31> (frame.offset, frame.offset + len(frame.data)),
<32> )
<33>
<34> # PADDING
<35> if epoch == tls.Epoch.INITIAL and self.is_client:
<36> push_bytes(buf, bytes(builder.remaining_space))
<37>
<38> if not builder.end_packet():
<39> break
<40>
<41> # discard initial keys
<42> if self.is_client and epoch == tls.Epoch.HANDSHAKE:
<43> self.cryptos</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
# offset: 1
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.connection.QuicConnection.__init__
self._remote_max_data = 0
self._remote_max_data_used = 0
at: aioquic.connection.QuicConnection._handle_max_data_frame
self._remote_max_data = max_data
at: aioquic.connection.QuicConnection._write_application
space = self.spaces[tls.Epoch.ONE_RTT]
buf = builder.buffer
at: aioquic.connection.QuicPacketSpace
expect_ack(self, packet_number: int, handler: QuicDeliveryHandler, args: Sequence[Any]=[]) -> None
expect_ack(packet_number: int, handler: QuicDeliveryHandler, args: Sequence[Any]=[]) -> None
at: aioquic.packet
quic_uint_length(value: int) -> int
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
push_stream_frame(buf: Buffer, stream_id: int, offset: int) -> Generator
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.packet_builder.QuicPacketBuilder
start_frame(frame_type: int) -> None
end_packet() -> bool
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def start_frame(self, frame_type: int) -> None:
+ """
+ Starts a new frame.
+ """
+ push_uint_var(self.buffer, frame_type)
+ if not self._ack_eliciting and frame_type not in [
+ QuicFrameType.ACK,
+ QuicFrameType.ACK_ECN,
+ QuicFrameType.PADDING,
+ ]:
+ self._ack_eliciting = True
+
===========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
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
+ 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]
# build datagrams
builder = QuicPacketBuilder(
host_cid=self.host_cid,
packet_number=self.packet_number,
peer_cid=self.peer_cid,
peer_token=self.peer_token,
spin_bit=self._spin_bit,
version=self._version,
)
if self.__close:
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)
push_close(builder.buffer, **self.__close)
builder.end_packet()
self.__close = None
break
else:
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch)
self._write_application(builder, network_path)
+ # update state
+ if builder.ack_eliciting:
+ self._loss.get_probe_timeout()
self.packet_number = builder.packet_number
# send datagrams
for datagram in builder.flush():
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
self.__send_pending_task = None
===========changed ref 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ @property
+ def ack_eliciting(self) -> bool:
+ """
+ Returns True if an ack-eliciting frame was written.
+ """
+ return self._ack_eliciting
+
===========changed ref 4===========
# module: aioquic.connection
+ class QuicPacketLoss:
+ def get_probe_timeout(self) -> float:
+ if not self._rtt_initialized:
+ return 0.5
+ return (
+ self._rtt_smoothed
+ + max(4 * self._rtt_variance, K_GRANULARITY)
+ + self.max_ack_delay / 1000
+ )
+
===========changed ref 5===========
# module: aioquic.connection
+ class QuicPacketLoss:
+ def __init__(self) -> None:
+ self.ack_delay_exponent = 3
+ self.max_ack_delay = 25 # ms
+
+ self._highest_acked_pn = -1
+ self._rtt_initialized = False
+ self._rtt_latest = 0.0
+ self._rtt_min = math.inf
+ self._rtt_smoothed = 0.0
+ self._rtt_variance = 0.0
+
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
dca8204794a60ea59fbe07f2fac782ba82510972
|
[stream] raise MAX_DATA and MAX_STREAM_DATA as needed
|
<s>[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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
<0> if is_client:
<1> assert (
<2> original_connection_id is None
<3> ), "Cannot set original_connection_id for a client"
<4> else:
<5> assert certificate is not None, "SSL certificate is required for a server"
<6> assert private_key is not None, "SSL private key is required for a server"
<7>
<8> self.alpn_protocols = alpn_protocols
<9> self.certificate = certificate
<10> self.is_client = is_client
<11> self.peer_cid = os.urandom(8)
<12> self._peer_cid_seq: Optional[int] = None
<13> self._peer_cid_available: List[QuicConnectionId] = []
<14> self.peer_token = b""
<15> self.private_key = private_key
<16> self.secrets_log_file = secrets_log_file
<17> self.server_name = server_name
<18> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<19>
<20> # counters for debugging
<21> self._stateless_retry_count = 0
<22> self._version_negotiation_count = 0
<23>
<24> self._loop = asyncio.get_event_loop()
<25> self.__close: Optional[Dict] = None
<26> self.__connected = asyncio.Event()
<27> self.__epoch = tls.Epoch.INITIAL
<28> self._host_cids = [
<29> QuicConnectionId(
<30> cid=os.urandom(8),
<31> sequence_number=0,
<32> stateless_reset</s>
|
===========below chunk 0===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = 1048576
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = 1048576
self._local_max_stream_data_bidi_remote = 1048576
self._local_max_stream_data_uni = 1048576
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._parameters_available = asyncio.Event()
self._parameters_received = False
self._ping_pending = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams</s>
===========below chunk 1===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s>i_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# things to send
self._retire_connection_ids: List[int] = []
# RTT estimation (seconds)
self._loss = QuicPacketLoss()
# callbacks
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionIdHandler = lambda c: None
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
if stream_handler is not None:
self._stream_handler = stream_handler
else:
self._stream_handler = lambda r, w: None
# frame handlers
self.__frame_handlers = [
(self._handle_padding_frame, EPOCH</s>
===========below chunk 2===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 3
<s>IZHO")),
(self._handle_padding_frame, EPOCHS("ZO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_reset_stream_frame, EPOCHS("ZO")),
(self._handle_stop_sending_frame, EPOCHS("ZO")),
(self._handle_crypto_frame, EPOCHS("IHO")),
(self._handle_new_token_frame, EPOCHS("O")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_max_data_frame, EPOCHS("ZO")),
(self._handle_max_stream_data_frame, EPOCHS("ZO")),
(self._handle_max_streams_</s>
===========below chunk 3===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 4
<s>_frame, EPOCHS("ZO")),
(self._handle_max_streams_uni_frame, EPOCHS("ZO")),
(self._handle_data_blocked_frame, EPOCHS("ZO")),
(self._handle_stream_data_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_new_connection_id_frame, EPOCHS("ZO")),
(self._handle_retire_connection_id_frame, EPOCHS("O")),
(self._handle_path_challenge_frame, EPOCHS("ZO")),
(self._handle_path_response_frame, EPOCHS("O")),
(self._handle_connection_close_frame, EPOCHS("IZHO")),
(self._handle_connection_close_frame, EPOCHS("ZO")),
]
|
|
aioquic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
8b4f9815b1348faec5f435ed9be62865349bacf3
|
[packet] simplify CRYPTO / STREAM frame writing
|
<21>:<add> write_crypto_frame(
<add> builder=builder,
<add> space=space,
<add> stream=self.streams[epoch],
<del> stream = self.streams[epoch]
<22>:<del> frame_overhead = 3 + quic_uint_length(stream.next_send_offset)
<23>:<del> frame = stream.get_frame(builder.remaining_space - frame_overhead)
<24>:<del> if frame is not None:
<25>:<del> builder.start_frame(QuicFrameType.CRYPTO)
<26>:<del> with packet.push_crypto_frame(buf, frame.offset):
<27>:<del> push_bytes(buf, frame.data)
<28>:<del> space.expect_ack(
<29>:<del> builder.packet_number,
<30>:<del> stream.on_data_delivery,
<31>:<del> (frame.offset, frame.offset + len(frame.data)),
<32>:<del> )
<33>:<del>
<34>:<del> # PADDING
<35>:<add> padding=(epoch == tls.Epoch.INITIAL and self.is_client),
<del> if epoch == tls.Epoch.INITIAL and self.is_client:
<36>:<add> )
<del> push_bytes(buf, bytes(builder.remaining_space))
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
<0> crypto = self.cryptos[epoch]
<1> space = self.spaces[epoch]
<2> if not crypto.send.is_valid():
<3> return
<4>
<5> buf = builder.buffer
<6>
<7> while True:
<8> if epoch == tls.Epoch.INITIAL:
<9> packet_type = PACKET_TYPE_INITIAL
<10> else:
<11> packet_type = PACKET_TYPE_HANDSHAKE
<12> builder.start_packet(packet_type, crypto)
<13>
<14> # ACK
<15> if space.ack_required and space.ack_queue:
<16> builder.start_frame(QuicFrameType.ACK)
<17> packet.push_ack_frame(buf, space.ack_queue, 0)
<18> space.ack_required = False
<19>
<20> # CRYPTO
<21> stream = self.streams[epoch]
<22> frame_overhead = 3 + quic_uint_length(stream.next_send_offset)
<23> frame = stream.get_frame(builder.remaining_space - frame_overhead)
<24> if frame is not None:
<25> builder.start_frame(QuicFrameType.CRYPTO)
<26> with packet.push_crypto_frame(buf, frame.offset):
<27> push_bytes(buf, frame.data)
<28> space.expect_ack(
<29> builder.packet_number,
<30> stream.on_data_delivery,
<31> (frame.offset, frame.offset + len(frame.data)),
<32> )
<33>
<34> # PADDING
<35> if epoch == tls.Epoch.INITIAL and self.is_client:
<36> push_bytes(buf, bytes(builder.remaining_space))
<37>
<38> if not builder.end_packet():
<39> break
<40>
<41> # discard initial keys
<42> if self.is_client and epoch == tls.Epoch.HANDSHAKE:
<43> self.cryptos[tls.Epoch</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
# offset: 1
===========unchanged ref 0===========
at: aioquic.connection
write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream, padding: bool=False) -> None
write_stream_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream, max_size: int) -> int
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_on_ping_delivery(delivery: QuicDeliveryState) -> None
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._ping_pending = False
self._remote_max_data = 0
self._remote_max_data_used = 0
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.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._write_application
crypto_stream_id = tls.Epoch.ONE_RTT
crypto_stream_id: Optional[tls.Epoch] = None
space = self.spaces[tls.Epoch.ONE_RTT]
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection.ping
self._ping_pending = True
at: aioquic.connection.QuicPacketSpace
expect_ack(packet_number: int, handler: QuicDeliveryHandler, args: Sequence[Any]=[]) -> None
at: aioquic.connection.QuicPacketSpace.__init__
self.ack_queue = RangeSet()
self.ack_required = False
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
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
start_frame(frame_type: int) -> None
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()
at: logging.LoggerAdapter
logger: Logger
extra: Mapping[str, Any]
===========unchanged ref 2===========
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
+ def write_crypto_frame(
+ builder: QuicPacketBuilder,
+ space: QuicPacketSpace,
+ stream: QuicStream,
+ padding: bool = False,
+ ) -> None:
+ frame_overhead = 3 + quic_uint_length(stream.next_send_offset)
+ frame = stream.get_frame(builder.remaining_space - frame_overhead)
+ if frame is not None:
+ builder.start_frame(QuicFrameType.CRYPTO)
+ push_uint_var(builder.buffer, frame.offset)
+ push_uint16(builder.buffer, len(frame.data) | 0x4000)
+ push_bytes(builder.buffer, frame.data)
+ space.expect_ack(
+ builder.packet_number,
+ stream.on_data_delivery,
+ (frame.offset, frame.offset + len(frame.data)),
+ )
+
+ # PADDING
+ if padding:
+ push_bytes(builder.buffer, bytes(builder.remaining_space))
+
===========changed ref 1===========
# module: aioquic.connection
+ def write_stream_frame(
+ builder: QuicPacketBuilder,
+ space: QuicPacketSpace,
+ stream: QuicStream,
+ max_size: int,
+ ) -> int:
+ buf = builder.buffer
+
+ # the frame data size is constrained by our peer's MAX_DATA and
+ # the space available in the current packet
+ frame_overhead = (
+ 3
+ + quic_uint_length(stream.stream_id)
+ + (quic_uint_length(stream.next_send_offset) if stream.next_send_offset else 0)
+ )
+ previous_send_highest = stream._send_highest
+ frame = stream.get_frame(min(builder.remaining_space - frame_overhead, max_size))
+
+ if frame is not None:
+ flags = QuicStreamFlag.LEN
+ if frame.offset:
+ flags |= QuicStreamFlag.OFF
+ if frame.fin:
+ flags |= QuicStreamFlag.FIN
+ builder.start_frame(QuicFrameType.STREAM_BASE | flags)
+ push_uint_var(buf, stream.stream_id)
+ if frame.offset:
+ push_uint_var(buf, frame.offset)
+ push_uint16(buf, len(frame.data) | 0x4000)
+ push_bytes(buf, frame.data)
+ space.expect_ack(
+ builder.packet_number,
+ stream.on_data_delivery,
+ (frame.offset, frame.offset + len(frame.data)),
+ )
+ return stream._send_highest - previous_send_highest
+ else:
+ return 0
+
===========changed ref 2===========
# module: aioquic.packet
- @contextmanager
- def push_crypto_frame(buf: Buffer, offset: int = 0) -> Generator:
- push_uint_var(buf, offset)
- push_uint16(buf, 0) # we always write the size as 2 bytes
- start = buf.tell()
- yield
- end = buf.tell()
- buf.seek(start - 2)
- push_uint16(buf, (end - start) | 0x4000)
- buf.seek(end)
-
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
95008579e0a2b390fd252ebccfd43a3869df4110
|
[connection] move some packet writing code
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
<0> crypto_stream_id: Optional[tls.Epoch] = None
<1> if self.cryptos[tls.Epoch.ONE_RTT].send.is_valid():
<2> crypto = self.cryptos[tls.Epoch.ONE_RTT]
<3> crypto_stream_id = 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> is_one_rtt = self.__epoch == tls.Epoch.ONE_RTT
<12>
<13> buf = builder.buffer
<14> while True:
<15> # write header
<16> builder.start_packet(packet_type, crypto)
<17>
<18> if is_one_rtt:
<19> # ACK
<20> if space.ack_required and space.ack_queue:
<21> builder.start_frame(QuicFrameType.ACK)
<22> packet.push_ack_frame(buf, space.ack_queue, 0)
<23> space.ack_required = False
<24>
<25> # PATH CHALLENGE
<26> if (
<27> not network_path.is_validated
<28> and network_path.local_challenge is None
<29> ):
<30> self._logger.info(
<31> "Network path %s sending challenge", network_path.addr
<32> )
<33> network_path.local_challenge = os.urandom(8)
<34> builder.start_frame(QuicFrameType.PATH_CHALLENGE)
<35> push_bytes(buf, network_path.local_challenge)
<36>
<37> # PATH</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 1
if network_path.remote_challenge is not None:
builder.start_frame(QuicFrameType.PATH_RESPONSE)
push_bytes(buf, 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)
packet.push_new_connection_id_frame(
buf,
connection_id.sequence_number,
connection_id.cid,
connection_id.stateless_reset_token,
)
connection_id.was_sent = True
space.expect_ack(
builder.packet_number,
self._on_new_connection_id_delivery,
(connection_id,),
)
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)
push_uint_var(buf, sequence_number)
space.expect_ack(
builder.packet_number,
self._on_retire_connection_id_delivery,
(sequence_number,),
)
# MAX_DATA
if (
self._local_max_data_used + MAX_DATA_WINDOW // 2
> self._local_max_data
):
self._local_max_data += MAX_DATA_WINDOW
self._logger.info(
"Local max_data raised to %d", self._local_max_data
)
builder.start_frame(Qu</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 2
<s> "Local max_data raised to %d", self._local_max_data
)
builder.start_frame(QuicFrameType.MAX_DATA)
push_uint_var(buf, self._local_max_data)
space.expect_ack(builder.packet_number, lambda d: None)
# STREAM limits
for stream_id, stream in self.streams.items():
if isinstance(stream_id, int):
self._write_stream_limits(builder, space, stream)
# PING
if self._ping_pending:
self._logger.info("Sending PING in packet %d", builder.packet_number)
builder.start_frame(QuicFrameType.PING)
space.expect_ack(builder.packet_number, self._on_ping_delivery)
self._ping_pending = False
for stream_id, stream in self.streams.items():
# CRYPTO
if stream_id == crypto_stream_id:
write_crypto_frame(builder=builder, space=space, stream=stream)
# STREAM
elif isinstance(stream_id, int):
self._remote_max_data_used += write_stream_frame(
builder=builder,
space=space,
stream=stream,
max_size=self._remote_max_data - self._remote_max_data_used,
)
if not builder.end_packet():
break
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.connection
write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream, padding: bool=False) -> None
write_stream_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream, max_size: 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
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_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(self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
_write_stream_limits(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__epoch = tls.Epoch.INITIAL
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._ping_pending = False
self._remote_max_data = 0
self._remote_max_data_used = 0
self._retire_connection_ids: List[int] = []
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._handle_max_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.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.ping
self._ping_pending = True
at: aioquic.connection.QuicConnectionId
cid: bytes
sequence_number: int
stateless_reset_token: bytes = b""
was_sent: bool = False
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
|
|
aioquic.connection/QuicConnection._write_stream_limits
|
Modified
|
aiortc~aioquic
|
95008579e0a2b390fd252ebccfd43a3869df4110
|
[connection] move some packet writing code
|
<0>:<add> # raise MAX_STREAM_DATA if needed
<3>:<add> "Stream %d local max_stream_data raised to %d",
<add> stream.stream_id,
<add> stream.max_stream_data_local,
<del> "Local max_stream_data raised to %d", stream.max_stream_data_local
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_stream_limits(
self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
<0> if stream._recv_highest + MAX_DATA_WINDOW // 2 > stream.max_stream_data_local:
<1> stream.max_stream_data_local += MAX_DATA_WINDOW
<2> self._logger.info(
<3> "Local max_stream_data raised to %d", stream.max_stream_data_local
<4> )
<5> builder.start_frame(QuicFrameType.MAX_STREAM_DATA)
<6> push_uint_var(builder.buffer, stream.stream_id)
<7> push_uint_var(builder.buffer, stream.max_stream_data_local)
<8> space.expect_ack(builder.packet_number, lambda d: None)
<9>
|
===========unchanged ref 0===========
at: aioquic.connection
MAX_DATA_WINDOW = 1048576
QuicPacketSpace()
at: aioquic.connection.QuicConnection.__init__
self._local_max_data = 1048576
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
at: aioquic.connection.QuicConnection._write_connection_limits
self._local_max_data += MAX_DATA_WINDOW
at: aioquic.connection.QuicPacketSpace
expect_ack(packet_number: int, handler: QuicDeliveryHandler, args: Sequence[Any]=[]) -> None
at: aioquic.packet
push_uint_var(buf: Buffer, value: int) -> None
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
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._recv_highest = 0 # the highest offset ever seen
at: aioquic.stream.QuicStream.add_frame
self._recv_highest = frame_end
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 + MAX_DATA_WINDOW // 2 > self._local_max_data:
+ self._local_max_data += MAX_DATA_WINDOW
+ self._logger.info("Local max_data raised to %d", self._local_max_data)
+ builder.start_frame(QuicFrameType.MAX_DATA)
+ push_uint_var(builder.buffer, self._local_max_data)
+ space.expect_ack(builder.packet_number, lambda d: None)
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
crypto_stream_id: Optional[tls.Epoch] = None
if self.cryptos[tls.Epoch.ONE_RTT].send.is_valid():
crypto = self.cryptos[tls.Epoch.ONE_RTT]
crypto_stream_id = tls.Epoch.ONE_RTT
packet_type = PACKET_TYPE_ONE_RTT
elif self.cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
crypto = self.cryptos[tls.Epoch.ZERO_RTT]
packet_type = PACKET_TYPE_ZERO_RTT
else:
return
space = self.spaces[tls.Epoch.ONE_RTT]
is_one_rtt = self.__epoch == tls.Epoch.ONE_RTT
buf = builder.buffer
while True:
# write header
builder.start_packet(packet_type, crypto)
if is_one_rtt:
# ACK
if space.ack_required and space.ack_queue:
builder.start_frame(QuicFrameType.ACK)
packet.push_ack_frame(buf, space.ack_queue, 0)
space.ack_required = False
# PATH CHALLENGE
if (
not network_path.is_validated
and network_path.local_challenge is None
):
self._logger.info(
"Network path %s sending challenge", network_path.addr
)
network_path.local_challenge = os.urandom(8)
builder.start_frame(QuicFrameType.PATH_CHALLENGE)
push_bytes(buf, network_path.local_challenge)
# PATH RESPONSE
if network_path.remote_challenge is not None:
builder.start_frame(QuicFrameType.PATH_RESPONSE)
push_bytes(</s>
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 1
<s>remote_challenge is not None:
builder.start_frame(QuicFrameType.PATH_RESPONSE)
push_bytes(buf, 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)
packet.push_new_connection_id_frame(
buf,
connection_id.sequence_number,
connection_id.cid,
connection_id.stateless_reset_token,
)
connection_id.was_sent = True
space.expect_ack(
builder.packet_number,
self._on_new_connection_id_delivery,
(connection_id,),
)
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)
push_uint_var(buf, sequence_number)
space.expect_ack(
builder.packet_number,
self._on_retire_connection_id_delivery,
(sequence_number,),
)
- # MAX_DATA
- if (
- self._local_max_data_used + MAX_DATA_WINDOW // 2
- > self._local_max_data
- ):
- self._local_max_data += MAX_DATA_WINDOW
- self._logger</s>
|
aioquic.stream/QuicStream.get_frame
|
Modified
|
aiortc~aioquic
|
92c55be42eecc7af75c6cf295c305a5123331ba9
|
[stream] rework stream limits
|
<14>:<add> start = r.start
<add> stop = min(r.stop, start + max_size)
<add> if max_offset is not None and stop > max_offset:
<add> stop = max_offset
<add> if stop <= start:
<del> size = min(size, r.stop - r.start)
<15>:<del> if self.stream_id is not None:
<16>:<del> size = min(size, self.max_stream_data_remote - r.start)
<17>:<del> if size <= 0:
<21>:<del> send = range(r.start, r.start + size)
<24>:<del> send.start
<25>:<add> start - self._send_buffer_start : stop - self._send_buffer_start
<del> - self._send_buffer_start : send.start
<26>:<del> + size
<27>:<del> - self._send_buffer_start
<29>:<add> offset=start,
<del> offset=send.start,
<31>:<add> self._send_pending.subtract(start, stop)
<del> self._send_pending.subtract(send.start, send.stop)
<34>:<add> if stop > self._send_highest:
<del> if send.stop > self._send_highest:
<35>:<add> self._send_highest = stop
<del> self._send_highest = send.stop
<38>:<add> if self._send_buffer_fin == stop:
<del> if self._send_buffer_fin == send.stop:
|
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def get_frame(
+ self, max_size: int, max_offset: Optional[int] = None
+ ) -> Optional[QuicStreamFrame]:
- def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
<0> """
<1> Get a frame of data to send.
<2> """
<3> # check there is something to send
<4> if not (self._send_pending or self._send_pending_eof):
<5> return None
<6>
<7> # FIN only
<8> if not self._send_pending:
<9> self._send_pending_eof = False
<10> return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
<11>
<12> # apply flow control
<13> r = self._send_pending[0]
<14> size = min(size, r.stop - r.start)
<15> if self.stream_id is not None:
<16> size = min(size, self.max_stream_data_remote - r.start)
<17> if size <= 0:
<18> return None
<19>
<20> # create frame
<21> send = range(r.start, r.start + size)
<22> frame = QuicStreamFrame(
<23> data=self._send_buffer[
<24> send.start
<25> - self._send_buffer_start : send.start
<26> + size
<27> - self._send_buffer_start
<28> ],
<29> offset=send.start,
<30> )
<31> self._send_pending.subtract(send.start, send.stop)
<32>
<33> # track the highest offset ever sent
<34> if send.stop > self._send_highest:
<35> self._send_highest = send.stop
<36>
<37> # if the buffer is empty and EOF was written, set the FIN bit
<38> if self._send_buffer_fin == send.stop:
<39> frame.fin = True
<40> self._send_pending_eof = False
<41>
<42> return frame
<43>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.rangeset.RangeSet
subtract(start: int, stop: int) -> None
at: aioquic.stream.QuicStream.__init__
self._send_buffer = bytearray()
self._send_buffer_fin: Optional[int] = None
self._send_highest = 0
self._send_pending = RangeSet()
self._send_pending_eof = False
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
at: aioquic.stream.QuicStream.on_data_delivery
self._send_buffer_start += size
self._send_pending_eof = True
at: aioquic.stream.QuicStream.write
self._send_buffer += data
self._send_buffer_stop += size
at: aioquic.stream.QuicStream.write_eof
self._send_buffer_fin = self._send_buffer_stop
self._send_pending_eof = True
|
aioquic.connection/write_stream_frame
|
Modified
|
aiortc~aioquic
|
92c55be42eecc7af75c6cf295c305a5123331ba9
|
[stream] rework stream limits
|
<10>:<add> frame = stream.get_frame(builder.remaining_space - frame_overhead, max_offset)
<del> frame = stream.get_frame(min(builder.remaining_space - frame_overhead, max_size))
|
# module: aioquic.connection
def write_stream_frame(
builder: QuicPacketBuilder,
space: QuicPacketSpace,
stream: QuicStream,
+ max_offset: int,
- max_size: int,
) -> int:
<0> buf = builder.buffer
<1>
<2> # the frame data size is constrained by our peer's MAX_DATA and
<3> # the space available in the current packet
<4> frame_overhead = (
<5> 3
<6> + quic_uint_length(stream.stream_id)
<7> + (quic_uint_length(stream.next_send_offset) if stream.next_send_offset else 0)
<8> )
<9> previous_send_highest = stream._send_highest
<10> frame = stream.get_frame(min(builder.remaining_space - frame_overhead, max_size))
<11>
<12> if frame is not None:
<13> flags = QuicStreamFlag.LEN
<14> if frame.offset:
<15> flags |= QuicStreamFlag.OFF
<16> if frame.fin:
<17> flags |= QuicStreamFlag.FIN
<18> builder.start_frame(QuicFrameType.STREAM_BASE | flags)
<19> push_uint_var(buf, stream.stream_id)
<20> if frame.offset:
<21> push_uint_var(buf, frame.offset)
<22> push_uint16(buf, len(frame.data) | 0x4000)
<23> push_bytes(buf, frame.data)
<24> space.expect_ack(
<25> builder.packet_number,
<26> stream.on_data_delivery,
<27> (frame.offset, frame.offset + len(frame.data)),
<28> )
<29> return stream._send_highest - previous_send_highest
<30> else:
<31> return 0
<32>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.connection.QuicPacketSpace
expect_ack(packet_number: int, handler: QuicDeliveryHandler, args: Sequence[Any]=[]) -> None
at: aioquic.packet
quic_uint_length(value: int) -> int
push_uint_var(buf: Buffer, value: int) -> None
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
start_frame(frame_type: int) -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
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
get_frame(max_size: int, max_offset: Optional[int]=None) -> Optional[QuicStreamFrame]
===========unchanged ref 1===========
on_data_delivery(delivery: QuicDeliveryState, start: int, stop: int) -> None
at: aioquic.stream.QuicStream.__init__
self._send_highest = 0
at: aioquic.stream.QuicStream.get_frame
self._send_highest = stop
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def get_frame(
+ self, max_size: int, max_offset: Optional[int] = None
+ ) -> Optional[QuicStreamFrame]:
- def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
if not (self._send_pending or self._send_pending_eof):
return None
# FIN only
if not self._send_pending:
self._send_pending_eof = False
return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
# apply flow control
r = self._send_pending[0]
+ start = r.start
+ stop = min(r.stop, start + max_size)
+ if max_offset is not None and stop > max_offset:
+ stop = max_offset
+ if stop <= start:
- size = min(size, r.stop - r.start)
- if self.stream_id is not None:
- size = min(size, self.max_stream_data_remote - r.start)
- if size <= 0:
return None
# create frame
- send = range(r.start, r.start + size)
frame = QuicStreamFrame(
data=self._send_buffer[
- send.start
+ start - self._send_buffer_start : stop - self._send_buffer_start
- - self._send_buffer_start : send.start
- + size
- - self._send_buffer_start
],
+ offset=start,
- offset=send.start,
)
+ self._send_pending.subtract(start, stop)
- self._send_pending.subtract(send.start, send.stop)
# track the highest offset ever sent
+ if stop > self._send_highest:
- if send.</s>
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def get_frame(
+ self, max_size: int, max_offset: Optional[int] = None
+ ) -> Optional[QuicStreamFrame]:
- def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
# offset: 1
<s>)
# track the highest offset ever sent
+ if stop > self._send_highest:
- if send.stop > self._send_highest:
+ self._send_highest = stop
- self._send_highest = send.stop
# if the buffer is empty and EOF was written, set the FIN bit
+ if self._send_buffer_fin == stop:
- if self._send_buffer_fin == send.stop:
frame.fin = True
self._send_pending_eof = False
return frame
===========changed ref 2===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
- def is_blocked(self) -> bool:
- """
- Returns True if there is data to send but the peer's MAX_STREAM_DATA
- prevents us from sending it.
- """
- return (
- bool(self._send_pending)
- and self._send_pending[0].start >= self.max_stream_data_remote
- )
-
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
92c55be42eecc7af75c6cf295c305a5123331ba9
|
[stream] rework stream limits
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
<0> crypto_stream_id: Optional[tls.Epoch] = None
<1> if self.cryptos[tls.Epoch.ONE_RTT].send.is_valid():
<2> crypto = self.cryptos[tls.Epoch.ONE_RTT]
<3> crypto_stream_id = 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> is_one_rtt = self.__epoch == tls.Epoch.ONE_RTT
<12>
<13> buf = builder.buffer
<14> while True:
<15> # write header
<16> builder.start_packet(packet_type, crypto)
<17>
<18> if is_one_rtt:
<19> # ACK
<20> if space.ack_required and space.ack_queue:
<21> builder.start_frame(QuicFrameType.ACK)
<22> packet.push_ack_frame(buf, space.ack_queue, 0)
<23> space.ack_required = False
<24>
<25> # PATH CHALLENGE
<26> if (
<27> not network_path.is_validated
<28> and network_path.local_challenge is None
<29> ):
<30> self._logger.info(
<31> "Network path %s sending challenge", network_path.addr
<32> )
<33> network_path.local_challenge = os.urandom(8)
<34> builder.start_frame(QuicFrameType.PATH_CHALLENGE)
<35> push_bytes(buf, network_path.local_challenge)
<36>
<37> # PATH</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 1
if network_path.remote_challenge is not None:
builder.start_frame(QuicFrameType.PATH_RESPONSE)
push_bytes(buf, 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)
packet.push_new_connection_id_frame(
buf,
connection_id.sequence_number,
connection_id.cid,
connection_id.stateless_reset_token,
)
connection_id.was_sent = True
space.expect_ack(
builder.packet_number,
self._on_new_connection_id_delivery,
(connection_id,),
)
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)
push_uint_var(buf, sequence_number)
space.expect_ack(
builder.packet_number,
self._on_retire_connection_id_delivery,
(sequence_number,),
)
# connection-level limits
self._write_connection_limits(builder=builder, space=space)
# stream-level limits
for stream_id, stream in self.streams.items():
if isinstance(stream_id, int):
self._write_stream_limits(
builder=builder, space=space, stream=stream
)
# PING
if self._ping</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 2
<s>limits(
builder=builder, space=space, stream=stream
)
# PING
if self._ping_pending:
self._logger.info("Sending PING in packet %d", builder.packet_number)
builder.start_frame(QuicFrameType.PING)
space.expect_ack(builder.packet_number, self._on_ping_delivery)
self._ping_pending = False
for stream_id, stream in self.streams.items():
# CRYPTO
if stream_id == crypto_stream_id:
write_crypto_frame(builder=builder, space=space, stream=stream)
# STREAM
elif isinstance(stream_id, int):
self._remote_max_data_used += write_stream_frame(
builder=builder,
space=space,
stream=stream,
max_size=self._remote_max_data - self._remote_max_data_used,
)
if not builder.end_packet():
break
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.connection
write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream, padding: bool=False) -> 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
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_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.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__epoch = tls.Epoch.INITIAL
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._ping_pending = False
===========unchanged ref 1===========
self._remote_max_data = 0
self._remote_max_data_used = 0
self._retire_connection_ids: List[int] = []
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._handle_max_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.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.ping
self._ping_pending = True
at: aioquic.connection.QuicConnectionId
cid: bytes
sequence_number: int
stateless_reset_token: bytes = b""
was_sent: bool = False
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.QuicPacketSpace
expect_ack(packet_number: int, handler: QuicDeliveryHandler, args: Sequence[Any]=[]) -> None
|
|
tests.test_stream/QuicStreamTest.test_send_data
|
Modified
|
aiortc~aioquic
|
92c55be42eecc7af75c6cf295c305a5123331ba9
|
[stream] rework stream limits
|
<0>:<add> stream = QuicStream()
<del> stream = QuicStream(stream_id=0, max_stream_data_remote=512)
<3>:<del> self.assertFalse(stream.is_blocked())
<10>:<del> self.assertFalse(stream.is_blocked())
<18>:<del> self.assertFalse(stream.is_blocked())
<26>:<del> self.assertFalse(stream.is_blocked())
|
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data(self):
<0> stream = QuicStream(stream_id=0, max_stream_data_remote=512)
<1>
<2> # nothing to send yet
<3> self.assertFalse(stream.is_blocked())
<4> frame = stream.get_frame(8)
<5> self.assertIsNone(frame)
<6>
<7> # write data, send a chunk
<8> stream.write(b"0123456789012345")
<9> self.assertEqual(list(stream._send_pending), [range(0, 16)])
<10> self.assertFalse(stream.is_blocked())
<11> frame = stream.get_frame(8)
<12> self.assertEqual(frame.data, b"01234567")
<13> self.assertFalse(frame.fin)
<14> self.assertEqual(frame.offset, 0)
<15> self.assertEqual(list(stream._send_pending), [range(8, 16)])
<16>
<17> # send another chunk
<18> self.assertFalse(stream.is_blocked())
<19> frame = stream.get_frame(8)
<20> self.assertEqual(frame.data, b"89012345")
<21> self.assertFalse(frame.fin)
<22> self.assertEqual(frame.offset, 8)
<23> self.assertEqual(list(stream._send_pending), [])
<24>
<25> # nothing more to send
<26> self.assertFalse(stream.is_blocked())
<27> frame = stream.get_frame(8)
<28> self.assertIsNone(frame)
<29> self.assertEqual(list(stream._send_pending), [])
<30>
|
===========unchanged ref 0===========
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.stream.QuicStream
get_frame(max_size: int, max_offset: Optional[int]=None) -> Optional[QuicStreamFrame]
write(data: bytes) -> None
at: aioquic.stream.QuicStream.__init__
self._send_pending = RangeSet()
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
assertIsNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def get_frame(
+ self, max_size: int, max_offset: Optional[int] = None
+ ) -> Optional[QuicStreamFrame]:
- def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
if not (self._send_pending or self._send_pending_eof):
return None
# FIN only
if not self._send_pending:
self._send_pending_eof = False
return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
# apply flow control
r = self._send_pending[0]
+ start = r.start
+ stop = min(r.stop, start + max_size)
+ if max_offset is not None and stop > max_offset:
+ stop = max_offset
+ if stop <= start:
- size = min(size, r.stop - r.start)
- if self.stream_id is not None:
- size = min(size, self.max_stream_data_remote - r.start)
- if size <= 0:
return None
# create frame
- send = range(r.start, r.start + size)
frame = QuicStreamFrame(
data=self._send_buffer[
- send.start
+ start - self._send_buffer_start : stop - self._send_buffer_start
- - self._send_buffer_start : send.start
- + size
- - self._send_buffer_start
],
+ offset=start,
- offset=send.start,
)
+ self._send_pending.subtract(start, stop)
- self._send_pending.subtract(send.start, send.stop)
# track the highest offset ever sent
+ if stop > self._send_highest:
- if send.</s>
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def get_frame(
+ self, max_size: int, max_offset: Optional[int] = None
+ ) -> Optional[QuicStreamFrame]:
- def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
# offset: 1
<s>)
# track the highest offset ever sent
+ if stop > self._send_highest:
- if send.stop > self._send_highest:
+ self._send_highest = stop
- self._send_highest = send.stop
# if the buffer is empty and EOF was written, set the FIN bit
+ if self._send_buffer_fin == stop:
- if self._send_buffer_fin == send.stop:
frame.fin = True
self._send_pending_eof = False
return frame
===========changed ref 2===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
- def is_blocked(self) -> bool:
- """
- Returns True if there is data to send but the peer's MAX_STREAM_DATA
- prevents us from sending it.
- """
- return (
- bool(self._send_pending)
- and self._send_pending[0].start >= self.max_stream_data_remote
- )
-
===========changed ref 3===========
# module: aioquic.connection
def write_stream_frame(
builder: QuicPacketBuilder,
space: QuicPacketSpace,
stream: QuicStream,
+ max_offset: int,
- max_size: int,
) -> int:
buf = builder.buffer
# the frame data size is constrained by our peer's MAX_DATA and
# the space available in the current packet
frame_overhead = (
3
+ quic_uint_length(stream.stream_id)
+ (quic_uint_length(stream.next_send_offset) if stream.next_send_offset else 0)
)
previous_send_highest = stream._send_highest
+ frame = stream.get_frame(builder.remaining_space - frame_overhead, max_offset)
- frame = stream.get_frame(min(builder.remaining_space - frame_overhead, max_size))
if frame is not None:
flags = QuicStreamFlag.LEN
if frame.offset:
flags |= QuicStreamFlag.OFF
if frame.fin:
flags |= QuicStreamFlag.FIN
builder.start_frame(QuicFrameType.STREAM_BASE | flags)
push_uint_var(buf, stream.stream_id)
if frame.offset:
push_uint_var(buf, frame.offset)
push_uint16(buf, len(frame.data) | 0x4000)
push_bytes(buf, frame.data)
space.expect_ack(
builder.packet_number,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
return stream._send_highest - previous_send_highest
else:
return 0
|
tests.test_stream/QuicStreamTest.test_send_data_and_fin
|
Modified
|
aiortc~aioquic
|
92c55be42eecc7af75c6cf295c305a5123331ba9
|
[stream] rework stream limits
|
<0>:<add> stream = QuicStream()
<del> stream = QuicStream(stream_id=0, max_stream_data_remote=512)
<3>:<del> self.assertFalse(stream.is_blocked())
<10>:<del> self.assertFalse(stream.is_blocked())
<17>:<del> self.assertFalse(stream.is_blocked())
<24>:<del> self.assertFalse(stream.is_blocked())
|
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data_and_fin(self):
<0> stream = QuicStream(stream_id=0, max_stream_data_remote=512)
<1>
<2> # nothing to send yet
<3> self.assertFalse(stream.is_blocked())
<4> frame = stream.get_frame(8)
<5> self.assertIsNone(frame)
<6>
<7> # write data and EOF, send a chunk
<8> stream.write(b"0123456789012345")
<9> stream.write_eof()
<10> self.assertFalse(stream.is_blocked())
<11> frame = stream.get_frame(8)
<12> self.assertEqual(frame.data, b"01234567")
<13> self.assertFalse(frame.fin)
<14> self.assertEqual(frame.offset, 0)
<15>
<16> # send another chunk
<17> self.assertFalse(stream.is_blocked())
<18> frame = stream.get_frame(8)
<19> self.assertEqual(frame.data, b"89012345")
<20> self.assertTrue(frame.fin)
<21> self.assertEqual(frame.offset, 8)
<22>
<23> # nothing more to send
<24> self.assertFalse(stream.is_blocked())
<25> frame = stream.get_frame(8)
<26> self.assertIsNone(frame)
<27>
|
===========unchanged ref 0===========
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
get_frame(max_size: int, max_offset: Optional[int]=None) -> Optional[QuicStreamFrame]
write(data: bytes) -> None
write_eof() -> None
at: tests.test_stream.QuicStreamTest.test_send_data_and_fin
stream = QuicStream()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
assertIsNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def get_frame(
+ self, max_size: int, max_offset: Optional[int] = None
+ ) -> Optional[QuicStreamFrame]:
- def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
if not (self._send_pending or self._send_pending_eof):
return None
# FIN only
if not self._send_pending:
self._send_pending_eof = False
return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
# apply flow control
r = self._send_pending[0]
+ start = r.start
+ stop = min(r.stop, start + max_size)
+ if max_offset is not None and stop > max_offset:
+ stop = max_offset
+ if stop <= start:
- size = min(size, r.stop - r.start)
- if self.stream_id is not None:
- size = min(size, self.max_stream_data_remote - r.start)
- if size <= 0:
return None
# create frame
- send = range(r.start, r.start + size)
frame = QuicStreamFrame(
data=self._send_buffer[
- send.start
+ start - self._send_buffer_start : stop - self._send_buffer_start
- - self._send_buffer_start : send.start
- + size
- - self._send_buffer_start
],
+ offset=start,
- offset=send.start,
)
+ self._send_pending.subtract(start, stop)
- self._send_pending.subtract(send.start, send.stop)
# track the highest offset ever sent
+ if stop > self._send_highest:
- if send.</s>
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def get_frame(
+ self, max_size: int, max_offset: Optional[int] = None
+ ) -> Optional[QuicStreamFrame]:
- def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
# offset: 1
<s>)
# track the highest offset ever sent
+ if stop > self._send_highest:
- if send.stop > self._send_highest:
+ self._send_highest = stop
- self._send_highest = send.stop
# if the buffer is empty and EOF was written, set the FIN bit
+ if self._send_buffer_fin == stop:
- if self._send_buffer_fin == send.stop:
frame.fin = True
self._send_pending_eof = False
return frame
===========changed ref 2===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data(self):
+ stream = QuicStream()
- stream = QuicStream(stream_id=0, max_stream_data_remote=512)
# nothing to send yet
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
# write data, send a chunk
stream.write(b"0123456789012345")
self.assertEqual(list(stream._send_pending), [range(0, 16)])
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"01234567")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 0)
self.assertEqual(list(stream._send_pending), [range(8, 16)])
# send another chunk
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"89012345")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 8)
self.assertEqual(list(stream._send_pending), [])
# nothing more to send
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
self.assertEqual(list(stream._send_pending), [])
===========changed ref 3===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
- def is_blocked(self) -> bool:
- """
- Returns True if there is data to send but the peer's MAX_STREAM_DATA
- prevents us from sending it.
- """
- return (
- bool(self._send_pending)
- and self._send_pending[0].start >= self.max_stream_data_remote
- )
-
===========changed ref 4===========
# module: aioquic.connection
def write_stream_frame(
builder: QuicPacketBuilder,
space: QuicPacketSpace,
stream: QuicStream,
+ max_offset: int,
- max_size: int,
) -> int:
buf = builder.buffer
# the frame data size is constrained by our peer's MAX_DATA and
# the space available in the current packet
frame_overhead = (
3
+ quic_uint_length(stream.stream_id)
+ (quic_uint_length(stream.next_send_offset) if stream.next_send_offset else 0)
)
previous_send_highest = stream._send_highest
+ frame = stream.get_frame(builder.remaining_space - frame_overhead, max_offset)
- frame = stream.get_frame(min(builder.remaining_space - frame_overhead, max_size))
if frame is not None:
flags = QuicStreamFlag.LEN
if frame.offset:
flags |= QuicStreamFlag.OFF
if frame.fin:
flags |= QuicStreamFlag.FIN
builder.start_frame(QuicFrameType.STREAM_BASE | flags)
push_uint_var(buf, stream.stream_id)
if frame.offset:
push_uint_var(buf, frame.offset)
push_uint16(buf, len(frame.data) | 0x4000)
push_bytes(buf, frame.data)
space.expect_ack(
builder.packet_number,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
return stream._send_highest - previous_send_highest
else:
return 0
|
tests.test_stream/QuicStreamTest.test_send_data_lost
|
Modified
|
aiortc~aioquic
|
92c55be42eecc7af75c6cf295c305a5123331ba9
|
[stream] rework stream limits
|
<0>:<add> stream = QuicStream()
<del> stream = QuicStream(stream_id=0, max_stream_data_remote=512)
<3>:<del> self.assertFalse(stream.is_blocked())
|
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data_lost(self):
<0> stream = QuicStream(stream_id=0, max_stream_data_remote=512)
<1>
<2> # nothing to send yet
<3> self.assertFalse(stream.is_blocked())
<4> frame = stream.get_frame(8)
<5> self.assertIsNone(frame)
<6>
<7> # write data and EOF
<8> stream.write(b"0123456789012345")
<9> stream.write_eof()
<10> self.assertEqual(list(stream._send_pending), [range(0, 16)])
<11>
<12> # send a chunk
<13> self.assertEqual(
<14> stream.get_frame(8), QuicStreamFrame(data=b"01234567", fin=False, offset=0)
<15> )
<16> self.assertEqual(list(stream._send_pending), [range(8, 16)])
<17>
<18> # send another chunk
<19> self.assertEqual(
<20> stream.get_frame(8), QuicStreamFrame(data=b"89012345", fin=True, offset=8)
<21> )
<22> self.assertEqual(list(stream._send_pending), [])
<23>
<24> # nothing more to send
<25> self.assertIsNone(stream.get_frame(8))
<26> self.assertEqual(list(stream._send_pending), [])
<27>
<28> # a chunk gets lost
<29> stream.on_data_delivery(QuicDeliveryState.LOST, 0, 8)
<30> self.assertEqual(list(stream._send_pending), [range(0, 8)])
<31>
<32> # send chunk again
<33> self.assertEqual(
<34> stream.get_frame(8), QuicStreamFrame(data=b"01234567", fin=False, offset=0)
<35> )
<36> self.assertEqual(list(stream._send_pending), [])
<37>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicDeliveryState()
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
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
get_frame(max_size: int, max_offset: Optional[int]=None) -> Optional[QuicStreamFrame]
on_data_delivery(delivery: QuicDeliveryState, start: int, stop: int) -> None
write(data: bytes) -> None
write_eof() -> None
at: aioquic.stream.QuicStream.__init__
self._send_pending = RangeSet()
at: tests.test_stream.QuicStreamTest.test_send_data_lost
stream = QuicStream()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertIsNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def get_frame(
+ self, max_size: int, max_offset: Optional[int] = None
+ ) -> Optional[QuicStreamFrame]:
- def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
if not (self._send_pending or self._send_pending_eof):
return None
# FIN only
if not self._send_pending:
self._send_pending_eof = False
return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
# apply flow control
r = self._send_pending[0]
+ start = r.start
+ stop = min(r.stop, start + max_size)
+ if max_offset is not None and stop > max_offset:
+ stop = max_offset
+ if stop <= start:
- size = min(size, r.stop - r.start)
- if self.stream_id is not None:
- size = min(size, self.max_stream_data_remote - r.start)
- if size <= 0:
return None
# create frame
- send = range(r.start, r.start + size)
frame = QuicStreamFrame(
data=self._send_buffer[
- send.start
+ start - self._send_buffer_start : stop - self._send_buffer_start
- - self._send_buffer_start : send.start
- + size
- - self._send_buffer_start
],
+ offset=start,
- offset=send.start,
)
+ self._send_pending.subtract(start, stop)
- self._send_pending.subtract(send.start, send.stop)
# track the highest offset ever sent
+ if stop > self._send_highest:
- if send.</s>
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def get_frame(
+ self, max_size: int, max_offset: Optional[int] = None
+ ) -> Optional[QuicStreamFrame]:
- def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
# offset: 1
<s>)
# track the highest offset ever sent
+ if stop > self._send_highest:
- if send.stop > self._send_highest:
+ self._send_highest = stop
- self._send_highest = send.stop
# if the buffer is empty and EOF was written, set the FIN bit
+ if self._send_buffer_fin == stop:
- if self._send_buffer_fin == send.stop:
frame.fin = True
self._send_pending_eof = False
return frame
===========changed ref 2===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data_and_fin(self):
+ stream = QuicStream()
- stream = QuicStream(stream_id=0, max_stream_data_remote=512)
# nothing to send yet
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
# write data and EOF, send a chunk
stream.write(b"0123456789012345")
stream.write_eof()
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"01234567")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 0)
# send another chunk
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"89012345")
self.assertTrue(frame.fin)
self.assertEqual(frame.offset, 8)
# nothing more to send
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
===========changed ref 3===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data(self):
+ stream = QuicStream()
- stream = QuicStream(stream_id=0, max_stream_data_remote=512)
# nothing to send yet
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
# write data, send a chunk
stream.write(b"0123456789012345")
self.assertEqual(list(stream._send_pending), [range(0, 16)])
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"01234567")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 0)
self.assertEqual(list(stream._send_pending), [range(8, 16)])
# send another chunk
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"89012345")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 8)
self.assertEqual(list(stream._send_pending), [])
# nothing more to send
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
self.assertEqual(list(stream._send_pending), [])
===========changed ref 4===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
- def is_blocked(self) -> bool:
- """
- Returns True if there is data to send but the peer's MAX_STREAM_DATA
- prevents us from sending it.
- """
- return (
- bool(self._send_pending)
- and self._send_pending[0].start >= self.max_stream_data_remote
- )
-
|
tests.test_stream/QuicStreamTest.test_send_data_lost_fin
|
Modified
|
aiortc~aioquic
|
92c55be42eecc7af75c6cf295c305a5123331ba9
|
[stream] rework stream limits
|
<0>:<add> stream = QuicStream()
<del> stream = QuicStream(stream_id=0, max_stream_data_remote=512)
<3>:<del> self.assertFalse(stream.is_blocked())
|
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data_lost_fin(self):
<0> stream = QuicStream(stream_id=0, max_stream_data_remote=512)
<1>
<2> # nothing to send yet
<3> self.assertFalse(stream.is_blocked())
<4> frame = stream.get_frame(8)
<5> self.assertIsNone(frame)
<6>
<7> # write data and EOF
<8> stream.write(b"0123456789012345")
<9> stream.write_eof()
<10> self.assertEqual(list(stream._send_pending), [range(0, 16)])
<11>
<12> # send a chunk
<13> self.assertEqual(
<14> stream.get_frame(8), QuicStreamFrame(data=b"01234567", fin=False, offset=0)
<15> )
<16> self.assertEqual(list(stream._send_pending), [range(8, 16)])
<17>
<18> # send another chunk
<19> self.assertEqual(
<20> stream.get_frame(8), QuicStreamFrame(data=b"89012345", fin=True, offset=8)
<21> )
<22> self.assertEqual(list(stream._send_pending), [])
<23>
<24> # nothing more to send
<25> self.assertIsNone(stream.get_frame(8))
<26> self.assertEqual(list(stream._send_pending), [])
<27>
<28> # a chunk gets lost
<29> stream.on_data_delivery(QuicDeliveryState.LOST, 8, 16)
<30> self.assertEqual(list(stream._send_pending), [range(8, 16)])
<31>
<32> # send chunk again
<33> self.assertEqual(
<34> stream.get_frame(8), QuicStreamFrame(data=b"89012345", fin=True, offset=8)
<35> )
<36> self.assertEqual(list(stream._send_pending), [])
<37>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicDeliveryState()
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
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
get_frame(max_size: int, max_offset: Optional[int]=None) -> Optional[QuicStreamFrame]
on_data_delivery(delivery: QuicDeliveryState, start: int, stop: int) -> None
write_eof() -> None
at: aioquic.stream.QuicStream.__init__
self._send_pending = RangeSet()
at: tests.test_stream.QuicStreamTest.test_send_data_lost_fin
stream = QuicStream()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertIsNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def get_frame(
+ self, max_size: int, max_offset: Optional[int] = None
+ ) -> Optional[QuicStreamFrame]:
- def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
if not (self._send_pending or self._send_pending_eof):
return None
# FIN only
if not self._send_pending:
self._send_pending_eof = False
return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
# apply flow control
r = self._send_pending[0]
+ start = r.start
+ stop = min(r.stop, start + max_size)
+ if max_offset is not None and stop > max_offset:
+ stop = max_offset
+ if stop <= start:
- size = min(size, r.stop - r.start)
- if self.stream_id is not None:
- size = min(size, self.max_stream_data_remote - r.start)
- if size <= 0:
return None
# create frame
- send = range(r.start, r.start + size)
frame = QuicStreamFrame(
data=self._send_buffer[
- send.start
+ start - self._send_buffer_start : stop - self._send_buffer_start
- - self._send_buffer_start : send.start
- + size
- - self._send_buffer_start
],
+ offset=start,
- offset=send.start,
)
+ self._send_pending.subtract(start, stop)
- self._send_pending.subtract(send.start, send.stop)
# track the highest offset ever sent
+ if stop > self._send_highest:
- if send.</s>
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def get_frame(
+ self, max_size: int, max_offset: Optional[int] = None
+ ) -> Optional[QuicStreamFrame]:
- def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
# offset: 1
<s>)
# track the highest offset ever sent
+ if stop > self._send_highest:
- if send.stop > self._send_highest:
+ self._send_highest = stop
- self._send_highest = send.stop
# if the buffer is empty and EOF was written, set the FIN bit
+ if self._send_buffer_fin == stop:
- if self._send_buffer_fin == send.stop:
frame.fin = True
self._send_pending_eof = False
return frame
===========changed ref 2===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data_and_fin(self):
+ stream = QuicStream()
- stream = QuicStream(stream_id=0, max_stream_data_remote=512)
# nothing to send yet
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
# write data and EOF, send a chunk
stream.write(b"0123456789012345")
stream.write_eof()
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"01234567")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 0)
# send another chunk
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"89012345")
self.assertTrue(frame.fin)
self.assertEqual(frame.offset, 8)
# nothing more to send
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
===========changed ref 3===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data_lost(self):
+ stream = QuicStream()
- stream = QuicStream(stream_id=0, max_stream_data_remote=512)
# nothing to send yet
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
# write data and EOF
stream.write(b"0123456789012345")
stream.write_eof()
self.assertEqual(list(stream._send_pending), [range(0, 16)])
# send a chunk
self.assertEqual(
stream.get_frame(8), QuicStreamFrame(data=b"01234567", fin=False, offset=0)
)
self.assertEqual(list(stream._send_pending), [range(8, 16)])
# send another chunk
self.assertEqual(
stream.get_frame(8), QuicStreamFrame(data=b"89012345", fin=True, offset=8)
)
self.assertEqual(list(stream._send_pending), [])
# nothing more to send
self.assertIsNone(stream.get_frame(8))
self.assertEqual(list(stream._send_pending), [])
# a chunk gets lost
stream.on_data_delivery(QuicDeliveryState.LOST, 0, 8)
self.assertEqual(list(stream._send_pending), [range(0, 8)])
# send chunk again
self.assertEqual(
stream.get_frame(8), QuicStreamFrame(data=b"01234567", fin=False, offset=0)
)
self.assertEqual(list(stream._send_pending), [])
|
tests.test_stream/QuicStreamTest.test_send_blocked
|
Modified
|
aiortc~aioquic
|
92c55be42eecc7af75c6cf295c305a5123331ba9
|
[stream] rework stream limits
|
<0>:<add> stream = QuicStream()
<add> max_offset = 12
<del> stream = QuicStream(stream_id=0, max_stream_data_remote=12)
<3>:<del> self.assertFalse(stream.is_blocked())
<4>:<add> frame = stream.get_frame(8, max_offset)
<del> frame = stream.get_frame(8)
<10>:<del> self.assertFalse(stream.is_blocked())
<18>:<del> self.assertFalse(stream.is_blocked())
<19>:<add> frame = stream.get_frame(8, max_offset)
<del> frame = stream.get_frame(8)
<26>:<del> self.assertTrue(stream.is_blocked())
<27>:<add> frame = stream.get_frame(8, max_offset)
<del> frame = stream.get_frame(8)
<33>:<del> self.assertTrue(stream.is_blocked())
<34>:<add> frame = stream.get_frame(8, max_offset)
<del> frame = stream.get_frame(8)
|
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_blocked(self):
<0> stream = QuicStream(stream_id=0, max_stream_data_remote=12)
<1>
<2> # nothing to send yet
<3> self.assertFalse(stream.is_blocked())
<4> frame = stream.get_frame(8)
<5> self.assertIsNone(frame)
<6> self.assertEqual(list(stream._send_pending), [])
<7>
<8> # write data, send a chunk
<9> stream.write(b"0123456789012345")
<10> self.assertFalse(stream.is_blocked())
<11> frame = stream.get_frame(8)
<12> self.assertEqual(frame.data, b"01234567")
<13> self.assertFalse(frame.fin)
<14> self.assertEqual(frame.offset, 0)
<15> self.assertEqual(list(stream._send_pending), [range(8, 16)])
<16>
<17> # send is limited by peer
<18> self.assertFalse(stream.is_blocked())
<19> frame = stream.get_frame(8)
<20> self.assertEqual(frame.data, b"8901")
<21> self.assertFalse(frame.fin)
<22> self.assertEqual(frame.offset, 8)
<23> self.assertEqual(list(stream._send_pending), [range(12, 16)])
<24>
<25> # unable to send, blocked
<26> self.assertTrue(stream.is_blocked())
<27> frame = stream.get_frame(8)
<28> self.assertIsNone(frame)
<29> self.assertEqual(list(stream._send_pending), [range(12, 16)])
<30>
<31> # write more data, still blocked
<32> stream.write(b"abcdefgh")
<33> self.assertTrue(stream.is_blocked())
<34> frame = stream.get_frame(8)
<35> self.assertIsNone(frame)
<36> self.assertEqual(list(stream._send_pending), [range(12, 24)])
<37>
<38> # peer</s>
|
===========below chunk 0===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_blocked(self):
# offset: 1
stream.max_stream_data_remote += 8
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"2345abcd")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 12)
self.assertEqual(list(stream._send_pending), [range(20, 24)])
# peer raises limit again, send remaining data
stream.max_stream_data_remote += 8
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"efgh")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 20)
self.assertEqual(list(stream._send_pending), [])
# nothing more to send
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
===========unchanged ref 0===========
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
get_frame(max_size: int, max_offset: Optional[int]=None) -> Optional[QuicStreamFrame]
write(data: bytes) -> None
write_eof() -> None
at: aioquic.stream.QuicStream.__init__
self._send_pending = RangeSet()
at: tests.test_stream.QuicStreamTest.test_send_blocked
stream = QuicStream()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
assertIsNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def get_frame(
+ self, max_size: int, max_offset: Optional[int] = None
+ ) -> Optional[QuicStreamFrame]:
- def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
if not (self._send_pending or self._send_pending_eof):
return None
# FIN only
if not self._send_pending:
self._send_pending_eof = False
return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
# apply flow control
r = self._send_pending[0]
+ start = r.start
+ stop = min(r.stop, start + max_size)
+ if max_offset is not None and stop > max_offset:
+ stop = max_offset
+ if stop <= start:
- size = min(size, r.stop - r.start)
- if self.stream_id is not None:
- size = min(size, self.max_stream_data_remote - r.start)
- if size <= 0:
return None
# create frame
- send = range(r.start, r.start + size)
frame = QuicStreamFrame(
data=self._send_buffer[
- send.start
+ start - self._send_buffer_start : stop - self._send_buffer_start
- - self._send_buffer_start : send.start
- + size
- - self._send_buffer_start
],
+ offset=start,
- offset=send.start,
)
+ self._send_pending.subtract(start, stop)
- self._send_pending.subtract(send.start, send.stop)
# track the highest offset ever sent
+ if stop > self._send_highest:
- if send.</s>
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def get_frame(
+ self, max_size: int, max_offset: Optional[int] = None
+ ) -> Optional[QuicStreamFrame]:
- def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
# offset: 1
<s>)
# track the highest offset ever sent
+ if stop > self._send_highest:
- if send.stop > self._send_highest:
+ self._send_highest = stop
- self._send_highest = send.stop
# if the buffer is empty and EOF was written, set the FIN bit
+ if self._send_buffer_fin == stop:
- if self._send_buffer_fin == send.stop:
frame.fin = True
self._send_pending_eof = False
return frame
===========changed ref 2===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data_and_fin(self):
+ stream = QuicStream()
- stream = QuicStream(stream_id=0, max_stream_data_remote=512)
# nothing to send yet
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
# write data and EOF, send a chunk
stream.write(b"0123456789012345")
stream.write_eof()
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"01234567")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 0)
# send another chunk
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"89012345")
self.assertTrue(frame.fin)
self.assertEqual(frame.offset, 8)
# nothing more to send
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
|
tests.test_stream/QuicStreamTest.test_send_fin_only
|
Modified
|
aiortc~aioquic
|
92c55be42eecc7af75c6cf295c305a5123331ba9
|
[stream] rework stream limits
|
<0>:<add> stream = QuicStream()
<del> stream = QuicStream(stream_id=0, max_stream_data_remote=512)
<3>:<del> self.assertFalse(stream.is_blocked())
<9>:<del> self.assertFalse(stream.is_blocked())
<16>:<del> self.assertFalse(stream.is_blocked())
|
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_fin_only(self):
<0> stream = QuicStream(stream_id=0, max_stream_data_remote=512)
<1>
<2> # nothing to send yet
<3> self.assertFalse(stream.is_blocked())
<4> frame = stream.get_frame(8)
<5> self.assertIsNone(frame)
<6>
<7> # write EOF
<8> stream.write_eof()
<9> self.assertFalse(stream.is_blocked())
<10> frame = stream.get_frame(8)
<11> self.assertEqual(frame.data, b"")
<12> self.assertTrue(frame.fin)
<13> self.assertEqual(frame.offset, 0)
<14>
<15> # nothing more to send
<16> self.assertFalse(stream.is_blocked())
<17> frame = stream.get_frame(8)
<18> self.assertIsNone(frame)
<19>
|
===========unchanged ref 0===========
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
get_frame(max_size: int, max_offset: Optional[int]=None) -> Optional[QuicStreamFrame]
write_eof() -> None
at: tests.test_stream.QuicStreamTest.test_send_fin_only
stream = QuicStream()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertIsNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def get_frame(
+ self, max_size: int, max_offset: Optional[int] = None
+ ) -> Optional[QuicStreamFrame]:
- def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
if not (self._send_pending or self._send_pending_eof):
return None
# FIN only
if not self._send_pending:
self._send_pending_eof = False
return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
# apply flow control
r = self._send_pending[0]
+ start = r.start
+ stop = min(r.stop, start + max_size)
+ if max_offset is not None and stop > max_offset:
+ stop = max_offset
+ if stop <= start:
- size = min(size, r.stop - r.start)
- if self.stream_id is not None:
- size = min(size, self.max_stream_data_remote - r.start)
- if size <= 0:
return None
# create frame
- send = range(r.start, r.start + size)
frame = QuicStreamFrame(
data=self._send_buffer[
- send.start
+ start - self._send_buffer_start : stop - self._send_buffer_start
- - self._send_buffer_start : send.start
- + size
- - self._send_buffer_start
],
+ offset=start,
- offset=send.start,
)
+ self._send_pending.subtract(start, stop)
- self._send_pending.subtract(send.start, send.stop)
# track the highest offset ever sent
+ if stop > self._send_highest:
- if send.</s>
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def get_frame(
+ self, max_size: int, max_offset: Optional[int] = None
+ ) -> Optional[QuicStreamFrame]:
- def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
# offset: 1
<s>)
# track the highest offset ever sent
+ if stop > self._send_highest:
- if send.stop > self._send_highest:
+ self._send_highest = stop
- self._send_highest = send.stop
# if the buffer is empty and EOF was written, set the FIN bit
+ if self._send_buffer_fin == stop:
- if self._send_buffer_fin == send.stop:
frame.fin = True
self._send_pending_eof = False
return frame
===========changed ref 2===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data_and_fin(self):
+ stream = QuicStream()
- stream = QuicStream(stream_id=0, max_stream_data_remote=512)
# nothing to send yet
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
# write data and EOF, send a chunk
stream.write(b"0123456789012345")
stream.write_eof()
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"01234567")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 0)
# send another chunk
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"89012345")
self.assertTrue(frame.fin)
self.assertEqual(frame.offset, 8)
# nothing more to send
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
===========changed ref 3===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data_lost_fin(self):
+ stream = QuicStream()
- stream = QuicStream(stream_id=0, max_stream_data_remote=512)
# nothing to send yet
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
# write data and EOF
stream.write(b"0123456789012345")
stream.write_eof()
self.assertEqual(list(stream._send_pending), [range(0, 16)])
# send a chunk
self.assertEqual(
stream.get_frame(8), QuicStreamFrame(data=b"01234567", fin=False, offset=0)
)
self.assertEqual(list(stream._send_pending), [range(8, 16)])
# send another chunk
self.assertEqual(
stream.get_frame(8), QuicStreamFrame(data=b"89012345", fin=True, offset=8)
)
self.assertEqual(list(stream._send_pending), [])
# nothing more to send
self.assertIsNone(stream.get_frame(8))
self.assertEqual(list(stream._send_pending), [])
# a chunk gets lost
stream.on_data_delivery(QuicDeliveryState.LOST, 8, 16)
self.assertEqual(list(stream._send_pending), [range(8, 16)])
# send chunk again
self.assertEqual(
stream.get_frame(8), QuicStreamFrame(data=b"89012345", fin=True, offset=8)
)
self.assertEqual(list(stream._send_pending), [])
|
tests.test_stream/QuicStreamTest.test_send_fin_only_despite_blocked
|
Modified
|
aiortc~aioquic
|
92c55be42eecc7af75c6cf295c305a5123331ba9
|
[stream] rework stream limits
|
<0>:<add> stream = QuicStream()
<del> stream = QuicStream(stream_id=0, max_stream_data_remote=0)
<3>:<del> self.assertFalse(stream.is_blocked())
<9>:<del> self.assertFalse(stream.is_blocked())
<16>:<del> self.assertFalse(stream.is_blocked())
|
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_fin_only_despite_blocked(self):
<0> stream = QuicStream(stream_id=0, max_stream_data_remote=0)
<1>
<2> # nothing to send yet
<3> self.assertFalse(stream.is_blocked())
<4> frame = stream.get_frame(8)
<5> self.assertIsNone(frame)
<6>
<7> # write EOF
<8> stream.write_eof()
<9> self.assertFalse(stream.is_blocked())
<10> frame = stream.get_frame(8)
<11> self.assertEqual(frame.data, b"")
<12> self.assertTrue(frame.fin)
<13> self.assertEqual(frame.offset, 0)
<14>
<15> # nothing more to send
<16> self.assertFalse(stream.is_blocked())
<17> frame = stream.get_frame(8)
<18> self.assertIsNone(frame)
<19>
|
===========changed ref 0===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_fin_only(self):
+ stream = QuicStream()
- stream = QuicStream(stream_id=0, max_stream_data_remote=512)
# nothing to send yet
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
# write EOF
stream.write_eof()
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"")
self.assertTrue(frame.fin)
self.assertEqual(frame.offset, 0)
# nothing more to send
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
===========changed ref 1===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data_and_fin(self):
+ stream = QuicStream()
- stream = QuicStream(stream_id=0, max_stream_data_remote=512)
# nothing to send yet
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
# write data and EOF, send a chunk
stream.write(b"0123456789012345")
stream.write_eof()
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"01234567")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 0)
# send another chunk
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"89012345")
self.assertTrue(frame.fin)
self.assertEqual(frame.offset, 8)
# nothing more to send
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
===========changed ref 2===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data_lost_fin(self):
+ stream = QuicStream()
- stream = QuicStream(stream_id=0, max_stream_data_remote=512)
# nothing to send yet
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
# write data and EOF
stream.write(b"0123456789012345")
stream.write_eof()
self.assertEqual(list(stream._send_pending), [range(0, 16)])
# send a chunk
self.assertEqual(
stream.get_frame(8), QuicStreamFrame(data=b"01234567", fin=False, offset=0)
)
self.assertEqual(list(stream._send_pending), [range(8, 16)])
# send another chunk
self.assertEqual(
stream.get_frame(8), QuicStreamFrame(data=b"89012345", fin=True, offset=8)
)
self.assertEqual(list(stream._send_pending), [])
# nothing more to send
self.assertIsNone(stream.get_frame(8))
self.assertEqual(list(stream._send_pending), [])
# a chunk gets lost
stream.on_data_delivery(QuicDeliveryState.LOST, 8, 16)
self.assertEqual(list(stream._send_pending), [range(8, 16)])
# send chunk again
self.assertEqual(
stream.get_frame(8), QuicStreamFrame(data=b"89012345", fin=True, offset=8)
)
self.assertEqual(list(stream._send_pending), [])
===========changed ref 3===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data_lost(self):
+ stream = QuicStream()
- stream = QuicStream(stream_id=0, max_stream_data_remote=512)
# nothing to send yet
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
# write data and EOF
stream.write(b"0123456789012345")
stream.write_eof()
self.assertEqual(list(stream._send_pending), [range(0, 16)])
# send a chunk
self.assertEqual(
stream.get_frame(8), QuicStreamFrame(data=b"01234567", fin=False, offset=0)
)
self.assertEqual(list(stream._send_pending), [range(8, 16)])
# send another chunk
self.assertEqual(
stream.get_frame(8), QuicStreamFrame(data=b"89012345", fin=True, offset=8)
)
self.assertEqual(list(stream._send_pending), [])
# nothing more to send
self.assertIsNone(stream.get_frame(8))
self.assertEqual(list(stream._send_pending), [])
# a chunk gets lost
stream.on_data_delivery(QuicDeliveryState.LOST, 0, 8)
self.assertEqual(list(stream._send_pending), [range(0, 8)])
# send chunk again
self.assertEqual(
stream.get_frame(8), QuicStreamFrame(data=b"01234567", fin=False, offset=0)
)
self.assertEqual(list(stream._send_pending), [])
===========changed ref 4===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data(self):
+ stream = QuicStream()
- stream = QuicStream(stream_id=0, max_stream_data_remote=512)
# nothing to send yet
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
# write data, send a chunk
stream.write(b"0123456789012345")
self.assertEqual(list(stream._send_pending), [range(0, 16)])
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"01234567")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 0)
self.assertEqual(list(stream._send_pending), [range(8, 16)])
# send another chunk
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"89012345")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 8)
self.assertEqual(list(stream._send_pending), [])
# nothing more to send
- self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
self.assertEqual(list(stream._send_pending), [])
|
aioquic.packet_builder/QuicPacketBuilder.__init__
|
Modified
|
aiortc~aioquic
|
34efc4f67275a20352097ed63ee99025a6b17dfc
|
[tests] improve packet builder tests
|
<1>:<add> self._pad_first_datagram = pad_first_datagram
|
# 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._peer_cid = peer_cid
<2> self._peer_token = peer_token
<3> self._spin_bit = spin_bit
<4> self._version = version
<5>
<6> # assembled datagrams
<7> self._ack_eliciting = False
<8> self._datagrams: List[bytes] = []
<9>
<10> # current packet
<11> self._crypto: Optional[CryptoPair] = None
<12> self._header_size = 0
<13> self._packet_number = packet_number
<14> self._packet_start = 0
<15> self._packet_type = 0
<16>
<17> self.buffer = Buffer(PACKET_MAX_SIZE)
<18>
|
===========unchanged ref 0===========
at: aioquic.crypto
CryptoPair()
at: aioquic.packet_builder.QuicPacketBuilder.end_packet
self._pad_first_datagram = False
self._packet_number += 1
self._crypto = None
at: aioquic.packet_builder.QuicPacketBuilder.flush
self._datagrams = []
at: aioquic.packet_builder.QuicPacketBuilder.start_frame
self._ack_eliciting = True
at: aioquic.packet_builder.QuicPacketBuilder.start_packet
self._packet_start = buf.tell()
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
at: typing
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: aioquic.packet
- def push_application_close_frame(
- buf: Buffer, error_code: int, reason_phrase: str
- ) -> None:
- reason_bytes = reason_phrase.encode("utf8")
- push_uint16(buf, error_code)
- push_uint_var(buf, len(reason_bytes))
- push_bytes(buf, reason_bytes)
-
===========changed ref 1===========
# module: aioquic.packet
- def push_transport_close_frame(
- buf: Buffer, error_code: int, frame_type: int, reason_phrase: str
- ) -> None:
- reason_bytes = reason_phrase.encode("utf8")
- push_uint16(buf, error_code)
- push_uint_var(buf, frame_type)
- push_uint_var(buf, len(reason_bytes))
- push_bytes(buf, reason_bytes)
-
|
aioquic.packet_builder/QuicPacketBuilder.end_packet
|
Modified
|
aiortc~aioquic
|
34efc4f67275a20352097ed63ee99025a6b17dfc
|
[tests] improve packet builder tests
|
<10>:<add>
<add> # pad initial datagram
<add> if self._pad_first_datagram:
<add> push_bytes(buf, bytes(self.remaining_space))
<add> packet_size = buf.tell() - self._packet_start
<add> self._pad_first_datagram = False
|
# 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> if is_long_header(self._packet_type):
<12> # finalize length
<13> buf.seek(
<14> self._packet_start
<15> + self._header_size
<16> - PACKET_NUMBER_SEND_SIZE
<17> - PACKET_LENGTH_SEND_SIZE
<18> )
<19> length = (
<20> packet_size
<21> - self._header_size
<22> + PACKET_NUMBER_SEND_SIZE
<23> + self._crypto.aead_tag_size
<24> )
<25> push_uint16(buf, length | 0x4000)
<26> push_packet_number(buf, self._packet_number)
<27> buf.seek(packet_size)
<28> else:
<29> # check whether we need padding
<30> padding_size = (
<31> PACKET_NUMBER_MAX_SIZE
<32> - PACKET_NUMBER_SEND_SIZE
<33> + self._header_size
<34> - packet_size
<35> )
<36> if padding_size > 0:
<37> push_bytes(buf, bytes(padding_size))
<38> packet_size += padding_size
<39>
<40> # encrypt in place
<41> plain = buf.data_slice(self._packet_start, self._packet_start + packet_size)
<42> buf.seek(self._packet_start)
<43> push_bytes(
<44> buf,
<45> self._crypto.encrypt_packet(
<46> plain[0 : self._header_size], plain[self._header_size : packet_size]
<47> ),
<48> )
<49>
<50> # short header packets cannot be coallesced</s>
|
===========below chunk 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
# offset: 1
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._crypto = None
return not empty
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
data_slice(start: int, end: int) -> bytes
seek(pos: int) -> None
tell() -> int
at: aioquic.crypto.CryptoPair
encrypt_packet(plain_header: bytes, plain_payload: bytes) -> bytes
at: aioquic.crypto.CryptoPair.__init__
self.aead_tag_size = 16
at: aioquic.packet
PACKET_NUMBER_MAX_SIZE = 4
is_long_header(first_byte: int) -> bool
at: aioquic.packet_builder
PACKET_LENGTH_SEND_SIZE = 2
PACKET_NUMBER_SEND_SIZE = 2
push_packet_number(buf: Buffer, packet_number: int) -> None
at: aioquic.packet_builder.QuicPacketBuilder
_flush_current_datagram() -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._pad_first_datagram = pad_first_datagram
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
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._crypto = None
at: aioquic.packet_builder.QuicPacketBuilder.start_packet
self._packet_start = buf.tell()
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
===========changed ref 0===========
# 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._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
self._ack_eliciting = False
self._datagrams: List[bytes] = []
# current packet
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
===========changed ref 1===========
# module: aioquic.packet
- def push_application_close_frame(
- buf: Buffer, error_code: int, reason_phrase: str
- ) -> None:
- reason_bytes = reason_phrase.encode("utf8")
- push_uint16(buf, error_code)
- push_uint_var(buf, len(reason_bytes))
- push_bytes(buf, reason_bytes)
-
===========changed ref 2===========
# module: aioquic.packet
- def push_transport_close_frame(
- buf: Buffer, error_code: int, frame_type: int, reason_phrase: str
- ) -> None:
- reason_bytes = reason_phrase.encode("utf8")
- push_uint16(buf, error_code)
- push_uint_var(buf, frame_type)
- push_uint_var(buf, len(reason_bytes))
- push_bytes(buf, reason_bytes)
-
|
aioquic.connection/write_crypto_frame
|
Modified
|
aiortc~aioquic
|
34efc4f67275a20352097ed63ee99025a6b17dfc
|
[tests] improve packet builder tests
|
<13>:<del> # PADDING
<14>:<del> if padding:
<15>:<del> push_bytes(builder.buffer, bytes(builder.remaining_space))
<16>:<del>
|
# module: aioquic.connection
def write_crypto_frame(
- builder: QuicPacketBuilder,
- space: QuicPacketSpace,
- stream: QuicStream,
- padding: bool = False,
+ builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
<0> frame_overhead = 3 + quic_uint_length(stream.next_send_offset)
<1> frame = stream.get_frame(builder.remaining_space - frame_overhead)
<2> if frame is not None:
<3> builder.start_frame(QuicFrameType.CRYPTO)
<4> push_uint_var(builder.buffer, frame.offset)
<5> push_uint16(builder.buffer, len(frame.data) | 0x4000)
<6> push_bytes(builder.buffer, frame.data)
<7> space.expect_ack(
<8> builder.packet_number,
<9> stream.on_data_delivery,
<10> (frame.offset, frame.offset + len(frame.data)),
<11> )
<12>
<13> # PADDING
<14> if padding:
<15> push_bytes(builder.buffer, bytes(builder.remaining_space))
<16>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.connection.write_close_frame
buf = builder.buffer
reason_bytes = reason_phrase.encode("utf8")
at: aioquic.packet
quic_uint_length(value: int) -> int
push_uint_var(buf: Buffer, value: int) -> None
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
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) -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
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
get_frame(max_size: int, max_offset: Optional[int]=None) -> Optional[QuicStreamFrame]
===========changed ref 0===========
# module: aioquic.connection
- def push_close(
- buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str
- ) -> None:
- if frame_type is None:
- push_uint_var(buf, QuicFrameType.APPLICATION_CLOSE)
- packet.push_application_close_frame(buf, error_code, reason_phrase)
- else:
- push_uint_var(buf, QuicFrameType.TRANSPORT_CLOSE)
- packet.push_transport_close_frame(buf, error_code, frame_type, reason_phrase)
-
===========changed ref 1===========
# module: aioquic.connection
+ def write_close_frame(
+ builder: QuicPacketBuilder,
+ error_code: int,
+ frame_type: Optional[int],
+ reason_phrase: str,
+ ) -> None:
+ buf = builder.buffer
+
+ reason_bytes = reason_phrase.encode("utf8")
+
+ if frame_type is None:
+ builder.start_frame(QuicFrameType.APPLICATION_CLOSE)
+ push_uint16(buf, error_code)
+ push_uint_var(buf, len(reason_bytes))
+ push_bytes(buf, reason_bytes)
+ else:
+ builder.start_frame(QuicFrameType.TRANSPORT_CLOSE)
+ push_uint16(buf, error_code)
+ push_uint_var(buf, frame_type)
+ push_uint_var(buf, len(reason_bytes))
+ push_bytes(buf, reason_bytes)
+
===========changed ref 2===========
# module: aioquic.packet
- def push_application_close_frame(
- buf: Buffer, error_code: int, reason_phrase: str
- ) -> None:
- reason_bytes = reason_phrase.encode("utf8")
- push_uint16(buf, error_code)
- push_uint_var(buf, len(reason_bytes))
- push_bytes(buf, reason_bytes)
-
===========changed ref 3===========
# module: aioquic.packet
- def push_transport_close_frame(
- buf: Buffer, error_code: int, frame_type: int, reason_phrase: str
- ) -> None:
- reason_bytes = reason_phrase.encode("utf8")
- push_uint16(buf, error_code)
- push_uint_var(buf, frame_type)
- push_uint_var(buf, len(reason_bytes))
- push_bytes(buf, reason_bytes)
-
===========changed ref 4===========
# 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._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
self._ack_eliciting = False
self._datagrams: List[bytes] = []
# current packet
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
===========changed ref 5===========
# 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:
+ push_bytes(buf, bytes(self.remaining_space))
+ packet_size = buf.tell() - self._packet_start
+ self._pad_first_datagram = False
if is_long_header(self._packet_type):
# finalize length
buf.seek(
self._packet_start
+ self._header_size
- PACKET_NUMBER_SEND_SIZE
- PACKET_LENGTH_SEND_SIZE
)
length = (
packet_size
- self._header_size
+ PACKET_NUMBER_SEND_SIZE
+ self._crypto.aead_tag_size
)
push_uint16(buf, length | 0x4000)
push_packet_number(buf, self._packet_number)
buf.seek(packet_size)
else:
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
push_bytes(buf, 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)
push_bytes(
buf,
self._crypto.encrypt_packet(
plain[0 : self._header_size], plain[self._header_size : packet_size]</s>
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
34efc4f67275a20352097ed63ee99025a6b17dfc
|
[tests] improve packet builder tests
|
<6>:<add> pad_first_datagram=(self.__epoch == tls.Epoch.INITIAL and self.is_client),
<21>:<add> write_close_frame(builder, **self.__close)
<del> push_close(builder.buffer, **self.__close)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
<0> network_path = self._network_paths[0]
<1>
<2> # build datagrams
<3> builder = QuicPacketBuilder(
<4> host_cid=self.host_cid,
<5> packet_number=self.packet_number,
<6> peer_cid=self.peer_cid,
<7> peer_token=self.peer_token,
<8> spin_bit=self._spin_bit,
<9> version=self._version,
<10> )
<11>
<12> if self.__close:
<13> for epoch, packet_type in (
<14> (tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
<15> (tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
<16> (tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
<17> ):
<18> crypto = self.cryptos[epoch]
<19> if crypto.send.is_valid():
<20> builder.start_packet(packet_type, crypto)
<21> push_close(builder.buffer, **self.__close)
<22> builder.end_packet()
<23> self.__close = None
<24> break
<25> else:
<26> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<27> self._write_handshake(builder, epoch)
<28> self._write_application(builder, network_path)
<29>
<30> # update state
<31> if builder.ack_eliciting:
<32> self._loss.get_probe_timeout()
<33> self.packet_number = builder.packet_number
<34>
<35> # send datagrams
<36> for datagram in builder.flush():
<37> self._transport.sendto(datagram, network_path.addr)
<38> network_path.bytes_sent += len(datagram)
<39> self.__send_pending_task = None
<40>
|
===========unchanged ref 0===========
at: aioquic.buffer.Buffer
seek(pos: int) -> None
at: aioquic.connection
write_close_frame(builder: QuicPacketBuilder, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_write_application(builder: QuicPacketBuilder, network_path: QuicNetworkPath) -> 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.peer_cid = os.urandom(8)
self.peer_token = b""
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__close: Optional[Dict] = None
self.__epoch = tls.Epoch.INITIAL
self.host_cid = self._host_cids[0].cid
self._network_paths: List[QuicNetworkPath] = []
self._spin_bit = False
self._version: Optional[int] = None
self._loss = QuicPacketLoss()
at: aioquic.connection.QuicConnection._consume_connection_id
self.peer_cid = connection_id.cid
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
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(),
}
===========unchanged ref 1===========
self.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
self.packet_number = 0
at: aioquic.connection.QuicConnection.close
self.__close = {
"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.QuicPacketLoss
get_probe_timeout() -> float
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
===========unchanged ref 2===========
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.stream.QuicStream
write(data: bytes) -> None
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
+ def write_close_frame(
+ builder: QuicPacketBuilder,
+ error_code: int,
+ frame_type: Optional[int],
+ reason_phrase: str,
+ ) -> None:
+ buf = builder.buffer
+
+ reason_bytes = reason_phrase.encode("utf8")
+
+ if frame_type is None:
+ builder.start_frame(QuicFrameType.APPLICATION_CLOSE)
+ push_uint16(buf, error_code)
+ push_uint_var(buf, len(reason_bytes))
+ push_bytes(buf, reason_bytes)
+ else:
+ builder.start_frame(QuicFrameType.TRANSPORT_CLOSE)
+ push_uint16(buf, error_code)
+ push_uint_var(buf, frame_type)
+ push_uint_var(buf, len(reason_bytes))
+ push_bytes(buf, reason_bytes)
+
===========changed ref 1===========
# 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:
+ push_bytes(buf, bytes(self.remaining_space))
+ packet_size = buf.tell() - self._packet_start
+ self._pad_first_datagram = False
if is_long_header(self._packet_type):
# finalize length
buf.seek(
self._packet_start
+ self._header_size
- PACKET_NUMBER_SEND_SIZE
- PACKET_LENGTH_SEND_SIZE
)
length = (
packet_size
- self._header_size
+ PACKET_NUMBER_SEND_SIZE
+ self._crypto.aead_tag_size
)
push_uint16(buf, length | 0x4000)
push_packet_number(buf, self._packet_number)
buf.seek(packet_size)
else:
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
push_bytes(buf, 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)
push_bytes(
buf,
self._crypto.encrypt_packet(
plain[0 : self._header_size], plain[self._header_size : packet_size]</s>
|
aioquic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
34efc4f67275a20352097ed63ee99025a6b17dfc
|
[tests] improve packet builder tests
|
<21>:<del> write_crypto_frame(
<22>:<del> builder=builder,
<23>:<del> space=space,
<24>:<del> stream=self.streams[epoch],
<25>:<del> padding=(epoch == tls.Epoch.INITIAL and self.is_client),
<26>:<del> )
<27>:<add> write_crypto_frame(builder=builder, space=space, stream=self.streams[epoch])
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
<0> crypto = self.cryptos[epoch]
<1> space = self.spaces[epoch]
<2> if not crypto.send.is_valid():
<3> return
<4>
<5> buf = builder.buffer
<6>
<7> while True:
<8> if epoch == tls.Epoch.INITIAL:
<9> packet_type = PACKET_TYPE_INITIAL
<10> else:
<11> packet_type = PACKET_TYPE_HANDSHAKE
<12> builder.start_packet(packet_type, crypto)
<13>
<14> # ACK
<15> if space.ack_required and space.ack_queue:
<16> builder.start_frame(QuicFrameType.ACK)
<17> packet.push_ack_frame(buf, space.ack_queue, 0)
<18> space.ack_required = False
<19>
<20> # CRYPTO
<21> write_crypto_frame(
<22> builder=builder,
<23> space=space,
<24> stream=self.streams[epoch],
<25> padding=(epoch == tls.Epoch.INITIAL and self.is_client),
<26> )
<27>
<28> if not builder.end_packet():
<29> break
<30>
<31> # discard initial keys
<32> if self.is_client and epoch == tls.Epoch.HANDSHAKE:
<33> self.cryptos[tls.Epoch.INITIAL].teardown()
<34>
|
===========unchanged ref 0===========
at: aioquic.connection
write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
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.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.connection.QuicPacketSpace.__init__
self.ack_queue = RangeSet()
self.ack_required = False
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) -> None
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
def write_crypto_frame(
- builder: QuicPacketBuilder,
- space: QuicPacketSpace,
- stream: QuicStream,
- padding: bool = False,
+ builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
frame_overhead = 3 + quic_uint_length(stream.next_send_offset)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:
builder.start_frame(QuicFrameType.CRYPTO)
push_uint_var(builder.buffer, frame.offset)
push_uint16(builder.buffer, len(frame.data) | 0x4000)
push_bytes(builder.buffer, frame.data)
space.expect_ack(
builder.packet_number,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
- # PADDING
- if padding:
- push_bytes(builder.buffer, bytes(builder.remaining_space))
-
===========changed ref 1===========
# 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:
+ push_bytes(buf, bytes(self.remaining_space))
+ packet_size = buf.tell() - self._packet_start
+ self._pad_first_datagram = False
if is_long_header(self._packet_type):
# finalize length
buf.seek(
self._packet_start
+ self._header_size
- PACKET_NUMBER_SEND_SIZE
- PACKET_LENGTH_SEND_SIZE
)
length = (
packet_size
- self._header_size
+ PACKET_NUMBER_SEND_SIZE
+ self._crypto.aead_tag_size
)
push_uint16(buf, length | 0x4000)
push_packet_number(buf, self._packet_number)
buf.seek(packet_size)
else:
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
push_bytes(buf, 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)
push_bytes(
buf,
self._crypto.encrypt_packet(
plain[0 : self._header_size], plain[self._header_size : packet_size]</s>
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
# offset: 1
<s>crypto.encrypt_packet(
plain[0 : self._header_size], plain[self._header_size : packet_size]
),
)
# 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._crypto = None
return not empty
|
tests.test_packet/FrameTest.test_transport_close
|
Modified
|
aiortc~aioquic
|
34efc4f67275a20352097ed63ee99025a6b17dfc
|
[tests] improve packet builder tests
|
<7>:<del> # serialize
<8>:<del> buf = Buffer(capacity=len(data))
<9>:<del> packet.push_transport_close_frame(buf, *frame)
<10>:<del> self.assertEqual(buf.data, data)
<11>:<del>
|
# module: tests.test_packet
class FrameTest(TestCase):
def test_transport_close(self):
<0> data = binascii.unhexlify("000a0212696c6c6567616c2041434b206672616d6500")
<1>
<2> # parse
<3> buf = Buffer(data=data)
<4> frame = packet.pull_transport_close_frame(buf)
<5> self.assertEqual(frame, (10, 2, "illegal ACK frame\x00"))
<6>
<7> # serialize
<8> buf = Buffer(capacity=len(data))
<9> packet.push_transport_close_frame(buf, *frame)
<10> self.assertEqual(buf.data, data)
<11>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.packet
pull_transport_close_frame(buf: Buffer) -> Tuple[int, int, str]
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.packet
- def push_application_close_frame(
- buf: Buffer, error_code: int, reason_phrase: str
- ) -> None:
- reason_bytes = reason_phrase.encode("utf8")
- push_uint16(buf, error_code)
- push_uint_var(buf, len(reason_bytes))
- push_bytes(buf, reason_bytes)
-
===========changed ref 1===========
# module: aioquic.packet
- def push_transport_close_frame(
- buf: Buffer, error_code: int, frame_type: int, reason_phrase: str
- ) -> None:
- reason_bytes = reason_phrase.encode("utf8")
- push_uint16(buf, error_code)
- push_uint_var(buf, frame_type)
- push_uint_var(buf, len(reason_bytes))
- push_bytes(buf, reason_bytes)
-
===========changed ref 2===========
# module: aioquic.connection
- def push_close(
- buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str
- ) -> None:
- if frame_type is None:
- push_uint_var(buf, QuicFrameType.APPLICATION_CLOSE)
- packet.push_application_close_frame(buf, error_code, reason_phrase)
- else:
- push_uint_var(buf, QuicFrameType.TRANSPORT_CLOSE)
- packet.push_transport_close_frame(buf, error_code, frame_type, reason_phrase)
-
===========changed ref 3===========
# module: aioquic.connection
+ def write_close_frame(
+ builder: QuicPacketBuilder,
+ error_code: int,
+ frame_type: Optional[int],
+ reason_phrase: str,
+ ) -> None:
+ buf = builder.buffer
+
+ reason_bytes = reason_phrase.encode("utf8")
+
+ if frame_type is None:
+ builder.start_frame(QuicFrameType.APPLICATION_CLOSE)
+ push_uint16(buf, error_code)
+ push_uint_var(buf, len(reason_bytes))
+ push_bytes(buf, reason_bytes)
+ else:
+ builder.start_frame(QuicFrameType.TRANSPORT_CLOSE)
+ push_uint16(buf, error_code)
+ push_uint_var(buf, frame_type)
+ push_uint_var(buf, len(reason_bytes))
+ push_bytes(buf, reason_bytes)
+
===========changed ref 4===========
# 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._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
self._ack_eliciting = False
self._datagrams: List[bytes] = []
# current packet
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
===========changed ref 5===========
# module: aioquic.connection
def write_crypto_frame(
- builder: QuicPacketBuilder,
- space: QuicPacketSpace,
- stream: QuicStream,
- padding: bool = False,
+ builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
frame_overhead = 3 + quic_uint_length(stream.next_send_offset)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:
builder.start_frame(QuicFrameType.CRYPTO)
push_uint_var(builder.buffer, frame.offset)
push_uint16(builder.buffer, len(frame.data) | 0x4000)
push_bytes(builder.buffer, frame.data)
space.expect_ack(
builder.packet_number,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
- # PADDING
- if padding:
- push_bytes(builder.buffer, bytes(builder.remaining_space))
-
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
crypto = self.cryptos[epoch]
space = self.spaces[epoch]
if not crypto.send.is_valid():
return
buf = builder.buffer
while True:
if epoch == tls.Epoch.INITIAL:
packet_type = PACKET_TYPE_INITIAL
else:
packet_type = PACKET_TYPE_HANDSHAKE
builder.start_packet(packet_type, crypto)
# ACK
if space.ack_required and space.ack_queue:
builder.start_frame(QuicFrameType.ACK)
packet.push_ack_frame(buf, space.ack_queue, 0)
space.ack_required = False
# CRYPTO
- write_crypto_frame(
- builder=builder,
- space=space,
- stream=self.streams[epoch],
- padding=(epoch == tls.Epoch.INITIAL and self.is_client),
- )
+ write_crypto_frame(builder=builder, space=space, stream=self.streams[epoch])
if not builder.end_packet():
break
# discard initial keys
if self.is_client and epoch == tls.Epoch.HANDSHAKE:
self.cryptos[tls.Epoch.INITIAL].teardown()
|
tests.test_packet/FrameTest.test_application_close
|
Modified
|
aiortc~aioquic
|
34efc4f67275a20352097ed63ee99025a6b17dfc
|
[tests] improve packet builder tests
|
<7>:<del> # serialize
<8>:<del> buf = Buffer(capacity=len(data))
<9>:<del> packet.push_application_close_frame(buf, *frame)
<10>:<del> self.assertEqual(buf.data, data)
<11>:<del>
|
# module: tests.test_packet
class FrameTest(TestCase):
def test_application_close(self):
<0> data = binascii.unhexlify("000008676f6f6462796500")
<1>
<2> # parse
<3> buf = Buffer(data=data)
<4> frame = packet.pull_application_close_frame(buf)
<5> self.assertEqual(frame, (0, "goodbye\x00"))
<6>
<7> # serialize
<8> buf = Buffer(capacity=len(data))
<9> packet.push_application_close_frame(buf, *frame)
<10> self.assertEqual(buf.data, data)
<11>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.packet
pull_application_close_frame(buf: Buffer) -> Tuple[int, str]
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_packet.FrameTest.test_application_close
buf = Buffer(data=data)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_packet
class FrameTest(TestCase):
def test_transport_close(self):
data = binascii.unhexlify("000a0212696c6c6567616c2041434b206672616d6500")
# parse
buf = Buffer(data=data)
frame = packet.pull_transport_close_frame(buf)
self.assertEqual(frame, (10, 2, "illegal ACK frame\x00"))
- # serialize
- buf = Buffer(capacity=len(data))
- packet.push_transport_close_frame(buf, *frame)
- self.assertEqual(buf.data, data)
-
===========changed ref 1===========
# module: aioquic.packet
- def push_application_close_frame(
- buf: Buffer, error_code: int, reason_phrase: str
- ) -> None:
- reason_bytes = reason_phrase.encode("utf8")
- push_uint16(buf, error_code)
- push_uint_var(buf, len(reason_bytes))
- push_bytes(buf, reason_bytes)
-
===========changed ref 2===========
# module: aioquic.packet
- def push_transport_close_frame(
- buf: Buffer, error_code: int, frame_type: int, reason_phrase: str
- ) -> None:
- reason_bytes = reason_phrase.encode("utf8")
- push_uint16(buf, error_code)
- push_uint_var(buf, frame_type)
- push_uint_var(buf, len(reason_bytes))
- push_bytes(buf, reason_bytes)
-
===========changed ref 3===========
# module: aioquic.connection
- def push_close(
- buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str
- ) -> None:
- if frame_type is None:
- push_uint_var(buf, QuicFrameType.APPLICATION_CLOSE)
- packet.push_application_close_frame(buf, error_code, reason_phrase)
- else:
- push_uint_var(buf, QuicFrameType.TRANSPORT_CLOSE)
- packet.push_transport_close_frame(buf, error_code, frame_type, reason_phrase)
-
===========changed ref 4===========
# module: aioquic.connection
+ def write_close_frame(
+ builder: QuicPacketBuilder,
+ error_code: int,
+ frame_type: Optional[int],
+ reason_phrase: str,
+ ) -> None:
+ buf = builder.buffer
+
+ reason_bytes = reason_phrase.encode("utf8")
+
+ if frame_type is None:
+ builder.start_frame(QuicFrameType.APPLICATION_CLOSE)
+ push_uint16(buf, error_code)
+ push_uint_var(buf, len(reason_bytes))
+ push_bytes(buf, reason_bytes)
+ else:
+ builder.start_frame(QuicFrameType.TRANSPORT_CLOSE)
+ push_uint16(buf, error_code)
+ push_uint_var(buf, frame_type)
+ push_uint_var(buf, len(reason_bytes))
+ push_bytes(buf, reason_bytes)
+
===========changed ref 5===========
# 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._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
self._ack_eliciting = False
self._datagrams: List[bytes] = []
# current packet
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
===========changed ref 6===========
# module: aioquic.connection
def write_crypto_frame(
- builder: QuicPacketBuilder,
- space: QuicPacketSpace,
- stream: QuicStream,
- padding: bool = False,
+ builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
frame_overhead = 3 + quic_uint_length(stream.next_send_offset)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:
builder.start_frame(QuicFrameType.CRYPTO)
push_uint_var(builder.buffer, frame.offset)
push_uint16(builder.buffer, len(frame.data) | 0x4000)
push_bytes(builder.buffer, frame.data)
space.expect_ack(
builder.packet_number,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
- # PADDING
- if padding:
- push_bytes(builder.buffer, bytes(builder.remaining_space))
-
===========changed ref 7===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
crypto = self.cryptos[epoch]
space = self.spaces[epoch]
if not crypto.send.is_valid():
return
buf = builder.buffer
while True:
if epoch == tls.Epoch.INITIAL:
packet_type = PACKET_TYPE_INITIAL
else:
packet_type = PACKET_TYPE_HANDSHAKE
builder.start_packet(packet_type, crypto)
# ACK
if space.ack_required and space.ack_queue:
builder.start_frame(QuicFrameType.ACK)
packet.push_ack_frame(buf, space.ack_queue, 0)
space.ack_required = False
# CRYPTO
- write_crypto_frame(
- builder=builder,
- space=space,
- stream=self.streams[epoch],
- padding=(epoch == tls.Epoch.INITIAL and self.is_client),
- )
+ write_crypto_frame(builder=builder, space=space, stream=self.streams[epoch])
if not builder.end_packet():
break
# discard initial keys
if self.is_client and epoch == tls.Epoch.HANDSHAKE:
self.cryptos[tls.Epoch.INITIAL].teardown()
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_padding
|
Modified
|
aiortc~aioquic
|
34efc4f67275a20352097ed63ee99025a6b17dfc
|
[tests] improve packet builder tests
|
<3>:<add> pad_first_datagram=True,
<14>:<add> builder.start_frame(QuicFrameType.CRYPTO)
<add> push_bytes(builder.buffer, bytes(100))
<del> push_bytes(builder.buffer, bytes(builder.remaining_space))
<15>:<del> self.assertEqual(builder.remaining_space, 0)
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_padding(self):
<0> builder = QuicPacketBuilder(
<1> host_cid=bytes(8),
<2> packet_number=0,
<3> peer_cid=bytes(8),
<4> peer_token=b"",
<5> spin_bit=False,
<6> version=QuicProtocolVersion.DRAFT_20,
<7> )
<8> crypto = CryptoPair()
<9> crypto.setup_initial(bytes(8), is_client=True)
<10>
<11> # INITIAL, fully padded
<12> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<13> self.assertEqual(builder.remaining_space, 1237)
<14> push_bytes(builder.buffer, bytes(builder.remaining_space))
<15> self.assertEqual(builder.remaining_space, 0)
<16> self.assertTrue(builder.end_packet())
<17>
<18> # check builder state
<19> self.assertEqual(builder.buffer.tell(), 1280)
<20> self.assertEqual(builder.packet_number, 1)
<21>
<22> # check datagrams
<23> datagrams = builder.flush()
<24> self.assertEqual(len(datagrams), 1)
<25> self.assertEqual(len(datagrams[0]), 1280)
<26>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.buffer.Buffer
tell() -> int
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
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(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.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> List[bytes]
start_frame(frame_type: int) -> None
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.packet_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:
+ push_bytes(buf, bytes(self.remaining_space))
+ packet_size = buf.tell() - self._packet_start
+ self._pad_first_datagram = False
if is_long_header(self._packet_type):
# finalize length
buf.seek(
self._packet_start
+ self._header_size
- PACKET_NUMBER_SEND_SIZE
- PACKET_LENGTH_SEND_SIZE
)
length = (
packet_size
- self._header_size
+ PACKET_NUMBER_SEND_SIZE
+ self._crypto.aead_tag_size
)
push_uint16(buf, length | 0x4000)
push_packet_number(buf, self._packet_number)
buf.seek(packet_size)
else:
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
push_bytes(buf, 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)
push_bytes(
buf,
self._crypto.encrypt_packet(
plain[0 : self._header_size], plain[self._header_size : packet_size]</s>
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
# offset: 1
<s>crypto.encrypt_packet(
plain[0 : self._header_size], plain[self._header_size : packet_size]
),
)
# 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._crypto = None
return not empty
===========changed ref 2===========
# module: aioquic.packet
- def push_application_close_frame(
- buf: Buffer, error_code: int, reason_phrase: str
- ) -> None:
- reason_bytes = reason_phrase.encode("utf8")
- push_uint16(buf, error_code)
- push_uint_var(buf, len(reason_bytes))
- push_bytes(buf, reason_bytes)
-
===========changed ref 3===========
# module: aioquic.packet
- def push_transport_close_frame(
- buf: Buffer, error_code: int, frame_type: int, reason_phrase: str
- ) -> None:
- reason_bytes = reason_phrase.encode("utf8")
- push_uint16(buf, error_code)
- push_uint_var(buf, frame_type)
- push_uint_var(buf, len(reason_bytes))
- push_bytes(buf, reason_bytes)
-
===========changed ref 4===========
# module: aioquic.connection
- def push_close(
- buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str
- ) -> None:
- if frame_type is None:
- push_uint_var(buf, QuicFrameType.APPLICATION_CLOSE)
- packet.push_application_close_frame(buf, error_code, reason_phrase)
- else:
- push_uint_var(buf, QuicFrameType.TRANSPORT_CLOSE)
- packet.push_transport_close_frame(buf, error_code, frame_type, reason_phrase)
-
===========changed ref 5===========
# module: tests.test_packet
class FrameTest(TestCase):
def test_application_close(self):
data = binascii.unhexlify("000008676f6f6462796500")
# parse
buf = Buffer(data=data)
frame = packet.pull_application_close_frame(buf)
self.assertEqual(frame, (0, "goodbye\x00"))
- # serialize
- buf = Buffer(capacity=len(data))
- packet.push_application_close_frame(buf, *frame)
- self.assertEqual(buf.data, data)
-
===========changed ref 6===========
# module: tests.test_packet
class FrameTest(TestCase):
def test_transport_close(self):
data = binascii.unhexlify("000a0212696c6c6567616c2041434b206672616d6500")
# parse
buf = Buffer(data=data)
frame = packet.pull_transport_close_frame(buf)
self.assertEqual(frame, (10, 2, "illegal ACK frame\x00"))
- # serialize
- buf = Buffer(capacity=len(data))
- packet.push_transport_close_frame(buf, *frame)
- self.assertEqual(buf.data, data)
-
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_then_short_header
|
Modified
|
aiortc~aioquic
|
34efc4f67275a20352097ed63ee99025a6b17dfc
|
[tests] improve packet builder tests
|
<14>:<add> builder.start_frame(QuicFrameType.CRYPTO)
<20>:<add> builder.start_frame(QuicFrameType.CRYPTO)
<22>:<add>
<add> # check builder
<add> self.assertTrue(builder.ack_eliciting)
<add> self.assertEqual(builder.buffer.tell(), 0)
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_short_header(self):
<0> builder = QuicPacketBuilder(
<1> host_cid=bytes(8),
<2> packet_number=0,
<3> peer_cid=bytes(8),
<4> peer_token=b"",
<5> spin_bit=False,
<6> version=QuicProtocolVersion.DRAFT_20,
<7> )
<8> crypto = CryptoPair()
<9> crypto.setup_initial(bytes(8), is_client=True)
<10>
<11> # INITIAL, fully padded
<12> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<13> self.assertEqual(builder.remaining_space, 1237)
<14> push_bytes(builder.buffer, bytes(builder.remaining_space))
<15> self.assertTrue(builder.end_packet())
<16>
<17> # ONE_RTT, fully padded
<18> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<19> self.assertEqual(builder.remaining_space, 1253)
<20> push_bytes(builder.buffer, bytes(builder.remaining_space))
<21> self.assertTrue(builder.end_packet())
<22>
<23> # check datagrams
<24> datagrams = builder.flush()
<25> self.assertEqual(len(datagrams), 2)
<26> self.assertEqual(len(datagrams[0]), 1280)
<27> self.assertEqual(len(datagrams[1]), 1280)
<28>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
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
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(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.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
start_frame(frame_type: int) -> None
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: tests.test_packet_builder.QuicPacketBuilderTest.test_long_header_padding
datagrams = builder.flush()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# 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:
+ push_bytes(buf, bytes(self.remaining_space))
+ packet_size = buf.tell() - self._packet_start
+ self._pad_first_datagram = False
if is_long_header(self._packet_type):
# finalize length
buf.seek(
self._packet_start
+ self._header_size
- PACKET_NUMBER_SEND_SIZE
- PACKET_LENGTH_SEND_SIZE
)
length = (
packet_size
- self._header_size
+ PACKET_NUMBER_SEND_SIZE
+ self._crypto.aead_tag_size
)
push_uint16(buf, length | 0x4000)
push_packet_number(buf, self._packet_number)
buf.seek(packet_size)
else:
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
push_bytes(buf, 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)
push_bytes(
buf,
self._crypto.encrypt_packet(
plain[0 : self._header_size], plain[self._header_size : packet_size]</s>
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
# offset: 1
<s>crypto.encrypt_packet(
plain[0 : self._header_size], plain[self._header_size : packet_size]
),
)
# 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._crypto = None
return not empty
===========changed ref 2===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_padding(self):
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
+ pad_first_datagram=True,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
crypto = CryptoPair()
crypto.setup_initial(bytes(8), is_client=True)
# INITIAL, fully padded
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1237)
+ builder.start_frame(QuicFrameType.CRYPTO)
+ push_bytes(builder.buffer, bytes(100))
- push_bytes(builder.buffer, bytes(builder.remaining_space))
- self.assertEqual(builder.remaining_space, 0)
self.assertTrue(builder.end_packet())
# check builder state
self.assertEqual(builder.buffer.tell(), 1280)
self.assertEqual(builder.packet_number, 1)
# check datagrams
datagrams = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 1280)
===========changed ref 3===========
# module: aioquic.packet
- def push_application_close_frame(
- buf: Buffer, error_code: int, reason_phrase: str
- ) -> None:
- reason_bytes = reason_phrase.encode("utf8")
- push_uint16(buf, error_code)
- push_uint_var(buf, len(reason_bytes))
- push_bytes(buf, reason_bytes)
-
===========changed ref 4===========
# module: aioquic.packet
- def push_transport_close_frame(
- buf: Buffer, error_code: int, frame_type: int, reason_phrase: str
- ) -> None:
- reason_bytes = reason_phrase.encode("utf8")
- push_uint16(buf, error_code)
- push_uint_var(buf, frame_type)
- push_uint_var(buf, len(reason_bytes))
- push_bytes(buf, reason_bytes)
-
===========changed ref 5===========
# module: aioquic.connection
- def push_close(
- buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str
- ) -> None:
- if frame_type is None:
- push_uint_var(buf, QuicFrameType.APPLICATION_CLOSE)
- packet.push_application_close_frame(buf, error_code, reason_phrase)
- else:
- push_uint_var(buf, QuicFrameType.TRANSPORT_CLOSE)
- packet.push_transport_close_frame(buf, error_code, frame_type, reason_phrase)
-
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_then_long_header
|
Modified
|
aiortc~aioquic
|
34efc4f67275a20352097ed63ee99025a6b17dfc
|
[tests] improve packet builder tests
|
<14>:<add> builder.start_frame(QuicFrameType.CRYPTO)
<add> push_bytes(builder.buffer, bytes(199))
<del> push_bytes(builder.buffer, bytes(200))
<23>:<add> builder.start_frame(QuicFrameType.CRYPTO)
<add> push_bytes(builder.buffer, bytes(299))
<del> push_bytes(builder.buffer, bytes(300))
<31>:<add> builder.start_frame(QuicFrameType.CRYPTO)
<add> push_bytes(builder.buffer, bytes(299))
<del> push_bytes(builder.buffer, bytes(300))
<32>:<add>
<add> # check builder
<add> self.assertTrue(builder.ack_eliciting)
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_long_header(self):
<0> builder = QuicPacketBuilder(
<1> host_cid=bytes(8),
<2> packet_number=0,
<3> peer_cid=bytes(8),
<4> peer_token=b"",
<5> spin_bit=False,
<6> version=QuicProtocolVersion.DRAFT_20,
<7> )
<8> crypto = CryptoPair()
<9> crypto.setup_initial(bytes(8), is_client=True)
<10>
<11> # INITIAL
<12> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<13> self.assertEqual(builder.remaining_space, 1237)
<14> push_bytes(builder.buffer, bytes(200))
<15> self.assertEqual(builder.buffer.tell(), 227)
<16> self.assertTrue(builder.end_packet())
<17> self.assertEqual(builder.buffer.tell(), 243)
<18>
<19> # HANDSHAKE
<20> builder.start_packet(PACKET_TYPE_HANDSHAKE, crypto)
<21> self.assertEqual(builder.buffer.tell(), 269)
<22> self.assertEqual(builder.remaining_space, 995)
<23> push_bytes(builder.buffer, bytes(300))
<24> self.assertEqual(builder.buffer.tell(), 569)
<25> self.assertTrue(builder.end_packet())
<26> self.assertEqual(builder.buffer.tell(), 585)
<27>
<28> # ONE_RTT
<29> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<30> self.assertEqual(builder.remaining_space, 668)
<31> push_bytes(builder.buffer, bytes(300))
<32> self.assertTrue(builder.end_packet())
<33> self.assertEqual(builder.buffer.tell(), 0)
<34>
<35> # check datagrams
<36> datagrams = builder.flush()
<37> self.assertEqual(len(datagrams), 1)
</s>
|
===========below chunk 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_long_header(self):
# offset: 1
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.buffer.Buffer
tell() -> int
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
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(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.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> List[bytes]
start_frame(frame_type: int) -> None
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: tests.test_packet_builder.QuicPacketBuilderTest.test_long_header_then_short_header
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
===========unchanged ref 1===========
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# 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:
+ push_bytes(buf, bytes(self.remaining_space))
+ packet_size = buf.tell() - self._packet_start
+ self._pad_first_datagram = False
if is_long_header(self._packet_type):
# finalize length
buf.seek(
self._packet_start
+ self._header_size
- PACKET_NUMBER_SEND_SIZE
- PACKET_LENGTH_SEND_SIZE
)
length = (
packet_size
- self._header_size
+ PACKET_NUMBER_SEND_SIZE
+ self._crypto.aead_tag_size
)
push_uint16(buf, length | 0x4000)
push_packet_number(buf, self._packet_number)
buf.seek(packet_size)
else:
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
push_bytes(buf, 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)
push_bytes(
buf,
self._crypto.encrypt_packet(
plain[0 : self._header_size], plain[self._header_size : packet_size]</s>
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
# offset: 1
<s>crypto.encrypt_packet(
plain[0 : self._header_size], plain[self._header_size : packet_size]
),
)
# 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._crypto = None
return not empty
===========changed ref 2===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_padding(self):
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
+ pad_first_datagram=True,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
crypto = CryptoPair()
crypto.setup_initial(bytes(8), is_client=True)
# INITIAL, fully padded
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1237)
+ builder.start_frame(QuicFrameType.CRYPTO)
+ push_bytes(builder.buffer, bytes(100))
- push_bytes(builder.buffer, bytes(builder.remaining_space))
- self.assertEqual(builder.remaining_space, 0)
self.assertTrue(builder.end_packet())
# check builder state
self.assertEqual(builder.buffer.tell(), 1280)
self.assertEqual(builder.packet_number, 1)
# check datagrams
datagrams = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 1280)
|
tests.test_packet_builder/QuicPacketBuilderTest.test_short_header_empty
|
Modified
|
aiortc~aioquic
|
34efc4f67275a20352097ed63ee99025a6b17dfc
|
[tests] improve packet builder tests
|
<14>:<add> self.assertFalse(builder.end_packet())
<15>:<add> # check builder
<add> self.assertFalse(builder.ack_eliciting)
<del> self.assertFalse(builder.end_packet())
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_empty(self):
<0> builder = QuicPacketBuilder(
<1> host_cid=bytes(8),
<2> packet_number=0,
<3> peer_cid=bytes(8),
<4> peer_token=b"",
<5> spin_bit=False,
<6> version=QuicProtocolVersion.DRAFT_20,
<7> )
<8> crypto = CryptoPair()
<9>
<10> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<11> self.assertEqual(builder.remaining_space, 1253)
<12>
<13> # nothing to write
<14>
<15> self.assertFalse(builder.end_packet())
<16> self.assertEqual(builder.buffer.tell(), 0)
<17> self.assertEqual(builder.packet_number, 0)
<18>
<19> datagrams = builder.flush()
<20> self.assertEqual(len(datagrams), 0)
<21>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(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.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: tests.test_packet_builder.QuicPacketBuilderTest.test_long_header_then_long_header
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_padding(self):
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
+ pad_first_datagram=True,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
crypto = CryptoPair()
crypto.setup_initial(bytes(8), is_client=True)
# INITIAL, fully padded
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1237)
+ builder.start_frame(QuicFrameType.CRYPTO)
+ push_bytes(builder.buffer, bytes(100))
- push_bytes(builder.buffer, bytes(builder.remaining_space))
- self.assertEqual(builder.remaining_space, 0)
self.assertTrue(builder.end_packet())
# check builder state
self.assertEqual(builder.buffer.tell(), 1280)
self.assertEqual(builder.packet_number, 1)
# check datagrams
datagrams = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 1280)
===========changed ref 1===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_short_header(self):
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
crypto = CryptoPair()
crypto.setup_initial(bytes(8), is_client=True)
# INITIAL, fully padded
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1237)
+ builder.start_frame(QuicFrameType.CRYPTO)
push_bytes(builder.buffer, bytes(builder.remaining_space))
self.assertTrue(builder.end_packet())
# ONE_RTT, fully padded
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertEqual(builder.remaining_space, 1253)
+ builder.start_frame(QuicFrameType.CRYPTO)
push_bytes(builder.buffer, bytes(builder.remaining_space))
self.assertTrue(builder.end_packet())
+
+ # check builder
+ self.assertTrue(builder.ack_eliciting)
+ self.assertEqual(builder.buffer.tell(), 0)
# check datagrams
datagrams = builder.flush()
self.assertEqual(len(datagrams), 2)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(len(datagrams[1]), 1280)
===========changed ref 2===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_long_header(self):
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
crypto = CryptoPair()
crypto.setup_initial(bytes(8), is_client=True)
# INITIAL
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1237)
+ builder.start_frame(QuicFrameType.CRYPTO)
+ push_bytes(builder.buffer, bytes(199))
- push_bytes(builder.buffer, bytes(200))
self.assertEqual(builder.buffer.tell(), 227)
self.assertTrue(builder.end_packet())
self.assertEqual(builder.buffer.tell(), 243)
# HANDSHAKE
builder.start_packet(PACKET_TYPE_HANDSHAKE, crypto)
self.assertEqual(builder.buffer.tell(), 269)
self.assertEqual(builder.remaining_space, 995)
+ builder.start_frame(QuicFrameType.CRYPTO)
+ push_bytes(builder.buffer, bytes(299))
- push_bytes(builder.buffer, bytes(300))
self.assertEqual(builder.buffer.tell(), 569)
self.assertTrue(builder.end_packet())
self.assertEqual(builder.buffer.tell(), 585)
# ONE_RTT
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertEqual(builder.remaining_space, 668)
+ builder.start_frame(QuicFrameType.CRYPTO)
+ push_bytes(builder.buffer, bytes(299))
- push_bytes(builder.buffer, bytes(300))</s>
===========changed ref 3===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_long_header(self):
# offset: 1
<s> <add> push_bytes(builder.buffer, bytes(299))
- push_bytes(builder.buffer, bytes(300))
+
+ # check builder
+ self.assertTrue(builder.ack_eliciting)
self.assertTrue(builder.end_packet())
self.assertEqual(builder.buffer.tell(), 0)
# check datagrams
datagrams = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 912)
===========changed ref 4===========
# module: aioquic.packet
- def push_application_close_frame(
- buf: Buffer, error_code: int, reason_phrase: str
- ) -> None:
- reason_bytes = reason_phrase.encode("utf8")
- push_uint16(buf, error_code)
- push_uint_var(buf, len(reason_bytes))
- push_bytes(buf, reason_bytes)
-
|
tests.test_packet_builder/QuicPacketBuilderTest.test_short_header_padding
|
Modified
|
aiortc~aioquic
|
34efc4f67275a20352097ed63ee99025a6b17dfc
|
[tests] improve packet builder tests
|
<14>:<add> builder.start_frame(QuicFrameType.CRYPTO)
<18>:<add> self.assertTrue(builder.ack_eliciting)
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_padding(self):
<0> builder = QuicPacketBuilder(
<1> host_cid=bytes(8),
<2> packet_number=0,
<3> peer_cid=bytes(8),
<4> peer_token=b"",
<5> spin_bit=False,
<6> version=QuicProtocolVersion.DRAFT_20,
<7> )
<8> crypto = CryptoPair()
<9> crypto.setup_initial(bytes(8), is_client=True)
<10>
<11> # ONE_RTT, fully padded
<12> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<13> self.assertEqual(builder.remaining_space, 1253)
<14> push_bytes(builder.buffer, bytes(builder.remaining_space))
<15> self.assertTrue(builder.end_packet())
<16>
<17> # check builder
<18> self.assertEqual(builder.buffer.tell(), 0)
<19> self.assertEqual(builder.packet_number, 1)
<20>
<21> # check datagrams
<22> datagrams = builder.flush()
<23> self.assertEqual(len(datagrams), 1)
<24> self.assertEqual(len(datagrams[0]), 1280)
<25>
|
===========unchanged ref 0===========
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.crypto
CryptoPair()
at: aioquic.packet
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> List[bytes]
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: tests.test_packet_builder.QuicPacketBuilderTest.test_short_header_empty
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# 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:
+ push_bytes(buf, bytes(self.remaining_space))
+ packet_size = buf.tell() - self._packet_start
+ self._pad_first_datagram = False
if is_long_header(self._packet_type):
# finalize length
buf.seek(
self._packet_start
+ self._header_size
- PACKET_NUMBER_SEND_SIZE
- PACKET_LENGTH_SEND_SIZE
)
length = (
packet_size
- self._header_size
+ PACKET_NUMBER_SEND_SIZE
+ self._crypto.aead_tag_size
)
push_uint16(buf, length | 0x4000)
push_packet_number(buf, self._packet_number)
buf.seek(packet_size)
else:
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
push_bytes(buf, 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)
push_bytes(
buf,
self._crypto.encrypt_packet(
plain[0 : self._header_size], plain[self._header_size : packet_size]</s>
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
# offset: 1
<s>crypto.encrypt_packet(
plain[0 : self._header_size], plain[self._header_size : packet_size]
),
)
# 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._crypto = None
return not empty
===========changed ref 2===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_empty(self):
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
crypto = CryptoPair()
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertEqual(builder.remaining_space, 1253)
# nothing to write
+ self.assertFalse(builder.end_packet())
+ # check builder
+ self.assertFalse(builder.ack_eliciting)
- self.assertFalse(builder.end_packet())
self.assertEqual(builder.buffer.tell(), 0)
self.assertEqual(builder.packet_number, 0)
datagrams = builder.flush()
self.assertEqual(len(datagrams), 0)
===========changed ref 3===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_padding(self):
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
+ pad_first_datagram=True,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
crypto = CryptoPair()
crypto.setup_initial(bytes(8), is_client=True)
# INITIAL, fully padded
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1237)
+ builder.start_frame(QuicFrameType.CRYPTO)
+ push_bytes(builder.buffer, bytes(100))
- push_bytes(builder.buffer, bytes(builder.remaining_space))
- self.assertEqual(builder.remaining_space, 0)
self.assertTrue(builder.end_packet())
# check builder state
self.assertEqual(builder.buffer.tell(), 1280)
self.assertEqual(builder.packet_number, 1)
# check datagrams
datagrams = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 1280)
|
aioquic.packet_builder/QuicPacketBuilder.start_frame
|
Modified
|
aiortc~aioquic
|
a63c651324fd03f25665700871cd698c95ce81f2
|
[connection] use frozenset for ack-eliciting / probing frame types
|
<4>:<del> if not self._ack_eliciting and frame_type not in [
<5>:<del> QuicFrameType.ACK,
<6>:<del> QuicFrameType.ACK_ECN,
<7>:<del> QuicFrameType.PADDING,
<8>:<del> ]:
<9>:<add> if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_frame(self, frame_type: int) -> None:
<0> """
<1> Starts a new frame.
<2> """
<3> push_uint_var(self.buffer, frame_type)
<4> if not self._ack_eliciting and frame_type not in [
<5> QuicFrameType.ACK,
<6> QuicFrameType.ACK_ECN,
<7> QuicFrameType.PADDING,
<8> ]:
<9> self._ack_eliciting = True
<10>
|
===========unchanged ref 0===========
at: aioquic.crypto
CryptoPair()
at: aioquic.packet
push_uint_var(buf: Buffer, value: int) -> None
NON_ACK_ELICITING_FRAME_TYPES = frozenset(
[QuicFrameType.ACK, QuicFrameType.ACK_ECN, QuicFrameType.PADDING]
)
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._ack_eliciting = False
self.buffer = Buffer(PACKET_MAX_SIZE)
===========changed ref 0===========
# module: aioquic.packet
+ NON_ACK_ELICITING_FRAME_TYPES = frozenset(
+ [QuicFrameType.ACK, QuicFrameType.ACK_ECN, QuicFrameType.PADDING]
+ )
+ PROBING_FRAME_TYPES = frozenset(
+ [
+ QuicFrameType.PATH_CHALLENGE,
+ QuicFrameType.PATH_RESPONSE,
+ QuicFrameType.PADDING,
+ QuicFrameType.NEW_CONNECTION_ID,
+ ]
+ )
|
aioquic.connection/QuicConnection._handle_crypto_frame
|
Modified
|
aiortc~aioquic
|
a63c651324fd03f25665700871cd698c95ce81f2
|
[connection] use frozenset for ack-eliciting / probing frame types
|
<10>:<add> self._push_crypto_data()
|
# module: aioquic.connection
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.streams[context.epoch]
<4> stream.add_frame(packet.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.send_buffer)
<10> except tls.Alert as exc:
<11> raise QuicConnectionError(
<12> error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),
<13> frame_type=QuicFrameType.CRYPTO,
<14> reason_phrase=str(exc),
<15> )
<16>
<17> # parse transport parameters
<18> if (
<19> not self._parameters_received
<20> and self.tls.received_extensions is not None
<21> ):
<22> for ext_type, ext_data in self.tls.received_extensions:
<23> if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
<24> self._parse_transport_parameters(ext_data)
<25> self._parameters_received = True
<26> break
<27> assert (
<28> self._parameters_received
<29> ), "No QUIC transport parameters received"
<30> self._logger.info("ALPN negotiated protocol %s", self.alpn_protocol)
<31>
<32> # update current epoch
<33> if self.__epoch == tls.Epoch.HANDSHAKE and self.tls.state in [
<34> tls.State.CLIENT_POST_HANDSHAKE,
<35> tls.State.SERVER_POST_HANDSHAKE,
<36> ]:
<37> self._replenish_connection_ids()
<38> self.__epoch = tls.Epoch.ONE_RTT
<39> # wakeup waiter
<40> if not self.__connected.is_set():
<41> self.__connected.set</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
# offset: 1
elif self.__epoch == tls.Epoch.INITIAL:
self.__epoch = tls.Epoch.HANDSHAKE
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_replenish_connection_ids() -> None
_replenish_connection_ids(self) -> None
_push_crypto_data() -> None
_parse_transport_parameters(data: bytes, from_session_ticket: bool=False) -> None
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__epoch = tls.Epoch.INITIAL
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._parameters_received = False
at: aioquic.connection.QuicConnection._handle_connection_close_frame
error_code, frame_type, reason_phrase = packet.pull_transport_close_frame(
buf
)
error_code, reason_phrase = packet.pull_application_close_frame(buf)
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
self.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
at: aioquic.connection.QuicReceiveContext
epoch: tls.Epoch
host_cid: bytes
network_path: QuicNetworkPath
===========unchanged ref 1===========
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)
pull_crypto_frame(buf: Buffer) -> QuicStreamFrame
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
pull_data() -> bytes
at: aioquic.tls
Alert(*args: object)
Epoch()
State()
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls.Alert
description: AlertDescription
at: aioquic.tls.Context
handle_message(input_data: bytes, output_buf: Dict[Epoch, Buffer]) -> None
at: aioquic.tls.Context.__init__
self.received_extensions: Optional[List[Extension]] = None
self.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: aioquic.tls.Context._client_handle_encrypted_extensions
self.received_extensions = encrypted_extensions.other_extensions
at: aioquic.tls.Context._server_handle_hello
self.received_extensions = peer_hello.other_extensions
at: aioquic.tls.Context._set_state
self.state = state
at: logging.LoggerAdapter
logger: Logger
extra: Mapping[str, Any]
===========unchanged ref 2===========
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.packet
+ NON_ACK_ELICITING_FRAME_TYPES = frozenset(
+ [QuicFrameType.ACK, QuicFrameType.ACK_ECN, QuicFrameType.PADDING]
+ )
+ PROBING_FRAME_TYPES = frozenset(
+ [
+ QuicFrameType.PATH_CHALLENGE,
+ QuicFrameType.PATH_RESPONSE,
+ QuicFrameType.PADDING,
+ QuicFrameType.NEW_CONNECTION_ID,
+ ]
+ )
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_frame(self, frame_type: int) -> None:
"""
Starts a new frame.
"""
push_uint_var(self.buffer, frame_type)
- if not self._ack_eliciting and frame_type not in [
- QuicFrameType.ACK,
- QuicFrameType.ACK_ECN,
- QuicFrameType.PADDING,
- ]:
+ if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
self._ack_eliciting = True
===========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 [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:
return
data = cast(bytes, data)
buf = Buffer(data=data)
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(pull_uint32(buf))
common = set(self.supported_versions).intersection(versions)
if not common:
self._logger.error("Could not find a common protocol version")
return
self._version = QuicProtocolVersion(max(common))
self._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 and header.packet_type == PACKET_TYPE_RETRY:
# stateless retry
if (
header.destination_cid == self.host_cid
and header.original_destination_cid == self.peer_cid
</s>
|
aioquic.connection/QuicConnection._payload_received
|
Modified
|
aiortc~aioquic
|
a63c651324fd03f25665700871cd698c95ce81f2
|
[connection] use frozenset for ack-eliciting / probing frame types
|
<5>:<add> is_ack_eliciting = False
<del> is_ack_only = True
<43>:<del> if frame_type not in [
<44>:<del> QuicFrameType.ACK,
<45>:<del> QuicFrameType.ACK_ECN,
<46>:<del> QuicFrameType.PADDING,
<47>:<del> ]:
<48>:<add> if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
<add> is_ack_eliciting = True
<del> is_ack_only = False
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _payload_received(
self, context: QuicReceiveContext, plain: bytes
) -> Tuple[bool, bool]:
<0> """
<1> Handle a QUIC packet payload.
<2> """
<3> buf = Buffer(data=plain)
<4>
<5> is_ack_only = True
<6> is_probing = None
<7> while not buf.eof():
<8> frame_type = pull_uint_var(buf)
<9>
<10> # check frame type is known
<11> try:
<12> frame_handler, frame_epochs = self.__frame_handlers[frame_type]
<13> except IndexError:
<14> raise QuicConnectionError(
<15> error_code=QuicErrorCode.PROTOCOL_VIOLATION,
<16> frame_type=frame_type,
<17> reason_phrase="Unknown frame type",
<18> )
<19>
<20> # check frame is allowed for the epoch
<21> if context.epoch not in frame_epochs:
<22> raise QuicConnectionError(
<23> error_code=QuicErrorCode.PROTOCOL_VIOLATION,
<24> frame_type=frame_type,
<25> reason_phrase="Unexpected frame type",
<26> )
<27>
<28> # handle the frame
<29> if frame_type != QuicFrameType.PADDING:
<30> self._logger.debug(
<31> "[%s] handling frame %s", context, frame_type_name(frame_type)
<32> )
<33> try:
<34> frame_handler(context, frame_type, buf)
<35> except BufferReadError:
<36> raise QuicConnectionError(
<37> error_code=QuicErrorCode.FRAME_ENCODING_ERROR,
<38> frame_type=frame_type,
<39> reason_phrase="Failed to parse frame",
<40> )
<41>
<42> # update ACK only / probing flags
<43> if frame_type not in [
<44> QuicFrameType.ACK,
<45> QuicFrameType.ACK_ECN,
<46> QuicFrameType.PADDING,
<47> ]:
<48> is_ack_only = False</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _payload_received(
self, context: QuicReceiveContext, plain: bytes
) -> Tuple[bool, bool]:
# offset: 1
if frame_type not in [
QuicFrameType.PATH_CHALLENGE,
QuicFrameType.PATH_RESPONSE,
QuicFrameType.PADDING,
QuicFrameType.NEW_CONNECTION_ID,
]:
is_probing = False
elif is_probing is None:
is_probing = True
self._push_crypto_data()
return is_ack_only, bool(is_probing)
===========unchanged ref 0===========
at: aioquic.buffer
BufferReadError(*args: object)
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.buffer.Buffer
eof() -> bool
at: aioquic.connection
frame_type_name(frame_type: int) -> str
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath)
at: aioquic.connection.QuicConnection.__init__
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._retire_connection_ids: List[int] = []
===========unchanged ref 1===========
self.__frame_handlers = [
(self._handle_padding_frame, EPOCHS("IZHO")),
(self._handle_padding_frame, EPOCHS("ZO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_reset_stream_frame, EPOCHS("ZO")),
(self._handle_stop_sending_frame, EPOCHS("ZO")),
(self._handle_crypto_frame, EPOCHS("IHO")),
(self._handle_new_token_frame, EPOCHS("O")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_max_data_frame, EPOCHS("ZO")),
(self._handle_max_stream_data_frame, EPOCHS("ZO")),
(self._handle_max_streams_bidi_frame, EPOCHS("ZO")),
(self._handle_max_streams_uni_frame, EPOCHS("ZO")),
(self._handle_data_blocked_frame, EPOCHS("ZO")),
(self._handle_stream_data_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_new_connection_id_frame,</s>
===========unchanged ref 2===========
at: aioquic.connection.QuicReceiveContext
epoch: tls.Epoch
at: aioquic.packet
QuicDeliveryState()
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
pull_uint_var(buf: Buffer) -> int
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
NON_ACK_ELICITING_FRAME_TYPES = frozenset(
[QuicFrameType.ACK, QuicFrameType.ACK_ECN, QuicFrameType.PADDING]
)
PROBING_FRAME_TYPES = frozenset(
[
QuicFrameType.PATH_CHALLENGE,
QuicFrameType.PATH_RESPONSE,
QuicFrameType.PADDING,
QuicFrameType.NEW_CONNECTION_ID,
]
)
at: logging.LoggerAdapter
debug(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a CRYPTO frame.
"""
stream = self.streams[context.epoch]
stream.add_frame(packet.pull_crypto_frame(buf))
data = stream.pull_data()
if data:
# pass data to TLS layer
try:
self.tls.handle_message(data, self.send_buffer)
+ 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 self.__epoch == tls.Epoch.HANDSHAKE and self.tls.state in [
tls.State.CLIENT_POST_HANDSHAKE,
tls.State.SERVER_POST_HANDSHAKE,
]:
self._replenish_connection_ids()
self.__epoch = tls.Epoch.ONE_RTT
# wakeup waiter
if not self.__connected.is_set():
self.__connected.set()
elif self.__epoch == tls.Epoch.INITIAL:
self.__epoch = tls.Epoch.HANDSHAKE
===========changed ref 1===========
# module: aioquic.packet
+ NON_ACK_ELICITING_FRAME_TYPES = frozenset(
+ [QuicFrameType.ACK, QuicFrameType.ACK_ECN, QuicFrameType.PADDING]
+ )
+ PROBING_FRAME_TYPES = frozenset(
+ [
+ QuicFrameType.PATH_CHALLENGE,
+ QuicFrameType.PATH_RESPONSE,
+ QuicFrameType.PADDING,
+ QuicFrameType.NEW_CONNECTION_ID,
+ ]
+ )
|
tests.test_connection/QuicConnectionTest.test_payload_received_padding_only
|
Modified
|
aiortc~aioquic
|
a63c651324fd03f25665700871cd698c95ce81f2
|
[connection] use frozenset for ack-eliciting / probing frame types
|
<12>:<add> is_ack_eliciting, is_probing = client._payload_received(
<del> is_ack_only, is_probing = client._payload_received(
<15>:<add> self.assertFalse(is_ack_eliciting)
<del> self.assertTrue(is_ack_only)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_payload_received_padding_only(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10>
<11> # client receives padding only
<12> is_ack_only, is_probing = client._payload_received(
<13> client_receive_context(client), b"\x00" * 1200
<14> )
<15> self.assertTrue(is_ack_only)
<16> self.assertTrue(is_probing)
<17>
|
===========unchanged ref 0===========
at: aioquic.connection
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, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_payload_received(context: QuicReceiveContext, plain: bytes) -> Tuple[bool, bool]
at: tests.test_connection
client_receive_context(client, epoch=tls.Epoch.ONE_RTT)
create_transport(client, server)
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()
)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _payload_received(
self, context: QuicReceiveContext, plain: bytes
) -> Tuple[bool, bool]:
"""
Handle a QUIC packet payload.
"""
buf = Buffer(data=plain)
+ is_ack_eliciting = False
- is_ack_only = True
is_probing = None
while not buf.eof():
frame_type = pull_uint_var(buf)
# check frame type is known
try:
frame_handler, frame_epochs = self.__frame_handlers[frame_type]
except IndexError:
raise QuicConnectionError(
error_code=QuicErrorCode.PROTOCOL_VIOLATION,
frame_type=frame_type,
reason_phrase="Unknown frame type",
)
# check frame is allowed for the epoch
if context.epoch not in frame_epochs:
raise QuicConnectionError(
error_code=QuicErrorCode.PROTOCOL_VIOLATION,
frame_type=frame_type,
reason_phrase="Unexpected frame type",
)
# handle the frame
if frame_type != QuicFrameType.PADDING:
self._logger.debug(
"[%s] handling frame %s", context, frame_type_name(frame_type)
)
try:
frame_handler(context, frame_type, buf)
except BufferReadError:
raise QuicConnectionError(
error_code=QuicErrorCode.FRAME_ENCODING_ERROR,
frame_type=frame_type,
reason_phrase="Failed to parse frame",
)
# update ACK only / probing flags
- if frame_type not in [
- QuicFrameType.ACK,
- QuicFrameType.ACK_ECN,
- QuicFrameType.PADDING,
- ]:
+ if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
+ is_ack_eliciting = True
- is_</s>
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _payload_received(
self, context: QuicReceiveContext, plain: bytes
) -> Tuple[bool, bool]:
# offset: 1
<s> NON_ACK_ELICITING_FRAME_TYPES:
+ is_ack_eliciting = True
- is_ack_only = False
+ if frame_type not in PROBING_FRAME_TYPES:
- if frame_type not in [
- QuicFrameType.PATH_CHALLENGE,
- QuicFrameType.PATH_RESPONSE,
- QuicFrameType.PADDING,
- QuicFrameType.NEW_CONNECTION_ID,
- ]:
is_probing = False
elif is_probing is None:
is_probing = True
+ return is_ack_eliciting, bool(is_probing)
- self._push_crypto_data()
- return is_ack_only, bool(is_probing)
-
===========changed ref 2===========
# module: aioquic.packet
+ NON_ACK_ELICITING_FRAME_TYPES = frozenset(
+ [QuicFrameType.ACK, QuicFrameType.ACK_ECN, QuicFrameType.PADDING]
+ )
+ PROBING_FRAME_TYPES = frozenset(
+ [
+ QuicFrameType.PATH_CHALLENGE,
+ QuicFrameType.PATH_RESPONSE,
+ QuicFrameType.PADDING,
+ QuicFrameType.NEW_CONNECTION_ID,
+ ]
+ )
===========changed ref 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_frame(self, frame_type: int) -> None:
"""
Starts a new frame.
"""
push_uint_var(self.buffer, frame_type)
- if not self._ack_eliciting and frame_type not in [
- QuicFrameType.ACK,
- QuicFrameType.ACK_ECN,
- QuicFrameType.PADDING,
- ]:
+ if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
self._ack_eliciting = True
|
aioquic.connection/QuicPacketLoss.detect_loss
|
Modified
|
aiortc~aioquic
|
e255fbfb7d244867ce389e324430ed016077b768
|
[loss] fix typo in packet number threshold
|
<3>:<add> packet_threshold = self._highest_acked_pn - K_PACKET_THRESHOLD
<del> packet_threshold = self._highest_acked_pn - K_GRANULARITY
|
# module: aioquic.connection
class QuicPacketLoss:
def detect_loss(self, space: QuicPacketSpace) -> None:
<0> """
<1> Check whether any packets should be declared lost.
<2> """
<3> packet_threshold = self._highest_acked_pn - K_GRANULARITY
<4> rtt = (
<5> max(self._rtt_latest, self._rtt_smoothed)
<6> if self._rtt_initialized
<7> else K_INITIAL_RTT
<8> )
<9> time_threshold = time.time() - K_TIME_THRESHOLD * rtt
<10>
<11> handlers = space.delivery_handlers
<12> timestamps = space.timestamps
<13> for packet_number, timestamp in list(timestamps.items()):
<14> if packet_number <= packet_threshold or (
<15> packet_number < self._highest_acked_pn and timestamp < time_threshold
<16> ):
<17> for handler, args in handlers[packet_number]:
<18> handler(QuicDeliveryState.LOST, *args)
<19> del handlers[packet_number]
<20> del timestamps[packet_number]
<21> else:
<22> break
<23>
|
===========unchanged ref 0===========
at: aioquic.connection
K_PACKET_THRESHOLD = 3
K_INITIAL_RTT = 0.5 # seconds
K_TIME_THRESHOLD = 9 / 8
at: aioquic.connection.QuicPacketLoss.__init__
self._highest_acked_pn = -1
self._rtt_initialized = False
self._rtt_latest = 0.0
self._rtt_smoothed = 0.0
at: aioquic.connection.QuicPacketLoss.ack_received
self._highest_acked_pn = largest_newly_acked
self._rtt_latest = max(latest_rtt, 0.001)
self._rtt_latest -= ack_delay
self._rtt_initialized = True
self._rtt_smoothed = latest_rtt
self._rtt_smoothed = 7 / 8 * self._rtt_smoothed + 1 / 8 * self._rtt_latest
at: aioquic.connection.QuicPacketSpace.__init__
self.delivery_handlers: Dict[int, List[Tuple[QuicDeliveryHandler, Any]]] = {}
self.timestamps: Dict[int, float] = {}
at: aioquic.packet
QuicDeliveryState()
at: time
time() -> float
|
aioquic.connection/QuicConnection._handle_ack_frame
|
Modified
|
aiortc~aioquic
|
a0c114714f333565f8b577ca4b22640d0eacfe4c
|
[connection] explicitly import packet helpers
|
<6>:<add> rangeset, ack_delay_encoded = pull_ack_frame(buf)
<del> rangeset, ack_delay_encoded = packet.pull_ack_frame(buf)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle an ACK frame.
<2> """
<3> ack_time = time.time()
<4> space = self.spaces[context.epoch]
<5>
<6> rangeset, ack_delay_encoded = packet.pull_ack_frame(buf)
<7> if frame_type == QuicFrameType.ACK_ECN:
<8> pull_uint_var(buf)
<9> pull_uint_var(buf)
<10> pull_uint_var(buf)
<11>
<12> # trigger callbacks
<13> largest_newly_acked = None
<14> largest_send_time = None
<15> handlers = space.delivery_handlers
<16> timestamps = space.timestamps
<17> for packet_range in rangeset:
<18> for packet_number in packet_range:
<19> if packet_number in handlers:
<20> # newly ack'd
<21> for handler, args in handlers[packet_number]:
<22> handler(QuicDeliveryState.ACKED, *args)
<23> del handlers[packet_number]
<24> largest_newly_acked = packet_number
<25> largest_send_time = timestamps.pop(packet_number)
<26>
<27> # update RTT estimate
<28> if largest_newly_acked is not None:
<29> self._loss.ack_received(
<30> largest_newly_acked=largest_newly_acked,
<31> latest_rtt=ack_time - largest_send_time,
<32> ack_delay_encoded=ack_delay_encoded,
<33> )
<34>
<35> # check for loss
<36> self._loss.detect_loss(space)
<37>
|
===========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)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
at: 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.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.connection.QuicConnection._send_pending
self.packet_number = builder.packet_number
at: aioquic.connection.QuicPacketSpace.__init__
self.delivery_handlers: Dict[int, List[Tuple[QuicDeliveryHandler, Any]]] = {}
self.timestamps: Dict[int, float] = {}
at: aioquic.connection.QuicReceiveContext
epoch: tls.Epoch
host_cid: bytes
network_path: QuicNetworkPath
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
at: aioquic.packet
QuicDeliveryState()
pull_uint_var(buf: Buffer) -> int
===========unchanged ref 1===========
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.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: time
time() -> float
at: typing.MutableMapping
pop(key: _KT) -> _VT
pop(key: _KT, default: Union[_VT, _T]=...) -> Union[_VT, _T]
|
aioquic.connection/QuicConnection._handle_connection_close_frame
|
Modified
|
aiortc~aioquic
|
a0c114714f333565f8b577ca4b22640d0eacfe4c
|
[connection] explicitly import packet helpers
|
<4>:<add> error_code, frame_type, reason_phrase = pull_transport_close_frame(buf)
<del> error_code, frame_type, reason_phrase = packet.pull_transport_close_frame(
<5>:<del> buf
<6>:<del> )
<8>:<add> error_code, reason_phrase = pull_application_close_frame(buf)
<del> error_code, reason_phrase = packet.pull_application_close_frame(buf)
|
# module: aioquic.connection
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 = packet.pull_transport_close_frame(
<5> buf
<6> )
<7> else:
<8> error_code, reason_phrase = packet.pull_application_close_frame(buf)
<9> frame_type = None
<10> self._logger.info(
<11> "Connection close code 0x%X, reason %s", error_code, reason_phrase
<12> )
<13> self._set_state(QuicConnectionState.DRAINING)
<14> self.connection_lost(
<15> maybe_connection_error(
<16> error_code=error_code,
<17> frame_type=frame_type,
<18> reason_phrase=reason_phrase,
<19> )
<20> )
<21>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionState()
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath)
at: aioquic.connection.QuicConnection
connection_lost(exc: Exception) -> None
_set_state(state: QuicConnectionState) -> None
at: aioquic.connection.QuicConnection.__init__
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketLoss()
at: aioquic.connection.QuicConnection._handle_ack_frame
ack_time = time.time()
space = self.spaces[context.epoch]
rangeset, ack_delay_encoded = pull_ack_frame(buf)
largest_newly_acked = packet_number
largest_newly_acked = None
largest_send_time = None
largest_send_time = timestamps.pop(packet_number)
at: aioquic.connection.QuicPacketLoss
detect_loss(space: QuicPacketSpace) -> None
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_transport_close_frame(buf: Buffer) -> Tuple[int, int, str]
pull_application_close_frame(buf: Buffer) -> Tuple[int, str]
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 _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle an ACK frame.
"""
ack_time = time.time()
space = self.spaces[context.epoch]
+ rangeset, ack_delay_encoded = pull_ack_frame(buf)
- rangeset, ack_delay_encoded = packet.pull_ack_frame(buf)
if frame_type == QuicFrameType.ACK_ECN:
pull_uint_var(buf)
pull_uint_var(buf)
pull_uint_var(buf)
# trigger callbacks
largest_newly_acked = None
largest_send_time = None
handlers = space.delivery_handlers
timestamps = space.timestamps
for packet_range in rangeset:
for packet_number in packet_range:
if packet_number in handlers:
# newly ack'd
for handler, args in handlers[packet_number]:
handler(QuicDeliveryState.ACKED, *args)
del handlers[packet_number]
largest_newly_acked = packet_number
largest_send_time = timestamps.pop(packet_number)
# update RTT estimate
if largest_newly_acked is not None:
self._loss.ack_received(
largest_newly_acked=largest_newly_acked,
latest_rtt=ack_time - largest_send_time,
ack_delay_encoded=ack_delay_encoded,
)
# check for loss
self._loss.detect_loss(space)
|
aioquic.connection/QuicConnection._handle_crypto_frame
|
Modified
|
aiortc~aioquic
|
a0c114714f333565f8b577ca4b22640d0eacfe4c
|
[connection] explicitly import packet helpers
|
<4>:<add> stream.add_frame(pull_crypto_frame(buf))
<del> stream.add_frame(packet.pull_crypto_frame(buf))
|
# module: aioquic.connection
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.streams[context.epoch]
<4> stream.add_frame(packet.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.send_buffer)
<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 self.__epoch == tls.Epoch.HANDSHAKE and self.tls.state in [
<35> tls.State.CLIENT_POST_HANDSHAKE,
<36> tls.State.SERVER_POST_HANDSHAKE,
<37> ]:
<38> self._replenish_connection_ids()
<39> self.__epoch = tls.Epoch.ONE_RTT
<40> # wakeup waiter
<41> if not self.__connected.is</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
# offset: 1
self.__connected.set()
elif self.__epoch == tls.Epoch.INITIAL:
self.__epoch = tls.Epoch.HANDSHAKE
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath)
at: aioquic.connection.QuicConnection
_replenish_connection_ids() -> None
_push_crypto_data() -> None
_parse_transport_parameters(data: bytes, from_session_ticket: bool=False) -> None
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__epoch = tls.Epoch.INITIAL
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._parameters_received = False
at: aioquic.connection.QuicConnection._handle_connection_close_frame
error_code, frame_type, reason_phrase = pull_transport_close_frame(buf)
error_code, reason_phrase = pull_application_close_frame(buf)
error_code, frame_type, reason_phrase = pull_transport_close_frame(buf)
frame_type = None
error_code, frame_type, reason_phrase = pull_transport_close_frame(buf)
error_code, reason_phrase = pull_application_close_frame(buf)
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
===========unchanged ref 1===========
self.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
at: aioquic.connection.QuicReceiveContext
epoch: tls.Epoch
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)
pull_crypto_frame(buf: Buffer) -> QuicStreamFrame
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
pull_data() -> bytes
at: aioquic.tls
Alert(*args: object)
Epoch()
State()
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls.Alert
description: AlertDescription
at: aioquic.tls.Context
handle_message(input_data: bytes, output_buf: Dict[Epoch, Buffer]) -> None
at: aioquic.tls.Context.__init__
self.received_extensions: Optional[List[Extension]] = None
self.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: aioquic.tls.Context._client_handle_encrypted_extensions
self.received_extensions = encrypted_extensions.other_extensions
at: aioquic.tls.Context._server_handle_hello
self.received_extensions = peer_hello.other_extensions
===========unchanged ref 2===========
at: aioquic.tls.Context._set_state
self.state = state
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 _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)
- error_code, frame_type, reason_phrase = packet.pull_transport_close_frame(
- buf
- )
else:
+ error_code, reason_phrase = pull_application_close_frame(buf)
- error_code, reason_phrase = packet.pull_application_close_frame(buf)
frame_type = None
self._logger.info(
"Connection close code 0x%X, reason %s", error_code, reason_phrase
)
self._set_state(QuicConnectionState.DRAINING)
self.connection_lost(
maybe_connection_error(
error_code=error_code,
frame_type=frame_type,
reason_phrase=reason_phrase,
)
)
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle an ACK frame.
"""
ack_time = time.time()
space = self.spaces[context.epoch]
+ rangeset, ack_delay_encoded = pull_ack_frame(buf)
- rangeset, ack_delay_encoded = packet.pull_ack_frame(buf)
if frame_type == QuicFrameType.ACK_ECN:
pull_uint_var(buf)
pull_uint_var(buf)
pull_uint_var(buf)
# trigger callbacks
largest_newly_acked = None
largest_send_time = None
handlers = space.delivery_handlers
timestamps = space.timestamps
for packet_range in rangeset:
for packet_number in packet_range:
if packet_number in handlers:
# newly ack'd
for handler, args in handlers[packet_number]:
handler(QuicDeliveryState.ACKED, *args)
del handlers[packet_number]
largest_newly_acked = packet_number
largest_send_time = timestamps.pop(packet_number)
# update RTT estimate
if largest_newly_acked is not None:
self._loss.ack_received(
largest_newly_acked=largest_newly_acked,
latest_rtt=ack_time - largest_send_time,
ack_delay_encoded=ack_delay_encoded,
)
# check for loss
self._loss.detect_loss(space)
|
aioquic.connection/QuicConnection._handle_new_connection_id_frame
|
Modified
|
aiortc~aioquic
|
a0c114714f333565f8b577ca4b22640d0eacfe4c
|
[connection] explicitly import packet helpers
|
<3>:<add> sequence_number, cid, stateless_reset_token = pull_new_connection_id_frame(buf)
<del> sequence_number, cid, stateless_reset_token = packet.pull_new_connection_id_frame(
<4>:<del> buf
<5>:<del> )
|
# 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 = packet.pull_new_connection_id_frame(
<4> buf
<5> )
<6> self._logger.info(
<7> "New connection ID received %d %s", sequence_number, dump_cid(cid)
<8> )
<9> self._peer_cid_available.append(
<10> QuicConnectionId(
<11> cid=cid,
<12> sequence_number=sequence_number,
<13> stateless_reset_token=stateless_reset_token,
<14> )
<15> )
<16>
|
===========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)
at: aioquic.connection.QuicConnection.__init__
self._peer_cid_available: List[QuicConnectionId] = []
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._remote_max_streams_uni = 0
at: aioquic.connection.QuicConnectionId
cid: bytes
sequence_number: int
stateless_reset_token: bytes = b""
was_sent: bool = False
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
pull_new_connection_id_frame(buf: Buffer) -> Tuple[int, bytes, bytes]
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 _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)
- error_code, frame_type, reason_phrase = packet.pull_transport_close_frame(
- buf
- )
else:
+ error_code, reason_phrase = pull_application_close_frame(buf)
- error_code, reason_phrase = packet.pull_application_close_frame(buf)
frame_type = None
self._logger.info(
"Connection close code 0x%X, reason %s", error_code, reason_phrase
)
self._set_state(QuicConnectionState.DRAINING)
self.connection_lost(
maybe_connection_error(
error_code=error_code,
frame_type=frame_type,
reason_phrase=reason_phrase,
)
)
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle an ACK frame.
"""
ack_time = time.time()
space = self.spaces[context.epoch]
+ rangeset, ack_delay_encoded = pull_ack_frame(buf)
- rangeset, ack_delay_encoded = packet.pull_ack_frame(buf)
if frame_type == QuicFrameType.ACK_ECN:
pull_uint_var(buf)
pull_uint_var(buf)
pull_uint_var(buf)
# trigger callbacks
largest_newly_acked = None
largest_send_time = None
handlers = space.delivery_handlers
timestamps = space.timestamps
for packet_range in rangeset:
for packet_number in packet_range:
if packet_number in handlers:
# newly ack'd
for handler, args in handlers[packet_number]:
handler(QuicDeliveryState.ACKED, *args)
del handlers[packet_number]
largest_newly_acked = packet_number
largest_send_time = timestamps.pop(packet_number)
# update RTT estimate
if largest_newly_acked is not None:
self._loss.ack_received(
largest_newly_acked=largest_newly_acked,
latest_rtt=ack_time - largest_send_time,
ack_delay_encoded=ack_delay_encoded,
)
# check for loss
self._loss.detect_loss(space)
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a CRYPTO frame.
"""
stream = self.streams[context.epoch]
+ stream.add_frame(pull_crypto_frame(buf))
- stream.add_frame(packet.pull_crypto_frame(buf))
data = stream.pull_data()
if data:
# pass data to TLS layer
try:
self.tls.handle_message(data, self.send_buffer)
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 self.__epoch == tls.Epoch.HANDSHAKE and self.tls.state in [
tls.State.CLIENT_POST_HANDSHAKE,
tls.State.SERVER_POST_HANDSHAKE,
]:
self._replenish_connection_ids()
self.__epoch = tls.Epoch.ONE_RTT
# wakeup waiter
if not self.__connected.is_set():
self.__connected.set()
elif self.__epoch == tls.Epoch.INITIAL:</s>
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
# offset: 1
<s> not self.__connected.is_set():
self.__connected.set()
elif self.__epoch == tls.Epoch.INITIAL:
self.__epoch = tls.Epoch.HANDSHAKE
|
aioquic.connection/QuicConnection._handle_new_token_frame
|
Modified
|
aiortc~aioquic
|
a0c114714f333565f8b577ca4b22640d0eacfe4c
|
[connection] explicitly import packet helpers
|
<3>:<add> pull_new_token_frame(buf)
<del> packet.pull_new_token_frame(buf)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_new_token_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a NEW_TOKEN frame.
<2> """
<3> packet.pull_new_token_frame(buf)
<4>
|
===========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)
at: aioquic.connection.QuicConnection._handle_new_connection_id_frame
sequence_number, cid, stateless_reset_token = pull_new_connection_id_frame(buf)
===========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)
- sequence_number, cid, stateless_reset_token = packet.pull_new_connection_id_frame(
- buf
- )
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_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)
- error_code, frame_type, reason_phrase = packet.pull_transport_close_frame(
- buf
- )
else:
+ error_code, reason_phrase = pull_application_close_frame(buf)
- error_code, reason_phrase = packet.pull_application_close_frame(buf)
frame_type = None
self._logger.info(
"Connection close code 0x%X, reason %s", error_code, reason_phrase
)
self._set_state(QuicConnectionState.DRAINING)
self.connection_lost(
maybe_connection_error(
error_code=error_code,
frame_type=frame_type,
reason_phrase=reason_phrase,
)
)
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle an ACK frame.
"""
ack_time = time.time()
space = self.spaces[context.epoch]
+ rangeset, ack_delay_encoded = pull_ack_frame(buf)
- rangeset, ack_delay_encoded = packet.pull_ack_frame(buf)
if frame_type == QuicFrameType.ACK_ECN:
pull_uint_var(buf)
pull_uint_var(buf)
pull_uint_var(buf)
# trigger callbacks
largest_newly_acked = None
largest_send_time = None
handlers = space.delivery_handlers
timestamps = space.timestamps
for packet_range in rangeset:
for packet_number in packet_range:
if packet_number in handlers:
# newly ack'd
for handler, args in handlers[packet_number]:
handler(QuicDeliveryState.ACKED, *args)
del handlers[packet_number]
largest_newly_acked = packet_number
largest_send_time = timestamps.pop(packet_number)
# update RTT estimate
if largest_newly_acked is not None:
self._loss.ack_received(
largest_newly_acked=largest_newly_acked,
latest_rtt=ack_time - largest_send_time,
ack_delay_encoded=ack_delay_encoded,
)
# check for loss
self._loss.detect_loss(space)
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a CRYPTO frame.
"""
stream = self.streams[context.epoch]
+ stream.add_frame(pull_crypto_frame(buf))
- stream.add_frame(packet.pull_crypto_frame(buf))
data = stream.pull_data()
if data:
# pass data to TLS layer
try:
self.tls.handle_message(data, self.send_buffer)
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 self.__epoch == tls.Epoch.HANDSHAKE and self.tls.state in [
tls.State.CLIENT_POST_HANDSHAKE,
tls.State.SERVER_POST_HANDSHAKE,
]:
self._replenish_connection_ids()
self.__epoch = tls.Epoch.ONE_RTT
# wakeup waiter
if not self.__connected.is_set():
self.__connected.set()
elif self.__epoch == tls.Epoch.INITIAL:</s>
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
# offset: 1
<s> not self.__connected.is_set():
self.__connected.set()
elif self.__epoch == tls.Epoch.INITIAL:
self.__epoch = tls.Epoch.HANDSHAKE
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
a0c114714f333565f8b577ca4b22640d0eacfe4c
|
[connection] explicitly import packet helpers
|
<22>:<add> push_ack_frame(buf, space.ack_queue, 0)
<del> packet.push_ack_frame(buf, space.ack_queue, 0)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
<0> crypto_stream_id: Optional[tls.Epoch] = None
<1> if self.cryptos[tls.Epoch.ONE_RTT].send.is_valid():
<2> crypto = self.cryptos[tls.Epoch.ONE_RTT]
<3> crypto_stream_id = 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> is_one_rtt = self.__epoch == tls.Epoch.ONE_RTT
<12>
<13> buf = builder.buffer
<14> while True:
<15> # write header
<16> builder.start_packet(packet_type, crypto)
<17>
<18> if is_one_rtt:
<19> # ACK
<20> if space.ack_required and space.ack_queue:
<21> builder.start_frame(QuicFrameType.ACK)
<22> packet.push_ack_frame(buf, space.ack_queue, 0)
<23> space.ack_required = False
<24>
<25> # PATH CHALLENGE
<26> if (
<27> not network_path.is_validated
<28> and network_path.local_challenge is None
<29> ):
<30> self._logger.info(
<31> "Network path %s sending challenge", network_path.addr
<32> )
<33> network_path.local_challenge = os.urandom(8)
<34> builder.start_frame(QuicFrameType.PATH_CHALLENGE)
<35> push_bytes(buf, network_path.local_challenge)
<36>
<37> # PATH</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 1
if network_path.remote_challenge is not None:
builder.start_frame(QuicFrameType.PATH_RESPONSE)
push_bytes(buf, 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)
packet.push_new_connection_id_frame(
buf,
connection_id.sequence_number,
connection_id.cid,
connection_id.stateless_reset_token,
)
connection_id.was_sent = True
space.expect_ack(
builder.packet_number,
self._on_new_connection_id_delivery,
(connection_id,),
)
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)
push_uint_var(buf, sequence_number)
space.expect_ack(
builder.packet_number,
self._on_retire_connection_id_delivery,
(sequence_number,),
)
# connection-level limits
self._write_connection_limits(builder=builder, space=space)
# stream-level limits
for stream_id, stream in self.streams.items():
if isinstance(stream_id, int):
self._write_stream_limits(
builder=builder, space=space, stream=stream
)
# PING
if self._ping</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 2
<s>limits(
builder=builder, space=space, stream=stream
)
# PING
if self._ping_pending:
self._logger.info("Sending PING in packet %d", builder.packet_number)
builder.start_frame(QuicFrameType.PING)
space.expect_ack(builder.packet_number, self._on_ping_delivery)
self._ping_pending = False
for stream_id, stream in self.streams.items():
# CRYPTO
if stream_id == crypto_stream_id:
write_crypto_frame(builder=builder, space=space, stream=stream)
# STREAM
elif isinstance(stream_id, int):
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
push_bytes(buf: Buffer, v: bytes) -> 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_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.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__epoch = tls.Epoch.INITIAL
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._ping_pending = False
self._remote_max_data = 0
self._remote_max_data_used = 0
===========unchanged ref 1===========
self._retire_connection_ids: List[int] = []
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._handle_max_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.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._update_traffic_key
crypto = self.cryptos[epoch]
at: aioquic.connection.QuicConnection.ping
self._ping_pending = True
at: aioquic.connection.QuicConnectionId
cid: bytes
sequence_number: int
stateless_reset_token: bytes = b""
was_sent: bool = False
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.QuicPacketSpace
expect_ack(packet_number: int, handler: QuicDeliveryHandler, args: Sequence[Any]=[]) -> None
|
aioquic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
a0c114714f333565f8b577ca4b22640d0eacfe4c
|
[connection] explicitly import packet helpers
|
<17>:<add> push_ack_frame(buf, space.ack_queue, 0)
<del> packet.push_ack_frame(buf, space.ack_queue, 0)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
<0> crypto = self.cryptos[epoch]
<1> space = self.spaces[epoch]
<2> if not crypto.send.is_valid():
<3> return
<4>
<5> buf = builder.buffer
<6>
<7> while True:
<8> if epoch == tls.Epoch.INITIAL:
<9> packet_type = PACKET_TYPE_INITIAL
<10> else:
<11> packet_type = PACKET_TYPE_HANDSHAKE
<12> builder.start_packet(packet_type, crypto)
<13>
<14> # ACK
<15> if space.ack_required and space.ack_queue:
<16> builder.start_frame(QuicFrameType.ACK)
<17> packet.push_ack_frame(buf, space.ack_queue, 0)
<18> space.ack_required = False
<19>
<20> # CRYPTO
<21> write_crypto_frame(builder=builder, space=space, stream=self.streams[epoch])
<22>
<23> if not builder.end_packet():
<24> break
<25>
<26> # discard initial keys
<27> if self.is_client and epoch == tls.Epoch.HANDSHAKE:
<28> self.cryptos[tls.Epoch.INITIAL].teardown()
<29>
|
===========unchanged ref 0===========
at: aioquic.connection
write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
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.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
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
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) -> None
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
===========unchanged ref 1===========
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 _handle_new_token_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a NEW_TOKEN frame.
"""
+ pull_new_token_frame(buf)
- packet.pull_new_token_frame(buf)
===========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)
- sequence_number, cid, stateless_reset_token = packet.pull_new_connection_id_frame(
- buf
- )
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_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)
- error_code, frame_type, reason_phrase = packet.pull_transport_close_frame(
- buf
- )
else:
+ error_code, reason_phrase = pull_application_close_frame(buf)
- error_code, reason_phrase = packet.pull_application_close_frame(buf)
frame_type = None
self._logger.info(
"Connection close code 0x%X, reason %s", error_code, reason_phrase
)
self._set_state(QuicConnectionState.DRAINING)
self.connection_lost(
maybe_connection_error(
error_code=error_code,
frame_type=frame_type,
reason_phrase=reason_phrase,
)
)
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle an ACK frame.
"""
ack_time = time.time()
space = self.spaces[context.epoch]
+ rangeset, ack_delay_encoded = pull_ack_frame(buf)
- rangeset, ack_delay_encoded = packet.pull_ack_frame(buf)
if frame_type == QuicFrameType.ACK_ECN:
pull_uint_var(buf)
pull_uint_var(buf)
pull_uint_var(buf)
# trigger callbacks
largest_newly_acked = None
largest_send_time = None
handlers = space.delivery_handlers
timestamps = space.timestamps
for packet_range in rangeset:
for packet_number in packet_range:
if packet_number in handlers:
# newly ack'd
for handler, args in handlers[packet_number]:
handler(QuicDeliveryState.ACKED, *args)
del handlers[packet_number]
largest_newly_acked = packet_number
largest_send_time = timestamps.pop(packet_number)
# update RTT estimate
if largest_newly_acked is not None:
self._loss.ack_received(
largest_newly_acked=largest_newly_acked,
latest_rtt=ack_time - largest_send_time,
ack_delay_encoded=ack_delay_encoded,
)
# check for loss
self._loss.detect_loss(space)
|
aioquic.packet_builder/QuicPacketBuilder.__init__
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
<7>:<add> # assembled datagrams and packets
<del> # assembled datagrams
<10>:<add> self._packets: List[QuicSentPacket] = []
<14>:<add> self._packet: Optional[QuicSentPacket] = None
|
# 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
<8> self._ack_eliciting = False
<9> self._datagrams: List[bytes] = []
<10>
<11> # current packet
<12> self._crypto: Optional[CryptoPair] = None
<13> self._header_size = 0
<14> self._packet_number = packet_number
<15> self._packet_start = 0
<16> self._packet_type = 0
<17>
<18> self.buffer = Buffer(PACKET_MAX_SIZE)
<19>
|
===========unchanged ref 0===========
at: aioquic.tls
Epoch()
at: dataclasses
field(*, default_factory: Callable[[], _T], init: bool=..., repr: bool=..., hash: Optional[bool]=..., compare: bool=..., metadata: Optional[Mapping[str, Any]]=...) -> _T
field(*, init: bool=..., repr: bool=..., hash: Optional[bool]=..., compare: bool=..., metadata: Optional[Mapping[str, Any]]=...) -> Any
field(*, default: _T, init: bool=..., repr: bool=..., hash: Optional[bool]=..., compare: bool=..., metadata: Optional[Mapping[str, Any]]=...) -> _T
dataclass(*, init: bool=..., repr: bool=..., eq: bool=..., order: bool=..., unsafe_hash: bool=..., frozen: bool=...) -> Callable[[Type[_T]], Type[_T]]
dataclass(_cls: None) -> Callable[[Type[_T]], Type[_T]]
dataclass(_cls: Type[_T]) -> Type[_T]
at: enum
Enum()
at: typing
Callable = _CallableType(collections.abc.Callable, 2)
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: aioquic.packet_builder
+ class QuicDeliveryState(Enum):
+ ACKED = 0
+ LOST = 1
+ EXPIRED = 2
+
===========changed ref 1===========
# module: aioquic.packet_builder
+ @dataclass
+ class QuicSentPacket:
+ epoch: Epoch
+ 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 2===========
# module: aioquic.packet
- class QuicDeliveryState(Enum):
- ACKED = 0
- LOST = 1
- EXPIRED = 2
-
|
aioquic.packet_builder/QuicPacketBuilder.flush
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
<5>:<add> packets = self._packets
<6>:<add> self._packets = []
<add> return datagrams, packets
<del> return datagrams
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
- def flush(self) -> List[bytes]:
<0> """
<1> Returns the assembled datagrams.
<2> """
<3> self._flush_current_datagram()
<4> datagrams = self._datagrams
<5> self._datagrams = []
<6> return datagrams
<7>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.packet_builder
PACKET_MAX_SIZE = 1280
QuicSentPacket(epoch: Epoch, 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.end_packet
self._packet_number += 1
self._packet = None
at: aioquic.packet_builder.QuicPacketBuilder.start_packet
self._packet = QuicSentPacket(
epoch=epoch,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_start = buf.tell()
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
===========changed ref 0===========
# module: aioquic.packet_builder
+ @dataclass
+ class QuicSentPacket:
+ epoch: Epoch
+ 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 1===========
# module: aioquic.packet_builder
+ class QuicDeliveryState(Enum):
+ ACKED = 0
+ LOST = 1
+ EXPIRED = 2
+
===========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._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
- # assembled datagrams
self._ack_eliciting = False
self._datagrams: List[bytes] = []
+ self._packets: List[QuicSentPacket] = []
# current packet
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
+ self._packet: Optional[QuicSentPacket] = None
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
===========changed ref 3===========
# module: aioquic.packet
- class QuicDeliveryState(Enum):
- ACKED = 0
- LOST = 1
- EXPIRED = 2
-
|
aioquic.packet_builder/QuicPacketBuilder.start_frame
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
<5>:<add> self._packet.is_ack_eliciting = True
<6>:<add> if frame_type == QuicFrameType.CRYPTO:
<add> self._packet.is_crypto_packet = True
<add> if handler is not None:
<add> self._packet.delivery_handlers.append((handler, args))
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def start_frame(
+ self,
+ frame_type: int,
+ handler: Optional[QuicDeliveryHandler] = None,
+ args: Sequence[Any] = [],
+ ) -> None:
- def start_frame(self, frame_type: int) -> None:
<0> """
<1> Starts a new frame.
<2> """
<3> push_uint_var(self.buffer, frame_type)
<4> if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
<5> self._ack_eliciting = True
<6>
|
===========unchanged ref 0===========
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._ack_eliciting = False
at: aioquic.packet_builder.QuicPacketBuilder.start_frame
self._ack_eliciting = True
===========changed ref 0===========
# module: aioquic.packet_builder
+ class QuicDeliveryState(Enum):
+ ACKED = 0
+ LOST = 1
+ EXPIRED = 2
+
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
- def flush(self) -> List[bytes]:
"""
Returns the assembled datagrams.
"""
self._flush_current_datagram()
datagrams = self._datagrams
+ packets = self._packets
self._datagrams = []
+ self._packets = []
+ return datagrams, packets
- return datagrams
===========changed ref 2===========
# module: aioquic.packet_builder
+ @dataclass
+ class QuicSentPacket:
+ epoch: Epoch
+ 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 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._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
- # assembled datagrams
self._ack_eliciting = False
self._datagrams: List[bytes] = []
+ self._packets: List[QuicSentPacket] = []
# current packet
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
+ self._packet: Optional[QuicSentPacket] = None
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
===========changed ref 4===========
# module: aioquic.packet
- class QuicDeliveryState(Enum):
- ACKED = 0
- LOST = 1
- EXPIRED = 2
-
|
aioquic.packet_builder/QuicPacketBuilder.start_packet
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
<10>:<add> # determine ack epoch
<add> if packet_type == PACKET_TYPE_INITIAL:
<add> epoch = Epoch.INITIAL
<add> elif packet_type == PACKET_TYPE_HANDSHAKE:
<add> epoch = Epoch.HANDSHAKE
<add> else:
<add> epoch = Epoch.ONE_RTT
<add>
<add> self._packet = QuicSentPacket(
<add> epoch=epoch,
<add> is_ack_eliciting=False,
<add> is_crypto_packet=False,
<add> packet_number=self._packet_number,
<add> )
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
<0> """
<1> Starts a new packet.
<2> """
<3> buf = self.buffer
<4>
<5> # if there is too little space remaining, start a new datagram
<6> # FIXME: the limit is arbitrary!
<7> if buf.capacity - buf.tell() < 128:
<8> self._flush_current_datagram()
<9>
<10> self._packet_start = buf.tell()
<11>
<12> # write header
<13> if is_long_header(packet_type):
<14> push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
<15> push_uint32(buf, self._version)
<16> push_uint8(
<17> buf,
<18> (encode_cid_length(len(self._peer_cid)) << 4)
<19> | encode_cid_length(len(self._host_cid)),
<20> )
<21> push_bytes(buf, self._peer_cid)
<22> push_bytes(buf, self._host_cid)
<23> if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
<24> push_uint_var(buf, len(self._peer_token))
<25> push_bytes(buf, self._peer_token)
<26> push_uint16(buf, 0) # length
<27> push_packet_number(buf, 0) # packet number
<28> else:
<29> push_uint8(
<30> buf,
<31> packet_type
<32> | (self._spin_bit << 5)
<33> | (crypto.key_phase << 2)
<34> | (PACKET_NUMBER_SEND_SIZE - 1),
<35> )
<36> push_bytes(buf, self._peer_cid)
<37> push_packet_number(buf, self._packet_number)
<38>
<39> self._crypto = crypto
<40> self._header_size = buf.tell() - self._packet_start
<41> </s>
|
===========below chunk 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
===========unchanged ref 0===========
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.crypto
CryptoPair()
at: aioquic.crypto.CryptoPair.__init__
self.aead_tag_size = 16
at: aioquic.packet
push_uint_var(buf: Buffer, value: int) -> None
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
NON_ACK_ELICITING_FRAME_TYPES = frozenset(
[QuicFrameType.ACK, QuicFrameType.ACK_ECN, QuicFrameType.PADDING]
)
at: aioquic.packet_builder
QuicDeliveryHandler = Callable[..., None]
QuicSentPacket(epoch: Epoch, 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() -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._ack_eliciting = False
self._datagrams: List[bytes] = []
self._packets: List[QuicSentPacket] = []
self._crypto: Optional[CryptoPair] = None
self._packet: Optional[QuicSentPacket] = None
self._packet_number = packet_number
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.packet_builder.QuicPacketBuilder.end_packet
self._packet_number += 1
self._crypto = None
self._packet = None
===========unchanged ref 1===========
at: aioquic.packet_builder.QuicPacketBuilder.start_packet
self._packet = QuicSentPacket(
epoch=epoch,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._crypto = crypto
at: aioquic.packet_builder.QuicSentPacket
is_ack_eliciting: bool
is_crypto_packet: bool
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: typing
Sequence = _alias(collections.abc.Sequence, 1)
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: aioquic.packet_builder
+ @dataclass
+ class QuicSentPacket:
+ epoch: Epoch
+ 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 1===========
# module: aioquic.packet_builder
+ class QuicDeliveryState(Enum):
+ ACKED = 0
+ LOST = 1
+ EXPIRED = 2
+
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
- def flush(self) -> List[bytes]:
"""
Returns the assembled datagrams.
"""
self._flush_current_datagram()
datagrams = self._datagrams
+ packets = self._packets
self._datagrams = []
+ self._packets = []
+ return datagrams, packets
- return datagrams
===========changed ref 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def start_frame(
+ self,
+ frame_type: int,
+ handler: Optional[QuicDeliveryHandler] = None,
+ args: Sequence[Any] = [],
+ ) -> None:
- def start_frame(self, frame_type: int) -> None:
"""
Starts a new frame.
"""
push_uint_var(self.buffer, frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
+ self._packet.is_ack_eliciting = True
self._ack_eliciting = True
+ if frame_type == QuicFrameType.CRYPTO:
+ self._packet.is_crypto_packet = True
+ if handler is not None:
+ self._packet.delivery_handlers.append((handler, args))
===========changed ref 4===========
# 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._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
- # assembled datagrams
self._ack_eliciting = False
self._datagrams: List[bytes] = []
+ self._packets: List[QuicSentPacket] = []
# current packet
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
+ self._packet: Optional[QuicSentPacket] = None
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
===========changed ref 5===========
# module: aioquic.packet
- class QuicDeliveryState(Enum):
- ACKED = 0
- LOST = 1
- EXPIRED = 2
-
|
aioquic.packet_builder/QuicPacketBuilder.end_packet
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
# 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> push_bytes(buf, bytes(self.remaining_space))
<14> packet_size = buf.tell() - self._packet_start
<15> self._pad_first_datagram = False
<16>
<17> if is_long_header(self._packet_type):
<18> # finalize length
<19> buf.seek(
<20> self._packet_start
<21> + self._header_size
<22> - PACKET_NUMBER_SEND_SIZE
<23> - PACKET_LENGTH_SEND_SIZE
<24> )
<25> length = (
<26> packet_size
<27> - self._header_size
<28> + PACKET_NUMBER_SEND_SIZE
<29> + self._crypto.aead_tag_size
<30> )
<31> push_uint16(buf, length | 0x4000)
<32> push_packet_number(buf, self._packet_number)
<33> buf.seek(packet_size)
<34> else:
<35> # check whether we need padding
<36> padding_size = (
<37> PACKET_NUMBER_MAX_SIZE
<38> - PACKET_NUMBER_SEND_SIZE
<39> + self._header_size
<40> - packet_size
<41> )
<42> if padding_size > 0:
<43> push_bytes(buf, bytes(padding_size))
<44> packet_size += padding_size
<45>
<46> # encrypt in place
<47> plain = buf.data_slice(self._packet_start, self._packet_start + packet_size)
<48> buf.seek(self._packet_start)
</s>
|
===========below chunk 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
# offset: 1
buf,
self._crypto.encrypt_packet(
plain[0 : self._header_size], plain[self._header_size : packet_size]
),
)
# 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._crypto = None
return not empty
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint8(buf: Buffer, v: int) -> None
push_uint16(buf: Buffer, v: int) -> None
push_uint32(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
tell() -> int
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
encode_cid_length(length: int) -> int
is_long_header(first_byte: int) -> bool
push_uint_var(buf: Buffer, value: int) -> None
at: aioquic.packet_builder
PACKET_NUMBER_SEND_SIZE = 2
push_packet_number(buf: Buffer, packet_number: int) -> None
QuicSentPacket(epoch: Epoch, 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() -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._host_cid = host_cid
self._peer_cid = peer_cid
self._peer_token = peer_token
self._spin_bit = spin_bit
self._version = version
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_number = packet_number
===========unchanged ref 1===========
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._crypto = None
self._packet = None
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.packet_builder
+ @dataclass
+ class QuicSentPacket:
+ epoch: Epoch
+ 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 1===========
# module: aioquic.packet_builder
+ class QuicDeliveryState(Enum):
+ ACKED = 0
+ LOST = 1
+ EXPIRED = 2
+
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
- def flush(self) -> List[bytes]:
"""
Returns the assembled datagrams.
"""
self._flush_current_datagram()
datagrams = self._datagrams
+ packets = self._packets
self._datagrams = []
+ self._packets = []
+ return datagrams, packets
- return datagrams
===========changed ref 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def start_frame(
+ self,
+ frame_type: int,
+ handler: Optional[QuicDeliveryHandler] = None,
+ args: Sequence[Any] = [],
+ ) -> None:
- def start_frame(self, frame_type: int) -> None:
"""
Starts a new frame.
"""
push_uint_var(self.buffer, frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
+ self._packet.is_ack_eliciting = True
self._ack_eliciting = True
+ if frame_type == QuicFrameType.CRYPTO:
+ self._packet.is_crypto_packet = True
+ if handler is not None:
+ self._packet.delivery_handlers.append((handler, args))
===========changed ref 4===========
# 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._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
- # assembled datagrams
self._ack_eliciting = False
self._datagrams: List[bytes] = []
+ self._packets: List[QuicSentPacket] = []
# current packet
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
+ self._packet: Optional[QuicSentPacket] = None
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
|
|
aioquic.connection/write_crypto_frame
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
<3>:<add> builder.start_frame(
<add> QuicFrameType.CRYPTO,
<add> stream.on_data_delivery,
<add> (frame.offset, frame.offset + len(frame.data)),
<add> )
<del> builder.start_frame(QuicFrameType.CRYPTO)
<7>:<del> space.expect_ack(
<8>:<del> builder.packet_number,
<9>:<del> stream.on_data_delivery,
<10>:<del> (frame.offset, frame.offset + len(frame.data)),
<11>:<del> )
|
# module: aioquic.connection
def write_crypto_frame(
builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
<0> frame_overhead = 3 + quic_uint_length(stream.next_send_offset)
<1> frame = stream.get_frame(builder.remaining_space - frame_overhead)
<2> if frame is not None:
<3> builder.start_frame(QuicFrameType.CRYPTO)
<4> push_uint_var(builder.buffer, frame.offset)
<5> push_uint16(builder.buffer, len(frame.data) | 0x4000)
<6> push_bytes(builder.buffer, frame.data)
<7> space.expect_ack(
<8> builder.packet_number,
<9> stream.on_data_delivery,
<10> (frame.offset, frame.offset + len(frame.data)),
<11> )
<12>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.connection.write_crypto_frame
frame_overhead = 3 + quic_uint_length(stream.next_send_offset)
at: aioquic.loss
QuicPacketSpace()
at: aioquic.packet
push_uint_var(buf: Buffer, value: int) -> None
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
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.stream.QuicStream
get_frame(max_size: int, max_offset: Optional[int]=None) -> Optional[QuicStreamFrame]
on_data_delivery(delivery: QuicDeliveryState, start: int, stop: int) -> None
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def start_frame(
+ self,
+ frame_type: int,
+ handler: Optional[QuicDeliveryHandler] = None,
+ args: Sequence[Any] = [],
+ ) -> None:
- def start_frame(self, frame_type: int) -> None:
"""
Starts a new frame.
"""
push_uint_var(self.buffer, frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
+ self._packet.is_ack_eliciting = True
self._ack_eliciting = True
+ if frame_type == QuicFrameType.CRYPTO:
+ self._packet.is_crypto_packet = True
+ if handler is not None:
+ self._packet.delivery_handlers.append((handler, args))
===========changed ref 1===========
+ # module: aioquic.loss
+
+
===========changed ref 2===========
# module: aioquic.packet_builder
+ QuicDeliveryHandler = Callable[..., None]
===========changed ref 3===========
# module: aioquic.packet_builder
+ class QuicDeliveryState(Enum):
+ ACKED = 0
+ LOST = 1
+ EXPIRED = 2
+
===========changed ref 4===========
# module: aioquic.packet
- class QuicDeliveryState(Enum):
- ACKED = 0
- LOST = 1
- EXPIRED = 2
-
===========changed ref 5===========
+ # module: aioquic.loss
+ K_PACKET_THRESHOLD = 3
+ K_INITIAL_RTT = 0.5 # seconds
+ K_GRANULARITY = 0.001 # seconds
+ K_TIME_THRESHOLD = 9 / 8
+
===========changed ref 6===========
+ # module: aioquic.loss
+ class QuicPacketLoss:
+ def on_loss_timeout(self) -> None:
+ loss_space = self.get_earliest_loss_time()
+ if loss_space is not None:
+ self.detect_loss(loss_space)
+ else:
+ self._pto_count += 1
+ self._send_probe()
+
===========changed ref 7===========
+ # module: aioquic.loss
+ class QuicPacketLoss:
+ def get_earliest_loss_time(self) -> Optional[QuicPacketSpace]:
+ loss_space = None
+ for space in self.spaces:
+ if space.loss_time is not None and (
+ loss_space is None or space.loss_time < loss_space.loss_time
+ ):
+ loss_space = space
+ return loss_space
+
===========changed ref 8===========
+ # module: aioquic.loss
+ class QuicPacketLoss:
+ def on_packet_sent(self, packet: QuicSentPacket) -> None:
+ if packet.is_crypto_packet:
+ self._time_of_last_sent_crypto_packet = packet.sent_time
+ if packet.is_ack_eliciting:
+ self._time_of_last_sent_ack_eliciting_packet = packet.sent_time
+
===========changed ref 9===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
- def flush(self) -> List[bytes]:
"""
Returns the assembled datagrams.
"""
self._flush_current_datagram()
datagrams = self._datagrams
+ packets = self._packets
self._datagrams = []
+ self._packets = []
+ return datagrams, packets
- return datagrams
===========changed ref 10===========
+ # module: aioquic.loss
+ class QuicPacketSpace:
+ def __init__(self) -> None:
+ self.ack_queue = RangeSet()
+ self.ack_required = False
+ self.expected_packet_number = 0
+
+ # sent packets and loss
+ self.largest_acked_packet = 0
+ self.loss_time: Optional[float] = None
+ self.sent_packets: Dict[int, QuicSentPacket] = {}
+
===========changed ref 11===========
# module: aioquic.packet_builder
+ @dataclass
+ class QuicSentPacket:
+ epoch: Epoch
+ 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 12===========
+ # module: aioquic.loss
+ class QuicPacketLoss:
+ def __init__(
+ self, get_time: Callable[[], float], send_probe: Callable[[], None]
+ ) -> None:
+ self.ack_delay_exponent = 3
+ self.max_ack_delay = 25 # ms
+ self.spaces: List[QuicPacketSpace] = []
+
+ # callbacks
+ self._get_time = get_time
+ self._send_probe = send_probe
+
+ self._crypto_count = 0
+ self._pto_count = 0
+
+ self._rtt_initialized = False
+ self._rtt_latest = 0.0
+ self._rtt_min = math.inf
+ self._rtt_smoothed = 0.0
+ self._rtt_variance = 0.0
+
+ self._time_of_last_sent_ack_eliciting_packet = 0.0
+ self._time_of_last_sent_crypto_packet = 0.0
+
|
aioquic.connection/write_stream_frame
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
<18>:<add> builder.start_frame(
<add> QuicFrameType.STREAM_BASE | flags,
<del> builder.start_frame(QuicFrameType.STREAM_BASE | flags)
<19>:<add> stream.on_data_delivery,
<add> (frame.offset, frame.offset + len(frame.data)),
<add> )
<24>:<del> space.expect_ack(
<25>:<del> builder.packet_number,
<26>:<del> stream.on_data_delivery,
<27>:<del> (frame.offset, frame.offset + len(frame.data)),
<28>:<del> )
|
# module: aioquic.connection
def write_stream_frame(
builder: QuicPacketBuilder,
space: QuicPacketSpace,
stream: QuicStream,
max_offset: int,
) -> int:
<0> buf = builder.buffer
<1>
<2> # the frame data size is constrained by our peer's MAX_DATA and
<3> # the space available in the current packet
<4> frame_overhead = (
<5> 3
<6> + quic_uint_length(stream.stream_id)
<7> + (quic_uint_length(stream.next_send_offset) if stream.next_send_offset else 0)
<8> )
<9> previous_send_highest = stream._send_highest
<10> frame = stream.get_frame(builder.remaining_space - frame_overhead, max_offset)
<11>
<12> if frame is not None:
<13> flags = QuicStreamFlag.LEN
<14> if frame.offset:
<15> flags |= QuicStreamFlag.OFF
<16> if frame.fin:
<17> flags |= QuicStreamFlag.FIN
<18> builder.start_frame(QuicFrameType.STREAM_BASE | flags)
<19> push_uint_var(buf, stream.stream_id)
<20> if frame.offset:
<21> push_uint_var(buf, frame.offset)
<22> push_uint16(buf, len(frame.data) | 0x4000)
<23> push_bytes(buf, frame.data)
<24> space.expect_ack(
<25> builder.packet_number,
<26> stream.on_data_delivery,
<27> (frame.offset, frame.offset + len(frame.data)),
<28> )
<29> return stream._send_highest - previous_send_highest
<30> else:
<31> return 0
<32>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.packet
quic_uint_length(value: int) -> int
push_uint_var(buf: Buffer, value: int) -> None
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
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.stream.QuicStream
get_frame(max_size: int, max_offset: Optional[int]=None) -> Optional[QuicStreamFrame]
on_data_delivery(delivery: QuicDeliveryState, start: int, stop: int) -> None
at: aioquic.stream.QuicStream.__init__
self._send_highest = 0
at: aioquic.stream.QuicStream.get_frame
self._send_highest = stop
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def start_frame(
+ self,
+ frame_type: int,
+ handler: Optional[QuicDeliveryHandler] = None,
+ args: Sequence[Any] = [],
+ ) -> None:
- def start_frame(self, frame_type: int) -> None:
"""
Starts a new frame.
"""
push_uint_var(self.buffer, frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
+ self._packet.is_ack_eliciting = True
self._ack_eliciting = True
+ if frame_type == QuicFrameType.CRYPTO:
+ self._packet.is_crypto_packet = True
+ if handler is not None:
+ self._packet.delivery_handlers.append((handler, args))
===========changed ref 1===========
# module: aioquic.connection
def write_crypto_frame(
builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
frame_overhead = 3 + quic_uint_length(stream.next_send_offset)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:
+ builder.start_frame(
+ QuicFrameType.CRYPTO,
+ stream.on_data_delivery,
+ (frame.offset, frame.offset + len(frame.data)),
+ )
- builder.start_frame(QuicFrameType.CRYPTO)
push_uint_var(builder.buffer, frame.offset)
push_uint16(builder.buffer, len(frame.data) | 0x4000)
push_bytes(builder.buffer, frame.data)
- space.expect_ack(
- builder.packet_number,
- stream.on_data_delivery,
- (frame.offset, frame.offset + len(frame.data)),
- )
===========changed ref 2===========
+ # module: aioquic.loss
+
+
===========changed ref 3===========
# module: aioquic.packet_builder
+ QuicDeliveryHandler = Callable[..., None]
===========changed ref 4===========
# module: aioquic.packet_builder
+ class QuicDeliveryState(Enum):
+ ACKED = 0
+ LOST = 1
+ EXPIRED = 2
+
===========changed ref 5===========
# module: aioquic.packet
- class QuicDeliveryState(Enum):
- ACKED = 0
- LOST = 1
- EXPIRED = 2
-
===========changed ref 6===========
+ # module: aioquic.loss
+ K_PACKET_THRESHOLD = 3
+ K_INITIAL_RTT = 0.5 # seconds
+ K_GRANULARITY = 0.001 # seconds
+ K_TIME_THRESHOLD = 9 / 8
+
===========changed ref 7===========
+ # module: aioquic.loss
+ class QuicPacketLoss:
+ def on_loss_timeout(self) -> None:
+ loss_space = self.get_earliest_loss_time()
+ if loss_space is not None:
+ self.detect_loss(loss_space)
+ else:
+ self._pto_count += 1
+ self._send_probe()
+
===========changed ref 8===========
+ # module: aioquic.loss
+ class QuicPacketLoss:
+ def get_earliest_loss_time(self) -> Optional[QuicPacketSpace]:
+ loss_space = None
+ for space in self.spaces:
+ if space.loss_time is not None and (
+ loss_space is None or space.loss_time < loss_space.loss_time
+ ):
+ loss_space = space
+ return loss_space
+
===========changed ref 9===========
+ # module: aioquic.loss
+ class QuicPacketLoss:
+ def on_packet_sent(self, packet: QuicSentPacket) -> None:
+ if packet.is_crypto_packet:
+ self._time_of_last_sent_crypto_packet = packet.sent_time
+ if packet.is_ack_eliciting:
+ self._time_of_last_sent_ack_eliciting_packet = packet.sent_time
+
===========changed ref 10===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
- def flush(self) -> List[bytes]:
"""
Returns the assembled datagrams.
"""
self._flush_current_datagram()
datagrams = self._datagrams
+ packets = self._packets
self._datagrams = []
+ self._packets = []
+ return datagrams, packets
- return datagrams
===========changed ref 11===========
+ # module: aioquic.loss
+ class QuicPacketSpace:
+ def __init__(self) -> None:
+ self.ack_queue = RangeSet()
+ self.ack_required = False
+ self.expected_packet_number = 0
+
+ # sent packets and loss
+ self.largest_acked_packet = 0
+ self.loss_time: Optional[float] = None
+ self.sent_packets: Dict[int, QuicSentPacket] = {}
+
===========changed ref 12===========
# module: aioquic.packet_builder
+ @dataclass
+ class QuicSentPacket:
+ epoch: Epoch
+ 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.__init__
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
<s>[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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
<0> if is_client:
<1> assert (
<2> original_connection_id is None
<3> ), "Cannot set original_connection_id for a client"
<4> else:
<5> assert certificate is not None, "SSL certificate is required for a server"
<6> assert private_key is not None, "SSL private key is required for a server"
<7>
<8> self.alpn_protocols = alpn_protocols
<9> self.certificate = certificate
<10> self.is_client = is_client
<11> self.peer_cid = os.urandom(8)
<12> self._peer_cid_seq: Optional[int] = None
<13> self._peer_cid_available: List[QuicConnectionId] = []
<14> self.peer_token = b""
<15> self.private_key = private_key
<16> self.secrets_log_file = secrets_log_file
<17> self.server_name = server_name
<18> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<19>
<20> # counters for debugging
<21> self._stateless_retry_count = 0
<22> self._version_negotiation_count = 0
<23>
<24> self._loop = asyncio.get_event_loop()
<25> self.__close: Optional[Dict] = None
<26> self.__connected = asyncio.Event()
<27> self.__epoch = tls.Epoch.INITIAL
<28> self._host_cids = [
<29> QuicConnectionId(
<30> cid=os.urandom(8),
<31> sequence_number=0,
<32> stateless_reset</s>
|
===========below chunk 0===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = 1048576
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._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._parameters_available = asyncio.Event()
self._parameters_received = False
self._ping_pending = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self</s>
===========below chunk 1===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s>_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._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# things to send
self._retire_connection_ids: List[int] = []
# RTT estimation (seconds)
self._loss = QuicPacketLoss()
# callbacks
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionIdHandler = lambda c: None
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
if stream_handler is not None:
self._stream_handler = stream_handler
else:
self._stream_handler = lambda r, w: None
# frame handlers
self.__frame_handlers = [
(self._handle_</s>
===========below chunk 2===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 3
<s>frame, EPOCHS("IZHO")),
(self._handle_padding_frame, EPOCHS("ZO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_reset_stream_frame, EPOCHS("ZO")),
(self._handle_stop_sending_frame, EPOCHS("ZO")),
(self._handle_crypto_frame, EPOCHS("IHO")),
(self._handle_new_token_frame, EPOCHS("O")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_max_data_frame, EPOCHS("ZO")),
(self._handle_max_stream_data_frame, EPOCHS("ZO")),
(self._</s>
===========below chunk 3===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 4
<s>max_streams_bidi_frame, EPOCHS("ZO")),
(self._handle_max_streams_uni_frame, EPOCHS("ZO")),
(self._handle_data_blocked_frame, EPOCHS("ZO")),
(self._handle_stream_data_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_new_connection_id_frame, EPOCHS("ZO")),
(self._handle_retire_connection_id_frame, EPOCHS("O")),
(self._handle_path_challenge_frame, EPOCHS("ZO")),
(self._handle_path_response_frame, EPOCHS("O")),
(self._handle_connection_close_frame, EPOCHS("IZHO")),
(self._handle_connection_close_frame, EPOCHS("ZO")),
]
|
|
aioquic.connection/QuicConnection._initialize
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
# 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.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
self.streams[tls.Epoch.INITIAL] = QuicStream()
self.streams[tls.Epoch.HANDSHAKE] = QuicStream()
self.streams[tls.Epoch.ONE_RTT] = QuicStream()
self.cryptos[tls.Epoch.INITIAL].setup_initial(
cid=peer_cid, is_client=self.is_client
)
self.packet_number = 0
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicConnectionState()
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath)
maybe_connection_error(error_code: int, frame_type: Optional[int], reason_phrase: str) -> Optional[QuicConnectionError]
at: aioquic.connection.QuicConnection
connection_lost(exc: Exception) -> None
_push_crypto_data() -> None
_parse_transport_parameters(data: bytes, from_session_ticket: bool=False) -> None
_set_loss_timer() -> None
_set_loss_timer(self) -> None
_set_state(self, state: QuicConnectionState) -> None
_set_state(state: QuicConnectionState) -> None
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._parameters_received = False
at: aioquic.connection.QuicConnection._handle_ack_frame
rangeset, ack_delay_encoded = pull_ack_frame(buf)
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
self.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
at: aioquic.connection.QuicReceiveContext
epoch: tls.Epoch
===========unchanged ref 1===========
host_cid: bytes
network_path: QuicNetworkPath
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)
pull_crypto_frame(buf: Buffer) -> QuicStreamFrame
pull_transport_close_frame(buf: Buffer) -> Tuple[int, int, str]
pull_application_close_frame(buf: Buffer) -> Tuple[int, str]
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
pull_data() -> bytes
at: aioquic.tls
Alert(*args: object)
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls.Alert
description: AlertDescription
at: aioquic.tls.Context
handle_message(input_data: bytes, output_buf: Dict[Epoch, Buffer]) -> None
at: aioquic.tls.Context.__init__
self.received_extensions: Optional[List[Extension]] = None
at: aioquic.tls.Context._client_handle_encrypted_extensions
self.received_extensions = encrypted_extensions.other_extensions
at: aioquic.tls.Context._server_handle_hello
self.received_extensions = peer_hello.other_extensions
at: logging.LoggerAdapter
logger: Logger
extra: Mapping[str, Any]
===========unchanged ref 2===========
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 QuicPacketSpace:
- def expect_ack(
- self, packet_number: int, handler: QuicDeliveryHandler, args: Sequence[Any] = []
- ) -> None:
- if packet_number not in self.delivery_handlers:
- self.delivery_handlers[packet_number] = []
- self.delivery_handlers[packet_number].append((handler, args))
- self.timestamps[packet_number] = time.time()
-
===========changed ref 1===========
# module: aioquic.connection
- class QuicPacketSpace:
- def __init__(self) -> None:
- self.ack_queue = RangeSet()
- self.ack_required = False
- self.expected_packet_number = 0
-
- # sent packets
- self.delivery_handlers: Dict[int, List[Tuple[QuicDeliveryHandler, Any]]] = {}
- self.timestamps: Dict[int, float] = {}
-
===========changed ref 2===========
# module: aioquic.connection
- class QuicPacketLoss:
- def get_probe_timeout(self) -> float:
- if not self._rtt_initialized:
- return 0.5
- return (
- self._rtt_smoothed
- + max(4 * self._rtt_variance, K_GRANULARITY)
- + self.max_ack_delay / 1000
- )
-
===========changed ref 3===========
# module: aioquic.connection
- QuicDeliveryHandler = Callable[..., None]
-
===========changed ref 4===========
# module: aioquic.connection
- class QuicPacketLoss:
- def __init__(self) -> None:
- self.ack_delay_exponent = 3
- self.max_ack_delay = 25 # ms
-
- self._highest_acked_pn = -1
- self._rtt_initialized = False
- self._rtt_latest = 0.0
- self._rtt_min = math.inf
- self._rtt_smoothed = 0.0
- self._rtt_variance = 0.0
-
|
|
aioquic.connection/QuicConnection._handle_ack_frame
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
<3>:<add> ack_time = self._loop.time()
<del> ack_time = time.time()
<13>:<add> is_ack_eliciting = False
<14>:<add> largest_sent_time = None
<del> largest_send_time = None
<15>:<del> handlers = space.delivery_handlers
<16>:<del> timestamps = space.timestamps
<19>:<add> packet = space.sent_packets.pop(packet_number, None)
<add> if packet is not None:
<del> if packet_number in handlers:
<21>:<add> self._logger.debug("Packet %d ACK'd", packet_number)
<add> for handler, args in packet.delivery_handlers:
<del> for handler, args in handlers[packet_number]:
<23>:<add> if packet.is_ack_eliciting:
<add> is_ack_eliciting = True
<del> del handlers[packet_number]
<25>:<add> largest_sent_time = packet.sent_time
<del> largest_send_time = timestamps.pop(packet_number)
<29>:<add> self._loss.on_ack_received(
<del> self._loss.ack_received(
<30>:<add> space=space,
<add> is_ack_eliciting=is_ack_eliciting,
<31>:<add> latest_rtt=ack_time - largest_sent_time,
<del> latest_rtt=ack_time - largest_send_time,
<35>:<add> # arm loss timer
<add> self._set
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle an ACK frame.
<2> """
<3> ack_time = time.time()
<4> space = self.spaces[context.epoch]
<5>
<6> rangeset, ack_delay_encoded = pull_ack_frame(buf)
<7> if frame_type == QuicFrameType.ACK_ECN:
<8> pull_uint_var(buf)
<9> pull_uint_var(buf)
<10> pull_uint_var(buf)
<11>
<12> # trigger callbacks
<13> largest_newly_acked = None
<14> largest_send_time = None
<15> handlers = space.delivery_handlers
<16> timestamps = space.timestamps
<17> for packet_range in rangeset:
<18> for packet_number in packet_range:
<19> if packet_number in handlers:
<20> # newly ack'd
<21> for handler, args in handlers[packet_number]:
<22> handler(QuicDeliveryState.ACKED, *args)
<23> del handlers[packet_number]
<24> largest_newly_acked = packet_number
<25> largest_send_time = timestamps.pop(packet_number)
<26>
<27> # update RTT estimate
<28> if largest_newly_acked is not None:
<29> self._loss.ack_received(
<30> largest_newly_acked=largest_newly_acked,
<31> latest_rtt=ack_time - largest_send_time,
<32> ack_delay_encoded=ack_delay_encoded,
<33> )
<34>
<35> # check for loss
<36> self._loss.detect_loss(space)
<37>
|
===========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)
at: aioquic.connection.QuicConnection
_replenish_connection_ids() -> None
at: aioquic.connection.QuicConnection.__init__
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._remote_max_data = 0
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
at: aioquic.tls
Epoch()
State()
at: aioquic.tls.Context.__init__
self.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: aioquic.tls.Context._set_state
self.state = state
at: asyncio.locks.Event
is_set() -> bool
set() -> None
at: logging.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 QuicPacketSpace:
- def expect_ack(
- self, packet_number: int, handler: QuicDeliveryHandler, args: Sequence[Any] = []
- ) -> None:
- if packet_number not in self.delivery_handlers:
- self.delivery_handlers[packet_number] = []
- self.delivery_handlers[packet_number].append((handler, args))
- self.timestamps[packet_number] = time.time()
-
===========changed ref 1===========
# module: aioquic.connection
- class QuicPacketSpace:
- def __init__(self) -> None:
- self.ack_queue = RangeSet()
- self.ack_required = False
- self.expected_packet_number = 0
-
- # sent packets
- self.delivery_handlers: Dict[int, List[Tuple[QuicDeliveryHandler, Any]]] = {}
- self.timestamps: Dict[int, float] = {}
-
===========changed ref 2===========
# module: aioquic.connection
- class QuicPacketLoss:
- def get_probe_timeout(self) -> float:
- if not self._rtt_initialized:
- return 0.5
- return (
- self._rtt_smoothed
- + max(4 * self._rtt_variance, K_GRANULARITY)
- + self.max_ack_delay / 1000
- )
-
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _initialize(self, peer_cid: bytes) -> None:
# TLS
self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
self.tls.alpn_protocols = self.alpn_protocols
self.tls.certificate = self.certificate
self.tls.certificate_private_key = self.private_key
self.tls.handshake_extensions = [
(
tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS,
self._serialize_transport_parameters(),
)
]
self.tls.server_name = self.server_name
# TLS session resumption
if (
self.is_client
and self._session_ticket is not None
and self._session_ticket.is_valid
and self._session_ticket.server_name == self.server_name
):
self.tls.session_ticket = self._session_ticket
# parse saved QUIC transport parameters - for 0-RTT
if self._session_ticket.max_early_data_size == 0xFFFFFFFF:
for ext_type, ext_data in self._session_ticket.other_extensions:
if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
self._parse_transport_parameters(
ext_data, from_session_ticket=True
)
break
# TLS callbacks
if self._session_ticket_fetcher is not None:
self.tls.get_session_ticket_cb = self._session_ticket_fetcher
if self._session_ticket_handler is not None:
self.tls.new_session_ticket_cb = self._session_ticket_handler
self.tls.update_traffic_key_cb = self._update_traffic_key
# packet spaces
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),</s>
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _initialize(self, peer_cid: bytes) -> None:
# offset: 1
<s> CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
self.streams[tls.Epoch.INITIAL] = QuicStream()
self.streams[tls.Epoch.HANDSHAKE] = QuicStream()
self.streams[tls.Epoch.ONE_RTT] = QuicStream()
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
- self.packet_number = 0
===========changed ref 5===========
# module: aioquic.connection
- QuicDeliveryHandler = Callable[..., None]
-
===========changed ref 6===========
# module: aioquic.connection
- class QuicPacketLoss:
- def __init__(self) -> None:
- self.ack_delay_exponent = 3
- self.max_ack_delay = 25 # ms
-
- self._highest_acked_pn = -1
- self._rtt_initialized = False
- self._rtt_latest = 0.0
- self._rtt_min = math.inf
- self._rtt_smoothed = 0.0
- self._rtt_variance = 0.0
-
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
<5>:<add> packet_number=self._packet_number,
<del> packet_number=self.packet_number,
<30>:<add> datagrams, packets = builder.flush()
<31>:<del> # update state
<32>:<del> if builder.ack_eliciting:
<33>:<del> self._loss.get_probe_timeout()
<34>:<add> if datagrams:
<add> self._packet_number = builder.packet_number
<del> self.packet_number = builder.packet_number
<36>:<add> # register packets
<add> now = self._loop.time()
<add> for packet in packets:
<add> self._logger.debug(
<add> "[%s] sending packet %d", packet.epoch.name, packet.packet_number
<add> )
<add> packet.sent_time = now
<add>
<add> self.spaces[packet.epoch].sent_packets[packet.packet_number] = packet
<add> self._loss.on_packet_sent(packet)
<add>
<add> # arm loss timer
<add> self._set_loss_timer()
<add>
<add> # send datagrams
<del> # send datagrams
<37>:<add> for datagram in datagrams:
<del> for datagram in builder.flush():
<38>:<add> self._transport.sendto(datagram
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
<0> network_path = self._network_paths[0]
<1>
<2> # build datagrams
<3> builder = QuicPacketBuilder(
<4> host_cid=self.host_cid,
<5> packet_number=self.packet_number,
<6> pad_first_datagram=(self.__epoch == tls.Epoch.INITIAL and self.is_client),
<7> peer_cid=self.peer_cid,
<8> peer_token=self.peer_token,
<9> spin_bit=self._spin_bit,
<10> version=self._version,
<11> )
<12>
<13> if self.__close:
<14> for epoch, packet_type in (
<15> (tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
<16> (tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
<17> (tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
<18> ):
<19> crypto = self.cryptos[epoch]
<20> if crypto.send.is_valid():
<21> builder.start_packet(packet_type, crypto)
<22> write_close_frame(builder, **self.__close)
<23> builder.end_packet()
<24> self.__close = None
<25> break
<26> else:
<27> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<28> self._write_handshake(builder, epoch)
<29> self._write_application(builder, network_path)
<30>
<31> # update state
<32> if builder.ack_eliciting:
<33> self._loss.get_probe_timeout()
<34> self.packet_number = builder.packet_number
<35>
<36> # send datagrams
<37> for datagram in builder.flush():
<38> self._transport.sendto(datagram, network_path.addr)
<39> network_path.bytes_sent += len(datagram)
<40> self.__send_pending_task = None
<41>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionState()
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self._loop = asyncio.get_event_loop()
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = 1048576
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 = QuicPacketLoss(
get_time=self._loop.time, send_probe=self._send_probe
)
self._loss_timer: Optional[asyncio.TimerHandle] = None
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._original_connection_id = original_connection_id
self._parameters_available = asyncio.Event()
self.__state = QuicConnectionState.FIRSTFLIGHT
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 += MAX_DATA_WINDOW
at: aioquic.connection.QuicConnection.datagram_received
self._original_connection_id = self.peer_cid
at: aioquic.loss.QuicPacketLoss
get_loss_detection_time() -> float
on_loss_timeout() -> None
===========unchanged ref 1===========
at: aioquic.packet
QuicTransportParameters(initial_version: Optional[QuicProtocolVersion]=None, negotiated_version: Optional[QuicProtocolVersion]=None, supported_versions: List[QuicProtocolVersion]=field(default_factory=list), original_connection_id: Optional[bytes]=None, idle_timeout: Optional[int]=None, stateless_reset_token: Optional[bytes]=None, max_packet_size: Optional[int]=None, initial_max_data: Optional[int]=None, initial_max_stream_data_bidi_local: Optional[int]=None, initial_max_stream_data_bidi_remote: Optional[int]=None, initial_max_stream_data_uni: Optional[int]=None, initial_max_streams_bidi: Optional[int]=None, initial_max_streams_uni: Optional[int]=None, ack_delay_exponent: Optional[int]=None, max_ack_delay: Optional[int]=None, disable_migration: Optional[bool]=False, preferred_address: Optional[bytes]=None)
push_quic_transport_parameters(buf: Buffer, params: QuicTransportParameters) -> None
at: aioquic.packet.QuicTransportParameters
initial_version: Optional[QuicProtocolVersion] = None
negotiated_version: Optional[QuicProtocolVersion] = None
supported_versions: List[QuicProtocolVersion] = field(default_factory=list)
original_connection_id: Optional[bytes] = None
idle_timeout: Optional[int] = None
stateless_reset_token: Optional[bytes] = None
max_packet_size: Optional[int] = None
initial_max_data: Optional[int] = None
initial_max_stream_data_bidi_local: Optional[int] = None
initial_max_stream_data_bidi_remote: Optional[int] = None
initial_max_stream_data_uni: Optional[int] = None
initial_max_streams_bidi: Optional[int] = None
===========unchanged ref 2===========
initial_max_streams_uni: Optional[int] = None
ack_delay_exponent: Optional[int] = None
max_ack_delay: Optional[int] = None
disable_migration: Optional[bool] = False
preferred_address: Optional[bytes] = None
at: asyncio.events.AbstractEventLoop
call_at(when: float, callback: Callable[..., Any], *args: Any) -> TimerHandle
at: asyncio.events.TimerHandle
__slots__ = ['_scheduled', '_when']
cancel() -> None
at: asyncio.locks.Event
is_set() -> bool
set() -> None
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.loss
+ class QuicPacketLoss:
+ def on_loss_timeout(self) -> None:
+ loss_space = self.get_earliest_loss_time()
+ if loss_space is not None:
+ self.detect_loss(loss_space)
+ else:
+ self._pto_count += 1
+ self._send_probe()
+
===========changed ref 1===========
+ # module: aioquic.loss
+ class QuicPacketLoss:
+ def get_loss_detection_time(self) -> float:
+ loss_space = self.get_earliest_loss_time()
+ if loss_space is not None:
+ return loss_space.loss_time
+
+ # check there are ACK-eliciting packets in flight
+ ack_eliciting_in_flight = False
+ for space in self.spaces:
+ for packet in space.sent_packets.values():
+ if packet.is_ack_eliciting:
+ ack_eliciting_in_flight = True
+ break
+ if not ack_eliciting_in_flight:
+ return None
+
+ # PTO
+ if not self._rtt_initialized:
+ timeout = 0.5
+ else:
+ timeout = (
+ self._rtt_smoothed
+ + max(4 * self._rtt_variance, K_GRANULARITY)
+ + self.max_ack_delay / 1000
+ ) * (2 ** self._pto_count)
+ return self._time_of_last_sent_ack_eliciting_packet + timeout
+
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _send_probe(self) -> None:
+ self._logger.info("Sending probe")
+ self._probe_pending = True
+ self._send_pending()
+
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
<14>:<add>
<add> # FIXME: implement congestion control
<add> packets = 0
<add> while packets < 5:
<del> while True:
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
<0> crypto_stream_id: Optional[tls.Epoch] = None
<1> if self.cryptos[tls.Epoch.ONE_RTT].send.is_valid():
<2> crypto = self.cryptos[tls.Epoch.ONE_RTT]
<3> crypto_stream_id = 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> is_one_rtt = self.__epoch == tls.Epoch.ONE_RTT
<12>
<13> buf = builder.buffer
<14> while True:
<15> # write header
<16> builder.start_packet(packet_type, crypto)
<17>
<18> if is_one_rtt:
<19> # ACK
<20> if space.ack_required and space.ack_queue:
<21> builder.start_frame(QuicFrameType.ACK)
<22> push_ack_frame(buf, space.ack_queue, 0)
<23> space.ack_required = False
<24>
<25> # PATH CHALLENGE
<26> if (
<27> not network_path.is_validated
<28> and network_path.local_challenge is None
<29> ):
<30> self._logger.info(
<31> "Network path %s sending challenge", network_path.addr
<32> )
<33> network_path.local_challenge = os.urandom(8)
<34> builder.start_frame(QuicFrameType.PATH_CHALLENGE)
<35> push_bytes(buf, network_path.local_challenge)
<36>
<37> # PATH RESPONSE
</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 1
builder.start_frame(QuicFrameType.PATH_RESPONSE)
push_bytes(buf, 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)
push_new_connection_id_frame(
buf,
connection_id.sequence_number,
connection_id.cid,
connection_id.stateless_reset_token,
)
connection_id.was_sent = True
space.expect_ack(
builder.packet_number,
self._on_new_connection_id_delivery,
(connection_id,),
)
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)
push_uint_var(buf, sequence_number)
space.expect_ack(
builder.packet_number,
self._on_retire_connection_id_delivery,
(sequence_number,),
)
# connection-level limits
self._write_connection_limits(builder=builder, space=space)
# stream-level limits
for stream_id, stream in self.streams.items():
if isinstance(stream_id, int):
self._write_stream_limits(
builder=builder, space=space, stream=stream
)
# PING
if self._ping_pending:
self._logger.info("Sending PING in packet</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 2
<s> )
# PING
if self._ping_pending:
self._logger.info("Sending PING in packet %d", builder.packet_number)
builder.start_frame(QuicFrameType.PING)
space.expect_ack(builder.packet_number, self._on_ping_delivery)
self._ping_pending = False
for stream_id, stream in self.streams.items():
# CRYPTO
if stream_id == crypto_stream_id:
write_crypto_frame(builder=builder, space=space, stream=stream)
# STREAM
elif isinstance(stream_id, int):
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.connection
MAX_DATA_WINDOW = 1048576
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_ping_delivery(delivery: QuicDeliveryState) -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self._local_max_data = 1048576
self._local_max_data_used = 0
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._remote_max_data = 0
self._remote_max_data_used = 0
self._ping_pending = False
self._probe_pending = False
at: aioquic.connection.QuicConnection._handle_max_data_frame
self._remote_max_data = max_data
at: aioquic.connection.QuicConnection._handle_stream_frame
self._local_max_data_used += newly_received
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.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
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._send_probe
self._probe_pending = True
at: aioquic.connection.QuicConnection._write_application
crypto_stream_id = tls.Epoch.ONE_RTT
crypto_stream_id: Optional[tls.Epoch] = None
space = self.spaces[tls.Epoch.ONE_RTT]
buf = builder.buffer
sequence_number = self._retire_connection_ids.pop(0)
at: aioquic.connection.QuicConnection.ping
self._ping_pending = True
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair
teardown() -> None
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.loss
QuicPacketSpace()
at: aioquic.loss.QuicPacketSpace.__init__
self.ack_queue = RangeSet()
self.ack_required = False
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
push_uint_var(buf: Buffer, value: int) -> None
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
push_ack_frame(buf: Buffer, rangeset: RangeSet, delay: int) -> None
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)
|
aioquic.connection/QuicConnection._write_connection_limits
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
<6>:<del> space.expect_ack(builder.packet_number, lambda d: None)
|
# 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> builder.start_frame(QuicFrameType.MAX_DATA)
<5> push_uint_var(builder.buffer, self._local_max_data)
<6> space.expect_ack(builder.packet_number, lambda d: None)
<7>
|
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _set_loss_timer(self) -> None:
+ loss_time = self._loss.get_loss_detection_time()
+ if self._loss_timer is not None:
+ self._loss_timer.cancel()
+ if loss_time is not None:
+ self._loss_timer = self._loop.call_at(loss_time, self._loss.on_loss_timeout)
+ else:
+ self._loss_timer = None
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _send_probe(self) -> None:
+ self._logger.info("Sending probe")
+ self._probe_pending = True
+ self._send_pending()
+
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
network_path = self._network_paths[0]
# build datagrams
builder = QuicPacketBuilder(
host_cid=self.host_cid,
+ packet_number=self._packet_number,
- packet_number=self.packet_number,
pad_first_datagram=(self.__epoch == tls.Epoch.INITIAL and self.is_client),
peer_cid=self.peer_cid,
peer_token=self.peer_token,
spin_bit=self._spin_bit,
version=self._version,
)
if self.__close:
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)
builder.end_packet()
self.__close = None
break
else:
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch)
self._write_application(builder, network_path)
+ datagrams, packets = builder.flush()
- # update state
- if builder.ack_eliciting:
- self._loss.get_probe_timeout()
+ if datagrams:
+ self._packet_number = builder.packet_number
- self.packet_number = builder.packet_number
+ # register packets
+ now = self._loop.time()
+ for packet in packets:
+ self._logger.debug(
+ "[%s] sending packet %d", packet.epoch.name, packet.</s>
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
<s> packets:
+ self._logger.debug(
+ "[%s] sending packet %d", packet.epoch.name, packet.packet_number
+ )
+ packet.sent_time = now
+
+ self.spaces[packet.epoch].sent_packets[packet.packet_number] = packet
+ self._loss.on_packet_sent(packet)
+
+ # arm loss timer
+ self._set_loss_timer()
+
+ # send datagrams
- # send datagrams
+ for datagram in datagrams:
- for datagram in builder.flush():
+ self._transport.sendto(datagram, network_path.addr)
- self._transport.sendto(datagram, network_path.addr)
+ network_path.bytes_sent += len(datagram)
- network_path.bytes_sent += len(datagram)
+
self.__send_pending_task = None
===========changed ref 4===========
+ # module: aioquic.loss
+
+
===========changed ref 5===========
# module: aioquic.packet_builder
+ QuicDeliveryHandler = Callable[..., None]
===========changed ref 6===========
# module: aioquic.connection
- QuicDeliveryHandler = Callable[..., None]
-
===========changed ref 7===========
# module: aioquic.packet_builder
+ class QuicDeliveryState(Enum):
+ ACKED = 0
+ LOST = 1
+ EXPIRED = 2
+
===========changed ref 8===========
# module: aioquic.packet
- class QuicDeliveryState(Enum):
- ACKED = 0
- LOST = 1
- EXPIRED = 2
-
===========changed ref 9===========
+ # module: aioquic.loss
+ K_PACKET_THRESHOLD = 3
+ K_INITIAL_RTT = 0.5 # seconds
+ K_GRANULARITY = 0.001 # seconds
+ K_TIME_THRESHOLD = 9 / 8
+
===========changed ref 10===========
+ # module: aioquic.loss
+ class QuicPacketLoss:
+ def on_loss_timeout(self) -> None:
+ loss_space = self.get_earliest_loss_time()
+ if loss_space is not None:
+ self.detect_loss(loss_space)
+ else:
+ self._pto_count += 1
+ self._send_probe()
+
===========changed ref 11===========
# module: aioquic.connection
- class QuicPacketSpace:
- def expect_ack(
- self, packet_number: int, handler: QuicDeliveryHandler, args: Sequence[Any] = []
- ) -> None:
- if packet_number not in self.delivery_handlers:
- self.delivery_handlers[packet_number] = []
- self.delivery_handlers[packet_number].append((handler, args))
- self.timestamps[packet_number] = time.time()
-
===========changed ref 12===========
+ # module: aioquic.loss
+ class QuicPacketLoss:
+ def get_earliest_loss_time(self) -> Optional[QuicPacketSpace]:
+ loss_space = None
+ for space in self.spaces:
+ if space.loss_time is not None and (
+ loss_space is None or space.loss_time < loss_space.loss_time
+ ):
+ loss_space = space
+ return loss_space
+
===========changed ref 13===========
+ # module: aioquic.loss
+ class QuicPacketLoss:
+ def on_packet_sent(self, packet: QuicSentPacket) -> None:
+ if packet.is_crypto_packet:
+ self._time_of_last_sent_crypto_packet = packet.sent_time
+ if packet.is_ack_eliciting:
+ self._time_of_last_sent_ack_eliciting_packet = packet.sent_time
+
===========changed ref 14===========
# module: aioquic.connection
- class QuicPacketLoss:
- def get_probe_timeout(self) -> float:
- if not self._rtt_initialized:
- return 0.5
- return (
- self._rtt_smoothed
- + max(4 * self._rtt_variance, K_GRANULARITY)
- + self.max_ack_delay / 1000
- )
-
===========changed ref 15===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
- def flush(self) -> List[bytes]:
"""
Returns the assembled datagrams.
"""
self._flush_current_datagram()
datagrams = self._datagrams
+ packets = self._packets
self._datagrams = []
+ self._packets = []
+ return datagrams, packets
- return datagrams
|
aioquic.connection/QuicConnection._write_stream_limits
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
<11>:<del> space.expect_ack(builder.packet_number, lambda d: None)
|
# 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> builder.start_frame(QuicFrameType.MAX_STREAM_DATA)
<9> push_uint_var(builder.buffer, stream.stream_id)
<10> push_uint_var(builder.buffer, stream.max_stream_data_local)
<11> space.expect_ack(builder.packet_number, lambda d: None)
<12>
|
===========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 + MAX_DATA_WINDOW // 2 > self._local_max_data:
self._local_max_data += MAX_DATA_WINDOW
self._logger.info("Local max_data raised to %d", self._local_max_data)
builder.start_frame(QuicFrameType.MAX_DATA)
push_uint_var(builder.buffer, self._local_max_data)
- space.expect_ack(builder.packet_number, lambda d: None)
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _set_loss_timer(self) -> None:
+ loss_time = self._loss.get_loss_detection_time()
+ if self._loss_timer is not None:
+ self._loss_timer.cancel()
+ if loss_time is not None:
+ self._loss_timer = self._loop.call_at(loss_time, self._loss.on_loss_timeout)
+ else:
+ self._loss_timer = None
+
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _send_probe(self) -> None:
+ self._logger.info("Sending probe")
+ self._probe_pending = True
+ self._send_pending()
+
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
network_path = self._network_paths[0]
# build datagrams
builder = QuicPacketBuilder(
host_cid=self.host_cid,
+ packet_number=self._packet_number,
- packet_number=self.packet_number,
pad_first_datagram=(self.__epoch == tls.Epoch.INITIAL and self.is_client),
peer_cid=self.peer_cid,
peer_token=self.peer_token,
spin_bit=self._spin_bit,
version=self._version,
)
if self.__close:
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)
builder.end_packet()
self.__close = None
break
else:
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch)
self._write_application(builder, network_path)
+ datagrams, packets = builder.flush()
- # update state
- if builder.ack_eliciting:
- self._loss.get_probe_timeout()
+ if datagrams:
+ self._packet_number = builder.packet_number
- self.packet_number = builder.packet_number
+ # register packets
+ now = self._loop.time()
+ for packet in packets:
+ self._logger.debug(
+ "[%s] sending packet %d", packet.epoch.name, packet.</s>
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
<s> packets:
+ self._logger.debug(
+ "[%s] sending packet %d", packet.epoch.name, packet.packet_number
+ )
+ packet.sent_time = now
+
+ self.spaces[packet.epoch].sent_packets[packet.packet_number] = packet
+ self._loss.on_packet_sent(packet)
+
+ # arm loss timer
+ self._set_loss_timer()
+
+ # send datagrams
- # send datagrams
+ for datagram in datagrams:
- for datagram in builder.flush():
+ self._transport.sendto(datagram, network_path.addr)
- self._transport.sendto(datagram, network_path.addr)
+ network_path.bytes_sent += len(datagram)
- network_path.bytes_sent += len(datagram)
+
self.__send_pending_task = None
===========changed ref 5===========
+ # module: aioquic.loss
+
+
===========changed ref 6===========
# module: aioquic.packet_builder
+ QuicDeliveryHandler = Callable[..., None]
===========changed ref 7===========
# module: aioquic.connection
- QuicDeliveryHandler = Callable[..., None]
-
===========changed ref 8===========
# module: aioquic.packet_builder
+ class QuicDeliveryState(Enum):
+ ACKED = 0
+ LOST = 1
+ EXPIRED = 2
+
===========changed ref 9===========
# module: aioquic.packet
- class QuicDeliveryState(Enum):
- ACKED = 0
- LOST = 1
- EXPIRED = 2
-
===========changed ref 10===========
+ # module: aioquic.loss
+ K_PACKET_THRESHOLD = 3
+ K_INITIAL_RTT = 0.5 # seconds
+ K_GRANULARITY = 0.001 # seconds
+ K_TIME_THRESHOLD = 9 / 8
+
===========changed ref 11===========
+ # module: aioquic.loss
+ class QuicPacketLoss:
+ def on_loss_timeout(self) -> None:
+ loss_space = self.get_earliest_loss_time()
+ if loss_space is not None:
+ self.detect_loss(loss_space)
+ else:
+ self._pto_count += 1
+ self._send_probe()
+
===========changed ref 12===========
# module: aioquic.connection
- class QuicPacketSpace:
- def expect_ack(
- self, packet_number: int, handler: QuicDeliveryHandler, args: Sequence[Any] = []
- ) -> None:
- if packet_number not in self.delivery_handlers:
- self.delivery_handlers[packet_number] = []
- self.delivery_handlers[packet_number].append((handler, args))
- self.timestamps[packet_number] = time.time()
-
===========changed ref 13===========
+ # module: aioquic.loss
+ class QuicPacketLoss:
+ def get_earliest_loss_time(self) -> Optional[QuicPacketSpace]:
+ loss_space = None
+ for space in self.spaces:
+ if space.loss_time is not None and (
+ loss_space is None or space.loss_time < loss_space.loss_time
+ ):
+ loss_space = space
+ return loss_space
+
===========changed ref 14===========
+ # module: aioquic.loss
+ class QuicPacketLoss:
+ def on_packet_sent(self, packet: QuicSentPacket) -> None:
+ if packet.is_crypto_packet:
+ self._time_of_last_sent_crypto_packet = packet.sent_time
+ if packet.is_ack_eliciting:
+ self._time_of_last_sent_ack_eliciting_packet = packet.sent_time
+
===========changed ref 15===========
# module: aioquic.connection
- class QuicPacketLoss:
- def get_probe_timeout(self) -> float:
- if not self._rtt_initialized:
- return 0.5
- return (
- self._rtt_smoothed
- + max(4 * self._rtt_variance, K_GRANULARITY)
- + self.max_ack_delay / 1000
- )
-
|
tests.test_connection/QuicConnectionTest.test_datagram_received_wrong_version
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
<10>:<add> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<del> builder.start_packet(PACKET_TYPE_INITIAL, crypto=crypto)
<14>:<add> for datagram in builder.flush()[0]:
<del> for datagram in builder.flush():
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_datagram_received_wrong_version(self):
<0> client, client_transport = create_standalone_client()
<1> self.assertEqual(client_transport.sent, 1)
<2>
<3> builder = QuicPacketBuilder(
<4> host_cid=client.peer_cid,
<5> peer_cid=client.host_cid,
<6> version=0xFF000011, # DRAFT_16
<7> )
<8> crypto = CryptoPair()
<9> crypto.setup_initial(client.host_cid, is_client=False)
<10> builder.start_packet(PACKET_TYPE_INITIAL, crypto=crypto)
<11> push_bytes(builder.buffer, bytes(1200))
<12> builder.end_packet()
<13>
<14> for datagram in builder.flush():
<15> client.datagram_received(datagram, SERVER_ADDR)
<16> self.assertEqual(client_transport.sent, 1)
<17>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.connection.QuicConnection.__init__
self.peer_cid = os.urandom(8)
self.host_cid = self._host_cids[0].cid
at: aioquic.connection.QuicConnection._consume_connection_id
self.peer_cid = connection_id.cid
at: aioquic.connection.QuicConnection.datagram_received
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(*, 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.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: tests.test_connection
SERVER_ADDR = ("2.3.4.5", 4433)
create_standalone_client()
at: tests.test_connection.FakeTransport.sendto
self.sent += 1
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
===========unchanged ref 1===========
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
- def flush(self) -> List[bytes]:
"""
Returns the assembled datagrams.
"""
self._flush_current_datagram()
datagrams = self._datagrams
+ packets = self._packets
self._datagrams = []
+ self._packets = []
+ return datagrams, packets
- return datagrams
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
buf = self.buffer
# if there is too little space remaining, start a new datagram
# FIXME: the limit is arbitrary!
if buf.capacity - buf.tell() < 128:
self._flush_current_datagram()
+ # 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._packet = QuicSentPacket(
+ epoch=epoch,
+ is_ack_eliciting=False,
+ is_crypto_packet=False,
+ packet_number=self._packet_number,
+ )
self._packet_start = buf.tell()
# write header
if is_long_header(packet_type):
push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
push_uint32(buf, self._version)
push_uint8(
buf,
(encode_cid_length(len(self._peer_cid)) << 4)
| encode_cid_length(len(self._host_cid)),
)
push_bytes(buf, self._peer_cid)
push_bytes(buf, self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
push_uint_var(buf, len(self._peer_token))
push_bytes(buf, self._peer_token)
push_uint16(buf, 0) # length
push_packet_number(buf, 0) # packet number
else:
push_uint8(
buf,
packet_type
|</s>
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
<s>, 0) # packet number
else:
push_uint8(
buf,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(buf, self._peer_cid)
push_packet_number(buf, self._packet_number)
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
===========changed ref 3===========
# 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:
push_bytes(buf, bytes(self.remaining_space))
packet_size = buf.tell() - self._packet_start
self._pad_first_datagram = False
if is_long_header(self._packet_type):
# finalize length
buf.seek(
self._packet_start
+ self._header_size
- PACKET_NUMBER_SEND_SIZE
- PACKET_LENGTH_SEND_SIZE
)
length = (
packet_size
- self._header_size
+ PACKET_NUMBER_SEND_SIZE
+ self._crypto.aead_tag_size
)
push_uint16(buf, length | 0x4000)
push_packet_number(buf, self._packet_number)
buf.seek(packet_size)
else:
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
push_bytes(buf, 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)
push_bytes(
buf,
self._crypto.encrypt_packet(
plain[0 : self._header_size], plain[self._header_size : packet_size]
),
</s>
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_empty
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
<19>:<add> datagrams, packets = builder.flush()
<del> datagrams = builder.flush()
<21>:<add> self.assertEqual(packets, [])
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_empty(self):
<0> builder = QuicPacketBuilder(
<1> host_cid=bytes(8),
<2> packet_number=0,
<3> peer_cid=bytes(8),
<4> peer_token=b"",
<5> spin_bit=False,
<6> version=QuicProtocolVersion.DRAFT_20,
<7> )
<8> crypto = CryptoPair()
<9>
<10> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<11> self.assertEqual(builder.remaining_space, 1237)
<12>
<13> # nothing to write
<14>
<15> self.assertFalse(builder.end_packet())
<16> self.assertEqual(builder.buffer.tell(), 0)
<17> self.assertEqual(builder.packet_number, 0)
<18>
<19> datagrams = builder.flush()
<20> self.assertEqual(len(datagrams), 0)
<21>
|
===========unchanged ref 0===========
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.crypto
CryptoPair()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
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.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
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
assertFalse(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
- def flush(self) -> List[bytes]:
"""
Returns the assembled datagrams.
"""
self._flush_current_datagram()
datagrams = self._datagrams
+ packets = self._packets
self._datagrams = []
+ self._packets = []
+ return datagrams, packets
- return datagrams
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
buf = self.buffer
# if there is too little space remaining, start a new datagram
# FIXME: the limit is arbitrary!
if buf.capacity - buf.tell() < 128:
self._flush_current_datagram()
+ # 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._packet = QuicSentPacket(
+ epoch=epoch,
+ is_ack_eliciting=False,
+ is_crypto_packet=False,
+ packet_number=self._packet_number,
+ )
self._packet_start = buf.tell()
# write header
if is_long_header(packet_type):
push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
push_uint32(buf, self._version)
push_uint8(
buf,
(encode_cid_length(len(self._peer_cid)) << 4)
| encode_cid_length(len(self._host_cid)),
)
push_bytes(buf, self._peer_cid)
push_bytes(buf, self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
push_uint_var(buf, len(self._peer_token))
push_bytes(buf, self._peer_token)
push_uint16(buf, 0) # length
push_packet_number(buf, 0) # packet number
else:
push_uint8(
buf,
packet_type
|</s>
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
<s>, 0) # packet number
else:
push_uint8(
buf,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(buf, self._peer_cid)
push_packet_number(buf, self._packet_number)
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
===========changed ref 3===========
# 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:
push_bytes(buf, bytes(self.remaining_space))
packet_size = buf.tell() - self._packet_start
self._pad_first_datagram = False
if is_long_header(self._packet_type):
# finalize length
buf.seek(
self._packet_start
+ self._header_size
- PACKET_NUMBER_SEND_SIZE
- PACKET_LENGTH_SEND_SIZE
)
length = (
packet_size
- self._header_size
+ PACKET_NUMBER_SEND_SIZE
+ self._crypto.aead_tag_size
)
push_uint16(buf, length | 0x4000)
push_packet_number(buf, self._packet_number)
buf.seek(packet_size)
else:
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
push_bytes(buf, 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)
push_bytes(
buf,
self._crypto.encrypt_packet(
plain[0 : self._header_size], plain[self._header_size : packet_size]
),
</s>
===========changed ref 4===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
# offset: 1
<s>
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._crypto = None
+ self._packet = None
return not empty
===========changed ref 5===========
+ # module: aioquic.loss
+
+
===========changed ref 6===========
# module: aioquic.packet_builder
+ QuicDeliveryHandler = Callable[..., None]
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_padding
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
<24>:<add> datagrams, packets = builder.flush()
<del> datagrams = builder.flush()
<27>:<add> self.assertEqual(
<add> packets,
<add> [
<add> QuicSentPacket(
<add> epoch=Epoch.INITIAL,
<add> is_ack_eliciting=True,
<add> is_crypto_packet=True,
<add> packet_number=0,
<add> sent_bytes=1280,
<add> )
<add> ],
<add> )
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_padding(self):
<0> builder = QuicPacketBuilder(
<1> host_cid=bytes(8),
<2> packet_number=0,
<3> pad_first_datagram=True,
<4> peer_cid=bytes(8),
<5> peer_token=b"",
<6> spin_bit=False,
<7> version=QuicProtocolVersion.DRAFT_20,
<8> )
<9> crypto = CryptoPair()
<10> crypto.setup_initial(bytes(8), is_client=True)
<11>
<12> # INITIAL, fully padded
<13> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<14> self.assertEqual(builder.remaining_space, 1237)
<15> builder.start_frame(QuicFrameType.CRYPTO)
<16> push_bytes(builder.buffer, bytes(100))
<17> self.assertTrue(builder.end_packet())
<18>
<19> # check builder state
<20> self.assertEqual(builder.buffer.tell(), 1280)
<21> self.assertEqual(builder.packet_number, 1)
<22>
<23> # check datagrams
<24> datagrams = builder.flush()
<25> self.assertEqual(len(datagrams), 1)
<26> self.assertEqual(len(datagrams[0]), 1280)
<27>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.buffer.Buffer
tell() -> int
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
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(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.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_frame(frame_type: int, handler: Optional[QuicDeliveryHandler]=None, args: Sequence[Any]=[]) -> None
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: tests.test_packet_builder.QuicPacketBuilderTest.test_long_header_empty
datagrams, packets = builder.flush()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
- def flush(self) -> List[bytes]:
"""
Returns the assembled datagrams.
"""
self._flush_current_datagram()
datagrams = self._datagrams
+ packets = self._packets
self._datagrams = []
+ self._packets = []
+ return datagrams, packets
- return datagrams
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def start_frame(
+ self,
+ frame_type: int,
+ handler: Optional[QuicDeliveryHandler] = None,
+ args: Sequence[Any] = [],
+ ) -> None:
- def start_frame(self, frame_type: int) -> None:
"""
Starts a new frame.
"""
push_uint_var(self.buffer, frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
+ self._packet.is_ack_eliciting = True
self._ack_eliciting = True
+ if frame_type == QuicFrameType.CRYPTO:
+ self._packet.is_crypto_packet = True
+ if handler is not None:
+ self._packet.delivery_handlers.append((handler, args))
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
buf = self.buffer
# if there is too little space remaining, start a new datagram
# FIXME: the limit is arbitrary!
if buf.capacity - buf.tell() < 128:
self._flush_current_datagram()
+ # 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._packet = QuicSentPacket(
+ epoch=epoch,
+ is_ack_eliciting=False,
+ is_crypto_packet=False,
+ packet_number=self._packet_number,
+ )
self._packet_start = buf.tell()
# write header
if is_long_header(packet_type):
push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
push_uint32(buf, self._version)
push_uint8(
buf,
(encode_cid_length(len(self._peer_cid)) << 4)
| encode_cid_length(len(self._host_cid)),
)
push_bytes(buf, self._peer_cid)
push_bytes(buf, self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
push_uint_var(buf, len(self._peer_token))
push_bytes(buf, self._peer_token)
push_uint16(buf, 0) # length
push_packet_number(buf, 0) # packet number
else:
push_uint8(
buf,
packet_type
|</s>
===========changed ref 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
<s>, 0) # packet number
else:
push_uint8(
buf,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(buf, self._peer_cid)
push_packet_number(buf, self._packet_number)
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_then_short_header
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
<21>:<add> builder.start_frame(QuicFrameType.STREAM_BASE)
<del> builder.start_frame(QuicFrameType.CRYPTO)
<30>:<add> datagrams, packets = builder.flush()
<del> datagrams = builder.flush()
<34>:<add> self.assertEqual(
<add> packets,
<add> [
<add> QuicSentPacket(
<add> epoch=Epoch.INITIAL,
<add> is_ack_eliciting=True,
<add> is_crypto_packet=True,
<add> packet_number=0,
<add> sent_bytes=1280,
<add> ),
<add> QuicSentPacket(
<add> epoch=Epoch.ONE_RTT,
<add> is_ack_eliciting=True,
<add> is_crypto_packet=False,
<add> packet_number=1,
<add> sent_bytes=1280,
<add> ),
<add> ],
<add> )
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_short_header(self):
<0> builder = QuicPacketBuilder(
<1> host_cid=bytes(8),
<2> packet_number=0,
<3> peer_cid=bytes(8),
<4> peer_token=b"",
<5> spin_bit=False,
<6> version=QuicProtocolVersion.DRAFT_20,
<7> )
<8> crypto = CryptoPair()
<9> crypto.setup_initial(bytes(8), is_client=True)
<10>
<11> # INITIAL, fully padded
<12> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<13> self.assertEqual(builder.remaining_space, 1237)
<14> builder.start_frame(QuicFrameType.CRYPTO)
<15> push_bytes(builder.buffer, bytes(builder.remaining_space))
<16> self.assertTrue(builder.end_packet())
<17>
<18> # ONE_RTT, fully padded
<19> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<20> self.assertEqual(builder.remaining_space, 1253)
<21> builder.start_frame(QuicFrameType.CRYPTO)
<22> push_bytes(builder.buffer, bytes(builder.remaining_space))
<23> self.assertTrue(builder.end_packet())
<24>
<25> # check builder
<26> self.assertTrue(builder.ack_eliciting)
<27> self.assertEqual(builder.buffer.tell(), 0)
<28>
<29> # check datagrams
<30> datagrams = builder.flush()
<31> self.assertEqual(len(datagrams), 2)
<32> self.assertEqual(len(datagrams[0]), 1280)
<33> self.assertEqual(len(datagrams[1]), 1280)
<34>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
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
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(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.packet_builder
QuicSentPacket(epoch: Epoch, 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
))
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) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
===========unchanged ref 1===========
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()
at: tests.test_packet_builder.QuicPacketBuilderTest.test_long_header_padding
datagrams, packets = builder.flush()
datagrams, packets = builder.flush()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.packet_builder
+ @dataclass
+ class QuicSentPacket:
+ epoch: Epoch
+ 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 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def start_frame(
+ self,
+ frame_type: int,
+ handler: Optional[QuicDeliveryHandler] = None,
+ args: Sequence[Any] = [],
+ ) -> None:
- def start_frame(self, frame_type: int) -> None:
"""
Starts a new frame.
"""
push_uint_var(self.buffer, frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
+ self._packet.is_ack_eliciting = True
self._ack_eliciting = True
+ if frame_type == QuicFrameType.CRYPTO:
+ self._packet.is_crypto_packet = True
+ if handler is not None:
+ self._packet.delivery_handlers.append((handler, args))
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
buf = self.buffer
# if there is too little space remaining, start a new datagram
# FIXME: the limit is arbitrary!
if buf.capacity - buf.tell() < 128:
self._flush_current_datagram()
+ # 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._packet = QuicSentPacket(
+ epoch=epoch,
+ is_ack_eliciting=False,
+ is_crypto_packet=False,
+ packet_number=self._packet_number,
+ )
self._packet_start = buf.tell()
# write header
if is_long_header(packet_type):
push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
push_uint32(buf, self._version)
push_uint8(
buf,
(encode_cid_length(len(self._peer_cid)) << 4)
| encode_cid_length(len(self._host_cid)),
)
push_bytes(buf, self._peer_cid)
push_bytes(buf, self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
push_uint_var(buf, len(self._peer_token))
push_bytes(buf, self._peer_token)
push_uint16(buf, 0) # length
push_packet_number(buf, 0) # packet number
else:
push_uint8(
buf,
packet_type
|</s>
===========changed ref 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
<s>, 0) # packet number
else:
push_uint8(
buf,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(buf, self._peer_cid)
push_packet_number(buf, self._packet_number)
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_then_long_header
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_long_header(self):
<0> builder = QuicPacketBuilder(
<1> host_cid=bytes(8),
<2> packet_number=0,
<3> peer_cid=bytes(8),
<4> peer_token=b"",
<5> spin_bit=False,
<6> version=QuicProtocolVersion.DRAFT_20,
<7> )
<8> crypto = CryptoPair()
<9> crypto.setup_initial(bytes(8), is_client=True)
<10>
<11> # INITIAL
<12> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<13> self.assertEqual(builder.remaining_space, 1237)
<14> builder.start_frame(QuicFrameType.CRYPTO)
<15> push_bytes(builder.buffer, bytes(199))
<16> self.assertEqual(builder.buffer.tell(), 227)
<17> self.assertTrue(builder.end_packet())
<18> self.assertEqual(builder.buffer.tell(), 243)
<19>
<20> # HANDSHAKE
<21> builder.start_packet(PACKET_TYPE_HANDSHAKE, crypto)
<22> self.assertEqual(builder.buffer.tell(), 269)
<23> self.assertEqual(builder.remaining_space, 995)
<24> builder.start_frame(QuicFrameType.CRYPTO)
<25> push_bytes(builder.buffer, bytes(299))
<26> self.assertEqual(builder.buffer.tell(), 569)
<27> self.assertTrue(builder.end_packet())
<28> self.assertEqual(builder.buffer.tell(), 585)
<29>
<30> # ONE_RTT
<31> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<32> self.assertEqual(builder.remaining_space, 668)
<33> builder.start_frame(QuicFrameType.CRYPTO)
<34> push_bytes(builder.buffer, bytes(299))
<35>
<36> # check builder
<37> self.assertTrue(</s>
|
===========below chunk 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_long_header(self):
# offset: 1
self.assertTrue(builder.end_packet())
self.assertEqual(builder.buffer.tell(), 0)
# check datagrams
datagrams = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 912)
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.crypto
CryptoPair()
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.packet_builder
QuicSentPacket(epoch: Epoch, 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
))
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_frame(frame_type: int, handler: Optional[QuicDeliveryHandler]=None, args: Sequence[Any]=[]) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.tls
Epoch()
===========unchanged ref 1===========
at: tests.test_packet_builder.QuicPacketBuilderTest.test_long_header_then_short_header
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def flush(self) -> Tuple[List[bytes], List[QuicSentPacket]]:
- def flush(self) -> List[bytes]:
"""
Returns the assembled datagrams.
"""
self._flush_current_datagram()
datagrams = self._datagrams
+ packets = self._packets
self._datagrams = []
+ self._packets = []
+ return datagrams, packets
- return datagrams
===========changed ref 1===========
# module: aioquic.packet_builder
+ @dataclass
+ class QuicSentPacket:
+ epoch: Epoch
+ 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 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def start_frame(
+ self,
+ frame_type: int,
+ handler: Optional[QuicDeliveryHandler] = None,
+ args: Sequence[Any] = [],
+ ) -> None:
- def start_frame(self, frame_type: int) -> None:
"""
Starts a new frame.
"""
push_uint_var(self.buffer, frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
+ self._packet.is_ack_eliciting = True
self._ack_eliciting = True
+ if frame_type == QuicFrameType.CRYPTO:
+ self._packet.is_crypto_packet = True
+ if handler is not None:
+ self._packet.delivery_handlers.append((handler, args))
===========changed ref 3===========
# 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:
push_bytes(buf, bytes(self.remaining_space))
packet_size = buf.tell() - self._packet_start
self._pad_first_datagram = False
if is_long_header(self._packet_type):
# finalize length
buf.seek(
self._packet_start
+ self._header_size
- PACKET_NUMBER_SEND_SIZE
- PACKET_LENGTH_SEND_SIZE
)
length = (
packet_size
- self._header_size
+ PACKET_NUMBER_SEND_SIZE
+ self._crypto.aead_tag_size
)
push_uint16(buf, length | 0x4000)
push_packet_number(buf, self._packet_number)
buf.seek(packet_size)
else:
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
push_bytes(buf, 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)
push_bytes(
buf,
self._crypto.encrypt_packet(
plain[0 : self._header_size], plain[self._header_size : packet_size]
),
</s>
===========changed ref 4===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
# offset: 1
<s>
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._crypto = None
+ self._packet = None
return not empty
|
|
tests.test_packet_builder/QuicPacketBuilderTest.test_short_header_empty
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
<21>:<add> datagrams, packets = builder.flush()
<del> datagrams = builder.flush()
<23>:<add> self.assertEqual(packets, [])
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_empty(self):
<0> builder = QuicPacketBuilder(
<1> host_cid=bytes(8),
<2> packet_number=0,
<3> peer_cid=bytes(8),
<4> peer_token=b"",
<5> spin_bit=False,
<6> version=QuicProtocolVersion.DRAFT_20,
<7> )
<8> crypto = CryptoPair()
<9>
<10> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<11> self.assertEqual(builder.remaining_space, 1253)
<12>
<13> # nothing to write
<14> self.assertFalse(builder.end_packet())
<15>
<16> # check builder
<17> self.assertFalse(builder.ack_eliciting)
<18> self.assertEqual(builder.buffer.tell(), 0)
<19> self.assertEqual(builder.packet_number, 0)
<20>
<21> datagrams = builder.flush()
<22> self.assertEqual(len(datagrams), 0)
<23>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.packet
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
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) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: tests.test_packet_builder.QuicPacketBuilderTest.test_long_header_then_long_header
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
crypto = CryptoPair()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def start_frame(
+ self,
+ frame_type: int,
+ handler: Optional[QuicDeliveryHandler] = None,
+ args: Sequence[Any] = [],
+ ) -> None:
- def start_frame(self, frame_type: int) -> None:
"""
Starts a new frame.
"""
push_uint_var(self.buffer, frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
+ self._packet.is_ack_eliciting = True
self._ack_eliciting = True
+ if frame_type == QuicFrameType.CRYPTO:
+ self._packet.is_crypto_packet = True
+ if handler is not None:
+ self._packet.delivery_handlers.append((handler, args))
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
buf = self.buffer
# if there is too little space remaining, start a new datagram
# FIXME: the limit is arbitrary!
if buf.capacity - buf.tell() < 128:
self._flush_current_datagram()
+ # 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._packet = QuicSentPacket(
+ epoch=epoch,
+ is_ack_eliciting=False,
+ is_crypto_packet=False,
+ packet_number=self._packet_number,
+ )
self._packet_start = buf.tell()
# write header
if is_long_header(packet_type):
push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
push_uint32(buf, self._version)
push_uint8(
buf,
(encode_cid_length(len(self._peer_cid)) << 4)
| encode_cid_length(len(self._host_cid)),
)
push_bytes(buf, self._peer_cid)
push_bytes(buf, self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
push_uint_var(buf, len(self._peer_token))
push_bytes(buf, self._peer_token)
push_uint16(buf, 0) # length
push_packet_number(buf, 0) # packet number
else:
push_uint8(
buf,
packet_type
|</s>
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
<s>, 0) # packet number
else:
push_uint8(
buf,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(buf, self._peer_cid)
push_packet_number(buf, self._packet_number)
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
===========changed ref 3===========
# 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:
push_bytes(buf, bytes(self.remaining_space))
packet_size = buf.tell() - self._packet_start
self._pad_first_datagram = False
if is_long_header(self._packet_type):
# finalize length
buf.seek(
self._packet_start
+ self._header_size
- PACKET_NUMBER_SEND_SIZE
- PACKET_LENGTH_SEND_SIZE
)
length = (
packet_size
- self._header_size
+ PACKET_NUMBER_SEND_SIZE
+ self._crypto.aead_tag_size
)
push_uint16(buf, length | 0x4000)
push_packet_number(buf, self._packet_number)
buf.seek(packet_size)
else:
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
push_bytes(buf, 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)
push_bytes(
buf,
self._crypto.encrypt_packet(
plain[0 : self._header_size], plain[self._header_size : packet_size]
),
</s>
|
tests.test_packet_builder/QuicPacketBuilderTest.test_short_header_padding
|
Modified
|
aiortc~aioquic
|
71a0a3fe0b18d72971bf80d36f13d491dfe32a35
|
[packet builder] build and store QuicSentPacket
|
<24>:<add> datagrams, packets = builder.flush()
<del> datagrams = builder.flush()
<27>:<add> self.assertEqual(
<add> packets,
<add> [
<add> QuicSentPacket(
<add> epoch=Epoch.ONE_RTT,
<add> is_ack_eliciting=True,
<add> is_crypto_packet=True,
<add> packet_number=0,
<add> sent_bytes=1280,
<add> )
<add> ],
<add> )
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_padding(self):
<0> builder = QuicPacketBuilder(
<1> host_cid=bytes(8),
<2> packet_number=0,
<3> peer_cid=bytes(8),
<4> peer_token=b"",
<5> spin_bit=False,
<6> version=QuicProtocolVersion.DRAFT_20,
<7> )
<8> crypto = CryptoPair()
<9> crypto.setup_initial(bytes(8), is_client=True)
<10>
<11> # ONE_RTT, fully padded
<12> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<13> self.assertEqual(builder.remaining_space, 1253)
<14> builder.start_frame(QuicFrameType.CRYPTO)
<15> push_bytes(builder.buffer, bytes(builder.remaining_space))
<16> self.assertTrue(builder.end_packet())
<17>
<18> # check builder
<19> self.assertTrue(builder.ack_eliciting)
<20> self.assertEqual(builder.buffer.tell(), 0)
<21> self.assertEqual(builder.packet_number, 1)
<22>
<23> # check datagrams
<24> datagrams = builder.flush()
<25> self.assertEqual(len(datagrams), 1)
<26> self.assertEqual(len(datagrams[0]), 1280)
<27>
|
===========unchanged ref 0===========
at: aioquic.packet_builder
QuicSentPacket(epoch: Epoch, 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()
at: tests.test_packet_builder.QuicPacketBuilderTest.test_long_header_then_long_header
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
===========changed ref 0===========
# module: aioquic.packet_builder
+ @dataclass
+ class QuicSentPacket:
+ epoch: Epoch
+ 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 1===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_empty(self):
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
crypto = CryptoPair()
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertEqual(builder.remaining_space, 1253)
# nothing to write
self.assertFalse(builder.end_packet())
# check builder
self.assertFalse(builder.ack_eliciting)
self.assertEqual(builder.buffer.tell(), 0)
self.assertEqual(builder.packet_number, 0)
+ datagrams, packets = builder.flush()
- datagrams = builder.flush()
self.assertEqual(len(datagrams), 0)
+ self.assertEqual(packets, [])
===========changed ref 2===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_empty(self):
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
crypto = CryptoPair()
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1237)
# nothing to write
self.assertFalse(builder.end_packet())
self.assertEqual(builder.buffer.tell(), 0)
self.assertEqual(builder.packet_number, 0)
+ datagrams, packets = builder.flush()
- datagrams = builder.flush()
self.assertEqual(len(datagrams), 0)
+ self.assertEqual(packets, [])
===========changed ref 3===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_padding(self):
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
pad_first_datagram=True,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
crypto = CryptoPair()
crypto.setup_initial(bytes(8), is_client=True)
# INITIAL, fully padded
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1237)
builder.start_frame(QuicFrameType.CRYPTO)
push_bytes(builder.buffer, bytes(100))
self.assertTrue(builder.end_packet())
# check builder state
self.assertEqual(builder.buffer.tell(), 1280)
self.assertEqual(builder.packet_number, 1)
# check datagrams
+ datagrams, packets = builder.flush()
- datagrams = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 1280)
+ self.assertEqual(
+ packets,
+ [
+ QuicSentPacket(
+ epoch=Epoch.INITIAL,
+ is_ack_eliciting=True,
+ is_crypto_packet=True,
+ packet_number=0,
+ sent_bytes=1280,
+ )
+ ],
+ )
===========changed ref 4===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_short_header(self):
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
crypto = CryptoPair()
crypto.setup_initial(bytes(8), is_client=True)
# INITIAL, fully padded
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1237)
builder.start_frame(QuicFrameType.CRYPTO)
push_bytes(builder.buffer, bytes(builder.remaining_space))
self.assertTrue(builder.end_packet())
# ONE_RTT, fully padded
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertEqual(builder.remaining_space, 1253)
+ builder.start_frame(QuicFrameType.STREAM_BASE)
- builder.start_frame(QuicFrameType.CRYPTO)
push_bytes(builder.buffer, bytes(builder.remaining_space))
self.assertTrue(builder.end_packet())
# check builder
self.assertTrue(builder.ack_eliciting)
self.assertEqual(builder.buffer.tell(), 0)
# check datagrams
+ datagrams, packets = builder.flush()
- datagrams = builder.flush()
self.assertEqual(len(datagrams), 2)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(len(datagrams[1]), 1280)
+ self.assertEqual(
+ packets,
+ [
+ QuicSentPacket(
+ epoch=Epoch.INITIAL,
+ is_ack_eliciting=True,
+ is_crypto</s>
===========changed ref 5===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_short_header(self):
# offset: 1
<s>(
+ epoch=Epoch.INITIAL,
+ is_ack_eliciting=True,
+ is_crypto_packet=True,
+ packet_number=0,
+ sent_bytes=1280,
+ ),
+ QuicSentPacket(
+ epoch=Epoch.ONE_RTT,
+ is_ack_eliciting=True,
+ is_crypto_packet=False,
+ packet_number=1,
+ sent_bytes=1280,
+ ),
+ ],
+ )
|
aioquic.stream/QuicStream.__init__
|
Modified
|
aiortc~aioquic
|
1166d06ea4f300ee4d34898a4b6cc0912b6bebf6
|
[connection] ensure MAX_DATA and MAX_STREAM_DATA get retransmitted
|
<2>:<add> self.max_stream_data_local_sent = max_stream_data_local
|
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
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_remote = max_stream_data_remote
<3>
<4> if stream_id is not None:
<5> self.reader = asyncio.StreamReader()
<6> self.writer = asyncio.StreamWriter(self, None, self.reader, None)
<7> else:
<8> self.reader = None
<9> self.writer = None
<10>
<11> self._recv_buffer = bytearray()
<12> self._recv_fin = False
<13> self._recv_highest = 0 # the highest offset ever seen
<14> self._recv_start = 0 # the offset for the start of the buffer
<15> self._recv_ranges = RangeSet()
<16>
<17> self._send_acked = RangeSet()
<18> self._send_buffer = bytearray()
<19> self._send_buffer_fin: Optional[int] = None
<20> self._send_highest = 0
<21> self._send_pending = RangeSet()
<22> self._send_pending_eof = False
<23> self._send_buffer_start = 0 # the offset for the start of the buffer
<24> self._send_buffer_stop = 0 # the offset for the stop of the buffer
<25>
<26> self.__stream_id = stream_id
<27>
|
===========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_fin = True
at: aioquic.stream.QuicStream.get_frame
self._send_pending_eof = False
self._send_highest = stop
at: aioquic.stream.QuicStream.on_data_delivery
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_start = r.stop
at: aioquic.stream.QuicStream.write
self._send_buffer += data
self._send_buffer_stop += size
at: aioquic.stream.QuicStream.write_eof
self._send_buffer_fin = self._send_buffer_stop
self._send_pending_eof = True
at: asyncio.streams
StreamWriter(transport: transports.BaseTransport, protocol: protocols.BaseProtocol, reader: Optional[StreamReader], loop: events.AbstractEventLoop)
StreamReader(limit: int=..., loop: Optional[events.AbstractEventLoop]=...)
at: asyncio.transports.BaseTransport
__slots__ = ('_extra',)
__init__(self, extra: Optional[Mapping[Any, Any]]=...) -> None
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
1166d06ea4f300ee4d34898a4b6cc0912b6bebf6
|
[connection] ensure MAX_DATA and MAX_STREAM_DATA get retransmitted
|
<s>[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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
<0> if is_client:
<1> assert (
<2> original_connection_id is None
<3> ), "Cannot set original_connection_id for a client"
<4> else:
<5> assert certificate is not None, "SSL certificate is required for a server"
<6> assert private_key is not None, "SSL private key is required for a server"
<7>
<8> self.alpn_protocols = alpn_protocols
<9> self.certificate = certificate
<10> self.is_client = is_client
<11> self.peer_cid = os.urandom(8)
<12> self._peer_cid_seq: Optional[int] = None
<13> self._peer_cid_available: List[QuicConnectionId] = []
<14> self.peer_token = b""
<15> self.private_key = private_key
<16> self.secrets_log_file = secrets_log_file
<17> self.server_name = server_name
<18> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<19>
<20> # counters for debugging
<21> self._stateless_retry_count = 0
<22> self._version_negotiation_count = 0
<23>
<24> self._loop = asyncio.get_event_loop()
<25> self.__close: Optional[Dict] = None
<26> self.__connected = asyncio.Event()
<27> self.__epoch = tls.Epoch.INITIAL
<28> self._host_cids = [
<29> QuicConnectionId(
<30> cid=os.urandom(8),
<31> sequence_number=0,
<32> stateless_reset</s>
|
===========below chunk 0===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = 1048576
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._loss = QuicPacketLoss(
get_time=self._loop.time, send_probe=self._send_probe
)
self._loss_timer: Optional[asyncio.TimerHandle] = None
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._packet_number = 0
self._parameters_available = asyncio.Event()
self._parameters_received = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
</s>
===========below chunk 1===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s> 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
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._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# things to send
self._ping_pending = False
self._probe_pending = False
self._retire_connection_ids: List[int] = []
# callbacks
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionIdHandler = lambda c: None
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
if stream_handler is not None:
</s>
===========below chunk 2===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 3
<s>._stream_handler = stream_handler
else:
self._stream_handler = lambda r, w: None
# frame handlers
self.__frame_handlers = [
(self._handle_padding_frame, EPOCHS("IZHO")),
(self._handle_padding_frame, EPOCHS("ZO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_reset_stream_frame, EPOCHS("ZO")),
(self._handle_stop_sending_frame, EPOCHS("ZO")),
(self._handle_crypto_frame, EPOCHS("IHO")),
(self._handle_new_token_frame, EPOCHS("O")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")</s>
===========below chunk 3===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 4
<s> (self._handle_max_data_frame, EPOCHS("ZO")),
(self._handle_max_stream_data_frame, EPOCHS("ZO")),
(self._handle_max_streams_bidi_frame, EPOCHS("ZO")),
(self._handle_max_streams_uni_frame, EPOCHS("ZO")),
(self._handle_data_blocked_frame, EPOCHS("ZO")),
(self._handle_stream_data_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_new_connection_id_frame, EPOCHS("ZO")),
(self._handle_retire_connection_id_frame, EPOCHS("O")),
(self._handle_path_challenge_frame, EPOCHS("ZO")),
(self._handle_path_response_frame, EPOCHS("O")),
(self._handle_connection_close_frame, EPOCHS("IZHO")),
(self._handle_connection_close_frame, EPOCHS("ZO")),
]
|
|
aioquic.connection/QuicConnection._write_connection_limits
|
Modified
|
aiortc~aioquic
|
1166d06ea4f300ee4d34898a4b6cc0912b6bebf6
|
[connection] ensure MAX_DATA and MAX_STREAM_DATA get retransmitted
|
<4>:<add> if self._local_max_data_sent != self._local_max_data:
<add> builder.start_frame(QuicFrameType.MAX_DATA, self._on_max_data_delivery)
<del> builder.start_frame(QuicFrameType.MAX_DATA)
<6>:<add> self._local_max_data_sent = 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 + 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> builder.start_frame(QuicFrameType.MAX_DATA)
<5> push_uint_var(builder.buffer, self._local_max_data)
<6>
|
===========unchanged ref 0===========
at: aioquic.connection
write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
at: aioquic.connection.QuicConnection._write_handshake
space = self.spaces[epoch]
at: aioquic.packet_builder.QuicPacketBuilder
end_packet() -> bool
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _on_max_stream_data_delivery(
+ self, delivery: QuicDeliveryState, stream: QuicStream
+ ) -> None:
+ if delivery != QuicDeliveryState.ACKED:
+ stream.max_stream_data_local_sent = 0
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _on_max_data_delivery(self, delivery: QuicDeliveryState) -> None:
+ if delivery != QuicDeliveryState.ACKED:
+ self._local_max_data_sent = 0
+
===========changed ref 2===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
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
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_fin = False
self._recv_highest = 0 # the highest offset ever seen
self._recv_start = 0 # the offset for the start of the buffer
self._recv_ranges = RangeSet()
self._send_acked = RangeSet()
self._send_buffer = bytearray()
self._send_buffer_fin: Optional[int] = None
self._send_highest = 0
self._send_pending = RangeSet()
self._send_pending_eof = False
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.__stream_id = stream_id
===========changed ref 3===========
<s>[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,
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"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.peer_cid = os.urandom(8)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self.host_cid = self</s>
===========changed ref 4===========
<s> = 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,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
<s>os.urandom(16),
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
+ self._local_max_data = MAX_DATA_WINDOW
+ self._local_max_data_sent = MAX_DATA_WINDOW
- self._local_max_data = 1048576
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._loss = QuicPacketLoss(
get_time=self._loop.time, send_probe=self._send_probe
)
self._loss_timer: Optional[asyncio.TimerHandle] = None
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._packet_number = 0
self._parameters</s>
|
aioquic.connection/QuicConnection._write_stream_limits
|
Modified
|
aiortc~aioquic
|
1166d06ea4f300ee4d34898a4b6cc0912b6bebf6
|
[connection] ensure MAX_DATA and MAX_STREAM_DATA get retransmitted
|
<8>:<add> if stream.max_stream_data_local_sent != stream.max_stream_data_local:
<add> builder.start_frame(
<add> QuicFrameType.MAX_STREAM_DATA,
<del> builder.start_frame(QuicFrameType.MAX_STREAM_DATA)
<9>:<add> self._on_max_stream_data_delivery,
<add> (stream,),
<add> )
<11>:<add> stream.max_stream_data_local_sent = stream.max_stream_data_local
|
# 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> builder.start_frame(QuicFrameType.MAX_STREAM_DATA)
<9> push_uint_var(builder.buffer, stream.stream_id)
<10> push_uint_var(builder.buffer, stream.max_stream_data_local)
<11>
|
===========unchanged ref 0===========
at: aioquic.connection
MAX_DATA_WINDOW = 1048576
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.loss
QuicPacketSpace()
at: aioquic.packet
push_uint_var(buf: Buffer, value: int) -> None
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
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: 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===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _on_max_data_delivery(self, delivery: QuicDeliveryState) -> None:
+ if delivery != QuicDeliveryState.ACKED:
+ self._local_max_data_sent = 0
+
===========changed ref 1===========
# 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 + MAX_DATA_WINDOW // 2 > self._local_max_data:
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.start_frame(QuicFrameType.MAX_DATA)
push_uint_var(builder.buffer, self._local_max_data)
+ self._local_max_data_sent = self._local_max_data
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _on_max_stream_data_delivery(
+ self, delivery: QuicDeliveryState, stream: QuicStream
+ ) -> None:
+ if delivery != QuicDeliveryState.ACKED:
+ stream.max_stream_data_local_sent = 0
+
===========changed ref 3===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
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
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_fin = False
self._recv_highest = 0 # the highest offset ever seen
self._recv_start = 0 # the offset for the start of the buffer
self._recv_ranges = RangeSet()
self._send_acked = RangeSet()
self._send_buffer = bytearray()
self._send_buffer_fin: Optional[int] = None
self._send_highest = 0
self._send_pending = RangeSet()
self._send_pending_eof = False
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.__stream_id = stream_id
===========changed ref 4===========
<s>[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,
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"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.peer_cid = os.urandom(8)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self.host_cid = self</s>
|
aioquic.loss/QuicPacketLoss.__init__
|
Modified
|
aiortc~aioquic
|
b6919c3ab263caac7722bb9178aea624cb1b6c39
|
[connection] stop loss timer on shutdown
|
<6>:<add> self._logger = logger
|
# module: aioquic.loss
class QuicPacketLoss:
def __init__(
+ self,
+ logger: logging.LoggerAdapter,
+ get_time: Callable[[], float],
+ send_probe: Callable[[], None],
- self, get_time: Callable[[], float], send_probe: Callable[[], None]
) -> None:
<0> self.ack_delay_exponent = 3
<1> self.max_ack_delay = 25 # ms
<2> self.spaces: List[QuicPacketSpace] = []
<3>
<4> # callbacks
<5> self._get_time = get_time
<6> self._send_probe = send_probe
<7>
<8> self._crypto_count = 0
<9> self._pto_count = 0
<10>
<11> self._rtt_initialized = False
<12> self._rtt_latest = 0.0
<13> self._rtt_min = math.inf
<14> self._rtt_smoothed = 0.0
<15> self._rtt_variance = 0.0
<16>
<17> self._time_of_last_sent_ack_eliciting_packet = 0.0
<18> self._time_of_last_sent_crypto_packet = 0.0
<19>
|
===========unchanged ref 0===========
at: aioquic.loss
QuicPacketSpace()
at: aioquic.loss.QuicPacketLoss.on_ack_received
self._rtt_latest = max(latest_rtt, 0.001)
self._rtt_latest -= ack_delay
self._rtt_min = self._rtt_latest
self._rtt_initialized = True
self._crypto_count = 0
self._pto_count = 0
at: aioquic.loss.QuicPacketLoss.on_loss_timeout
self._pto_count += 1
at: logging
LoggerAdapter(logger: Logger, extra: Mapping[str, Any])
at: math
inf: float
at: typing
Callable = _CallableType(collections.abc.Callable, 2)
List = _alias(list, 1, inst=False, name='List')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.