{ // 获取包含Hugging Face文本的span元素 const spans = link.querySelectorAll('span.whitespace-nowrap, span.hidden.whitespace-nowrap'); spans.forEach(span => { if (span.textContent && span.textContent.trim().match(/Hugging\s*Face/i)) { span.textContent = 'AI快站'; } }); }); // 替换logo图片的alt属性 document.querySelectorAll('img[alt*="Hugging"], img[alt*="Face"]').forEach(img => { if (img.alt.match(/Hugging\s*Face/i)) { img.alt = 'AI快站 logo'; } }); } // 替换导航栏中的链接 function replaceNavigationLinks() { // 已替换标记,防止重复运行 if (window._navLinksReplaced) { return; } // 已经替换过的链接集合,防止重复替换 const replacedLinks = new Set(); // 只在导航栏区域查找和替换链接 const headerArea = document.querySelector('header') || document.querySelector('nav'); if (!headerArea) { return; } // 在导航区域内查找链接 const navLinks = headerArea.querySelectorAll('a'); navLinks.forEach(link => { // 如果已经替换过,跳过 if (replacedLinks.has(link)) return; const linkText = link.textContent.trim(); const linkHref = link.getAttribute('href') || ''; // 替换Spaces链接 - 仅替换一次 if ( (linkHref.includes('/spaces') || linkHref === '/spaces' || linkText === 'Spaces' || linkText.match(/^s*Spacess*$/i)) && linkText !== 'OCR模型免费转Markdown' && linkText !== 'OCR模型免费转Markdown' ) { link.textContent = 'OCR模型免费转Markdown'; link.href = 'https://fast360.xyz'; link.setAttribute('target', '_blank'); link.setAttribute('rel', 'noopener noreferrer'); replacedLinks.add(link); } // 删除Posts链接 else if ( (linkHref.includes('/posts') || linkHref === '/posts' || linkText === 'Posts' || linkText.match(/^s*Postss*$/i)) ) { if (link.parentNode) { link.parentNode.removeChild(link); } replacedLinks.add(link); } // 替换Docs链接 - 仅替换一次 else if ( (linkHref.includes('/docs') || linkHref === '/docs' || linkText === 'Docs' || linkText.match(/^s*Docss*$/i)) && linkText !== '模型下载攻略' ) { link.textContent = '模型下载攻略'; link.href = '/'; replacedLinks.add(link); } // 删除Enterprise链接 else if ( (linkHref.includes('/enterprise') || linkHref === '/enterprise' || linkText === 'Enterprise' || linkText.match(/^s*Enterprises*$/i)) ) { if (link.parentNode) { link.parentNode.removeChild(link); } replacedLinks.add(link); } }); // 查找可能嵌套的Spaces和Posts文本 const textNodes = []; function findTextNodes(element) { if (element.nodeType === Node.TEXT_NODE) { const text = element.textContent.trim(); if (text === 'Spaces' || text === 'Posts' || text === 'Enterprise') { textNodes.push(element); } } else { for (const child of element.childNodes) { findTextNodes(child); } } } // 只在导航区域内查找文本节点 findTextNodes(headerArea); // 替换找到的文本节点 textNodes.forEach(node => { const text = node.textContent.trim(); if (text === 'Spaces') { node.textContent = node.textContent.replace(/Spaces/g, 'OCR模型免费转Markdown'); } else if (text === 'Posts') { // 删除Posts文本节点 if (node.parentNode) { node.parentNode.removeChild(node); } } else if (text === 'Enterprise') { // 删除Enterprise文本节点 if (node.parentNode) { node.parentNode.removeChild(node); } } }); // 标记已替换完成 window._navLinksReplaced = true; } // 替换代码区域中的域名 function replaceCodeDomains() { // 特别处理span.hljs-string和span.njs-string元素 document.querySelectorAll('span.hljs-string, span.njs-string, span[class*="hljs-string"], span[class*="njs-string"]').forEach(span => { if (span.textContent && span.textContent.includes('huggingface.co')) { span.textContent = span.textContent.replace(/huggingface.co/g, 'aifasthub.com'); } }); // 替换hljs-string类的span中的域名(移除多余的转义符号) document.querySelectorAll('span.hljs-string, span[class*="hljs-string"]').forEach(span => { if (span.textContent && span.textContent.includes('huggingface.co')) { span.textContent = span.textContent.replace(/huggingface.co/g, 'aifasthub.com'); } }); // 替换pre和code标签中包含git clone命令的域名 document.querySelectorAll('pre, code').forEach(element => { if (element.textContent && element.textContent.includes('git clone')) { const text = element.innerHTML; if (text.includes('huggingface.co')) { element.innerHTML = text.replace(/huggingface.co/g, 'aifasthub.com'); } } }); // 处理特定的命令行示例 document.querySelectorAll('pre, code').forEach(element => { const text = element.innerHTML; if (text.includes('huggingface.co')) { // 针对git clone命令的专门处理 if (text.includes('git clone') || text.includes('GIT_LFS_SKIP_SMUDGE=1')) { element.innerHTML = text.replace(/huggingface.co/g, 'aifasthub.com'); } } }); // 特别处理模型下载页面上的代码片段 document.querySelectorAll('.flex.border-t, .svelte_hydrator, .inline-block').forEach(container => { const content = container.innerHTML; if (content && content.includes('huggingface.co')) { container.innerHTML = content.replace(/huggingface.co/g, 'aifasthub.com'); } }); // 特别处理模型仓库克隆对话框中的代码片段 try { // 查找包含"Clone this model repository"标题的对话框 const cloneDialog = document.querySelector('.svelte_hydration_boundary, [data-target="MainHeader"]'); if (cloneDialog) { // 查找对话框中所有的代码片段和命令示例 const codeElements = cloneDialog.querySelectorAll('pre, code, span'); codeElements.forEach(element => { if (element.textContent && element.textContent.includes('huggingface.co')) { if (element.innerHTML.includes('huggingface.co')) { element.innerHTML = element.innerHTML.replace(/huggingface.co/g, 'aifasthub.com'); } else { element.textContent = element.textContent.replace(/huggingface.co/g, 'aifasthub.com'); } } }); } // 更精确地定位克隆命令中的域名 document.querySelectorAll('[data-target]').forEach(container => { const codeBlocks = container.querySelectorAll('pre, code, span.hljs-string'); codeBlocks.forEach(block => { if (block.textContent && block.textContent.includes('huggingface.co')) { if (block.innerHTML.includes('huggingface.co')) { block.innerHTML = block.innerHTML.replace(/huggingface.co/g, 'aifasthub.com'); } else { block.textContent = block.textContent.replace(/huggingface.co/g, 'aifasthub.com'); } } }); }); } catch (e) { // 错误处理但不打印日志 } } // 当DOM加载完成后执行替换 if (document.readyState === 'loading') { document.addEventListener('DOMContentLoaded', () => { replaceHeaderBranding(); replaceNavigationLinks(); replaceCodeDomains(); // 只在必要时执行替换 - 3秒后再次检查 setTimeout(() => { if (!window._navLinksReplaced) { console.log('[Client] 3秒后重新检查导航链接'); replaceNavigationLinks(); } }, 3000); }); } else { replaceHeaderBranding(); replaceNavigationLinks(); replaceCodeDomains(); // 只在必要时执行替换 - 3秒后再次检查 setTimeout(() => { if (!window._navLinksReplaced) { console.log('[Client] 3秒后重新检查导航链接'); replaceNavigationLinks(); } }, 3000); } // 增加一个MutationObserver来处理可能的动态元素加载 const observer = new MutationObserver(mutations => { // 检查是否导航区域有变化 const hasNavChanges = mutations.some(mutation => { // 检查是否存在header或nav元素变化 return Array.from(mutation.addedNodes).some(node => { if (node.nodeType === Node.ELEMENT_NODE) { // 检查是否是导航元素或其子元素 if (node.tagName === 'HEADER' || node.tagName === 'NAV' || node.querySelector('header, nav')) { return true; } // 检查是否在导航元素内部 let parent = node.parentElement; while (parent) { if (parent.tagName === 'HEADER' || parent.tagName === 'NAV') { return true; } parent = parent.parentElement; } } return false; }); }); // 只在导航区域有变化时执行替换 if (hasNavChanges) { // 重置替换状态,允许再次替换 window._navLinksReplaced = false; replaceHeaderBranding(); replaceNavigationLinks(); } }); // 开始观察document.body的变化,包括子节点 if (document.body) { observer.observe(document.body, { childList: true, subtree: true }); } else { document.addEventListener('DOMContentLoaded', () => { observer.observe(document.body, { childList: true, subtree: true }); }); } })(); \n + \n + \"\"\"\n + "}}},{"rowIdx":1833,"cells":{"path":{"kind":"string","value":"aioquic.stream/QuicStream.get_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"135636bd74280024db5dae53ddbcf8193e201b27"},"commit_message":{"kind":"string","value":"[stream] do not send more data than MAX_STREAM_DATA allows"},"ground_truth":{"kind":"string","value":" <6>: \n # flow control\n if self.stream_id is not None:\n size = min(size, self.max_stream_data_remote - self._send_start)\n \n"},"main_code":{"kind":"string","value":" # module: aioquic.stream\n class QuicStream:\n def get_frame(self, size: int) -> QuicStreamFrame:\n <0> \"\"\"\n <1> Get a frame of data to send.\n <2> \"\"\"\n <3> assert not self._send_complete, \"cannot call get_frame() after completion\"\n <4> \n <5> size = min(size, len(self._send_buffer))\n <6> frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)\n <7> self._send_buffer = self._send_buffer[size:]\n <8> self._send_start += size\n <9> \n<10> # if the buffer is empty and EOF was written, set the FIN bit\n<11> if self._send_eof and not self._send_buffer:\n<12> frame.fin = True\n<13> self._send_complete = True\n<14> \n<15> return frame\n<16> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.packet\n QuicStreamFrame(data: bytes=b\"\", fin: bool=False, offset: int=0)\n \n at: aioquic.packet.QuicStreamFrame\n data: bytes = b\"\"\n \n fin: bool = False\n \n offset: int = 0\n \n at: aioquic.stream.QuicStream.__init__\n self.max_stream_data_remote = max_stream_data_remote\n \n self._send_buffer = bytearray()\n \n self._send_complete = False\n \n self._send_start = 0\n \n at: aioquic.stream.QuicStream.get_frame\n self._send_complete = True\n \n at: aioquic.stream.QuicStream.write\n self._send_buffer += data\n \n "}}},{"rowIdx":1834,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection._write_application"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"135636bd74280024db5dae53ddbcf8193e201b27"},"commit_message":{"kind":"string","value":"[stream] do not send more data than MAX_STREAM_DATA allows"},"ground_truth":{"kind":"string","value":"<38>: if (\n isinstance(stream_id, int)\n and stream.has_data_to_send()\n if isinstance(stream_id, int) and stream.has_data_to_send():\n<39>: and not stream.is_blocked()\n ):\n"},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _write_application(self) -> Iterator[bytes]:\n <0> epoch = tls.Epoch.ONE_RTT\n <1> space = self.spaces[epoch]\n <2> if not space.crypto.send.is_valid():\n <3> return\n <4> \n <5> buf = Buffer(capacity=PACKET_MAX_SIZE)\n <6> \n <7> while True:\n <8> # write header\n <9> push_uint8(\n<10> buf,\n<11> PACKET_FIXED_BIT\n<12> | (self._spin_bit << 5)\n<13> | (space.crypto.key_phase << 2)\n<14> | (PACKET_NUMBER_SEND_SIZE - 1),\n<15> )\n<16> push_bytes(buf, self.peer_cid)\n<17> push_uint16(buf, self.packet_number)\n<18> header_size = buf.tell()\n<19> \n<20> # ACK\n<21> if self.send_ack[epoch] and space.ack_queue:\n<22> push_uint_var(buf, QuicFrameType.ACK)\n<23> packet.push_ack_frame(buf, space.ack_queue, 0)\n<24> self.send_ack[epoch] = False\n<25> \n<26> # FLOW CONTROL\n<27> for control_frame in self._pending_flow_control:\n<28> push_bytes(buf, control_frame)\n<29> self._pending_flow_control = []\n<30> \n<31> # CLOSE\n<32> if self.__close and self.__epoch == epoch:\n<33> push_close(buf, **self.__close)\n<34> self.__close = None\n<35> \n<36> # STREAM\n<37> for stream_id, stream in self.streams.items():\n<38> if isinstance(stream_id, int) and stream.has_data_to_send():\n<39> frame = stream.get_frame(\n<40> PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6\n<41> )\n<42> flags = QuicStreamFlag.LEN\n<43> if frame.offset:\n<44> flags |= QuicStream"},"context":{"kind":"string","value":"===========below chunk 0===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _write_application(self) -> Iterator[bytes]:\n # offset: 1\n if frame.fin:\n flags |= QuicStreamFlag.FIN\n push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)\n with push_stream_frame(buf, 0, frame.offset):\n push_bytes(buf, frame.data)\n \n packet_size = buf.tell()\n if packet_size > header_size:\n # encrypt\n data = buf.data\n yield space.crypto.encrypt_packet(\n data[0:header_size], data[header_size:packet_size]\n )\n \n self.packet_number += 1\n buf.seek(0)\n else:\n break\n \n \n===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n push_bytes(buf: Buffer, v: bytes) -> None\n \n push_uint8(buf: Buffer, v: int) -> None\n \n push_uint16(buf: Buffer, v: int) -> None\n \n at: aioquic.buffer.Buffer\n tell() -> int\n \n at: aioquic.connection\n PACKET_MAX_SIZE = 1280\n \n push_close(buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None\n \n at: aioquic.connection.PacketSpace.__init__\n self.ack_queue = RangeSet()\n \n self.crypto = CryptoPair()\n \n at: aioquic.connection.QuicConnection\n supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]\n \n at: aioquic.connection.QuicConnection.__init__\n self.peer_cid = os.urandom(8)\n \n self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}\n \n self.__close: Optional[Dict] = None\n \n self.__epoch = tls.Epoch.INITIAL\n \n self._pending_flow_control: List[bytes] = []\n \n self._spin_bit = False\n \n at: aioquic.connection.QuicConnection._handle_crypto_frame\n self.__epoch = tls.Epoch.ONE_RTT\n self.__epoch = tls.Epoch.HANDSHAKE\n \n at: aioquic.connection.QuicConnection._initialize\n self.send_ack = {\n tls.Epoch.INITIAL: False,\n tls.Epoch.HANDSHAKE: False,\n tls.Epoch.ONE_RTT: False,\n }\n \n self.spaces = {\n tls.Epoch.INITIAL: PacketSpace(),\n tls.Epoch.HANDSHAKE: PacketSpace(),\n tls.Epoch.ONE_RTT: PacketSpace(),\n }\n \n self.packet_number = 0\n \n \n===========unchanged ref 1===========\n at: aioquic.connection.QuicConnection._write_application\n self.packet_number += 1\n \n at: aioquic.connection.QuicConnection._write_handshake\n self.__close = None\n \n self.packet_number += 1\n \n at: aioquic.connection.QuicConnection.close\n self.__close = {\n \"error_code\": error_code,\n \"frame_type\": frame_type,\n \"reason_phrase\": reason_phrase,\n }\n \n at: aioquic.connection.QuicConnection.datagram_received\n self.peer_cid = header.source_cid\n \n self._spin_bit = not get_spin_bit(plain_header[0])\n self._spin_bit = get_spin_bit(plain_header[0])\n \n at: aioquic.crypto.CryptoContext\n is_valid() -> bool\n \n at: aioquic.crypto.CryptoPair\n encrypt_packet(plain_header: bytes, plain_payload: bytes) -> bytes\n \n at: aioquic.crypto.CryptoPair.__init__\n self.aead_tag_size = 16\n \n self.send = CryptoContext()\n \n at: aioquic.packet\n PACKET_FIXED_BIT = 0x40\n \n PACKET_NUMBER_SEND_SIZE = 2\n \n push_uint_var(buf: Buffer, value: int) -> None\n \n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n push_ack_frame(buf: Buffer, rangeset: RangeSet, delay: int) -> None\n \n QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)\n QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n push_stream_frame(buf: Buffer, stream_id: int, offset: int) -> Generator\n \n at: aioquic.packet.QuicStreamFrame\n data: bytes = b\"\"\n \n \n===========unchanged ref 2===========\n fin: bool = False\n \n offset: int = 0\n \n at: aioquic.stream.QuicStream\n get_frame(size: int) -> QuicStreamFrame\n \n has_data_to_send() -> bool\n \n is_blocked()\n \n at: aioquic.tls\n Epoch()\n \n at: typing\n Iterator = _alias(collections.abc.Iterator, 1)\n \n \n===========changed ref 0===========\n # module: aioquic.stream\n class QuicStream:\n + def is_blocked(self):\n + \"\"\"\n + Returns True if there is data to send but the peer's MAX_STREAM_DATA\n + prevents us from sending it.\n + \"\"\"\n + return self._send_buffer and self._send_start >= self.max_stream_data_remote\n + \n===========changed ref 1===========\n # module: aioquic.stream\n class QuicStream:\n def get_frame(self, size: int) -> QuicStreamFrame:\n \"\"\"\n Get a frame of data to send.\n \"\"\"\n assert not self._send_complete, \"cannot call get_frame() after completion\"\n \n size = min(size, len(self._send_buffer))\n + \n + # flow control\n + if self.stream_id is not None:\n + size = min(size, self.max_stream_data_remote - self._send_start)\n + \n frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)\n self._send_buffer = self._send_buffer[size:]\n self._send_start += size\n \n # if the buffer is empty and EOF was written, set the FIN bit\n if self._send_eof and not self._send_buffer:\n frame.fin = True\n self._send_complete = True\n \n return frame\n "}}},{"rowIdx":1835,"cells":{"path":{"kind":"string","value":"tests.test_stream/QuicStreamTest.test_send_data"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"135636bd74280024db5dae53ddbcf8193e201b27"},"commit_message":{"kind":"string","value":"[stream] do not send more data than MAX_STREAM_DATA allows"},"ground_truth":{"kind":"string","value":" <0>: stream = QuicStream(stream_id=0, max_stream_data_remote=512)\n stream = QuicStream()\n <3>: self.assertFalse(stream.is_blocked())\n <6>: self.assertFalse(stream.is_blocked())\n<11>: self.assertFalse(stream.is_blocked())\n<16>: self.assertFalse(stream.is_blocked())\n"},"main_code":{"kind":"string","value":" # module: tests.test_stream\n class QuicStreamTest(TestCase):\n def test_send_data(self):\n <0> stream = QuicStream()\n <1> \n <2> self.assertFalse(stream.has_data_to_send())\n <3> stream.write(b\"0123456789012345\")\n <4> \n <5> self.assertTrue(stream.has_data_to_send())\n <6> frame = stream.get_frame(8)\n <7> self.assertEqual(frame.data, b\"01234567\")\n <8> self.assertEqual(frame.offset, 0)\n <9> \n<10> self.assertTrue(stream.has_data_to_send())\n<11> frame = stream.get_frame(8)\n<12> self.assertEqual(frame.data, b\"89012345\")\n<13> self.assertEqual(frame.offset, 8)\n<14> \n<15> self.assertFalse(stream.has_data_to_send())\n<16> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.packet.QuicStreamFrame\n data: bytes = b\"\"\n \n fin: bool = False\n \n offset: int = 0\n \n at: aioquic.stream\n QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)\n \n at: aioquic.stream.QuicStream\n get_frame(size: int) -> QuicStreamFrame\n \n has_data_to_send() -> bool\n \n is_blocked()\n \n write(data: bytes) -> None\n \n at: unittest.case.TestCase\n failureException: Type[BaseException]\n \n longMessage: bool\n \n maxDiff: Optional[int]\n \n _testMethodName: str\n \n _testMethodDoc: str\n \n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n assertTrue(expr: Any, msg: Any=...) -> None\n \n assertFalse(expr: Any, msg: Any=...) -> None\n \n \n===========changed ref 0===========\n # module: aioquic.stream\n class QuicStream:\n + def is_blocked(self):\n + \"\"\"\n + Returns True if there is data to send but the peer's MAX_STREAM_DATA\n + prevents us from sending it.\n + \"\"\"\n + return self._send_buffer and self._send_start >= self.max_stream_data_remote\n + \n===========changed ref 1===========\n # module: aioquic.stream\n class QuicStream:\n def get_frame(self, size: int) -> QuicStreamFrame:\n \"\"\"\n Get a frame of data to send.\n \"\"\"\n assert not self._send_complete, \"cannot call get_frame() after completion\"\n \n size = min(size, len(self._send_buffer))\n + \n + # flow control\n + if self.stream_id is not None:\n + size = min(size, self.max_stream_data_remote - self._send_start)\n + \n frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)\n self._send_buffer = self._send_buffer[size:]\n self._send_start += size\n \n # if the buffer is empty and EOF was written, set the FIN bit\n if self._send_eof and not self._send_buffer:\n frame.fin = True\n self._send_complete = True\n \n return frame\n \n===========changed ref 2===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _write_application(self) -> Iterator[bytes]:\n epoch = tls.Epoch.ONE_RTT\n space = self.spaces[epoch]\n if not space.crypto.send.is_valid():\n return\n \n buf = Buffer(capacity=PACKET_MAX_SIZE)\n \n while True:\n # write header\n push_uint8(\n buf,\n PACKET_FIXED_BIT\n | (self._spin_bit << 5)\n | (space.crypto.key_phase << 2)\n | (PACKET_NUMBER_SEND_SIZE - 1),\n )\n push_bytes(buf, self.peer_cid)\n push_uint16(buf, self.packet_number)\n header_size = buf.tell()\n \n # ACK\n if self.send_ack[epoch] and space.ack_queue:\n push_uint_var(buf, QuicFrameType.ACK)\n packet.push_ack_frame(buf, space.ack_queue, 0)\n self.send_ack[epoch] = False\n \n # FLOW CONTROL\n for control_frame in self._pending_flow_control:\n push_bytes(buf, control_frame)\n self._pending_flow_control = []\n \n # CLOSE\n if self.__close and self.__epoch == epoch:\n push_close(buf, **self.__close)\n self.__close = None\n \n # STREAM\n for stream_id, stream in self.streams.items():\n + if (\n + isinstance(stream_id, int)\n + and stream.has_data_to_send()\n - if isinstance(stream_id, int) and stream.has_data_to_send():\n + and not stream.is_blocked()\n + ):\n frame = stream.get_frame(\n PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6\n )\n flags = QuicStreamFlag.LEN\n if frame.offset:\n flags |= Qu\n===========changed ref 3===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _write_application(self) -> Iterator[bytes]:\n # offset: 1\n tag_size - 6\n )\n flags = QuicStreamFlag.LEN\n if frame.offset:\n flags |= QuicStreamFlag.OFF\n if frame.fin:\n flags |= QuicStreamFlag.FIN\n push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)\n with push_stream_frame(buf, 0, frame.offset):\n push_bytes(buf, frame.data)\n \n packet_size = buf.tell()\n if packet_size > header_size:\n # encrypt\n data = buf.data\n yield space.crypto.encrypt_packet(\n data[0:header_size], data[header_size:packet_size]\n )\n \n self.packet_number += 1\n buf.seek(0)\n else:\n break\n "}}},{"rowIdx":1836,"cells":{"path":{"kind":"string","value":"tests.test_stream/QuicStreamTest.test_send_data_and_fin"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"135636bd74280024db5dae53ddbcf8193e201b27"},"commit_message":{"kind":"string","value":"[stream] do not send more data than MAX_STREAM_DATA allows"},"ground_truth":{"kind":"string","value":" <0>: stream = QuicStream(stream_id=0, max_stream_data_remote=512)\n stream = QuicStream()\n <5>: self.assertFalse(stream.is_blocked())\n<11>: self.assertFalse(stream.is_blocked())\n<17>: self.assertFalse(stream.is_blocked())\n"},"main_code":{"kind":"string","value":" # module: tests.test_stream\n class QuicStreamTest(TestCase):\n def test_send_data_and_fin(self):\n <0> stream = QuicStream()\n <1> stream.write(b\"0123456789012345\")\n <2> stream.write_eof()\n <3> \n <4> self.assertTrue(stream.has_data_to_send())\n <5> frame = stream.get_frame(8)\n <6> self.assertEqual(frame.data, b\"01234567\")\n <7> self.assertEqual(frame.offset, 0)\n <8> self.assertFalse(frame.fin)\n <9> \n<10> self.assertTrue(stream.has_data_to_send())\n<11> frame = stream.get_frame(8)\n<12> self.assertEqual(frame.data, b\"89012345\")\n<13> self.assertEqual(frame.offset, 8)\n<14> self.assertTrue(frame.fin)\n<15> \n<16> self.assertFalse(stream.has_data_to_send())\n<17> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.packet.QuicStreamFrame\n data: bytes = b\"\"\n \n fin: bool = False\n \n offset: int = 0\n \n at: aioquic.stream\n QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)\n \n at: aioquic.stream.QuicStream\n get_frame(size: int) -> QuicStreamFrame\n \n has_data_to_send() -> bool\n \n is_blocked()\n \n write(data: bytes) -> None\n \n write_eof() -> None\n \n at: tests.test_stream.QuicStreamTest.test_send_data\n stream = QuicStream(stream_id=0, max_stream_data_remote=512)\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n assertTrue(expr: Any, msg: Any=...) -> None\n \n assertFalse(expr: Any, msg: Any=...) -> None\n \n \n===========changed ref 0===========\n # module: aioquic.stream\n class QuicStream:\n + def is_blocked(self):\n + \"\"\"\n + Returns True if there is data to send but the peer's MAX_STREAM_DATA\n + prevents us from sending it.\n + \"\"\"\n + return self._send_buffer and self._send_start >= self.max_stream_data_remote\n + \n===========changed ref 1===========\n # module: aioquic.stream\n class QuicStream:\n def get_frame(self, size: int) -> QuicStreamFrame:\n \"\"\"\n Get a frame of data to send.\n \"\"\"\n assert not self._send_complete, \"cannot call get_frame() after completion\"\n \n size = min(size, len(self._send_buffer))\n + \n + # flow control\n + if self.stream_id is not None:\n + size = min(size, self.max_stream_data_remote - self._send_start)\n + \n frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)\n self._send_buffer = self._send_buffer[size:]\n self._send_start += size\n \n # if the buffer is empty and EOF was written, set the FIN bit\n if self._send_eof and not self._send_buffer:\n frame.fin = True\n self._send_complete = True\n \n return frame\n \n===========changed ref 2===========\n # module: tests.test_stream\n class QuicStreamTest(TestCase):\n def test_send_data(self):\n + stream = QuicStream(stream_id=0, max_stream_data_remote=512)\n - stream = QuicStream()\n \n self.assertFalse(stream.has_data_to_send())\n + self.assertFalse(stream.is_blocked())\n stream.write(b\"0123456789012345\")\n \n self.assertTrue(stream.has_data_to_send())\n + self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertEqual(frame.data, b\"01234567\")\n self.assertEqual(frame.offset, 0)\n \n self.assertTrue(stream.has_data_to_send())\n + self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertEqual(frame.data, b\"89012345\")\n self.assertEqual(frame.offset, 8)\n \n self.assertFalse(stream.has_data_to_send())\n + self.assertFalse(stream.is_blocked())\n \n===========changed ref 3===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _write_application(self) -> Iterator[bytes]:\n epoch = tls.Epoch.ONE_RTT\n space = self.spaces[epoch]\n if not space.crypto.send.is_valid():\n return\n \n buf = Buffer(capacity=PACKET_MAX_SIZE)\n \n while True:\n # write header\n push_uint8(\n buf,\n PACKET_FIXED_BIT\n | (self._spin_bit << 5)\n | (space.crypto.key_phase << 2)\n | (PACKET_NUMBER_SEND_SIZE - 1),\n )\n push_bytes(buf, self.peer_cid)\n push_uint16(buf, self.packet_number)\n header_size = buf.tell()\n \n # ACK\n if self.send_ack[epoch] and space.ack_queue:\n push_uint_var(buf, QuicFrameType.ACK)\n packet.push_ack_frame(buf, space.ack_queue, 0)\n self.send_ack[epoch] = False\n \n # FLOW CONTROL\n for control_frame in self._pending_flow_control:\n push_bytes(buf, control_frame)\n self._pending_flow_control = []\n \n # CLOSE\n if self.__close and self.__epoch == epoch:\n push_close(buf, **self.__close)\n self.__close = None\n \n # STREAM\n for stream_id, stream in self.streams.items():\n + if (\n + isinstance(stream_id, int)\n + and stream.has_data_to_send()\n - if isinstance(stream_id, int) and stream.has_data_to_send():\n + and not stream.is_blocked()\n + ):\n frame = stream.get_frame(\n PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6\n )\n flags = QuicStreamFlag.LEN\n if frame.offset:\n flags |= Qu\n===========changed ref 4===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _write_application(self) -> Iterator[bytes]:\n # offset: 1\n tag_size - 6\n )\n flags = QuicStreamFlag.LEN\n if frame.offset:\n flags |= QuicStreamFlag.OFF\n if frame.fin:\n flags |= QuicStreamFlag.FIN\n push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)\n with push_stream_frame(buf, 0, frame.offset):\n push_bytes(buf, frame.data)\n \n packet_size = buf.tell()\n if packet_size > header_size:\n # encrypt\n data = buf.data\n yield space.crypto.encrypt_packet(\n data[0:header_size], data[header_size:packet_size]\n )\n \n self.packet_number += 1\n buf.seek(0)\n else:\n break\n "}}},{"rowIdx":1837,"cells":{"path":{"kind":"string","value":"tests.test_stream/QuicStreamTest.test_send_fin_only"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"135636bd74280024db5dae53ddbcf8193e201b27"},"commit_message":{"kind":"string","value":"[stream] do not send more data than MAX_STREAM_DATA allows"},"ground_truth":{"kind":"string","value":" <0>: stream = QuicStream(stream_id=0, max_stream_data_remote=512)\n stream = QuicStream()\n"},"main_code":{"kind":"string","value":" # module: tests.test_stream\n class QuicStreamTest(TestCase):\n def test_send_fin_only(self):\n <0> stream = QuicStream()\n <1> self.assertFalse(stream.has_data_to_send())\n <2> \n <3> stream.write_eof()\n <4> self.assertTrue(stream.has_data_to_send())\n <5> frame = stream.get_frame(8)\n <6> self.assertEqual(frame.data, b\"\")\n <7> self.assertEqual(frame.offset, 0)\n <8> self.assertTrue(frame.fin)\n <9> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.stream\n QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)\n \n at: aioquic.stream.QuicStream\n has_data_to_send() -> bool\n \n is_blocked()\n \n at: tests.test_stream.QuicStreamTest.test_send_data_and_fin\n stream = QuicStream(stream_id=0, max_stream_data_remote=512)\n \n frame = stream.get_frame(8)\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n assertTrue(expr: Any, msg: Any=...) -> None\n \n assertFalse(expr: Any, msg: Any=...) -> None\n \n \n===========changed ref 0===========\n # module: aioquic.stream\n class QuicStream:\n + def is_blocked(self):\n + \"\"\"\n + Returns True if there is data to send but the peer's MAX_STREAM_DATA\n + prevents us from sending it.\n + \"\"\"\n + return self._send_buffer and self._send_start >= self.max_stream_data_remote\n + \n===========changed ref 1===========\n # module: tests.test_stream\n class QuicStreamTest(TestCase):\n def test_send_data_and_fin(self):\n + stream = QuicStream(stream_id=0, max_stream_data_remote=512)\n - stream = QuicStream()\n stream.write(b\"0123456789012345\")\n stream.write_eof()\n \n self.assertTrue(stream.has_data_to_send())\n + self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertEqual(frame.data, b\"01234567\")\n self.assertEqual(frame.offset, 0)\n self.assertFalse(frame.fin)\n \n self.assertTrue(stream.has_data_to_send())\n + self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertEqual(frame.data, b\"89012345\")\n self.assertEqual(frame.offset, 8)\n self.assertTrue(frame.fin)\n \n self.assertFalse(stream.has_data_to_send())\n + self.assertFalse(stream.is_blocked())\n \n===========changed ref 2===========\n # module: tests.test_stream\n class QuicStreamTest(TestCase):\n def test_send_data(self):\n + stream = QuicStream(stream_id=0, max_stream_data_remote=512)\n - stream = QuicStream()\n \n self.assertFalse(stream.has_data_to_send())\n + self.assertFalse(stream.is_blocked())\n stream.write(b\"0123456789012345\")\n \n self.assertTrue(stream.has_data_to_send())\n + self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertEqual(frame.data, b\"01234567\")\n self.assertEqual(frame.offset, 0)\n \n self.assertTrue(stream.has_data_to_send())\n + self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertEqual(frame.data, b\"89012345\")\n self.assertEqual(frame.offset, 8)\n \n self.assertFalse(stream.has_data_to_send())\n + self.assertFalse(stream.is_blocked())\n \n===========changed ref 3===========\n # module: aioquic.stream\n class QuicStream:\n def get_frame(self, size: int) -> QuicStreamFrame:\n \"\"\"\n Get a frame of data to send.\n \"\"\"\n assert not self._send_complete, \"cannot call get_frame() after completion\"\n \n size = min(size, len(self._send_buffer))\n + \n + # flow control\n + if self.stream_id is not None:\n + size = min(size, self.max_stream_data_remote - self._send_start)\n + \n frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)\n self._send_buffer = self._send_buffer[size:]\n self._send_start += size\n \n # if the buffer is empty and EOF was written, set the FIN bit\n if self._send_eof and not self._send_buffer:\n frame.fin = True\n self._send_complete = True\n \n return frame\n \n===========changed ref 4===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _write_application(self) -> Iterator[bytes]:\n epoch = tls.Epoch.ONE_RTT\n space = self.spaces[epoch]\n if not space.crypto.send.is_valid():\n return\n \n buf = Buffer(capacity=PACKET_MAX_SIZE)\n \n while True:\n # write header\n push_uint8(\n buf,\n PACKET_FIXED_BIT\n | (self._spin_bit << 5)\n | (space.crypto.key_phase << 2)\n | (PACKET_NUMBER_SEND_SIZE - 1),\n )\n push_bytes(buf, self.peer_cid)\n push_uint16(buf, self.packet_number)\n header_size = buf.tell()\n \n # ACK\n if self.send_ack[epoch] and space.ack_queue:\n push_uint_var(buf, QuicFrameType.ACK)\n packet.push_ack_frame(buf, space.ack_queue, 0)\n self.send_ack[epoch] = False\n \n # FLOW CONTROL\n for control_frame in self._pending_flow_control:\n push_bytes(buf, control_frame)\n self._pending_flow_control = []\n \n # CLOSE\n if self.__close and self.__epoch == epoch:\n push_close(buf, **self.__close)\n self.__close = None\n \n # STREAM\n for stream_id, stream in self.streams.items():\n + if (\n + isinstance(stream_id, int)\n + and stream.has_data_to_send()\n - if isinstance(stream_id, int) and stream.has_data_to_send():\n + and not stream.is_blocked()\n + ):\n frame = stream.get_frame(\n PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6\n )\n flags = QuicStreamFlag.LEN\n if frame.offset:\n flags |= Qu\n===========changed ref 5===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _write_application(self) -> Iterator[bytes]:\n # offset: 1\n tag_size - 6\n )\n flags = QuicStreamFlag.LEN\n if frame.offset:\n flags |= QuicStreamFlag.OFF\n if frame.fin:\n flags |= QuicStreamFlag.FIN\n push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)\n with push_stream_frame(buf, 0, frame.offset):\n push_bytes(buf, frame.data)\n \n packet_size = buf.tell()\n if packet_size > header_size:\n # encrypt\n data = buf.data\n yield space.crypto.encrypt_packet(\n data[0:header_size], data[header_size:packet_size]\n )\n \n self.packet_number += 1\n buf.seek(0)\n else:\n break\n "}}},{"rowIdx":1838,"cells":{"path":{"kind":"string","value":"aioquic.stream/QuicStream.get_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"cbc648c0974daa5a3f98f850527ac8d4981a6648"},"commit_message":{"kind":"string","value":"[connection] rework some size calculations, honour peer's MAX_DATA"},"ground_truth":{"kind":"string","value":" <3>: # check there is something to send\n if self._send_complete or not self.has_data_to_send():\n return None\n assert not self._send_complete, \"cannot call get_frame() after completion\"\n <5>: size = min(size, len(self._send_buffer))\n <6>: \n <7>: # apply flow control\n # flow control\n<10>: if size < 0 or (size == 0 and self._send_buffer and not self._send_eof):\n return None\n<11>: # create frame\n size = min(size, len(self._send_buffer))\n"},"main_code":{"kind":"string","value":" # module: aioquic.stream\n + class QuicStream(asyncio.BaseTransport):\n - class QuicStream:\n + def get_frame(self, size: int) -> Optional[QuicStreamFrame]:\n - def get_frame(self, size: int) -> QuicStreamFrame:\n <0> \"\"\"\n <1> Get a frame of data to send.\n <2> \"\"\"\n <3> assert not self._send_complete, \"cannot call get_frame() after completion\"\n <4> \n <5> size = min(size, len(self._send_buffer))\n <6> \n <7> # flow control\n <8> if self.stream_id is not None:\n <9> size = min(size, self.max_stream_data_remote - self._send_start)\n<10> \n<11> frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)\n<12> self._send_buffer = self._send_buffer[size:]\n<13> self._send_start += size\n<14> \n<15> # if the buffer is empty and EOF was written, set the FIN bit\n<16> if self._send_eof and not self._send_buffer:\n<17> frame.fin = True\n<18> self._send_complete = True\n<19> \n<20> return frame\n<21> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.packet\n QuicStreamFrame(data: bytes=b\"\", fin: bool=False, offset: int=0)\n \n at: aioquic.packet.QuicStreamFrame\n data: bytes = b\"\"\n \n fin: bool = False\n \n offset: int = 0\n \n at: aioquic.stream.QuicStream\n has_data_to_send(self) -> bool\n has_data_to_send() -> bool\n \n at: aioquic.stream.QuicStream.__init__\n self.max_stream_data_remote = max_stream_data_remote\n \n self._send_buffer = bytearray()\n \n self._send_complete = False\n \n self._send_eof = False\n \n self._send_start = 0\n \n at: aioquic.stream.QuicStream.get_frame\n self._send_complete = True\n \n at: aioquic.stream.QuicStream.write\n self._send_buffer += data\n \n at: aioquic.stream.QuicStream.write_eof\n self._send_eof = True\n \n \n===========changed ref 0===========\n # module: aioquic.packet\n + def quic_uint_length(value: int) -> int:\n + \"\"\"\n + Returns the number of bytes required to encode the given value\n + as a QUIC variable-length unsigned integer.\n + \"\"\"\n + for i, (_, _, mask) in enumerate(UINT_VAR_FORMATS):\n + if value <= mask:\n + return 2 ** i\n + raise ValueError(\"Integer is too big for a variable-length integer\")\n + "}}},{"rowIdx":1839,"cells":{"path":{"kind":"string","value":"aioquic.stream/QuicStream.is_blocked"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"cbc648c0974daa5a3f98f850527ac8d4981a6648"},"commit_message":{"kind":"string","value":"[connection] rework some size calculations, honour peer's MAX_DATA"},"ground_truth":{"kind":"string","value":" <4>: return (\n bool(self._send_buffer) and self._send_start >= self.max_stream_data_remote\n return self._send_buffer and self._send_start >= self.max_stream_data_remote\n <5>: )\n"},"main_code":{"kind":"string","value":" # module: aioquic.stream\n + class QuicStream(asyncio.BaseTransport):\n - class QuicStream:\n + def is_blocked(self) -> bool:\n - def is_blocked(self):\n <0> \"\"\"\n <1> Returns True if there is data to send but the peer's MAX_STREAM_DATA\n <2> prevents us from sending it.\n <3> \"\"\"\n <4> return self._send_buffer and self._send_start >= self.max_stream_data_remote\n <5> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.stream.QuicStream.__init__\n self._send_buffer = bytearray()\n \n self._send_complete = False\n \n self._send_eof = False\n \n at: aioquic.stream.QuicStream.get_frame\n self._send_buffer = self._send_buffer[size:]\n \n self._send_complete = True\n \n at: aioquic.stream.QuicStream.write\n self._send_buffer += data\n \n at: aioquic.stream.QuicStream.write_eof\n self._send_eof = True\n \n \n===========changed ref 0===========\n # module: aioquic.stream\n + class QuicStream(asyncio.BaseTransport):\n - class QuicStream:\n + def get_frame(self, size: int) -> Optional[QuicStreamFrame]:\n - def get_frame(self, size: int) -> QuicStreamFrame:\n \"\"\"\n Get a frame of data to send.\n \"\"\"\n + # check there is something to send\n + if self._send_complete or not self.has_data_to_send():\n + return None\n - assert not self._send_complete, \"cannot call get_frame() after completion\"\n \n - size = min(size, len(self._send_buffer))\n - \n + # apply flow control\n - # flow control\n if self.stream_id is not None:\n size = min(size, self.max_stream_data_remote - self._send_start)\n + if size < 0 or (size == 0 and self._send_buffer and not self._send_eof):\n + return None\n \n + # create frame\n + size = min(size, len(self._send_buffer))\n frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)\n self._send_buffer = self._send_buffer[size:]\n self._send_start += size\n \n # if the buffer is empty and EOF was written, set the FIN bit\n if self._send_eof and not self._send_buffer:\n frame.fin = True\n self._send_complete = True\n \n return frame\n \n===========changed ref 1===========\n # module: aioquic.packet\n + def quic_uint_length(value: int) -> int:\n + \"\"\"\n + Returns the number of bytes required to encode the given value\n + as a QUIC variable-length unsigned integer.\n + \"\"\"\n + for i, (_, _, mask) in enumerate(UINT_VAR_FORMATS):\n + if value <= mask:\n + return 2 ** i\n + raise ValueError(\"Integer is too big for a variable-length integer\")\n + "}}},{"rowIdx":1840,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection.__init__"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"cbc648c0974daa5a3f98f850527ac8d4981a6648"},"commit_message":{"kind":"string","value":"[connection] rework some size calculations, honour peer's MAX_DATA"},"ground_truth":{"kind":"string","value":""},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n <0> if not is_client:\n <1> assert certificate is not None, \"SSL certificate is required\"\n <2> assert private_key is not None, \"SSL private key is required\"\n <3> \n <4> self.alpn_protocols = alpn_protocols\n <5> self.certificate = certificate\n <6> self.is_client = is_client\n <7> self.host_cid = os.urandom(8)\n <8> self.peer_cid = os.urandom(8)\n <9> self.peer_cid_set = False\n<10> self.peer_token = b\"\"\n<11> self.private_key = private_key\n<12> self.secrets_log_file = secrets_log_file\n<13> self.server_name = server_name\n<14> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}\n<15> \n<16> self.__close: Optional[Dict] = None\n<17> self.__connected = asyncio.Event()\n<18> self.__epoch = tls.Epoch.INITIAL\n<19> self._local_idle_timeout = 60000 # milliseconds\n<20> self._local_max_data = 1048576\n<21> self._local_max_data_used = 0\n<22> self._local_max_stream_data_bidi_local = 1048576\n<23> self._local_max_stream_data_bidi_remote = 1048576\n<24> self._local_max_stream_data_uni = 1048576\n<25> self._local_max_streams_bidi = 128\n<26> self._local_max_streams_uni = 128\n<27> self.__logger = logger\n<28> self.__path_challenge: Optional[bytes] = None\n<29> self._path: Optional[Qu"},"context":{"kind":"string","value":"===========below chunk 0===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n # offset: 1\n self._pending_flow_control: List[bytes] = []\n self._remote_idle_timeout = 0 # milliseconds\n self._remote_max_data = 0\n self._remote_max_stream_data_bidi_local = 0\n self._remote_max_stream_data_bidi_remote = 0\n self._remote_max_stream_data_uni = 0\n self._remote_max_streams_bidi = 0\n self._remote_max_streams_uni = 0\n self._spin_bit = False\n self._spin_highest_pn = 0\n self.__send_pending_task: Optional[asyncio.Handle] = None\n self.__state = QuicConnectionState.FIRSTFLIGHT\n self.__transport: Optional[asyncio.DatagramTransport] = None\n self._version: Optional[int] = None\n \n # callbacks\n self.stream_created_cb: Callable[\n [asyncio.StreamReader, asyncio.StreamWriter], None\n ] = lambda r, w: None\n \n # frame handlers\n self.__frame_handlers = [\n self._handle_padding_frame,\n self._handle_padding_frame,\n self._handle_ack_frame,\n self._handle_ack_frame,\n self._handle_reset_stream_frame,\n self._handle_stop_sending_frame,\n self._handle_crypto_frame,\n self._handle_new_token_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n \n===========below chunk 1===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n # offset: 2\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_max_data_frame,\n self._handle_max_stream_data_frame,\n self._handle_max_streams_bidi_frame,\n self._handle_max_streams_uni_frame,\n self._handle_data_blocked_frame,\n self._handle_stream_data_blocked_frame,\n self._handle_streams_blocked_frame,\n self._handle_streams_blocked_frame,\n self._handle_new_connection_id_frame,\n self._handle_retire_connection_id_frame,\n self._handle_path_challenge_frame,\n self._handle_path_response_frame,\n self._handle_connection_close_frame,\n self._handle_connection_close_frame,\n ]\n \n \n===========unchanged ref 0===========\n at: aioquic.connection\n logger = logging.getLogger(\"quic\")\n \n QuicConnectionState()\n \n QuicNetworkPath(addr: Any)\n \n at: aioquic.connection.QuicConnection\n supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]\n \n _handle_ack_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None\n \n _handle_connection_close_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None\n \n _handle_crypto_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None\n \n _handle_data_blocked_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None\n \n _handle_max_data_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None\n \n _handle_max_stream_data_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None\n \n _handle_max_streams_bidi_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None\n \n _handle_max_streams_uni_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None\n \n _handle_new_connection_id_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None\n \n _handle_new_token_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None\n \n _handle_padding_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None\n \n _handle_path_challenge_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None\n \n _handle_path_response_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None\n \n _handle_reset_stream_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None\n \n \n===========unchanged ref 1===========\n _handle_retire_connection_id_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None\n \n _handle_stop_sending_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None\n \n _handle_stream_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None\n \n _handle_stream_data_blocked_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None\n \n _handle_streams_blocked_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.connection.QuicConnection._handle_crypto_frame\n self.__epoch = tls.Epoch.ONE_RTT\n self.__epoch = tls.Epoch.HANDSHAKE\n \n at: aioquic.connection.QuicConnection._handle_max_data_frame\n self._remote_max_data = max_data\n \n at: aioquic.connection.QuicConnection._handle_max_streams_bidi_frame\n self._remote_max_streams_bidi = max_streams\n \n at: aioquic.connection.QuicConnection._handle_max_streams_uni_frame\n self._remote_max_streams_uni = max_streams\n \n at: aioquic.connection.QuicConnection._handle_stream_frame\n self._local_max_data_used += newly_received\n \n at: aioquic.connection.QuicConnection._parse_transport_parameters\n self._remote_idle_timeout = quic_transport_parameters.idle_timeout\n \n at: aioquic.connection.QuicConnection._send_path_challenge\n self.__path_challenge = os.urandom(8)\n \n at: aioquic.connection.QuicConnection._send_pending\n self.__send_pending_task = None\n \n at: aioquic.connection.QuicConnection._send_soon\n self.__send_pending_task = loop.call_soon(self._send_pending)\n \n "}}},{"rowIdx":1841,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection._write_application"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"cbc648c0974daa5a3f98f850527ac8d4981a6648"},"commit_message":{"kind":"string","value":"[connection] rework some size calculations, honour peer's MAX_DATA"},"ground_truth":{"kind":"string","value":" <6>: capacity = buf.capacity - space.crypto.aead_tag_size\n<38>: if (\n<39>: if isinstance(stream_id, int):\n isinstance(stream_id, int)\n<40>: # the frame data size is constrained by our peer's MAX_DATA and\n # the space available in the current packet\n frame_overhead = (\n 3\n + quic_uint_length(stream_id)\n + (\n quic_uint_length(stream._send_start)\n if stream._send_start\n else 0\n )\n and stream.has_data_to_send()\n<41>: and not stream.is_blocked()\n<42>: )\n ):\n<44>: min(\n capacity - buf.tell() - frame_overhead,\n self._remote_max_data - self._remote_max_data_used,\n )\n PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6\n<46>: \n if frame is not None:\n flags = QuicStreamFlag.LEN\n flags\n"},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _write_application(self) -> Iterator[bytes]:\n <0> epoch = tls.Epoch.ONE_RTT\n <1> space = self.spaces[epoch]\n <2> if not space.crypto.send.is_valid():\n <3> return\n <4> \n <5> buf = Buffer(capacity=PACKET_MAX_SIZE)\n <6> \n <7> while True:\n <8> # write header\n <9> push_uint8(\n<10> buf,\n<11> PACKET_FIXED_BIT\n<12> | (self._spin_bit << 5)\n<13> | (space.crypto.key_phase << 2)\n<14> | (PACKET_NUMBER_SEND_SIZE - 1),\n<15> )\n<16> push_bytes(buf, self.peer_cid)\n<17> push_uint16(buf, self.packet_number)\n<18> header_size = buf.tell()\n<19> \n<20> # ACK\n<21> if self.send_ack[epoch] and space.ack_queue:\n<22> push_uint_var(buf, QuicFrameType.ACK)\n<23> packet.push_ack_frame(buf, space.ack_queue, 0)\n<24> self.send_ack[epoch] = False\n<25> \n<26> # FLOW CONTROL\n<27> for control_frame in self._pending_flow_control:\n<28> push_bytes(buf, control_frame)\n<29> self._pending_flow_control = []\n<30> \n<31> # CLOSE\n<32> if self.__close and self.__epoch == epoch:\n<33> push_close(buf, **self.__close)\n<34> self.__close = None\n<35> \n<36> # STREAM\n<37> for stream_id, stream in self.streams.items():\n<38> if (\n<39> isinstance(stream_id, int)\n<40> and stream.has_data_to_send()\n<41> and not stream.is_blocked()\n<42> ):\n<43> frame = stream.get_frame(\n<44> PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6\n<45> )\n<46> flags"},"context":{"kind":"string","value":"===========below chunk 0===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _write_application(self) -> Iterator[bytes]:\n # offset: 1\n if frame.offset:\n flags |= QuicStreamFlag.OFF\n if frame.fin:\n flags |= QuicStreamFlag.FIN\n push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)\n with push_stream_frame(buf, 0, frame.offset):\n push_bytes(buf, frame.data)\n \n packet_size = buf.tell()\n if packet_size > header_size:\n # encrypt\n data = buf.data\n yield space.crypto.encrypt_packet(\n data[0:header_size], data[header_size:packet_size]\n )\n \n self.packet_number += 1\n buf.seek(0)\n else:\n break\n \n \n===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n push_bytes(buf: Buffer, v: bytes) -> None\n \n push_uint8(buf: Buffer, v: int) -> None\n \n push_uint16(buf: Buffer, v: int) -> None\n \n at: aioquic.buffer.Buffer\n tell() -> int\n \n at: aioquic.connection\n PACKET_MAX_SIZE = 1280\n \n push_close(buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None\n \n at: aioquic.connection.PacketSpace.__init__\n self.ack_queue = RangeSet()\n \n self.crypto = CryptoPair()\n \n at: aioquic.connection.QuicConnection.__init__\n self.peer_cid = os.urandom(8)\n \n self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}\n \n self.__close: Optional[Dict] = None\n \n self.__epoch = tls.Epoch.INITIAL\n \n self._pending_flow_control: List[bytes] = []\n \n self._remote_max_data = 0\n \n self._remote_max_data_used = 0\n \n self._spin_bit = False\n \n at: aioquic.connection.QuicConnection._handle_crypto_frame\n self.__epoch = tls.Epoch.ONE_RTT\n self.__epoch = tls.Epoch.HANDSHAKE\n \n at: aioquic.connection.QuicConnection._handle_max_data_frame\n self._remote_max_data = max_data\n \n at: aioquic.connection.QuicConnection._initialize\n self.tls = tls.Context(is_client=self.is_client, logger=self.__logger)\n \n self.send_ack = {\n tls.Epoch.INITIAL: False,\n tls.Epoch.HANDSHAKE: False,\n tls.Epoch.ONE_RTT: False,\n }\n \n \n===========unchanged ref 1===========\n self.spaces = {\n tls.Epoch.INITIAL: PacketSpace(),\n tls.Epoch.HANDSHAKE: PacketSpace(),\n tls.Epoch.ONE_RTT: PacketSpace(),\n }\n \n self.packet_number = 0\n \n at: aioquic.connection.QuicConnection._update_traffic_key\n crypto = self.spaces[epoch].crypto\n \n at: aioquic.connection.QuicConnection._write_application\n self._remote_max_data_used += len(frame.data)\n \n self.packet_number += 1\n \n at: aioquic.connection.QuicConnection._write_handshake\n self.__close = None\n \n self.packet_number += 1\n \n at: aioquic.connection.QuicConnection.close\n self.__close = {\n \"error_code\": error_code,\n \"frame_type\": frame_type,\n \"reason_phrase\": reason_phrase,\n }\n \n at: aioquic.connection.QuicConnection.datagram_received\n self.peer_cid = header.source_cid\n \n self._spin_bit = not get_spin_bit(plain_header[0])\n self._spin_bit = get_spin_bit(plain_header[0])\n \n at: aioquic.crypto.CryptoContext\n is_valid() -> bool\n \n setup(cipher_suite: CipherSuite, secret: bytes) -> None\n \n at: aioquic.crypto.CryptoPair.__init__\n self.aead_tag_size = 16\n \n self.recv = CryptoContext()\n \n self.send = CryptoContext()\n \n at: aioquic.packet\n PACKET_FIXED_BIT = 0x40\n \n PACKET_NUMBER_SEND_SIZE = 2\n \n quic_uint_length(value: int) -> int\n \n push_uint_var(buf: Buffer, value: int) -> None\n \n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n \n===========unchanged ref 2===========\n push_ack_frame(buf: Buffer, rangeset: RangeSet, delay: int) -> None\n \n QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)\n QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n at: aioquic.packet.QuicStreamFrame\n data: bytes = b\"\"\n \n fin: bool = False\n \n offset: int = 0\n \n at: aioquic.stream.QuicStream\n get_frame(size: int) -> Optional[QuicStreamFrame]\n \n at: aioquic.stream.QuicStream.__init__\n self._send_start = 0\n \n at: aioquic.stream.QuicStream.get_frame\n self._send_start += size\n \n at: aioquic.tls\n Epoch()\n \n at: aioquic.tls.Context.__init__\n self.key_schedule: Optional[KeySchedule] = None\n \n at: aioquic.tls.Context._client_handle_hello\n self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)\n \n at: aioquic.tls.Context._server_handle_hello\n self.key_schedule = KeySchedule(cipher_suite)\n \n at: aioquic.tls.KeySchedule.__init__\n self.cipher_suite = cipher_suite\n \n at: typing\n Iterator = _alias(collections.abc.Iterator, 1)\n \n \n===========changed ref 0===========\n # module: aioquic.packet\n + def quic_uint_length(value: int) -> int:\n + \"\"\"\n + Returns the number of bytes required to encode the given value\n + as a QUIC variable-length unsigned integer.\n + \"\"\"\n + for i, (_, _, mask) in enumerate(UINT_VAR_FORMATS):\n + if value <= mask:\n + return 2 ** i\n + raise ValueError(\"Integer is too big for a variable-length integer\")\n + "}}},{"rowIdx":1842,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection._write_handshake"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"cbc648c0974daa5a3f98f850527ac8d4981a6648"},"commit_message":{"kind":"string","value":"[connection] rework some size calculations, honour peer's MAX_DATA"},"ground_truth":{"kind":"string","value":" <5>: capacity = buf.capacity - space.crypto.aead_tag_size\n<36>: # CRYPTO\n<37>: if stream.has_data_to_send():\n<38>: # CRYPTO\n<39>: frame = stream.get_frame(\n<40>: PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 4\n<41>: )\n<42>: frame_overhead = 3 + quic_uint_length(stream._send_start)\n frame = stream.get_frame(capacity - buf.tell() - frame_overhead)\n if frame is not None:\n"},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]:\n <0> space = self.spaces[epoch]\n <1> if not space.crypto.send.is_valid():\n <2> return\n <3> \n <4> buf = Buffer(capacity=PACKET_MAX_SIZE)\n <5> \n <6> while True:\n <7> if epoch == tls.Epoch.INITIAL:\n <8> packet_type = PACKET_TYPE_INITIAL\n <9> else:\n<10> packet_type = PACKET_TYPE_HANDSHAKE\n<11> \n<12> # write header\n<13> push_quic_header(\n<14> buf,\n<15> QuicHeader(\n<16> version=self._version,\n<17> packet_type=packet_type | (PACKET_NUMBER_SEND_SIZE - 1),\n<18> destination_cid=self.peer_cid,\n<19> source_cid=self.host_cid,\n<20> token=self.peer_token,\n<21> ),\n<22> )\n<23> header_size = buf.tell()\n<24> \n<25> # ACK\n<26> if self.send_ack[epoch] and space.ack_queue:\n<27> push_uint_var(buf, QuicFrameType.ACK)\n<28> packet.push_ack_frame(buf, space.ack_queue, 0)\n<29> self.send_ack[epoch] = False\n<30> \n<31> # CLOSE\n<32> if self.__close and self.__epoch == epoch:\n<33> push_close(buf, **self.__close)\n<34> self.__close = None\n<35> \n<36> stream = self.streams[epoch]\n<37> if stream.has_data_to_send():\n<38> # CRYPTO\n<39> frame = stream.get_frame(\n<40> PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 4\n<41> )\n<42> push_uint_var(buf, QuicFrameType.CRYPTO)\n<43> with packet.push_crypto_frame(buf, frame.offset):\n<44> push_bytes(buf, frame.data)"},"context":{"kind":"string","value":"===========below chunk 0===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]:\n # offset: 1\n # PADDING\n if epoch == tls.Epoch.INITIAL and self.is_client:\n push_bytes(\n buf,\n bytes(\n PACKET_MAX_SIZE - space.crypto.aead_tag_size - buf.tell()\n ),\n )\n \n packet_size = buf.tell()\n if packet_size > header_size:\n # finalize length\n buf.seek(header_size - PACKET_NUMBER_SEND_SIZE - 2)\n length = packet_size - header_size + 2 + space.crypto.aead_tag_size\n push_uint16(buf, length | 0x4000)\n push_uint16(buf, self.packet_number)\n buf.seek(packet_size)\n \n # encrypt\n data = buf.data\n yield space.crypto.encrypt_packet(\n data[0:header_size], data[header_size:packet_size]\n )\n \n self.packet_number += 1\n buf.seek(0)\n else:\n break\n \n \n===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n push_bytes(buf: Buffer, v: bytes) -> None\n \n push_uint16(buf: Buffer, v: int) -> None\n \n at: aioquic.buffer.Buffer\n seek(pos: int) -> None\n \n tell() -> int\n \n at: aioquic.connection\n PACKET_MAX_SIZE = 1280\n \n push_close(buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None\n \n at: aioquic.connection.PacketSpace.__init__\n self.ack_queue = RangeSet()\n \n self.crypto = CryptoPair()\n \n at: aioquic.connection.QuicConnection.__init__\n self.is_client = is_client\n \n self.host_cid = os.urandom(8)\n \n self.peer_cid = os.urandom(8)\n \n self.peer_token = b\"\"\n \n self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}\n \n self.__close: Optional[Dict] = None\n \n self.__epoch = tls.Epoch.INITIAL\n \n self._remote_max_data_used = 0\n \n self._version: Optional[int] = None\n \n at: aioquic.connection.QuicConnection._handle_crypto_frame\n self.__epoch = tls.Epoch.ONE_RTT\n self.__epoch = tls.Epoch.HANDSHAKE\n \n at: aioquic.connection.QuicConnection._initialize\n self.send_ack = {\n tls.Epoch.INITIAL: False,\n tls.Epoch.HANDSHAKE: False,\n tls.Epoch.ONE_RTT: False,\n }\n \n self.spaces = {\n tls.Epoch.INITIAL: PacketSpace(),\n tls.Epoch.HANDSHAKE: PacketSpace(),\n tls.Epoch.ONE_RTT: PacketSpace(),\n }\n \n self.packet_number = 0\n \n \n===========unchanged ref 1===========\n at: aioquic.connection.QuicConnection._write_application\n space = self.spaces[epoch]\n \n buf = Buffer(capacity=PACKET_MAX_SIZE)\n \n header_size = buf.tell()\n \n self.__close = None\n \n frame = stream.get_frame(\n min(\n capacity - buf.tell() - frame_overhead,\n self._remote_max_data - self._remote_max_data_used,\n )\n )\n \n at: aioquic.connection.QuicConnection._write_handshake\n self.packet_number += 1\n \n at: aioquic.connection.QuicConnection.close\n self.__close = {\n \"error_code\": error_code,\n \"frame_type\": frame_type,\n \"reason_phrase\": reason_phrase,\n }\n \n at: aioquic.connection.QuicConnection.connect\n self._version = max(self.supported_versions)\n \n at: aioquic.connection.QuicConnection.datagram_received\n self._version = QuicProtocolVersion(header.version)\n self._version = QuicProtocolVersion(max(common))\n \n self.peer_cid = header.source_cid\n \n self.peer_token = header.token\n \n at: aioquic.crypto.CryptoContext\n is_valid() -> bool\n \n at: aioquic.crypto.CryptoPair\n encrypt_packet(plain_header: bytes, plain_payload: bytes) -> bytes\n \n at: aioquic.crypto.CryptoPair.__init__\n self.aead_tag_size = 16\n \n self.send = CryptoContext()\n \n at: aioquic.packet\n PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00\n \n PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20\n \n PACKET_NUMBER_SEND_SIZE = 2\n \n \n===========unchanged ref 2===========\n QuicHeader(version: Optional[int], packet_type: int, destination_cid: bytes, source_cid: bytes, original_destination_cid: bytes=b\"\", token: bytes=b\"\", rest_length: int=0)\n \n quic_uint_length(value: int) -> int\n \n push_uint_var(buf: Buffer, value: int) -> None\n \n push_quic_header(buf: Buffer, header: QuicHeader) -> None\n \n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n push_ack_frame(buf: Buffer, rangeset: RangeSet, delay: int) -> None\n \n push_crypto_frame(buf: Buffer, offset: int=0) -> Generator\n \n at: aioquic.packet.QuicHeader\n version: Optional[int]\n \n packet_type: int\n \n destination_cid: bytes\n \n source_cid: bytes\n \n original_destination_cid: bytes = b\"\"\n \n token: bytes = b\"\"\n \n rest_length: int = 0\n \n at: aioquic.packet.QuicStreamFrame\n data: bytes = b\"\"\n \n offset: int = 0\n \n at: aioquic.stream.QuicStream\n get_frame(size: int) -> Optional[QuicStreamFrame]\n \n at: aioquic.stream.QuicStream.__init__\n self._send_start = 0\n \n at: aioquic.stream.QuicStream.get_frame\n self._send_start += size\n \n at: aioquic.tls\n Epoch()\n \n at: typing\n Iterator = _alias(collections.abc.Iterator, 1)\n \n \n===========changed ref 0===========\n # module: aioquic.packet\n + def quic_uint_length(value: int) -> int:\n + \"\"\"\n + Returns the number of bytes required to encode the given value\n + as a QUIC variable-length unsigned integer.\n + \"\"\"\n + for i, (_, _, mask) in enumerate(UINT_VAR_FORMATS):\n + if value <= mask:\n + return 2 ** i\n + raise ValueError(\"Integer is too big for a variable-length integer\")\n + "}}},{"rowIdx":1843,"cells":{"path":{"kind":"string","value":"tests.test_stream/QuicStreamTest.test_send_data"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"cbc648c0974daa5a3f98f850527ac8d4981a6648"},"commit_message":{"kind":"string","value":"[connection] rework some size calculations, honour peer's MAX_DATA"},"ground_truth":{"kind":"string","value":" <2>: # nothing to send yet\n <4>: frame = stream.get_frame(8)\n self.assertIsNone(frame)\n \n # write data, send a chunk\n <5>: \n<10>: self.assertFalse(frame.fin)\n<12>: # send another chunk\n<16>: self.assertFalse(frame.fin)\n<18>: # nothing more to send\n<20>: frame = stream.get_frame(8)\n self.assertIsNone(frame)\n"},"main_code":{"kind":"string","value":" # module: tests.test_stream\n class QuicStreamTest(TestCase):\n def test_send_data(self):\n <0> stream = QuicStream(stream_id=0, max_stream_data_remote=512)\n <1> \n <2> self.assertFalse(stream.has_data_to_send())\n <3> self.assertFalse(stream.is_blocked())\n <4> stream.write(b\"0123456789012345\")\n <5> \n <6> self.assertTrue(stream.has_data_to_send())\n <7> self.assertFalse(stream.is_blocked())\n <8> frame = stream.get_frame(8)\n <9> self.assertEqual(frame.data, b\"01234567\")\n<10> self.assertEqual(frame.offset, 0)\n<11> \n<12> self.assertTrue(stream.has_data_to_send())\n<13> self.assertFalse(stream.is_blocked())\n<14> frame = stream.get_frame(8)\n<15> self.assertEqual(frame.data, b\"89012345\")\n<16> self.assertEqual(frame.offset, 8)\n<17> \n<18> self.assertFalse(stream.has_data_to_send())\n<19> self.assertFalse(stream.is_blocked())\n<20> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.packet.QuicStreamFrame\n data: bytes = b\"\"\n \n fin: bool = False\n \n offset: int = 0\n \n at: aioquic.stream\n QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)\n \n at: aioquic.stream.QuicStream\n get_frame(size: int) -> Optional[QuicStreamFrame]\n \n has_data_to_send() -> bool\n \n is_blocked() -> bool\n \n write(data: bytes) -> None\n \n at: unittest.case.TestCase\n failureException: Type[BaseException]\n \n longMessage: bool\n \n maxDiff: Optional[int]\n \n _testMethodName: str\n \n _testMethodDoc: str\n \n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n assertTrue(expr: Any, msg: Any=...) -> None\n \n assertFalse(expr: Any, msg: Any=...) -> None\n \n assertIsNone(obj: Any, msg: Any=...) -> None\n \n \n===========changed ref 0===========\n # module: aioquic.stream\n + class QuicStream(asyncio.BaseTransport):\n - class QuicStream:\n + def is_blocked(self) -> bool:\n - def is_blocked(self):\n \"\"\"\n Returns True if there is data to send but the peer's MAX_STREAM_DATA\n prevents us from sending it.\n \"\"\"\n + return (\n + bool(self._send_buffer) and self._send_start >= self.max_stream_data_remote\n - return self._send_buffer and self._send_start >= self.max_stream_data_remote\n + )\n \n===========changed ref 1===========\n # module: aioquic.stream\n + class QuicStream(asyncio.BaseTransport):\n - class QuicStream:\n + def get_frame(self, size: int) -> Optional[QuicStreamFrame]:\n - def get_frame(self, size: int) -> QuicStreamFrame:\n \"\"\"\n Get a frame of data to send.\n \"\"\"\n + # check there is something to send\n + if self._send_complete or not self.has_data_to_send():\n + return None\n - assert not self._send_complete, \"cannot call get_frame() after completion\"\n \n - size = min(size, len(self._send_buffer))\n - \n + # apply flow control\n - # flow control\n if self.stream_id is not None:\n size = min(size, self.max_stream_data_remote - self._send_start)\n + if size < 0 or (size == 0 and self._send_buffer and not self._send_eof):\n + return None\n \n + # create frame\n + size = min(size, len(self._send_buffer))\n frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)\n self._send_buffer = self._send_buffer[size:]\n self._send_start += size\n \n # if the buffer is empty and EOF was written, set the FIN bit\n if self._send_eof and not self._send_buffer:\n frame.fin = True\n self._send_complete = True\n \n return frame\n \n===========changed ref 2===========\n # module: aioquic.packet\n + def quic_uint_length(value: int) -> int:\n + \"\"\"\n + Returns the number of bytes required to encode the given value\n + as a QUIC variable-length unsigned integer.\n + \"\"\"\n + for i, (_, _, mask) in enumerate(UINT_VAR_FORMATS):\n + if value <= mask:\n + return 2 ** i\n + raise ValueError(\"Integer is too big for a variable-length integer\")\n + \n===========changed ref 3===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]:\n space = self.spaces[epoch]\n if not space.crypto.send.is_valid():\n return\n \n buf = Buffer(capacity=PACKET_MAX_SIZE)\n + capacity = buf.capacity - space.crypto.aead_tag_size\n \n while True:\n if epoch == tls.Epoch.INITIAL:\n packet_type = PACKET_TYPE_INITIAL\n else:\n packet_type = PACKET_TYPE_HANDSHAKE\n \n # write header\n push_quic_header(\n buf,\n QuicHeader(\n version=self._version,\n packet_type=packet_type | (PACKET_NUMBER_SEND_SIZE - 1),\n destination_cid=self.peer_cid,\n source_cid=self.host_cid,\n token=self.peer_token,\n ),\n )\n header_size = buf.tell()\n \n # ACK\n if self.send_ack[epoch] and space.ack_queue:\n push_uint_var(buf, QuicFrameType.ACK)\n packet.push_ack_frame(buf, space.ack_queue, 0)\n self.send_ack[epoch] = False\n \n # CLOSE\n if self.__close and self.__epoch == epoch:\n push_close(buf, **self.__close)\n self.__close = None\n \n + # CRYPTO\n stream = self.streams[epoch]\n - if stream.has_data_to_send():\n - # CRYPTO\n - frame = stream.get_frame(\n - PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 4\n - )\n + frame_overhead = 3 + quic_uint_length(stream._send_start)\n + frame = stream.get_frame(capacity - buf.tell() - frame_overhead)\n + if frame is not None:\n push_uint_\n===========changed ref 4===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]:\n # offset: 1\n frame(capacity - buf.tell() - frame_overhead)\n + if frame is not None:\n push_uint_var(buf, QuicFrameType.CRYPTO)\n with packet.push_crypto_frame(buf, frame.offset):\n push_bytes(buf, frame.data)\n \n # PADDING\n if epoch == tls.Epoch.INITIAL and self.is_client:\n - push_bytes(\n - buf,\n - bytes(\n - PACKET_MAX_SIZE - space.crypto.aead_tag_size - buf.tell()\n - ),\n - )\n + push_bytes(buf, bytes(capacity - buf.tell()))\n \n packet_size = buf.tell()\n if packet_size > header_size:\n # finalize length\n buf.seek(header_size - PACKET_NUMBER_SEND_SIZE - 2)\n length = packet_size - header_size + 2 + space.crypto.aead_tag_size\n push_uint16(buf, length | 0x4000)\n push_uint16(buf, self.packet_number)\n buf.seek(packet_size)\n \n # encrypt\n data = buf.data\n yield space.crypto.encrypt_packet(\n data[0:header_size], data[header_size:packet_size]\n )\n \n self.packet_number += 1\n buf.seek(0)\n else:\n break\n "}}},{"rowIdx":1844,"cells":{"path":{"kind":"string","value":"tests.test_stream/QuicStreamTest.test_send_data_and_fin"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"cbc648c0974daa5a3f98f850527ac8d4981a6648"},"commit_message":{"kind":"string","value":"[connection] rework some size calculations, honour peer's MAX_DATA"},"ground_truth":{"kind":"string","value":" <1>: \n # nothing to send yet\n self.assertFalse(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertIsNone(frame)\n \n # write data and EOF, send a chunk\n <3>: \n <8>: self.assertFalse(frame.fin)\n <9>: self.assertFalse(frame.fin)\n<11>: # send another chunk\n<15>: self.assertTrue(frame.fin)\n<16>: self.assertTrue(frame.fin)\n<18>: # nothing more to send\n<20>: frame = stream.get_frame(8)\n self.assertIsNone(frame)\n"},"main_code":{"kind":"string","value":" # module: tests.test_stream\n class QuicStreamTest(TestCase):\n def test_send_data_and_fin(self):\n <0> stream = QuicStream(stream_id=0, max_stream_data_remote=512)\n <1> stream.write(b\"0123456789012345\")\n <2> stream.write_eof()\n <3> \n <4> self.assertTrue(stream.has_data_to_send())\n <5> self.assertFalse(stream.is_blocked())\n <6> frame = stream.get_frame(8)\n <7> self.assertEqual(frame.data, b\"01234567\")\n <8> self.assertEqual(frame.offset, 0)\n <9> self.assertFalse(frame.fin)\n<10> \n<11> self.assertTrue(stream.has_data_to_send())\n<12> self.assertFalse(stream.is_blocked())\n<13> frame = stream.get_frame(8)\n<14> self.assertEqual(frame.data, b\"89012345\")\n<15> self.assertEqual(frame.offset, 8)\n<16> self.assertTrue(frame.fin)\n<17> \n<18> self.assertFalse(stream.has_data_to_send())\n<19> self.assertFalse(stream.is_blocked())\n<20> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.packet.QuicStreamFrame\n data: bytes = b\"\"\n \n fin: bool = False\n \n offset: int = 0\n \n at: aioquic.stream\n QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)\n \n at: aioquic.stream.QuicStream\n get_frame(size: int) -> Optional[QuicStreamFrame]\n \n has_data_to_send() -> bool\n \n is_blocked() -> bool\n \n write(data: bytes) -> None\n \n at: tests.test_stream.QuicStreamTest.test_send_data\n stream = QuicStream(stream_id=0, max_stream_data_remote=512)\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n assertFalse(expr: Any, msg: Any=...) -> None\n \n assertIsNone(obj: Any, msg: Any=...) -> None\n \n \n===========changed ref 0===========\n # module: aioquic.stream\n + class QuicStream(asyncio.BaseTransport):\n - class QuicStream:\n + def is_blocked(self) -> bool:\n - def is_blocked(self):\n \"\"\"\n Returns True if there is data to send but the peer's MAX_STREAM_DATA\n prevents us from sending it.\n \"\"\"\n + return (\n + bool(self._send_buffer) and self._send_start >= self.max_stream_data_remote\n - return self._send_buffer and self._send_start >= self.max_stream_data_remote\n + )\n \n===========changed ref 1===========\n # module: aioquic.stream\n + class QuicStream(asyncio.BaseTransport):\n - class QuicStream:\n + def get_frame(self, size: int) -> Optional[QuicStreamFrame]:\n - def get_frame(self, size: int) -> QuicStreamFrame:\n \"\"\"\n Get a frame of data to send.\n \"\"\"\n + # check there is something to send\n + if self._send_complete or not self.has_data_to_send():\n + return None\n - assert not self._send_complete, \"cannot call get_frame() after completion\"\n \n - size = min(size, len(self._send_buffer))\n - \n + # apply flow control\n - # flow control\n if self.stream_id is not None:\n size = min(size, self.max_stream_data_remote - self._send_start)\n + if size < 0 or (size == 0 and self._send_buffer and not self._send_eof):\n + return None\n \n + # create frame\n + size = min(size, len(self._send_buffer))\n frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)\n self._send_buffer = self._send_buffer[size:]\n self._send_start += size\n \n # if the buffer is empty and EOF was written, set the FIN bit\n if self._send_eof and not self._send_buffer:\n frame.fin = True\n self._send_complete = True\n \n return frame\n \n===========changed ref 2===========\n # module: tests.test_stream\n class QuicStreamTest(TestCase):\n def test_send_data(self):\n stream = QuicStream(stream_id=0, max_stream_data_remote=512)\n \n + # nothing to send yet\n self.assertFalse(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n + frame = stream.get_frame(8)\n + self.assertIsNone(frame)\n + \n + # write data, send a chunk\n stream.write(b\"0123456789012345\")\n - \n self.assertTrue(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertEqual(frame.data, b\"01234567\")\n + self.assertFalse(frame.fin)\n self.assertEqual(frame.offset, 0)\n \n + # send another chunk\n self.assertTrue(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertEqual(frame.data, b\"89012345\")\n + self.assertFalse(frame.fin)\n self.assertEqual(frame.offset, 8)\n \n + # nothing more to send\n self.assertFalse(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n + frame = stream.get_frame(8)\n + self.assertIsNone(frame)\n \n===========changed ref 3===========\n # module: aioquic.packet\n + def quic_uint_length(value: int) -> int:\n + \"\"\"\n + Returns the number of bytes required to encode the given value\n + as a QUIC variable-length unsigned integer.\n + \"\"\"\n + for i, (_, _, mask) in enumerate(UINT_VAR_FORMATS):\n + if value <= mask:\n + return 2 ** i\n + raise ValueError(\"Integer is too big for a variable-length integer\")\n + \n===========changed ref 4===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]:\n space = self.spaces[epoch]\n if not space.crypto.send.is_valid():\n return\n \n buf = Buffer(capacity=PACKET_MAX_SIZE)\n + capacity = buf.capacity - space.crypto.aead_tag_size\n \n while True:\n if epoch == tls.Epoch.INITIAL:\n packet_type = PACKET_TYPE_INITIAL\n else:\n packet_type = PACKET_TYPE_HANDSHAKE\n \n # write header\n push_quic_header(\n buf,\n QuicHeader(\n version=self._version,\n packet_type=packet_type | (PACKET_NUMBER_SEND_SIZE - 1),\n destination_cid=self.peer_cid,\n source_cid=self.host_cid,\n token=self.peer_token,\n ),\n )\n header_size = buf.tell()\n \n # ACK\n if self.send_ack[epoch] and space.ack_queue:\n push_uint_var(buf, QuicFrameType.ACK)\n packet.push_ack_frame(buf, space.ack_queue, 0)\n self.send_ack[epoch] = False\n \n # CLOSE\n if self.__close and self.__epoch == epoch:\n push_close(buf, **self.__close)\n self.__close = None\n \n + # CRYPTO\n stream = self.streams[epoch]\n - if stream.has_data_to_send():\n - # CRYPTO\n - frame = stream.get_frame(\n - PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 4\n - )\n + frame_overhead = 3 + quic_uint_length(stream._send_start)\n + frame = stream.get_frame(capacity - buf.tell() - frame_overhead)\n + if frame is not None:\n push_uint_"}}},{"rowIdx":1845,"cells":{"path":{"kind":"string","value":"tests.test_stream/QuicStreamTest.test_send_blocked"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"cbc648c0974daa5a3f98f850527ac8d4981a6648"},"commit_message":{"kind":"string","value":"[connection] rework some size calculations, honour peer's MAX_DATA"},"ground_truth":{"kind":"string","value":" <2>: # nothing to send yet\n <4>: frame = stream.get_frame(8)\n self.assertIsNone(frame)\n \n # write data, send a chunk\n <5>: \n<10>: self.assertFalse(frame.fin)\n<12>: # send is limited by peer\n<16>: self.assertFalse(frame.fin)\n<18>: # unable to send, blocked\n<20>: frame = stream.get_frame(8)\n self.assertIsNone(frame)\n"},"main_code":{"kind":"string","value":" # module: tests.test_stream\n class QuicStreamTest(TestCase):\n def test_send_blocked(self):\n <0> stream = QuicStream(stream_id=0, max_stream_data_remote=12)\n <1> \n <2> self.assertFalse(stream.has_data_to_send())\n <3> self.assertFalse(stream.is_blocked())\n <4> stream.write(b\"0123456789012345\")\n <5> \n <6> self.assertTrue(stream.has_data_to_send())\n <7> self.assertFalse(stream.is_blocked())\n <8> frame = stream.get_frame(8)\n <9> self.assertEqual(frame.data, b\"01234567\")\n<10> self.assertEqual(frame.offset, 0)\n<11> \n<12> self.assertTrue(stream.has_data_to_send())\n<13> self.assertFalse(stream.is_blocked())\n<14> frame = stream.get_frame(8)\n<15> self.assertEqual(frame.data, b\"8901\")\n<16> self.assertEqual(frame.offset, 8)\n<17> \n<18> self.assertTrue(stream.has_data_to_send())\n<19> self.assertTrue(stream.is_blocked())\n<20> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.stream.QuicStream\n get_frame(size: int) -> Optional[QuicStreamFrame]\n \n has_data_to_send() -> bool\n \n is_blocked() -> bool\n \n at: tests.test_stream.QuicStreamTest.test_send_data_and_fin\n stream = QuicStream(stream_id=0, max_stream_data_remote=512)\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n assertTrue(expr: Any, msg: Any=...) -> None\n \n assertFalse(expr: Any, msg: Any=...) -> None\n \n assertIsNone(obj: Any, msg: Any=...) -> None\n \n \n===========changed ref 0===========\n # module: aioquic.stream\n + class QuicStream(asyncio.BaseTransport):\n - class QuicStream:\n + def is_blocked(self) -> bool:\n - def is_blocked(self):\n \"\"\"\n Returns True if there is data to send but the peer's MAX_STREAM_DATA\n prevents us from sending it.\n \"\"\"\n + return (\n + bool(self._send_buffer) and self._send_start >= self.max_stream_data_remote\n - return self._send_buffer and self._send_start >= self.max_stream_data_remote\n + )\n \n===========changed ref 1===========\n # module: aioquic.stream\n + class QuicStream(asyncio.BaseTransport):\n - class QuicStream:\n + def get_frame(self, size: int) -> Optional[QuicStreamFrame]:\n - def get_frame(self, size: int) -> QuicStreamFrame:\n \"\"\"\n Get a frame of data to send.\n \"\"\"\n + # check there is something to send\n + if self._send_complete or not self.has_data_to_send():\n + return None\n - assert not self._send_complete, \"cannot call get_frame() after completion\"\n \n - size = min(size, len(self._send_buffer))\n - \n + # apply flow control\n - # flow control\n if self.stream_id is not None:\n size = min(size, self.max_stream_data_remote - self._send_start)\n + if size < 0 or (size == 0 and self._send_buffer and not self._send_eof):\n + return None\n \n + # create frame\n + size = min(size, len(self._send_buffer))\n frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)\n self._send_buffer = self._send_buffer[size:]\n self._send_start += size\n \n # if the buffer is empty and EOF was written, set the FIN bit\n if self._send_eof and not self._send_buffer:\n frame.fin = True\n self._send_complete = True\n \n return frame\n \n===========changed ref 2===========\n # module: tests.test_stream\n class QuicStreamTest(TestCase):\n def test_send_data(self):\n stream = QuicStream(stream_id=0, max_stream_data_remote=512)\n \n + # nothing to send yet\n self.assertFalse(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n + frame = stream.get_frame(8)\n + self.assertIsNone(frame)\n + \n + # write data, send a chunk\n stream.write(b\"0123456789012345\")\n - \n self.assertTrue(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertEqual(frame.data, b\"01234567\")\n + self.assertFalse(frame.fin)\n self.assertEqual(frame.offset, 0)\n \n + # send another chunk\n self.assertTrue(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertEqual(frame.data, b\"89012345\")\n + self.assertFalse(frame.fin)\n self.assertEqual(frame.offset, 8)\n \n + # nothing more to send\n self.assertFalse(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n + frame = stream.get_frame(8)\n + self.assertIsNone(frame)\n \n===========changed ref 3===========\n # module: tests.test_stream\n class QuicStreamTest(TestCase):\n def test_send_data_and_fin(self):\n stream = QuicStream(stream_id=0, max_stream_data_remote=512)\n + \n + # nothing to send yet\n + self.assertFalse(stream.has_data_to_send())\n + self.assertFalse(stream.is_blocked())\n + frame = stream.get_frame(8)\n + self.assertIsNone(frame)\n + \n + # write data and EOF, send a chunk\n stream.write(b\"0123456789012345\")\n stream.write_eof()\n - \n self.assertTrue(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertEqual(frame.data, b\"01234567\")\n + self.assertFalse(frame.fin)\n self.assertEqual(frame.offset, 0)\n - self.assertFalse(frame.fin)\n \n + # send another chunk\n self.assertTrue(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertEqual(frame.data, b\"89012345\")\n + self.assertTrue(frame.fin)\n self.assertEqual(frame.offset, 8)\n - self.assertTrue(frame.fin)\n \n + # nothing more to send\n self.assertFalse(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n + frame = stream.get_frame(8)\n + self.assertIsNone(frame)\n \n===========changed ref 4===========\n # module: aioquic.packet\n + def quic_uint_length(value: int) -> int:\n + \"\"\"\n + Returns the number of bytes required to encode the given value\n + as a QUIC variable-length unsigned integer.\n + \"\"\"\n + for i, (_, _, mask) in enumerate(UINT_VAR_FORMATS):\n + if value <= mask:\n + return 2 ** i\n + raise ValueError(\"Integer is too big for a variable-length integer\")\n + "}}},{"rowIdx":1846,"cells":{"path":{"kind":"string","value":"tests.test_stream/QuicStreamTest.test_send_fin_only"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"cbc648c0974daa5a3f98f850527ac8d4981a6648"},"commit_message":{"kind":"string","value":"[connection] rework some size calculations, honour peer's MAX_DATA"},"ground_truth":{"kind":"string","value":" <1>: \n # nothing to send yet\n <2>: self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertIsNone(frame)\n <3>: # write EOF\n <5>: self.assertFalse(stream.is_blocked())\n <7>: self.assertTrue(frame.fin)\n <8>: self.assertTrue(frame.fin)\n"},"main_code":{"kind":"string","value":" # module: tests.test_stream\n class QuicStreamTest(TestCase):\n def test_send_fin_only(self):\n <0> stream = QuicStream(stream_id=0, max_stream_data_remote=512)\n <1> self.assertFalse(stream.has_data_to_send())\n <2> \n <3> stream.write_eof()\n <4> self.assertTrue(stream.has_data_to_send())\n <5> frame = stream.get_frame(8)\n <6> self.assertEqual(frame.data, b\"\")\n <7> self.assertEqual(frame.offset, 0)\n <8> self.assertTrue(frame.fin)\n <9> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.stream\n QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)\n \n at: aioquic.stream.QuicStream\n get_frame(size: int) -> Optional[QuicStreamFrame]\n \n has_data_to_send() -> bool\n \n is_blocked() -> bool\n \n write(data: bytes) -> None\n \n at: unittest.case.TestCase\n assertFalse(expr: Any, msg: Any=...) -> None\n \n assertIsNone(obj: Any, msg: Any=...) -> None\n \n \n===========changed ref 0===========\n # module: aioquic.stream\n + class QuicStream(asyncio.BaseTransport):\n - class QuicStream:\n + def is_blocked(self) -> bool:\n - def is_blocked(self):\n \"\"\"\n Returns True if there is data to send but the peer's MAX_STREAM_DATA\n prevents us from sending it.\n \"\"\"\n + return (\n + bool(self._send_buffer) and self._send_start >= self.max_stream_data_remote\n - return self._send_buffer and self._send_start >= self.max_stream_data_remote\n + )\n \n===========changed ref 1===========\n # module: aioquic.stream\n + class QuicStream(asyncio.BaseTransport):\n - class QuicStream:\n + def get_frame(self, size: int) -> Optional[QuicStreamFrame]:\n - def get_frame(self, size: int) -> QuicStreamFrame:\n \"\"\"\n Get a frame of data to send.\n \"\"\"\n + # check there is something to send\n + if self._send_complete or not self.has_data_to_send():\n + return None\n - assert not self._send_complete, \"cannot call get_frame() after completion\"\n \n - size = min(size, len(self._send_buffer))\n - \n + # apply flow control\n - # flow control\n if self.stream_id is not None:\n size = min(size, self.max_stream_data_remote - self._send_start)\n + if size < 0 or (size == 0 and self._send_buffer and not self._send_eof):\n + return None\n \n + # create frame\n + size = min(size, len(self._send_buffer))\n frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)\n self._send_buffer = self._send_buffer[size:]\n self._send_start += size\n \n # if the buffer is empty and EOF was written, set the FIN bit\n if self._send_eof and not self._send_buffer:\n frame.fin = True\n self._send_complete = True\n \n return frame\n \n===========changed ref 2===========\n # module: tests.test_stream\n class QuicStreamTest(TestCase):\n def test_send_blocked(self):\n stream = QuicStream(stream_id=0, max_stream_data_remote=12)\n \n + # nothing to send yet\n self.assertFalse(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n + frame = stream.get_frame(8)\n + self.assertIsNone(frame)\n + \n + # write data, send a chunk\n stream.write(b\"0123456789012345\")\n - \n self.assertTrue(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertEqual(frame.data, b\"01234567\")\n + self.assertFalse(frame.fin)\n self.assertEqual(frame.offset, 0)\n \n + # send is limited by peer\n self.assertTrue(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertEqual(frame.data, b\"8901\")\n + self.assertFalse(frame.fin)\n self.assertEqual(frame.offset, 8)\n \n + # unable to send, blocked\n self.assertTrue(stream.has_data_to_send())\n self.assertTrue(stream.is_blocked())\n + frame = stream.get_frame(8)\n + self.assertIsNone(frame)\n \n===========changed ref 3===========\n # module: tests.test_stream\n class QuicStreamTest(TestCase):\n def test_send_data(self):\n stream = QuicStream(stream_id=0, max_stream_data_remote=512)\n \n + # nothing to send yet\n self.assertFalse(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n + frame = stream.get_frame(8)\n + self.assertIsNone(frame)\n + \n + # write data, send a chunk\n stream.write(b\"0123456789012345\")\n - \n self.assertTrue(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertEqual(frame.data, b\"01234567\")\n + self.assertFalse(frame.fin)\n self.assertEqual(frame.offset, 0)\n \n + # send another chunk\n self.assertTrue(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertEqual(frame.data, b\"89012345\")\n + self.assertFalse(frame.fin)\n self.assertEqual(frame.offset, 8)\n \n + # nothing more to send\n self.assertFalse(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n + frame = stream.get_frame(8)\n + self.assertIsNone(frame)\n \n===========changed ref 4===========\n # module: tests.test_stream\n class QuicStreamTest(TestCase):\n def test_send_data_and_fin(self):\n stream = QuicStream(stream_id=0, max_stream_data_remote=512)\n + \n + # nothing to send yet\n + self.assertFalse(stream.has_data_to_send())\n + self.assertFalse(stream.is_blocked())\n + frame = stream.get_frame(8)\n + self.assertIsNone(frame)\n + \n + # write data and EOF, send a chunk\n stream.write(b\"0123456789012345\")\n stream.write_eof()\n - \n self.assertTrue(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertEqual(frame.data, b\"01234567\")\n + self.assertFalse(frame.fin)\n self.assertEqual(frame.offset, 0)\n - self.assertFalse(frame.fin)\n \n + # send another chunk\n self.assertTrue(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n frame = stream.get_frame(8)\n self.assertEqual(frame.data, b\"89012345\")\n + self.assertTrue(frame.fin)\n self.assertEqual(frame.offset, 8)\n - self.assertTrue(frame.fin)\n \n + # nothing more to send\n self.assertFalse(stream.has_data_to_send())\n self.assertFalse(stream.is_blocked())\n + frame = stream.get_frame(8)\n + self.assertIsNone(frame)\n \n===========changed ref 5===========\n # module: aioquic.packet\n + def quic_uint_length(value: int) -> int:\n + \"\"\"\n + Returns the number of bytes required to encode the given value\n + as a QUIC variable-length unsigned integer.\n + \"\"\"\n + for i, (_, _, mask) in enumerate(UINT_VAR_FORMATS):\n + if value <= mask:\n + return 2 ** i\n + raise ValueError(\"Integer is too big for a variable-length integer\")\n + "}}},{"rowIdx":1847,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection.__init__"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<29>: self._network_paths: List[QuicNetworkPath] = []\n self._path: Optional[Qu\n"},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n <0> if not is_client:\n <1> assert certificate is not None, \"SSL certificate is required\"\n <2> assert private_key is not None, \"SSL private key is required\"\n <3> \n <4> self.alpn_protocols = alpn_protocols\n <5> self.certificate = certificate\n <6> self.is_client = is_client\n <7> self.host_cid = os.urandom(8)\n <8> self.peer_cid = os.urandom(8)\n <9> self.peer_cid_set = False\n<10> self.peer_token = b\"\"\n<11> self.private_key = private_key\n<12> self.secrets_log_file = secrets_log_file\n<13> self.server_name = server_name\n<14> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}\n<15> \n<16> self.__close: Optional[Dict] = None\n<17> self.__connected = asyncio.Event()\n<18> self.__epoch = tls.Epoch.INITIAL\n<19> self._local_idle_timeout = 60000 # milliseconds\n<20> self._local_max_data = 1048576\n<21> self._local_max_data_used = 0\n<22> self._local_max_stream_data_bidi_local = 1048576\n<23> self._local_max_stream_data_bidi_remote = 1048576\n<24> self._local_max_stream_data_uni = 1048576\n<25> self._local_max_streams_bidi = 128\n<26> self._local_max_streams_uni = 128\n<27> self.__logger = logger\n<28> self.__path_challenge: Optional[bytes] = None\n<29> self._path: Optional[Qu"},"context":{"kind":"string","value":"===========below chunk 0===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n # offset: 1\n self._pending_flow_control: List[bytes] = []\n self._remote_idle_timeout = 0 # milliseconds\n self._remote_max_data = 0\n self._remote_max_data_used = 0\n self._remote_max_stream_data_bidi_local = 0\n self._remote_max_stream_data_bidi_remote = 0\n self._remote_max_stream_data_uni = 0\n self._remote_max_streams_bidi = 0\n self._remote_max_streams_uni = 0\n self._spin_bit = False\n self._spin_highest_pn = 0\n self.__send_pending_task: Optional[asyncio.Handle] = None\n self.__state = QuicConnectionState.FIRSTFLIGHT\n self.__transport: Optional[asyncio.DatagramTransport] = None\n self._version: Optional[int] = None\n \n # callbacks\n self.stream_created_cb: Callable[\n [asyncio.StreamReader, asyncio.StreamWriter], None\n ] = lambda r, w: None\n \n # frame handlers\n self.__frame_handlers = [\n self._handle_padding_frame,\n self._handle_padding_frame,\n self._handle_ack_frame,\n self._handle_ack_frame,\n self._handle_reset_stream_frame,\n self._handle_stop_sending_frame,\n self._handle_crypto_frame,\n self._handle_new_token_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame\n===========below chunk 1===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n # offset: 2\n ,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_max_data_frame,\n self._handle_max_stream_data_frame,\n self._handle_max_streams_bidi_frame,\n self._handle_max_streams_uni_frame,\n self._handle_data_blocked_frame,\n self._handle_stream_data_blocked_frame,\n self._handle_streams_blocked_frame,\n self._handle_streams_blocked_frame,\n self._handle_new_connection_id_frame,\n self._handle_retire_connection_id_frame,\n self._handle_path_challenge_frame,\n self._handle_path_response_frame,\n self._handle_connection_close_frame,\n self._handle_connection_close_frame,\n ]\n \n \n===========unchanged ref 0===========\n at: aioquic.connection\n logger = logging.getLogger(\"quic\")\n \n QuicConnectionState()\n \n QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, challenge: Optional[bytes]=None, is_validated: bool=False)\n \n at: aioquic.connection.QuicConnection\n _handle_ack_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_crypto_frame(self, context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n _handle_crypto_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_max_data_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_max_stream_data_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_max_streams_bidi_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_max_streams_uni_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_new_token_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n _handle_new_token_frame(self, context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_padding_frame(self, context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n _handle_padding_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_reset_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_stop_sending_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n \n===========unchanged ref 1===========\n _handle_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.connection.QuicConnection._handle_crypto_frame\n self.__epoch = tls.Epoch.ONE_RTT\n self.__epoch = tls.Epoch.HANDSHAKE\n \n at: aioquic.connection.QuicConnection._handle_max_data_frame\n self._remote_max_data = max_data\n \n at: aioquic.connection.QuicConnection._handle_max_streams_bidi_frame\n self._remote_max_streams_bidi = max_streams\n \n at: aioquic.connection.QuicConnection._handle_max_streams_uni_frame\n self._remote_max_streams_uni = max_streams\n \n at: aioquic.connection.QuicConnection._handle_stream_frame\n self._local_max_data_used += newly_received\n \n at: aioquic.connection.QuicConnection._parse_transport_parameters\n self._remote_idle_timeout = quic_transport_parameters.idle_timeout\n \n at: aioquic.connection.QuicConnection._send_pending\n self.__send_pending_task = None\n \n at: aioquic.connection.QuicConnection._send_soon\n self.__send_pending_task = loop.call_soon(self._send_pending)\n \n at: aioquic.connection.QuicConnection._set_state\n self.__state = state\n \n at: aioquic.connection.QuicConnection._write_application\n self._pending_flow_control = []\n \n self.__close = None\n \n self._remote_max_data_used += len(frame.data)\n \n at: aioquic.connection.QuicConnection._write_handshake\n self.__close = None\n \n at: aioquic.connection.QuicConnection.close\n self.__close = {\n \"error_code\": error_code,\n \"frame_type\": frame_type,\n \"reason_phrase\": reason_phrase,\n }\n \n "}}},{"rowIdx":1848,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection.connect"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":" <3>: self._network_paths = [QuicNetworkPath(addr, is_validated=True)]\n self._path = QuicNetworkPath(addr)\n"},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def connect(self, addr: NetworkAddress) -> None:\n - def connect(self, addr: Any) -> None:\n <0> \"\"\"\n <1> Initiate the TLS handshake and wait for it to complete.\n <2> \"\"\"\n <3> self._path = QuicNetworkPath(addr)\n <4> self._version = max(self.supported_versions)\n <5> self._connect()\n <6> await self.__connected.wait()\n <7> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.connection\n QuicConnectionState()\n \n maybe_connection_error(error_code: int, frame_type: Optional[int], reason_phrase: str) -> Optional[QuicConnectionError]\n \n at: aioquic.connection.QuicConnection\n connection_lost(exc: Exception) -> None\n \n _set_state(state: QuicConnectionState) -> None\n \n \n===========changed ref 0===========\n # module: aioquic.connection\n + @dataclass\n + class QuicReceiveContext:\n + epoch: tls.Epoch\n + network_path: QuicNetworkPath\n + \n===========changed ref 1===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n - def __init__(self, addr: Any) -> None:\n - self.addr = addr\n - \n===========changed ref 2===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + def can_send(self, size: int) -> bool:\n + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received\n + \n===========changed ref 3===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + addr: NetworkAddress\n - addr: Any\n + bytes_received: int = 0\n - bytes_received = 0\n + bytes_sent: int = 0\n - bytes_sent = 0\n + challenge: Optional[bytes] = None\n + is_validated: bool = False\n - is_validated = False\n \n===========changed ref 4===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n if not is_client:\n assert certificate is not None, \"SSL certificate is required\"\n assert private_key is not None, \"SSL private key is required\"\n \n self.alpn_protocols = alpn_protocols\n self.certificate = certificate\n self.is_client = is_client\n self.host_cid = os.urandom(8)\n self.peer_cid = os.urandom(8)\n self.peer_cid_set = False\n self.peer_token = b\"\"\n self.private_key = private_key\n self.secrets_log_file = secrets_log_file\n self.server_name = server_name\n self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}\n \n self.__close: Optional[Dict] = None\n self.__connected = asyncio.Event()\n self.__epoch = tls.Epoch.INITIAL\n self._local_idle_timeout = 60000 # milliseconds\n self._local_max_data = 1048576\n self._local_max_data_used = 0\n self._local_max_stream_data_bidi_local = 1048576\n self._local_max_stream_data_bidi_remote = 1048576\n self._local_max_stream_data_uni = 1048576\n self._local_max_streams_bidi = 128\n self._local_max_streams_uni = 128\n self.__logger = logger\n self.__path_challenge: Optional[bytes] = None\n + self._network_paths: List[QuicNetworkPath] = []\n - self._path: Optional[QuicNetworkPath] = None\n self._pending\n===========changed ref 5===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n # offset: 1\n List[QuicNetworkPath] = []\n - self._path: Optional[QuicNetworkPath] = None\n self._pending_flow_control: List[bytes] = []\n self._remote_idle_timeout = 0 # milliseconds\n self._remote_max_data = 0\n self._remote_max_data_used = 0\n self._remote_max_stream_data_bidi_local = 0\n self._remote_max_stream_data_bidi_remote = 0\n self._remote_max_stream_data_uni = 0\n self._remote_max_streams_bidi = 0\n self._remote_max_streams_uni = 0\n self._spin_bit = False\n self._spin_highest_pn = 0\n self.__send_pending_task: Optional[asyncio.Handle] = None\n self.__state = QuicConnectionState.FIRSTFLIGHT\n self.__transport: Optional[asyncio.DatagramTransport] = None\n self._version: Optional[int] = None\n \n # callbacks\n self.stream_created_cb: Callable[\n [asyncio.StreamReader, asyncio.StreamWriter], None\n ] = lambda r, w: None\n \n # frame handlers\n self.__frame_handlers = [\n self._handle_padding_frame,\n self._handle_padding_frame,\n self._handle_ack_frame,\n self._handle_ack_frame,\n self._handle_reset_stream_frame,\n self._handle_stop_sending_frame,\n \n===========changed ref 6===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n # offset: 2\n handle_crypto_frame,\n self._handle_new_token_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_max_data_frame,\n self._handle_max_stream_data_frame,\n self._handle_max_streams_bidi_frame,\n self._handle_max_streams_uni_frame,\n self._handle_data_blocked_frame,\n self._handle_stream_data_blocked_frame,\n self._handle_streams_blocked_frame,\n self._handle_streams_blocked_frame,\n self._handle_new_connection_id_frame,\n self._handle_retire_connection_id_frame,\n self._handle_path_challenge_frame,\n self._handle_path_response_frame,\n self._handle_connection_close_frame,\n self._handle_connection_close_frame,\n ]\n "}}},{"rowIdx":1849,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection.datagram_received"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":""},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:\n - def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None:\n <0> \"\"\"\n <1> Handle an incoming datagram.\n <2> \"\"\"\n <3> # stop handling packets when closing\n <4> if self.__state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:\n <5> return\n <6> \n <7> data = cast(bytes, data)\n <8> buf = Buffer(data=data)\n <9> while not buf.eof():\n<10> start_off = buf.tell()\n<11> header = pull_quic_header(buf, host_cid_length=len(self.host_cid))\n<12> \n<13> # check destination CID matches\n<14> if self.is_client and header.destination_cid != self.host_cid:\n<15> return\n<16> \n<17> # check protocol version\n<18> if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:\n<19> # version negotiation\n<20> versions = []\n<21> while not buf.eof():\n<22> versions.append(pull_uint32(buf))\n<23> common = set(self.supported_versions).intersection(versions)\n<24> if not common:\n<25> self.__logger.error(\"Could not find a common protocol version\")\n<26> return\n<27> self._version = QuicProtocolVersion(max(common))\n<28> self.__logger.info(\"Retrying with %s\", self._version)\n<29> self._connect()\n<30> return\n<31> elif (\n<32> header.version is not None\n<33> and header.version not in self.supported_versions\n<34> ):\n<35> # unsupported version\n<36> return\n<37> \n<38> if self.is_client and header.packet_type == PACKET_TYPE_RETRY:\n<39> # stateless retry\n<40> if (\n<41> header.destination_cid == self.host_cid\n<42> and header.original_destination_cid == self.peer_cid\n "},"context":{"kind":"string","value":"===========below chunk 0===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:\n - def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None:\n # offset: 1\n self.__logger.info(\"Performing stateless retry\")\n self.peer_cid = header.source_cid\n self.peer_token = header.token\n self._connect()\n return\n \n # server initialization\n if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT:\n assert (\n header.packet_type == PACKET_TYPE_INITIAL\n ), \"first packet must be INITIAL\"\n self._path = QuicNetworkPath(addr)\n self._version = QuicProtocolVersion(header.version)\n self._initialize(header.destination_cid)\n \n # decrypt packet\n encrypted_off = buf.tell() - start_off\n end_off = buf.tell() + header.rest_length\n pull_bytes(buf, header.rest_length)\n \n epoch = get_epoch(header.packet_type)\n space = self.spaces[epoch]\n if not space.crypto.recv.is_valid():\n return\n try:\n plain_header, plain_payload, packet_number = space.crypto.decrypt_packet(\n data[start_off:end_off], encrypted_off\n )\n except CryptoError as exc:\n self.__logger.warning(exc)\n return\n \n if not self.peer_cid_set:\n self.peer_cid = header.source_cid\n self.peer_cid_set = True\n \n # update state\n if self.__state == QuicConnectionState.FIRSTFLIGHT:\n self._set_state(QuicConnectionState.CONNECTED)\n \n # update spin bit\n if (\n not is_long_header(plain_header[0])\n and packet_number > self._spin_highest_pn\n ):\n if self.is_client:\n \n===========below chunk 1===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:\n - def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None:\n # offset: 2\n ])\n and packet_number > self._spin_highest_pn\n ):\n if self.is_client:\n self._spin_bit = not get_spin_bit(plain_header[0])\n else:\n self._spin_bit = get_spin_bit(plain_header[0])\n self._spin_highest_pn = packet_number\n \n # handle payload\n try:\n is_ack_only, is_probing = self._payload_received(epoch, plain_payload)\n except QuicConnectionError as exc:\n self.__logger.warning(exc)\n self.close(\n error_code=exc.error_code,\n frame_type=exc.frame_type,\n reason_phrase=exc.reason_phrase,\n )\n return\n \n # record packet as received\n self._path.bytes_received += buf.tell() - start_off\n space.ack_queue.add(packet_number)\n if not is_ack_only:\n self.send_ack[epoch] = True\n \n self._send_pending()\n \n \n===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n pull_bytes(buf: Buffer, length: int) -> bytes\n \n pull_uint32(buf: Buffer) -> int\n \n at: aioquic.buffer.Buffer\n eof() -> bool\n \n tell() -> int\n \n at: aioquic.connection\n NetworkAddress = Any\n \n get_epoch(packet_type: int) -> tls.Epoch\n \n QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)\n \n QuicConnectionState()\n \n QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath)\n \n at: aioquic.connection.PacketSpace.__init__\n self.crypto = CryptoPair()\n \n at: aioquic.connection.QuicConnection\n supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]\n \n _connect() -> None\n \n _find_network_path(addr: NetworkAddress) -> QuicNetworkPath\n \n _initialize(peer_cid: bytes) -> None\n \n _payload_received(context: QuicReceiveContext, plain: bytes) -> Tuple[bool, bool]\n _payload_received(self, context: QuicReceiveContext, plain: bytes) -> Tuple[bool, bool]\n \n _set_state(state: QuicConnectionState) -> None\n \n at: aioquic.connection.QuicConnection.__init__\n self.is_client = is_client\n \n self.host_cid = os.urandom(8)\n \n self.peer_cid = os.urandom(8)\n \n self.peer_cid_set = False\n \n self.peer_token = b\"\"\n \n self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}\n \n self.__logger = logger\n \n self._network_paths: List[QuicNetworkPath] = []\n \n self._spin_bit = False\n \n self._spin_highest_pn = 0\n \n \n===========unchanged ref 1===========\n self.__state = QuicConnectionState.FIRSTFLIGHT\n \n self.__transport: Optional[asyncio.DatagramTransport] = None\n \n self._version: Optional[int] = None\n \n at: aioquic.connection.QuicConnection._initialize\n self.spaces = {\n tls.Epoch.INITIAL: PacketSpace(),\n tls.Epoch.HANDSHAKE: PacketSpace(),\n tls.Epoch.ONE_RTT: PacketSpace(),\n }\n \n at: aioquic.connection.QuicConnection._set_state\n self.__state = state\n \n at: aioquic.connection.QuicConnection.connect\n self._network_paths = [QuicNetworkPath(addr, is_validated=True)]\n \n self._version = max(self.supported_versions)\n \n at: aioquic.connection.QuicConnection.create_stream\n stream = self.streams[stream_id] = QuicStream(\n connection=self,\n stream_id=stream_id,\n max_stream_data_local=max_stream_data_local,\n max_stream_data_remote=max_stream_data_remote,\n )\n \n at: aioquic.connection.QuicReceiveContext\n epoch: tls.Epoch\n \n network_path: QuicNetworkPath\n \n at: aioquic.crypto\n CryptoError(*args: object)\n \n at: aioquic.crypto.CryptoContext\n is_valid() -> bool\n \n at: aioquic.crypto.CryptoPair\n decrypt_packet(packet: bytes, encrypted_offset: int) -> Tuple[bytes, bytes, int]\n \n at: aioquic.crypto.CryptoPair.__init__\n self.recv = CryptoContext()\n \n at: aioquic.packet\n PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00\n \n PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30\n \n "}}},{"rowIdx":1850,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection._handle_crypto_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":" <3>: stream = self.streams[context.epoch]\n stream = self.streams[epoch]\n"},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_crypto_frame(\n + self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n - self, epoch: tls.Epoch, frame_type: int, buf: Buffer\n ) -> None:\n <0> \"\"\"\n <1> Handle a CRYPTO frame.\n <2> \"\"\"\n <3> stream = self.streams[epoch]\n <4> stream.add_frame(packet.pull_crypto_frame(buf))\n <5> data = stream.pull_data()\n <6> if data:\n <7> # pass data to TLS layer\n <8> try:\n <9> self.tls.handle_message(data, self.send_buffer)\n<10> except tls.Alert as exc:\n<11> raise QuicConnectionError(\n<12> error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),\n<13> frame_type=QuicFrameType.CRYPTO,\n<14> reason_phrase=str(exc),\n<15> )\n<16> \n<17> # update current epoch\n<18> if self.tls.state in [\n<19> tls.State.CLIENT_POST_HANDSHAKE,\n<20> tls.State.SERVER_POST_HANDSHAKE,\n<21> ]:\n<22> if not self.__connected.is_set():\n<23> # parse transport parameters\n<24> for ext_type, ext_data in self.tls.received_extensions:\n<25> if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:\n<26> self._parse_transport_parameters(ext_data)\n<27> break\n<28> self.__connected.set()\n<29> self.__epoch = tls.Epoch.ONE_RTT\n<30> else:\n<31> self.__epoch = tls.Epoch.HANDSHAKE\n<32> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnectionState()\n \n QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath)\n \n maybe_connection_error(error_code: int, frame_type: Optional[int], reason_phrase: str) -> Optional[QuicConnectionError]\n \n at: aioquic.connection.QuicConnection\n connection_lost(exc: Exception) -> None\n \n _set_state(state: QuicConnectionState) -> None\n \n at: aioquic.connection.QuicConnection.__init__\n self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}\n \n self.__logger = logger\n \n at: aioquic.connection.QuicReceiveContext\n epoch: tls.Epoch\n \n at: aioquic.packet\n pull_uint_var(buf: Buffer) -> int\n \n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n pull_crypto_frame(buf: Buffer) -> QuicStreamFrame\n \n pull_transport_close_frame(buf: Buffer) -> Tuple[int, int, str]\n \n pull_application_close_frame(buf: Buffer) -> Tuple[int, str]\n \n at: aioquic.stream.QuicStream\n add_frame(frame: QuicStreamFrame) -> None\n \n at: logging.Logger\n info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None\n \n \n===========changed ref 0===========\n # module: aioquic.connection\n + @dataclass\n + class QuicReceiveContext:\n + epoch: tls.Epoch\n + network_path: QuicNetworkPath\n + \n===========changed ref 1===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath:\n + # check existing network paths\n + for idx, network_path in enumerate(self._network_paths):\n + if network_path.addr == addr:\n + return network_path\n + \n + # new network path\n + network_path = QuicNetworkPath(addr)\n + self.__logger.info(\"Network path %s discovered\", network_path.addr)\n + return network_path\n + \n===========changed ref 2===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def connect(self, addr: NetworkAddress) -> None:\n - def connect(self, addr: Any) -> None:\n \"\"\"\n Initiate the TLS handshake and wait for it to complete.\n \"\"\"\n + self._network_paths = [QuicNetworkPath(addr, is_validated=True)]\n - self._path = QuicNetworkPath(addr)\n self._version = max(self.supported_versions)\n self._connect()\n await self.__connected.wait()\n \n===========changed ref 3===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n - def __init__(self, addr: Any) -> None:\n - self.addr = addr\n - \n===========changed ref 4===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + def can_send(self, size: int) -> bool:\n + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received\n + \n===========changed ref 5===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + addr: NetworkAddress\n - addr: Any\n + bytes_received: int = 0\n - bytes_received = 0\n + bytes_sent: int = 0\n - bytes_sent = 0\n + challenge: Optional[bytes] = None\n + is_validated: bool = False\n - is_validated = False\n \n===========changed ref 6===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:\n - def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None:\n \"\"\"\n Handle an incoming datagram.\n \"\"\"\n # stop handling packets when closing\n if self.__state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:\n return\n \n data = cast(bytes, data)\n buf = Buffer(data=data)\n while not buf.eof():\n start_off = buf.tell()\n header = pull_quic_header(buf, host_cid_length=len(self.host_cid))\n \n # check destination CID matches\n if self.is_client and header.destination_cid != self.host_cid:\n return\n \n # check protocol version\n if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:\n # version negotiation\n versions = []\n while not buf.eof():\n versions.append(pull_uint32(buf))\n common = set(self.supported_versions).intersection(versions)\n if not common:\n self.__logger.error(\"Could not find a common protocol version\")\n return\n self._version = QuicProtocolVersion(max(common))\n self.__logger.info(\"Retrying with %s\", self._version)\n self._connect()\n return\n elif (\n header.version is not None\n and header.version not in self.supported_versions\n ):\n # unsupported version\n return\n \n if self.is_client and header.packet_type == PACKET_TYPE_RETRY:\n # stateless retry\n if (\n header.destination_cid == self.host_cid\n and header.original_destination_cid == self.peer_cid\n ):\n self.__logger.info(\"Performing stateless retry\")\n self.peer_cid = header.source_cid\n self.peer_token = header.token\n \n===========changed ref 7===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:\n - def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None:\n # offset: 1\n stateless retry\")\n self.peer_cid = header.source_cid\n self.peer_token = header.token\n self._connect()\n return\n \n + network_path = self._find_network_path(addr)\n + \n # server initialization\n if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT:\n assert (\n header.packet_type == PACKET_TYPE_INITIAL\n ), \"first packet must be INITIAL\"\n + self._network_paths = [network_path]\n - self._path = QuicNetworkPath(addr)\n self._version = QuicProtocolVersion(header.version)\n self._initialize(header.destination_cid)\n \n # decrypt packet\n encrypted_off = buf.tell() - start_off\n end_off = buf.tell() + header.rest_length\n pull_bytes(buf, header.rest_length)\n \n epoch = get_epoch(header.packet_type)\n space = self.spaces[epoch]\n if not space.crypto.recv.is_valid():\n return\n try:\n plain_header, plain_payload, packet_number = space.crypto.decrypt_packet(\n data[start_off:end_off], encrypted_off\n )\n except CryptoError as exc:\n self.__logger.warning(exc)\n return\n \n if not self.peer_cid_set:\n self.peer_cid = header.source_cid\n self.peer_cid_set = True\n \n # update state\n if self.__state == QuicConnectionState.FIRSTFLIGHT:\n self._set_state(QuicConnectionState"}}},{"rowIdx":1851,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection._handle_path_response_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":" <4>: if data != context.network_path.challenge:\n if data != self.__path_challenge:\n<10>: self.__logger.info(\"Network path %s validated\", context.network_path.addr)\n context.network_path.is_validated = True\n"},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_path_response_frame(\n + self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n - self, epoch: tls.Epoch, frame_type: int, buf: Buffer\n ) -> None:\n <0> \"\"\"\n <1> Handle a PATH_RESPONSE frame.\n <2> \"\"\"\n <3> data = pull_bytes(buf, 8)\n <4> if data != self.__path_challenge:\n <5> raise QuicConnectionError(\n <6> error_code=QuicErrorCode.PROTOCOL_VIOLATION,\n <7> frame_type=frame_type,\n <8> reason_phrase=\"Response does not match challenge\",\n <9> )\n<10> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath)\n \n at: aioquic.packet\n pull_new_token_frame(buf: Buffer) -> bytes\n \n pull_new_connection_id_frame(buf: Buffer) -> Tuple[int, bytes, bytes]\n \n \n===========changed ref 0===========\n # module: aioquic.connection\n + @dataclass\n + class QuicReceiveContext:\n + epoch: tls.Epoch\n + network_path: QuicNetworkPath\n + \n===========changed ref 1===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath:\n + # check existing network paths\n + for idx, network_path in enumerate(self._network_paths):\n + if network_path.addr == addr:\n + return network_path\n + \n + # new network path\n + network_path = QuicNetworkPath(addr)\n + self.__logger.info(\"Network path %s discovered\", network_path.addr)\n + return network_path\n + \n===========changed ref 2===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_crypto_frame(\n + self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n - self, epoch: tls.Epoch, frame_type: int, buf: Buffer\n ) -> None:\n \"\"\"\n Handle a CRYPTO frame.\n \"\"\"\n + stream = self.streams[context.epoch]\n - stream = self.streams[epoch]\n stream.add_frame(packet.pull_crypto_frame(buf))\n data = stream.pull_data()\n if data:\n # pass data to TLS layer\n try:\n self.tls.handle_message(data, self.send_buffer)\n except tls.Alert as exc:\n raise QuicConnectionError(\n error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),\n frame_type=QuicFrameType.CRYPTO,\n reason_phrase=str(exc),\n )\n \n # update current epoch\n if self.tls.state in [\n tls.State.CLIENT_POST_HANDSHAKE,\n tls.State.SERVER_POST_HANDSHAKE,\n ]:\n if not self.__connected.is_set():\n # parse transport parameters\n for ext_type, ext_data in self.tls.received_extensions:\n if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:\n self._parse_transport_parameters(ext_data)\n break\n self.__connected.set()\n self.__epoch = tls.Epoch.ONE_RTT\n else:\n self.__epoch = tls.Epoch.HANDSHAKE\n \n===========changed ref 3===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def connect(self, addr: NetworkAddress) -> None:\n - def connect(self, addr: Any) -> None:\n \"\"\"\n Initiate the TLS handshake and wait for it to complete.\n \"\"\"\n + self._network_paths = [QuicNetworkPath(addr, is_validated=True)]\n - self._path = QuicNetworkPath(addr)\n self._version = max(self.supported_versions)\n self._connect()\n await self.__connected.wait()\n \n===========changed ref 4===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n - def __init__(self, addr: Any) -> None:\n - self.addr = addr\n - \n===========changed ref 5===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + def can_send(self, size: int) -> bool:\n + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received\n + \n===========changed ref 6===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + addr: NetworkAddress\n - addr: Any\n + bytes_received: int = 0\n - bytes_received = 0\n + bytes_sent: int = 0\n - bytes_sent = 0\n + challenge: Optional[bytes] = None\n + is_validated: bool = False\n - is_validated = False\n \n===========changed ref 7===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:\n - def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None:\n \"\"\"\n Handle an incoming datagram.\n \"\"\"\n # stop handling packets when closing\n if self.__state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:\n return\n \n data = cast(bytes, data)\n buf = Buffer(data=data)\n while not buf.eof():\n start_off = buf.tell()\n header = pull_quic_header(buf, host_cid_length=len(self.host_cid))\n \n # check destination CID matches\n if self.is_client and header.destination_cid != self.host_cid:\n return\n \n # check protocol version\n if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:\n # version negotiation\n versions = []\n while not buf.eof():\n versions.append(pull_uint32(buf))\n common = set(self.supported_versions).intersection(versions)\n if not common:\n self.__logger.error(\"Could not find a common protocol version\")\n return\n self._version = QuicProtocolVersion(max(common))\n self.__logger.info(\"Retrying with %s\", self._version)\n self._connect()\n return\n elif (\n header.version is not None\n and header.version not in self.supported_versions\n ):\n # unsupported version\n return\n \n if self.is_client and header.packet_type == PACKET_TYPE_RETRY:\n # stateless retry\n if (\n header.destination_cid == self.host_cid\n and header.original_destination_cid == self.peer_cid\n ):\n self.__logger.info(\"Performing stateless retry\")\n self.peer_cid = header.source_cid\n self.peer_token = header.token\n "}}},{"rowIdx":1852,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection._payload_received"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<24>: self.__frame_handlers[frame_type](context, frame_type, buf)\n self.__frame_handlers[frame_type](epoch, frame_type, buf)\n"},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _payload_received(\n + self, context: QuicReceiveContext, plain: bytes\n + ) -> Tuple[bool, bool]:\n - def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> Tuple[bool, bool]:\n <0> buf = Buffer(data=plain)\n <1> \n <2> is_ack_only = True\n <3> is_probing = None\n <4> while not buf.eof():\n <5> frame_type = pull_uint_var(buf)\n <6> if frame_type not in [\n <7> QuicFrameType.ACK,\n <8> QuicFrameType.ACK_ECN,\n <9> QuicFrameType.PADDING,\n<10> ]:\n<11> is_ack_only = False\n<12> \n<13> if frame_type not in [\n<14> QuicFrameType.PATH_CHALLENGE,\n<15> QuicFrameType.PATH_RESPONSE,\n<16> QuicFrameType.PADDING,\n<17> QuicFrameType.NEW_CONNECTION_ID,\n<18> ]:\n<19> is_probing = False\n<20> elif is_probing is None:\n<21> is_probing = True\n<22> \n<23> if frame_type < len(self.__frame_handlers):\n<24> self.__frame_handlers[frame_type](epoch, frame_type, buf)\n<25> else:\n<26> raise QuicConnectionError(\n<27> error_code=QuicErrorCode.PROTOCOL_VIOLATION,\n<28> frame_type=frame_type,\n<29> reason_phrase=\"Unexpected frame type\",\n<30> )\n<31> \n<32> self._push_crypto_data()\n<33> \n<34> return is_ack_only, bool(is_probing)\n<35> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath)\n \n at: aioquic.connection.QuicConnection\n _assert_stream_can_receive(frame_type: int, stream_id: int) -> None\n \n _get_or_create_stream(frame_type: int, stream_id: int) -> QuicStream\n \n at: aioquic.connection.QuicConnection.__init__\n self._local_max_data_used = 0\n \n at: aioquic.connection.QuicConnection._handle_stream_frame\n frame = QuicStreamFrame(\n offset=offset,\n data=pull_bytes(buf, length),\n fin=bool(flags & QuicStreamFlag.FIN),\n )\n \n stream = self._get_or_create_stream(frame_type, stream_id)\n \n newly_received = max(0, offset + length - stream._recv_highest)\n \n at: aioquic.packet\n pull_uint_var(buf: Buffer) -> int\n \n at: aioquic.stream.QuicStream\n add_frame(frame: QuicStreamFrame) -> None\n \n at: typing\n Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')\n \n \n===========changed ref 0===========\n # module: aioquic.connection\n + @dataclass\n + class QuicReceiveContext:\n + epoch: tls.Epoch\n + network_path: QuicNetworkPath\n + \n===========changed ref 1===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_path_response_frame(\n + self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n - self, epoch: tls.Epoch, frame_type: int, buf: Buffer\n ) -> None:\n \"\"\"\n Handle a PATH_RESPONSE frame.\n \"\"\"\n data = pull_bytes(buf, 8)\n + if data != context.network_path.challenge:\n - if data != self.__path_challenge:\n raise QuicConnectionError(\n error_code=QuicErrorCode.PROTOCOL_VIOLATION,\n frame_type=frame_type,\n reason_phrase=\"Response does not match challenge\",\n )\n + self.__logger.info(\"Network path %s validated\", context.network_path.addr)\n + context.network_path.is_validated = True\n \n===========changed ref 2===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath:\n + # check existing network paths\n + for idx, network_path in enumerate(self._network_paths):\n + if network_path.addr == addr:\n + return network_path\n + \n + # new network path\n + network_path = QuicNetworkPath(addr)\n + self.__logger.info(\"Network path %s discovered\", network_path.addr)\n + return network_path\n + \n===========changed ref 3===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_crypto_frame(\n + self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n - self, epoch: tls.Epoch, frame_type: int, buf: Buffer\n ) -> None:\n \"\"\"\n Handle a CRYPTO frame.\n \"\"\"\n + stream = self.streams[context.epoch]\n - stream = self.streams[epoch]\n stream.add_frame(packet.pull_crypto_frame(buf))\n data = stream.pull_data()\n if data:\n # pass data to TLS layer\n try:\n self.tls.handle_message(data, self.send_buffer)\n except tls.Alert as exc:\n raise QuicConnectionError(\n error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),\n frame_type=QuicFrameType.CRYPTO,\n reason_phrase=str(exc),\n )\n \n # update current epoch\n if self.tls.state in [\n tls.State.CLIENT_POST_HANDSHAKE,\n tls.State.SERVER_POST_HANDSHAKE,\n ]:\n if not self.__connected.is_set():\n # parse transport parameters\n for ext_type, ext_data in self.tls.received_extensions:\n if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:\n self._parse_transport_parameters(ext_data)\n break\n self.__connected.set()\n self.__epoch = tls.Epoch.ONE_RTT\n else:\n self.__epoch = tls.Epoch.HANDSHAKE\n \n===========changed ref 4===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def connect(self, addr: NetworkAddress) -> None:\n - def connect(self, addr: Any) -> None:\n \"\"\"\n Initiate the TLS handshake and wait for it to complete.\n \"\"\"\n + self._network_paths = [QuicNetworkPath(addr, is_validated=True)]\n - self._path = QuicNetworkPath(addr)\n self._version = max(self.supported_versions)\n self._connect()\n await self.__connected.wait()\n \n===========changed ref 5===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n - def __init__(self, addr: Any) -> None:\n - self.addr = addr\n - \n===========changed ref 6===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + def can_send(self, size: int) -> bool:\n + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received\n + \n===========changed ref 7===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + addr: NetworkAddress\n - addr: Any\n + bytes_received: int = 0\n - bytes_received = 0\n + bytes_sent: int = 0\n - bytes_sent = 0\n + challenge: Optional[bytes] = None\n + is_validated: bool = False\n - is_validated = False\n "}}},{"rowIdx":1853,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection._send_path_challenge"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":" <0>: if network_path.challenge is None:\n network_path.challenge = os.urandom(8)\n self.__path_challenge = os.urandom(8)\n <2>: bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge\n bytes([QuicFrameType.PATH_CHALLENGE]) + self.__path_challenge\n"},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _send_path_challenge(self, network_path: QuicNetworkPath) -> None:\n - def _send_path_challenge(self) -> None:\n <0> self.__path_challenge = os.urandom(8)\n <1> self._pending_flow_control.append(\n <2> bytes([QuicFrameType.PATH_CHALLENGE]) + self.__path_challenge\n <3> )\n <4> self._send_pending()\n <5> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.packet\n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n \n===========changed ref 0===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_path_response_frame(\n + self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n - self, epoch: tls.Epoch, frame_type: int, buf: Buffer\n ) -> None:\n \"\"\"\n Handle a PATH_RESPONSE frame.\n \"\"\"\n data = pull_bytes(buf, 8)\n + if data != context.network_path.challenge:\n - if data != self.__path_challenge:\n raise QuicConnectionError(\n error_code=QuicErrorCode.PROTOCOL_VIOLATION,\n frame_type=frame_type,\n reason_phrase=\"Response does not match challenge\",\n )\n + self.__logger.info(\"Network path %s validated\", context.network_path.addr)\n + context.network_path.is_validated = True\n \n===========changed ref 1===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _payload_received(\n + self, context: QuicReceiveContext, plain: bytes\n + ) -> Tuple[bool, bool]:\n - def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> Tuple[bool, bool]:\n buf = Buffer(data=plain)\n \n is_ack_only = True\n is_probing = None\n while not buf.eof():\n frame_type = pull_uint_var(buf)\n if frame_type not in [\n QuicFrameType.ACK,\n QuicFrameType.ACK_ECN,\n QuicFrameType.PADDING,\n ]:\n is_ack_only = False\n \n if frame_type not in [\n QuicFrameType.PATH_CHALLENGE,\n QuicFrameType.PATH_RESPONSE,\n QuicFrameType.PADDING,\n QuicFrameType.NEW_CONNECTION_ID,\n ]:\n is_probing = False\n elif is_probing is None:\n is_probing = True\n \n if frame_type < len(self.__frame_handlers):\n + self.__frame_handlers[frame_type](context, frame_type, buf)\n - self.__frame_handlers[frame_type](epoch, frame_type, buf)\n else:\n raise QuicConnectionError(\n error_code=QuicErrorCode.PROTOCOL_VIOLATION,\n frame_type=frame_type,\n reason_phrase=\"Unexpected frame type\",\n )\n \n self._push_crypto_data()\n \n return is_ack_only, bool(is_probing)\n \n===========changed ref 2===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath:\n + # check existing network paths\n + for idx, network_path in enumerate(self._network_paths):\n + if network_path.addr == addr:\n + return network_path\n + \n + # new network path\n + network_path = QuicNetworkPath(addr)\n + self.__logger.info(\"Network path %s discovered\", network_path.addr)\n + return network_path\n + \n===========changed ref 3===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_crypto_frame(\n + self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n - self, epoch: tls.Epoch, frame_type: int, buf: Buffer\n ) -> None:\n \"\"\"\n Handle a CRYPTO frame.\n \"\"\"\n + stream = self.streams[context.epoch]\n - stream = self.streams[epoch]\n stream.add_frame(packet.pull_crypto_frame(buf))\n data = stream.pull_data()\n if data:\n # pass data to TLS layer\n try:\n self.tls.handle_message(data, self.send_buffer)\n except tls.Alert as exc:\n raise QuicConnectionError(\n error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),\n frame_type=QuicFrameType.CRYPTO,\n reason_phrase=str(exc),\n )\n \n # update current epoch\n if self.tls.state in [\n tls.State.CLIENT_POST_HANDSHAKE,\n tls.State.SERVER_POST_HANDSHAKE,\n ]:\n if not self.__connected.is_set():\n # parse transport parameters\n for ext_type, ext_data in self.tls.received_extensions:\n if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:\n self._parse_transport_parameters(ext_data)\n break\n self.__connected.set()\n self.__epoch = tls.Epoch.ONE_RTT\n else:\n self.__epoch = tls.Epoch.HANDSHAKE\n \n===========changed ref 4===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def connect(self, addr: NetworkAddress) -> None:\n - def connect(self, addr: Any) -> None:\n \"\"\"\n Initiate the TLS handshake and wait for it to complete.\n \"\"\"\n + self._network_paths = [QuicNetworkPath(addr, is_validated=True)]\n - self._path = QuicNetworkPath(addr)\n self._version = max(self.supported_versions)\n self._connect()\n await self.__connected.wait()\n \n===========changed ref 5===========\n # module: aioquic.connection\n + @dataclass\n + class QuicReceiveContext:\n + epoch: tls.Epoch\n + network_path: QuicNetworkPath\n + \n===========changed ref 6===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n - def __init__(self, addr: Any) -> None:\n - self.addr = addr\n - \n===========changed ref 7===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + def can_send(self, size: int) -> bool:\n + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received\n + \n===========changed ref 8===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + addr: NetworkAddress\n - addr: Any\n + bytes_received: int = 0\n - bytes_received = 0\n + bytes_sent: int = 0\n - bytes_sent = 0\n + challenge: Optional[bytes] = None\n + is_validated: bool = False\n - is_validated = False\n "}}},{"rowIdx":1854,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection._send_pending"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":" <0>: network_path = self._network_paths[0]\n <1>: self.__transport.sendto(datagram, network_path.addr)\n self.__transport.sendto(datagram, self._path.addr)\n <2>: network_path.bytes_sent += len(datagram)\n self._path.bytes_sent += len(datagram)\n"},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _send_pending(self) -> None:\n <0> for datagram in self._pending_datagrams():\n <1> self.__transport.sendto(datagram, self._path.addr)\n <2> self._path.bytes_sent += len(datagram)\n <3> self.__send_pending_task = None\n <4> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.connection\n QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)\n \n at: aioquic.connection.QuicConnection.__init__\n self.__frame_handlers = [\n self._handle_padding_frame,\n self._handle_padding_frame,\n self._handle_ack_frame,\n self._handle_ack_frame,\n self._handle_reset_stream_frame,\n self._handle_stop_sending_frame,\n self._handle_crypto_frame,\n self._handle_new_token_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_max_data_frame,\n self._handle_max_stream_data_frame,\n self._handle_max_streams_bidi_frame,\n self._handle_max_streams_uni_frame,\n self._handle_data_blocked_frame,\n self._handle_stream_data_blocked_frame,\n self._handle_streams_blocked_frame,\n self._handle_streams_blocked_frame,\n self._handle_new_connection_id_frame,\n self._handle_retire_connection_id_frame,\n self._handle_path_challenge_frame,\n self._handle_path_response_frame,\n self._handle_connection_close_frame,\n self._handle_connection_close_frame,\n ]\n \n at: aioquic.connection.QuicConnection._payload_received\n buf = Buffer(data=plain)\n \n frame_type = pull_uint_var(buf)\n \n at: aioquic.packet\n QuicErrorCode(x: Union[str, bytes, bytearray], base: int)\n QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n \n===========changed ref 0===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _send_path_challenge(self, network_path: QuicNetworkPath) -> None:\n - def _send_path_challenge(self) -> None:\n + if network_path.challenge is None:\n + network_path.challenge = os.urandom(8)\n - self.__path_challenge = os.urandom(8)\n self._pending_flow_control.append(\n + bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge\n - bytes([QuicFrameType.PATH_CHALLENGE]) + self.__path_challenge\n )\n self._send_pending()\n \n===========changed ref 1===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_path_response_frame(\n + self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n - self, epoch: tls.Epoch, frame_type: int, buf: Buffer\n ) -> None:\n \"\"\"\n Handle a PATH_RESPONSE frame.\n \"\"\"\n data = pull_bytes(buf, 8)\n + if data != context.network_path.challenge:\n - if data != self.__path_challenge:\n raise QuicConnectionError(\n error_code=QuicErrorCode.PROTOCOL_VIOLATION,\n frame_type=frame_type,\n reason_phrase=\"Response does not match challenge\",\n )\n + self.__logger.info(\"Network path %s validated\", context.network_path.addr)\n + context.network_path.is_validated = True\n \n===========changed ref 2===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _payload_received(\n + self, context: QuicReceiveContext, plain: bytes\n + ) -> Tuple[bool, bool]:\n - def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> Tuple[bool, bool]:\n buf = Buffer(data=plain)\n \n is_ack_only = True\n is_probing = None\n while not buf.eof():\n frame_type = pull_uint_var(buf)\n if frame_type not in [\n QuicFrameType.ACK,\n QuicFrameType.ACK_ECN,\n QuicFrameType.PADDING,\n ]:\n is_ack_only = False\n \n if frame_type not in [\n QuicFrameType.PATH_CHALLENGE,\n QuicFrameType.PATH_RESPONSE,\n QuicFrameType.PADDING,\n QuicFrameType.NEW_CONNECTION_ID,\n ]:\n is_probing = False\n elif is_probing is None:\n is_probing = True\n \n if frame_type < len(self.__frame_handlers):\n + self.__frame_handlers[frame_type](context, frame_type, buf)\n - self.__frame_handlers[frame_type](epoch, frame_type, buf)\n else:\n raise QuicConnectionError(\n error_code=QuicErrorCode.PROTOCOL_VIOLATION,\n frame_type=frame_type,\n reason_phrase=\"Unexpected frame type\",\n )\n \n self._push_crypto_data()\n \n return is_ack_only, bool(is_probing)\n \n===========changed ref 3===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath:\n + # check existing network paths\n + for idx, network_path in enumerate(self._network_paths):\n + if network_path.addr == addr:\n + return network_path\n + \n + # new network path\n + network_path = QuicNetworkPath(addr)\n + self.__logger.info(\"Network path %s discovered\", network_path.addr)\n + return network_path\n + \n===========changed ref 4===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_crypto_frame(\n + self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n - self, epoch: tls.Epoch, frame_type: int, buf: Buffer\n ) -> None:\n \"\"\"\n Handle a CRYPTO frame.\n \"\"\"\n + stream = self.streams[context.epoch]\n - stream = self.streams[epoch]\n stream.add_frame(packet.pull_crypto_frame(buf))\n data = stream.pull_data()\n if data:\n # pass data to TLS layer\n try:\n self.tls.handle_message(data, self.send_buffer)\n except tls.Alert as exc:\n raise QuicConnectionError(\n error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),\n frame_type=QuicFrameType.CRYPTO,\n reason_phrase=str(exc),\n )\n \n # update current epoch\n if self.tls.state in [\n tls.State.CLIENT_POST_HANDSHAKE,\n tls.State.SERVER_POST_HANDSHAKE,\n ]:\n if not self.__connected.is_set():\n # parse transport parameters\n for ext_type, ext_data in self.tls.received_extensions:\n if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:\n self._parse_transport_parameters(ext_data)\n break\n self.__connected.set()\n self.__epoch = tls.Epoch.ONE_RTT\n else:\n self.__epoch = tls.Epoch.HANDSHAKE\n "}}},{"rowIdx":1855,"cells":{"path":{"kind":"string","value":"tests.test_connection/create_standalone_client"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":" <5>: client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n client._path = QuicNetworkPath(SERVER_ADDR)\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n def create_standalone_client():\n <0> client = QuicConnection(is_client=True)\n <1> client_transport = FakeTransport(CLIENT_ADDR)\n <2> client.connection_made(client_transport)\n <3> \n <4> # like connect() but without waiting\n <5> client._path = QuicNetworkPath(SERVER_ADDR)\n <6> client._version = max(client.supported_versions)\n <7> client._connect()\n <8> \n <9> return client, client_transport\n<10> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.connection\n QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath)\n \n at: aioquic.connection.QuicConnection.__init__\n self._network_paths: List[QuicNetworkPath] = []\n \n at: aioquic.connection.QuicConnection.connect\n self._network_paths = [QuicNetworkPath(addr, is_validated=True)]\n \n at: aioquic.connection.QuicConnection.datagram_received\n self._network_paths = [network_path]\n \n at: aioquic.connection.QuicReceiveContext\n epoch: tls.Epoch\n \n network_path: QuicNetworkPath\n \n at: aioquic.tls\n Epoch()\n \n at: tests.test_connection.FakeTransport\n sent = 0\n \n target = None\n \n at: tests.test_connection.FakeTransport.__init__\n self.local_addr = local_addr\n \n \n===========changed ref 0===========\n # module: aioquic.connection\n + @dataclass\n + class QuicReceiveContext:\n + epoch: tls.Epoch\n + network_path: QuicNetworkPath\n + \n===========changed ref 1===========\n # module: aioquic.connection\n + NetworkAddress = Any\n \n \n===========changed ref 2===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n - def __init__(self, addr: Any) -> None:\n - self.addr = addr\n - \n===========changed ref 3===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + def can_send(self, size: int) -> bool:\n + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received\n + \n===========changed ref 4===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + addr: NetworkAddress\n - addr: Any\n + bytes_received: int = 0\n - bytes_received = 0\n + bytes_sent: int = 0\n - bytes_sent = 0\n + challenge: Optional[bytes] = None\n + is_validated: bool = False\n - is_validated = False\n \n===========changed ref 5===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def connect(self, addr: NetworkAddress) -> None:\n - def connect(self, addr: Any) -> None:\n \"\"\"\n Initiate the TLS handshake and wait for it to complete.\n \"\"\"\n + self._network_paths = [QuicNetworkPath(addr, is_validated=True)]\n - self._path = QuicNetworkPath(addr)\n self._version = max(self.supported_versions)\n self._connect()\n await self.__connected.wait()\n \n===========changed ref 6===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath:\n + # check existing network paths\n + for idx, network_path in enumerate(self._network_paths):\n + if network_path.addr == addr:\n + return network_path\n + \n + # new network path\n + network_path = QuicNetworkPath(addr)\n + self.__logger.info(\"Network path %s discovered\", network_path.addr)\n + return network_path\n + \n===========changed ref 7===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _send_pending(self) -> None:\n + network_path = self._network_paths[0]\n for datagram in self._pending_datagrams():\n + self.__transport.sendto(datagram, network_path.addr)\n - self.__transport.sendto(datagram, self._path.addr)\n + network_path.bytes_sent += len(datagram)\n - self._path.bytes_sent += len(datagram)\n self.__send_pending_task = None\n \n===========changed ref 8===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _send_path_challenge(self, network_path: QuicNetworkPath) -> None:\n - def _send_path_challenge(self) -> None:\n + if network_path.challenge is None:\n + network_path.challenge = os.urandom(8)\n - self.__path_challenge = os.urandom(8)\n self._pending_flow_control.append(\n + bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge\n - bytes([QuicFrameType.PATH_CHALLENGE]) + self.__path_challenge\n )\n self._send_pending()\n \n===========changed ref 9===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_path_response_frame(\n + self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n - self, epoch: tls.Epoch, frame_type: int, buf: Buffer\n ) -> None:\n \"\"\"\n Handle a PATH_RESPONSE frame.\n \"\"\"\n data = pull_bytes(buf, 8)\n + if data != context.network_path.challenge:\n - if data != self.__path_challenge:\n raise QuicConnectionError(\n error_code=QuicErrorCode.PROTOCOL_VIOLATION,\n frame_type=frame_type,\n reason_phrase=\"Response does not match challenge\",\n )\n + self.__logger.info(\"Network path %s validated\", context.network_path.addr)\n + context.network_path.is_validated = True\n \n===========changed ref 10===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _payload_received(\n + self, context: QuicReceiveContext, plain: bytes\n + ) -> Tuple[bool, bool]:\n - def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> Tuple[bool, bool]:\n buf = Buffer(data=plain)\n \n is_ack_only = True\n is_probing = None\n while not buf.eof():\n frame_type = pull_uint_var(buf)\n if frame_type not in [\n QuicFrameType.ACK,\n QuicFrameType.ACK_ECN,\n QuicFrameType.PADDING,\n ]:\n is_ack_only = False\n \n if frame_type not in [\n QuicFrameType.PATH_CHALLENGE,\n QuicFrameType.PATH_RESPONSE,\n QuicFrameType.PADDING,\n QuicFrameType.NEW_CONNECTION_ID,\n ]:\n is_probing = False\n elif is_probing is None:\n is_probing = True\n \n if frame_type < len(self.__frame_handlers):\n + self.__frame_handlers[frame_type](context, frame_type, buf)\n - self.__frame_handlers[frame_type](epoch, frame_type, buf)\n else:\n raise QuicConnectionError(\n error_code=QuicErrorCode.PROTOCOL_VIOLATION,\n frame_type=frame_type,\n reason_phrase=\"Unexpected frame type\",\n )\n \n self._push_crypto_data()\n \n return is_ack_only, bool(is_probing)\n "}}},{"rowIdx":1856,"cells":{"path":{"kind":"string","value":"tests.test_connection/create_transport"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<10>: client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n client._path = QuicNetworkPath(SERVER_ADDR)\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n def create_transport(client, server):\n <0> client_transport = FakeTransport(CLIENT_ADDR)\n <1> client_transport.target = server\n <2> \n <3> server_transport = FakeTransport(SERVER_ADDR)\n <4> server_transport.target = client\n <5> \n <6> server.connection_made(server_transport)\n <7> client.connection_made(client_transport)\n <8> \n <9> # like connect() but without waiting\n<10> client._path = QuicNetworkPath(SERVER_ADDR)\n<11> client._version = max(client.supported_versions)\n<12> client._connect()\n<13> \n<14> return client_transport, server_transport\n<15> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.connection\n QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, challenge: Optional[bytes]=None, is_validated: bool=False)\n \n at: aioquic.connection.QuicConnection\n supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]\n \n connection_made(transport: asyncio.BaseTransport) -> None\n \n _connect() -> None\n \n at: aioquic.connection.QuicConnection.__init__\n self._network_paths: List[QuicNetworkPath] = []\n \n self._version: Optional[int] = None\n \n at: aioquic.connection.QuicConnection.connect\n self._network_paths = [QuicNetworkPath(addr, is_validated=True)]\n \n self._version = max(self.supported_versions)\n \n at: aioquic.connection.QuicConnection.datagram_received\n self._version = QuicProtocolVersion(header.version)\n self._version = QuicProtocolVersion(max(common))\n \n self._network_paths = [network_path]\n \n at: aioquic.connection.QuicNetworkPath\n addr: NetworkAddress\n \n bytes_received: int = 0\n \n bytes_sent: int = 0\n \n challenge: Optional[bytes] = None\n \n is_validated: bool = False\n \n at: tests.test_connection\n CLIENT_ADDR = None\n \n SERVER_ADDR = None\n \n FakeTransport(local_addr)\n \n at: tests.test_connection.FakeTransport\n target = None\n \n at: tests.test_connection.create_standalone_client\n client = QuicConnection(is_client=True)\n \n \n===========changed ref 0===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + addr: NetworkAddress\n - addr: Any\n + bytes_received: int = 0\n - bytes_received = 0\n + bytes_sent: int = 0\n - bytes_sent = 0\n + challenge: Optional[bytes] = None\n + is_validated: bool = False\n - is_validated = False\n \n===========changed ref 1===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 2===========\n # module: tests.test_connection\n def create_standalone_client():\n client = QuicConnection(is_client=True)\n client_transport = FakeTransport(CLIENT_ADDR)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client, client_transport\n \n===========changed ref 3===========\n # module: aioquic.connection\n + NetworkAddress = Any\n \n \n===========changed ref 4===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n - def __init__(self, addr: Any) -> None:\n - self.addr = addr\n - \n===========changed ref 5===========\n # module: aioquic.connection\n + @dataclass\n + class QuicReceiveContext:\n + epoch: tls.Epoch\n + network_path: QuicNetworkPath\n + \n===========changed ref 6===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + def can_send(self, size: int) -> bool:\n + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received\n + \n===========changed ref 7===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def connect(self, addr: NetworkAddress) -> None:\n - def connect(self, addr: Any) -> None:\n \"\"\"\n Initiate the TLS handshake and wait for it to complete.\n \"\"\"\n + self._network_paths = [QuicNetworkPath(addr, is_validated=True)]\n - self._path = QuicNetworkPath(addr)\n self._version = max(self.supported_versions)\n self._connect()\n await self.__connected.wait()\n \n===========changed ref 8===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath:\n + # check existing network paths\n + for idx, network_path in enumerate(self._network_paths):\n + if network_path.addr == addr:\n + return network_path\n + \n + # new network path\n + network_path = QuicNetworkPath(addr)\n + self.__logger.info(\"Network path %s discovered\", network_path.addr)\n + return network_path\n + \n===========changed ref 9===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _send_pending(self) -> None:\n + network_path = self._network_paths[0]\n for datagram in self._pending_datagrams():\n + self.__transport.sendto(datagram, network_path.addr)\n - self.__transport.sendto(datagram, self._path.addr)\n + network_path.bytes_sent += len(datagram)\n - self._path.bytes_sent += len(datagram)\n self.__send_pending_task = None\n \n===========changed ref 10===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _send_path_challenge(self, network_path: QuicNetworkPath) -> None:\n - def _send_path_challenge(self) -> None:\n + if network_path.challenge is None:\n + network_path.challenge = os.urandom(8)\n - self.__path_challenge = os.urandom(8)\n self._pending_flow_control.append(\n + bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge\n - bytes([QuicFrameType.PATH_CHALLENGE]) + self.__path_challenge\n )\n self._send_pending()\n \n===========changed ref 11===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_path_response_frame(\n + self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n - self, epoch: tls.Epoch, frame_type: int, buf: Buffer\n ) -> None:\n \"\"\"\n Handle a PATH_RESPONSE frame.\n \"\"\"\n data = pull_bytes(buf, 8)\n + if data != context.network_path.challenge:\n - if data != self.__path_challenge:\n raise QuicConnectionError(\n error_code=QuicErrorCode.PROTOCOL_VIOLATION,\n frame_type=frame_type,\n reason_phrase=\"Response does not match challenge\",\n )\n + self.__logger.info(\"Network path %s validated\", context.network_path.addr)\n + context.network_path.is_validated = True\n "}}},{"rowIdx":1857,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_ack_frame_ecn"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":" <0>: client, client_transport = create_standalone_client()\n \n client = QuicConnection(is_client=True)\n <2>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_ack_frame_ecn(self):\n <0> client = QuicConnection(is_client=True)\n <1> client._handle_ack_frame(\n <2> tls.Epoch.ONE_RTT,\n <3> QuicFrameType.ACK_ECN,\n <4> Buffer(data=b\"\\x00\\x02\\x00\\x00\\x00\\x00\\x00\"),\n <5> )\n <6> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.connection.QuicConnection.__init__\n self.peer_cid = os.urandom(8)\n \n at: aioquic.connection.QuicConnection.datagram_received\n self.peer_cid = header.source_cid\n \n at: tests.test_connection\n SERVER_ADDR = None\n \n at: tests.test_connection.FakeTransport.sendto\n self.sent += 1\n \n at: tests.test_connection.QuicConnectionTest.test_datagram_received_retry_wrong_destination_cid\n client, client_transport = create_standalone_client()\n \n client, client_transport = create_standalone_client()\n \n at: unittest.case.TestCase\n failureException: Type[BaseException]\n \n longMessage: bool\n \n maxDiff: Optional[int]\n \n _testMethodName: str\n \n _testMethodDoc: str\n \n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_standalone_client():\n client = QuicConnection(is_client=True)\n client_transport = FakeTransport(CLIENT_ADDR)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client, client_transport\n \n===========changed ref 2===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 3===========\n # module: aioquic.connection\n + NetworkAddress = Any\n \n \n===========changed ref 4===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n - def __init__(self, addr: Any) -> None:\n - self.addr = addr\n - \n===========changed ref 5===========\n # module: aioquic.connection\n + @dataclass\n + class QuicReceiveContext:\n + epoch: tls.Epoch\n + network_path: QuicNetworkPath\n + \n===========changed ref 6===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + def can_send(self, size: int) -> bool:\n + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received\n + \n===========changed ref 7===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + addr: NetworkAddress\n - addr: Any\n + bytes_received: int = 0\n - bytes_received = 0\n + bytes_sent: int = 0\n - bytes_sent = 0\n + challenge: Optional[bytes] = None\n + is_validated: bool = False\n - is_validated = False\n \n===========changed ref 8===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def connect(self, addr: NetworkAddress) -> None:\n - def connect(self, addr: Any) -> None:\n \"\"\"\n Initiate the TLS handshake and wait for it to complete.\n \"\"\"\n + self._network_paths = [QuicNetworkPath(addr, is_validated=True)]\n - self._path = QuicNetworkPath(addr)\n self._version = max(self.supported_versions)\n self._connect()\n await self.__connected.wait()\n \n===========changed ref 9===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath:\n + # check existing network paths\n + for idx, network_path in enumerate(self._network_paths):\n + if network_path.addr == addr:\n + return network_path\n + \n + # new network path\n + network_path = QuicNetworkPath(addr)\n + self.__logger.info(\"Network path %s discovered\", network_path.addr)\n + return network_path\n + \n===========changed ref 10===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _send_pending(self) -> None:\n + network_path = self._network_paths[0]\n for datagram in self._pending_datagrams():\n + self.__transport.sendto(datagram, network_path.addr)\n - self.__transport.sendto(datagram, self._path.addr)\n + network_path.bytes_sent += len(datagram)\n - self._path.bytes_sent += len(datagram)\n self.__send_pending_task = None\n \n===========changed ref 11===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _send_path_challenge(self, network_path: QuicNetworkPath) -> None:\n - def _send_path_challenge(self) -> None:\n + if network_path.challenge is None:\n + network_path.challenge = os.urandom(8)\n - self.__path_challenge = os.urandom(8)\n self._pending_flow_control.append(\n + bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge\n - bytes([QuicFrameType.PATH_CHALLENGE]) + self.__path_challenge\n )\n self._send_pending()\n \n===========changed ref 12===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_path_response_frame(\n + self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n - self, epoch: tls.Epoch, frame_type: int, buf: Buffer\n ) -> None:\n \"\"\"\n Handle a PATH_RESPONSE frame.\n \"\"\"\n data = pull_bytes(buf, 8)\n + if data != context.network_path.challenge:\n - if data != self.__path_challenge:\n raise QuicConnectionError(\n error_code=QuicErrorCode.PROTOCOL_VIOLATION,\n frame_type=frame_type,\n reason_phrase=\"Response does not match challenge\",\n )\n + self.__logger.info(\"Network path %s validated\", context.network_path.addr)\n + context.network_path.is_validated = True\n "}}},{"rowIdx":1858,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_data_blocked_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<12>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_data_blocked_frame(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # client receives DATA_BLOCKED: 12345\n<11> client._handle_data_blocked_frame(\n<12> tls.Epoch.ONE_RTT,\n<13> QuicFrameType.DATA_BLOCKED,\n<14> Buffer(data=encode_uint_var(12345)),\n<15> )\n<16> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.connection\n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n close(error_code: int=QuicErrorCode.NO_ERROR, frame_type: Optional[int]=None, reason_phrase: str=\"\") -> None\n \n at: aioquic.packet\n QuicErrorCode(x: Union[str, bytes, bytearray], base: int)\n QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n create_transport(client, server)\n \n at: tests.test_connection.FakeTransport.sendto\n self.sent += 1\n \n at: tests.test_connection.QuicConnectionTest.test_handle_connection_close_frame_app\n client = QuicConnection(is_client=True)\n \n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 1===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_ack_frame_ecn(self):\n + client, client_transport = create_standalone_client()\n + \n - client = QuicConnection(is_client=True)\n client._handle_ack_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.ACK_ECN,\n Buffer(data=b\"\\x00\\x02\\x00\\x00\\x00\\x00\\x00\"),\n )\n \n===========changed ref 2===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 3===========\n # module: tests.test_connection\n def create_standalone_client():\n client = QuicConnection(is_client=True)\n client_transport = FakeTransport(CLIENT_ADDR)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client, client_transport\n \n===========changed ref 4===========\n # module: aioquic.connection\n + NetworkAddress = Any\n \n \n===========changed ref 5===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n - def __init__(self, addr: Any) -> None:\n - self.addr = addr\n - \n===========changed ref 6===========\n # module: aioquic.connection\n + @dataclass\n + class QuicReceiveContext:\n + epoch: tls.Epoch\n + network_path: QuicNetworkPath\n + \n===========changed ref 7===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + def can_send(self, size: int) -> bool:\n + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received\n + \n===========changed ref 8===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + addr: NetworkAddress\n - addr: Any\n + bytes_received: int = 0\n - bytes_received = 0\n + bytes_sent: int = 0\n - bytes_sent = 0\n + challenge: Optional[bytes] = None\n + is_validated: bool = False\n - is_validated = False\n \n===========changed ref 9===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def connect(self, addr: NetworkAddress) -> None:\n - def connect(self, addr: Any) -> None:\n \"\"\"\n Initiate the TLS handshake and wait for it to complete.\n \"\"\"\n + self._network_paths = [QuicNetworkPath(addr, is_validated=True)]\n - self._path = QuicNetworkPath(addr)\n self._version = max(self.supported_versions)\n self._connect()\n await self.__connected.wait()\n \n===========changed ref 10===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath:\n + # check existing network paths\n + for idx, network_path in enumerate(self._network_paths):\n + if network_path.addr == addr:\n + return network_path\n + \n + # new network path\n + network_path = QuicNetworkPath(addr)\n + self.__logger.info(\"Network path %s discovered\", network_path.addr)\n + return network_path\n + \n===========changed ref 11===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _send_pending(self) -> None:\n + network_path = self._network_paths[0]\n for datagram in self._pending_datagrams():\n + self.__transport.sendto(datagram, network_path.addr)\n - self.__transport.sendto(datagram, self._path.addr)\n + network_path.bytes_sent += len(datagram)\n - self._path.bytes_sent += len(datagram)\n self.__send_pending_task = None\n \n===========changed ref 12===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _send_path_challenge(self, network_path: QuicNetworkPath) -> None:\n - def _send_path_challenge(self) -> None:\n + if network_path.challenge is None:\n + network_path.challenge = os.urandom(8)\n - self.__path_challenge = os.urandom(8)\n self._pending_flow_control.append(\n + bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge\n - bytes([QuicFrameType.PATH_CHALLENGE]) + self.__path_challenge\n )\n self._send_pending()\n \n===========changed ref 13===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_path_response_frame(\n + self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n - self, epoch: tls.Epoch, frame_type: int, buf: Buffer\n ) -> None:\n \"\"\"\n Handle a PATH_RESPONSE frame.\n \"\"\"\n data = pull_bytes(buf, 8)\n + if data != context.network_path.challenge:\n - if data != self.__path_challenge:\n raise QuicConnectionError(\n error_code=QuicErrorCode.PROTOCOL_VIOLATION,\n frame_type=frame_type,\n reason_phrase=\"Response does not match challenge\",\n )\n + self.__logger.info(\"Network path %s validated\", context.network_path.addr)\n + context.network_path.is_validated = True\n "}}},{"rowIdx":1859,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_max_data_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<13>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_data_frame(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> self.assertEqual(client._remote_max_data, 1048576)\n<10> \n<11> # client receives MAX_DATA raising limit\n<12> client._handle_max_data_frame(\n<13> tls.Epoch.ONE_RTT,\n<14> QuicFrameType.MAX_DATA,\n<15> Buffer(data=encode_uint_var(1048577)),\n<16> )\n<17> self.assertEqual(client._remote_max_data, 1048577)\n<18> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n _handle_data_blocked_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.packet\n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n encode_uint_var(v)\n \n client_receive_context(client)\n \n create_transport(client, server)\n \n at: tests.test_connection.QuicConnectionTest.test_handle_data_blocked_frame\n client = QuicConnection(is_client=True)\n \n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_data_blocked_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives DATA_BLOCKED: 12345\n client._handle_data_blocked_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.DATA_BLOCKED,\n Buffer(data=encode_uint_var(12345)),\n )\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_ack_frame_ecn(self):\n + client, client_transport = create_standalone_client()\n + \n - client = QuicConnection(is_client=True)\n client._handle_ack_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.ACK_ECN,\n Buffer(data=b\"\\x00\\x02\\x00\\x00\\x00\\x00\\x00\"),\n )\n \n===========changed ref 4===========\n # module: tests.test_connection\n def create_standalone_client():\n client = QuicConnection(is_client=True)\n client_transport = FakeTransport(CLIENT_ADDR)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client, client_transport\n \n===========changed ref 5===========\n # module: aioquic.connection\n + NetworkAddress = Any\n \n \n===========changed ref 6===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n - def __init__(self, addr: Any) -> None:\n - self.addr = addr\n - \n===========changed ref 7===========\n # module: aioquic.connection\n + @dataclass\n + class QuicReceiveContext:\n + epoch: tls.Epoch\n + network_path: QuicNetworkPath\n + \n===========changed ref 8===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + def can_send(self, size: int) -> bool:\n + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received\n + \n===========changed ref 9===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + addr: NetworkAddress\n - addr: Any\n + bytes_received: int = 0\n - bytes_received = 0\n + bytes_sent: int = 0\n - bytes_sent = 0\n + challenge: Optional[bytes] = None\n + is_validated: bool = False\n - is_validated = False\n \n===========changed ref 10===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def connect(self, addr: NetworkAddress) -> None:\n - def connect(self, addr: Any) -> None:\n \"\"\"\n Initiate the TLS handshake and wait for it to complete.\n \"\"\"\n + self._network_paths = [QuicNetworkPath(addr, is_validated=True)]\n - self._path = QuicNetworkPath(addr)\n self._version = max(self.supported_versions)\n self._connect()\n await self.__connected.wait()\n \n===========changed ref 11===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath:\n + # check existing network paths\n + for idx, network_path in enumerate(self._network_paths):\n + if network_path.addr == addr:\n + return network_path\n + \n + # new network path\n + network_path = QuicNetworkPath(addr)\n + self.__logger.info(\"Network path %s discovered\", network_path.addr)\n + return network_path\n + \n===========changed ref 12===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _send_pending(self) -> None:\n + network_path = self._network_paths[0]\n for datagram in self._pending_datagrams():\n + self.__transport.sendto(datagram, network_path.addr)\n - self.__transport.sendto(datagram, self._path.addr)\n + network_path.bytes_sent += len(datagram)\n - self._path.bytes_sent += len(datagram)\n self.__send_pending_task = None\n \n===========changed ref 13===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _send_path_challenge(self, network_path: QuicNetworkPath) -> None:\n - def _send_path_challenge(self) -> None:\n + if network_path.challenge is None:\n + network_path.challenge = os.urandom(8)\n - self.__path_challenge = os.urandom(8)\n self._pending_flow_control.append(\n + bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge\n - bytes([QuicFrameType.PATH_CHALLENGE]) + self.__path_challenge\n )\n self._send_pending()\n "}}},{"rowIdx":1860,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_max_stream_data_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<17>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n<25>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_stream_data_frame(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # client creates bidirectional stream 0\n<11> reader, writer = run(client.create_stream())\n<12> stream = writer.transport\n<13> self.assertEqual(stream.max_stream_data_remote, 1048576)\n<14> \n<15> # client receives MAX_STREAM_DATA raising limit\n<16> client._handle_max_stream_data_frame(\n<17> tls.Epoch.ONE_RTT,\n<18> QuicFrameType.MAX_STREAM_DATA,\n<19> Buffer(data=b\"\\x00\" + encode_uint_var(1048577)),\n<20> )\n<21> self.assertEqual(stream.max_stream_data_remote, 1048577)\n<22> \n<23> # client receives MAX_STREAM_DATA lowering limit\n<24> client._handle_max_stream_data_frame(\n<25> tls.Epoch.ONE_RTT,\n<26> QuicFrameType.MAX_STREAM_DATA,\n<27> Buffer(data=b\"\\x00\" + encode_uint_var(1048575)),\n<28> )\n<29> self.assertEqual(stream.max_stream_data_remote, 1048577)\n<30> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]\n \n _handle_max_data_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_max_stream_data_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.connection.QuicConnection.__init__\n self._remote_max_data = 0\n \n at: aioquic.connection.QuicConnection._handle_max_data_frame\n self._remote_max_data = max_data\n \n at: aioquic.packet\n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n encode_uint_var(v)\n \n client_receive_context(client)\n \n create_transport(client, server)\n \n at: tests.test_connection.QuicConnectionTest.test_handle_max_data_frame\n client = QuicConnection(is_client=True)\n \n \n===========unchanged ref 1===========\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n at: tests.utils\n run(coro)\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_data_blocked_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives DATA_BLOCKED: 12345\n client._handle_data_blocked_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.DATA_BLOCKED,\n Buffer(data=encode_uint_var(12345)),\n )\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_ack_frame_ecn(self):\n + client, client_transport = create_standalone_client()\n + \n - client = QuicConnection(is_client=True)\n client._handle_ack_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.ACK_ECN,\n Buffer(data=b\"\\x00\\x02\\x00\\x00\\x00\\x00\\x00\"),\n )\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_data_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n self.assertEqual(client._remote_max_data, 1048576)\n \n # client receives MAX_DATA raising limit\n client._handle_max_data_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.MAX_DATA,\n Buffer(data=encode_uint_var(1048577)),\n )\n self.assertEqual(client._remote_max_data, 1048577)\n \n===========changed ref 5===========\n # module: tests.test_connection\n def create_standalone_client():\n client = QuicConnection(is_client=True)\n client_transport = FakeTransport(CLIENT_ADDR)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client, client_transport\n \n===========changed ref 6===========\n # module: aioquic.connection\n + NetworkAddress = Any\n \n \n===========changed ref 7===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n - def __init__(self, addr: Any) -> None:\n - self.addr = addr\n - \n===========changed ref 8===========\n # module: aioquic.connection\n + @dataclass\n + class QuicReceiveContext:\n + epoch: tls.Epoch\n + network_path: QuicNetworkPath\n + \n===========changed ref 9===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + def can_send(self, size: int) -> bool:\n + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received\n + \n===========changed ref 10===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + addr: NetworkAddress\n - addr: Any\n + bytes_received: int = 0\n - bytes_received = 0\n + bytes_sent: int = 0\n - bytes_sent = 0\n + challenge: Optional[bytes] = None\n + is_validated: bool = False\n - is_validated = False\n \n===========changed ref 11===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def connect(self, addr: NetworkAddress) -> None:\n - def connect(self, addr: Any) -> None:\n \"\"\"\n Initiate the TLS handshake and wait for it to complete.\n \"\"\"\n + self._network_paths = [QuicNetworkPath(addr, is_validated=True)]\n - self._path = QuicNetworkPath(addr)\n self._version = max(self.supported_versions)\n self._connect()\n await self.__connected.wait()\n "}}},{"rowIdx":1861,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_max_stream_data_frame_receive_only"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<16>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_stream_data_frame_receive_only(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # server creates unidirectional stream 3\n<11> run(server.create_stream(is_unidirectional=True))\n<12> \n<13> # client receives MAX_STREAM_DATA: 3, 1\n<14> with self.assertRaises(QuicConnectionError) as cm:\n<15> client._handle_max_stream_data_frame(\n<16> tls.Epoch.ONE_RTT,\n<17> QuicFrameType.MAX_STREAM_DATA,\n<18> Buffer(data=b\"\\x03\\x01\"),\n<19> )\n<20> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n<21> self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA)\n<22> self.assertEqual(cm.exception.reason_phrase, \"Stream is receive-only\")\n<23> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n _handle_max_stream_data_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.packet\n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n encode_uint_var(v)\n \n client_receive_context(client)\n \n create_transport(client, server)\n \n at: tests.test_connection.QuicConnectionTest.test_handle_max_stream_data_frame\n client = QuicConnection(is_client=True)\n \n stream = writer.transport\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_data_blocked_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives DATA_BLOCKED: 12345\n client._handle_data_blocked_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.DATA_BLOCKED,\n Buffer(data=encode_uint_var(12345)),\n )\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_ack_frame_ecn(self):\n + client, client_transport = create_standalone_client()\n + \n - client = QuicConnection(is_client=True)\n client._handle_ack_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.ACK_ECN,\n Buffer(data=b\"\\x00\\x02\\x00\\x00\\x00\\x00\\x00\"),\n )\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_data_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n self.assertEqual(client._remote_max_data, 1048576)\n \n # client receives MAX_DATA raising limit\n client._handle_max_data_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.MAX_DATA,\n Buffer(data=encode_uint_var(1048577)),\n )\n self.assertEqual(client._remote_max_data, 1048577)\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_stream_data_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates bidirectional stream 0\n reader, writer = run(client.create_stream())\n stream = writer.transport\n self.assertEqual(stream.max_stream_data_remote, 1048576)\n \n # client receives MAX_STREAM_DATA raising limit\n client._handle_max_stream_data_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.MAX_STREAM_DATA,\n Buffer(data=b\"\\x00\" + encode_uint_var(1048577)),\n )\n self.assertEqual(stream.max_stream_data_remote, 1048577)\n \n # client receives MAX_STREAM_DATA lowering limit\n client._handle_max_stream_data_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.MAX_STREAM_DATA,\n Buffer(data=b\"\\x00\" + encode_uint_var(1048575)),\n )\n self.assertEqual(stream.max_stream_data_remote, 1048577)\n \n===========changed ref 6===========\n # module: tests.test_connection\n def create_standalone_client():\n client = QuicConnection(is_client=True)\n client_transport = FakeTransport(CLIENT_ADDR)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client, client_transport\n \n===========changed ref 7===========\n # module: aioquic.connection\n + NetworkAddress = Any\n \n \n===========changed ref 8===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n - def __init__(self, addr: Any) -> None:\n - self.addr = addr\n - \n===========changed ref 9===========\n # module: aioquic.connection\n + @dataclass\n + class QuicReceiveContext:\n + epoch: tls.Epoch\n + network_path: QuicNetworkPath\n + \n===========changed ref 10===========\n # module: aioquic.connection\n + @dataclass\n class QuicNetworkPath:\n + def can_send(self, size: int) -> bool:\n + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received\n + "}}},{"rowIdx":1862,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_max_streams_bidi_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<13>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n<21>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_streams_bidi_frame(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> self.assertEqual(client._remote_max_streams_bidi, 128)\n<10> \n<11> # client receives MAX_STREAMS_BIDI raising limit\n<12> client._handle_max_streams_bidi_frame(\n<13> tls.Epoch.ONE_RTT,\n<14> QuicFrameType.MAX_STREAMS_BIDI,\n<15> Buffer(data=encode_uint_var(129)),\n<16> )\n<17> self.assertEqual(client._remote_max_streams_bidi, 129)\n<18> \n<19> # client receives MAX_STREAMS_BIDI lowering limit\n<20> client._handle_max_streams_bidi_frame(\n<21> tls.Epoch.ONE_RTT,\n<22> QuicFrameType.MAX_STREAMS_BIDI,\n<23> Buffer(data=encode_uint_var(127)),\n<24> )\n<25> self.assertEqual(client._remote_max_streams_bidi, 129)\n<26> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)\n \n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n _handle_max_stream_data_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_max_streams_bidi_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.connection.QuicConnection.__init__\n self._remote_max_streams_bidi = 0\n \n at: aioquic.connection.QuicConnection._handle_max_streams_bidi_frame\n self._remote_max_streams_bidi = max_streams\n \n at: aioquic.packet\n QuicErrorCode(x: Union[str, bytes, bytearray], base: int)\n QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n client_receive_context(client)\n \n create_transport(client, server)\n \n \n===========unchanged ref 1===========\n at: tests.test_connection.QuicConnectionTest.test_handle_max_stream_data_frame_receive_only\n client = QuicConnection(is_client=True)\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]\n assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None\n \n at: unittest.case._AssertRaisesContext.__exit__\n self.exception = exc_value.with_traceback(None)\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_data_blocked_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives DATA_BLOCKED: 12345\n client._handle_data_blocked_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.DATA_BLOCKED,\n Buffer(data=encode_uint_var(12345)),\n )\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_ack_frame_ecn(self):\n + client, client_transport = create_standalone_client()\n + \n - client = QuicConnection(is_client=True)\n client._handle_ack_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.ACK_ECN,\n Buffer(data=b\"\\x00\\x02\\x00\\x00\\x00\\x00\\x00\"),\n )\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_data_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n self.assertEqual(client._remote_max_data, 1048576)\n \n # client receives MAX_DATA raising limit\n client._handle_max_data_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.MAX_DATA,\n Buffer(data=encode_uint_var(1048577)),\n )\n self.assertEqual(client._remote_max_data, 1048577)\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_stream_data_frame_receive_only(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # server creates unidirectional stream 3\n run(server.create_stream(is_unidirectional=True))\n \n # client receives MAX_STREAM_DATA: 3, 1\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_max_stream_data_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.MAX_STREAM_DATA,\n Buffer(data=b\"\\x03\\x01\"),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA)\n self.assertEqual(cm.exception.reason_phrase, \"Stream is receive-only\")\n "}}},{"rowIdx":1863,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_max_streams_uni_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<13>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n<21>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_streams_uni_frame(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> self.assertEqual(client._remote_max_streams_uni, 128)\n<10> \n<11> # client receives MAX_STREAMS_UNI raising limit\n<12> client._handle_max_streams_uni_frame(\n<13> tls.Epoch.ONE_RTT,\n<14> QuicFrameType.MAX_STREAMS_UNI,\n<15> Buffer(data=encode_uint_var(129)),\n<16> )\n<17> self.assertEqual(client._remote_max_streams_uni, 129)\n<18> \n<19> # client receives MAX_STREAMS_UNI raising limit\n<20> client._handle_max_streams_uni_frame(\n<21> tls.Epoch.ONE_RTT,\n<22> QuicFrameType.MAX_STREAMS_UNI,\n<23> Buffer(data=encode_uint_var(127)),\n<24> )\n<25> self.assertEqual(client._remote_max_streams_uni, 129)\n<26> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n _handle_max_streams_bidi_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_max_streams_uni_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.connection.QuicConnection.__init__\n self._remote_max_streams_bidi = 0\n \n self._remote_max_streams_uni = 0\n \n at: aioquic.connection.QuicConnection._handle_max_streams_bidi_frame\n self._remote_max_streams_bidi = max_streams\n \n at: aioquic.connection.QuicConnection._handle_max_streams_uni_frame\n self._remote_max_streams_uni = max_streams\n \n at: aioquic.packet\n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n encode_uint_var(v)\n \n client_receive_context(client)\n \n create_transport(client, server)\n \n \n===========unchanged ref 1===========\n at: tests.test_connection.QuicConnectionTest.test_handle_max_streams_bidi_frame\n client = QuicConnection(is_client=True)\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_data_blocked_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives DATA_BLOCKED: 12345\n client._handle_data_blocked_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.DATA_BLOCKED,\n Buffer(data=encode_uint_var(12345)),\n )\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_ack_frame_ecn(self):\n + client, client_transport = create_standalone_client()\n + \n - client = QuicConnection(is_client=True)\n client._handle_ack_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.ACK_ECN,\n Buffer(data=b\"\\x00\\x02\\x00\\x00\\x00\\x00\\x00\"),\n )\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_data_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n self.assertEqual(client._remote_max_data, 1048576)\n \n # client receives MAX_DATA raising limit\n client._handle_max_data_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.MAX_DATA,\n Buffer(data=encode_uint_var(1048577)),\n )\n self.assertEqual(client._remote_max_data, 1048577)\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_stream_data_frame_receive_only(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # server creates unidirectional stream 3\n run(server.create_stream(is_unidirectional=True))\n \n # client receives MAX_STREAM_DATA: 3, 1\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_max_stream_data_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.MAX_STREAM_DATA,\n Buffer(data=b\"\\x03\\x01\"),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA)\n self.assertEqual(cm.exception.reason_phrase, \"Stream is receive-only\")\n "}}},{"rowIdx":1864,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_new_connection_id_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<12>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_new_connection_id_frame(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # client receives NEW_CONNECTION_ID\n<11> client._handle_new_connection_id_frame(\n<12> tls.Epoch.ONE_RTT,\n<13> QuicFrameType.NEW_CONNECTION_ID,\n<14> Buffer(\n<15> data=binascii.unhexlify(\n<16> \"02117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8\"\n<17> )\n<18> ),\n<19> )\n<20> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n _handle_max_streams_uni_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.connection.QuicConnection.__init__\n self._remote_max_streams_uni = 0\n \n at: aioquic.connection.QuicConnection._handle_max_streams_uni_frame\n self._remote_max_streams_uni = max_streams\n \n at: aioquic.packet\n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n encode_uint_var(v)\n \n client_receive_context(client)\n \n at: tests.test_connection.QuicConnectionTest.test_handle_max_streams_uni_frame\n client = QuicConnection(is_client=True)\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_data_blocked_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives DATA_BLOCKED: 12345\n client._handle_data_blocked_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.DATA_BLOCKED,\n Buffer(data=encode_uint_var(12345)),\n )\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_ack_frame_ecn(self):\n + client, client_transport = create_standalone_client()\n + \n - client = QuicConnection(is_client=True)\n client._handle_ack_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.ACK_ECN,\n Buffer(data=b\"\\x00\\x02\\x00\\x00\\x00\\x00\\x00\"),\n )\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_data_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n self.assertEqual(client._remote_max_data, 1048576)\n \n # client receives MAX_DATA raising limit\n client._handle_max_data_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.MAX_DATA,\n Buffer(data=encode_uint_var(1048577)),\n )\n self.assertEqual(client._remote_max_data, 1048577)\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_streams_uni_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n self.assertEqual(client._remote_max_streams_uni, 128)\n \n # client receives MAX_STREAMS_UNI raising limit\n client._handle_max_streams_uni_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.MAX_STREAMS_UNI,\n Buffer(data=encode_uint_var(129)),\n )\n self.assertEqual(client._remote_max_streams_uni, 129)\n \n # client receives MAX_STREAMS_UNI raising limit\n client._handle_max_streams_uni_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.MAX_STREAMS_UNI,\n Buffer(data=encode_uint_var(127)),\n )\n self.assertEqual(client._remote_max_streams_uni, 129)\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_stream_data_frame_receive_only(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # server creates unidirectional stream 3\n run(server.create_stream(is_unidirectional=True))\n \n # client receives MAX_STREAM_DATA: 3, 1\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_max_stream_data_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.MAX_STREAM_DATA,\n Buffer(data=b\"\\x03\\x01\"),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA)\n self.assertEqual(cm.exception.reason_phrase, \"Stream is receive-only\")\n "}}},{"rowIdx":1865,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_new_token_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<12>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_new_token_frame(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # client receives NEW_TOKEN\n<11> client._handle_new_token_frame(\n<12> tls.Epoch.ONE_RTT,\n<13> QuicFrameType.NEW_TOKEN,\n<14> Buffer(data=binascii.unhexlify(\"080102030405060708\")),\n<15> )\n<16> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n _handle_new_connection_id_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.packet\n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n at: binascii\n unhexlify(hexstr: _Ascii, /) -> bytes\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n client_receive_context(client)\n \n at: tests.test_connection.QuicConnectionTest.test_handle_new_connection_id_frame\n client = QuicConnection(is_client=True)\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_new_connection_id_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives NEW_CONNECTION_ID\n client._handle_new_connection_id_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.NEW_CONNECTION_ID,\n Buffer(\n data=binascii.unhexlify(\n \"02117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8\"\n )\n ),\n )\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_data_blocked_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives DATA_BLOCKED: 12345\n client._handle_data_blocked_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.DATA_BLOCKED,\n Buffer(data=encode_uint_var(12345)),\n )\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_ack_frame_ecn(self):\n + client, client_transport = create_standalone_client()\n + \n - client = QuicConnection(is_client=True)\n client._handle_ack_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.ACK_ECN,\n Buffer(data=b\"\\x00\\x02\\x00\\x00\\x00\\x00\\x00\"),\n )\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_data_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n self.assertEqual(client._remote_max_data, 1048576)\n \n # client receives MAX_DATA raising limit\n client._handle_max_data_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.MAX_DATA,\n Buffer(data=encode_uint_var(1048577)),\n )\n self.assertEqual(client._remote_max_data, 1048577)\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_streams_uni_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n self.assertEqual(client._remote_max_streams_uni, 128)\n \n # client receives MAX_STREAMS_UNI raising limit\n client._handle_max_streams_uni_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.MAX_STREAMS_UNI,\n Buffer(data=encode_uint_var(129)),\n )\n self.assertEqual(client._remote_max_streams_uni, 129)\n \n # client receives MAX_STREAMS_UNI raising limit\n client._handle_max_streams_uni_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.MAX_STREAMS_UNI,\n Buffer(data=encode_uint_var(127)),\n )\n self.assertEqual(client._remote_max_streams_uni, 129)\n \n===========changed ref 6===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_stream_data_frame_receive_only(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # server creates unidirectional stream 3\n run(server.create_stream(is_unidirectional=True))\n \n # client receives MAX_STREAM_DATA: 3, 1\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_max_stream_data_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.MAX_STREAM_DATA,\n Buffer(data=b\"\\x03\\x01\"),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA)\n self.assertEqual(cm.exception.reason_phrase, \"Stream is receive-only\")\n "}}},{"rowIdx":1866,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_path_challenge_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<11>: network_path = server._network_paths[0]\n network_path.is_validated = False\n server._send_path_challenge(network_path)\n server._send_path_challenge()\n<12>: run(asyncio.sleep(0))\n self.assertTrue(network_path.is_validated)\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_path_challenge_frame(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # server sends PATH_CHALLENGE\n<11> server._send_path_challenge()\n<12> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection.QuicConnection\n _handle_new_token_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.packet\n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n at: binascii\n unhexlify(hexstr: _Ascii, /) -> bytes\n \n at: tests.test_connection\n client_receive_context(client)\n \n create_transport(client, server)\n \n at: tests.test_connection.QuicConnectionTest.test_handle_new_token_frame\n client = QuicConnection(is_client=True)\n \n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_new_token_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives NEW_TOKEN\n client._handle_new_token_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.NEW_TOKEN,\n Buffer(data=binascii.unhexlify(\"080102030405060708\")),\n )\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_new_connection_id_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives NEW_CONNECTION_ID\n client._handle_new_connection_id_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.NEW_CONNECTION_ID,\n Buffer(\n data=binascii.unhexlify(\n \"02117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8\"\n )\n ),\n )\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_data_blocked_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives DATA_BLOCKED: 12345\n client._handle_data_blocked_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.DATA_BLOCKED,\n Buffer(data=encode_uint_var(12345)),\n )\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_ack_frame_ecn(self):\n + client, client_transport = create_standalone_client()\n + \n - client = QuicConnection(is_client=True)\n client._handle_ack_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.ACK_ECN,\n Buffer(data=b\"\\x00\\x02\\x00\\x00\\x00\\x00\\x00\"),\n )\n \n===========changed ref 6===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_data_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n self.assertEqual(client._remote_max_data, 1048576)\n \n # client receives MAX_DATA raising limit\n client._handle_max_data_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.MAX_DATA,\n Buffer(data=encode_uint_var(1048577)),\n )\n self.assertEqual(client._remote_max_data, 1048577)\n \n===========changed ref 7===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_max_streams_uni_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n self.assertEqual(client._remote_max_streams_uni, 128)\n \n # client receives MAX_STREAMS_UNI raising limit\n client._handle_max_streams_uni_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.MAX_STREAMS_UNI,\n Buffer(data=encode_uint_var(129)),\n )\n self.assertEqual(client._remote_max_streams_uni, 129)\n \n # client receives MAX_STREAMS_UNI raising limit\n client._handle_max_streams_uni_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.MAX_STREAMS_UNI,\n Buffer(data=encode_uint_var(127)),\n )\n self.assertEqual(client._remote_max_streams_uni, 129)\n "}}},{"rowIdx":1867,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_path_response_frame_bad"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<13>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_path_response_frame_bad(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # server receives unsollicited PATH_RESPONSE\n<11> with self.assertRaises(QuicConnectionError) as cm:\n<12> server._handle_path_response_frame(\n<13> tls.Epoch.ONE_RTT,\n<14> QuicFrameType.PATH_RESPONSE,\n<15> Buffer(data=b\"\\x11\\x22\\x33\\x44\\x55\\x66\\x77\\x88\"),\n<16> )\n<17> self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)\n<18> self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)\n<19> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.connection\n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n _send_path_challenge(network_path: QuicNetworkPath) -> None\n \n at: aioquic.connection.QuicConnection.__init__\n self._network_paths: List[QuicNetworkPath] = []\n \n at: aioquic.connection.QuicConnection.connect\n self._network_paths = [QuicNetworkPath(addr, is_validated=True)]\n \n at: aioquic.connection.QuicConnection.datagram_received\n self._network_paths = [network_path]\n \n at: aioquic.connection.QuicNetworkPath\n is_validated: bool = False\n \n at: asyncio.tasks\n sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n create_transport(client, server)\n \n at: tests.test_connection.QuicConnectionTest.test_handle_path_challenge_frame\n client = QuicConnection(is_client=True)\n \n at: tests.utils\n run(coro)\n \n at: unittest.case.TestCase\n assertTrue(expr: Any, msg: Any=...) -> None\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 1===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _send_path_challenge(self, network_path: QuicNetworkPath) -> None:\n - def _send_path_challenge(self) -> None:\n + if network_path.challenge is None:\n + network_path.challenge = os.urandom(8)\n - self.__path_challenge = os.urandom(8)\n self._pending_flow_control.append(\n + bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge\n - bytes([QuicFrameType.PATH_CHALLENGE]) + self.__path_challenge\n )\n self._send_pending()\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_path_challenge_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # server sends PATH_CHALLENGE\n + network_path = server._network_paths[0]\n + network_path.is_validated = False\n + server._send_path_challenge(network_path)\n - server._send_path_challenge()\n + run(asyncio.sleep(0))\n + self.assertTrue(network_path.is_validated)\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_new_token_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives NEW_TOKEN\n client._handle_new_token_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.NEW_TOKEN,\n Buffer(data=binascii.unhexlify(\"080102030405060708\")),\n )\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_new_connection_id_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives NEW_CONNECTION_ID\n client._handle_new_connection_id_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.NEW_CONNECTION_ID,\n Buffer(\n data=binascii.unhexlify(\n \"02117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8\"\n )\n ),\n )\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_data_blocked_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives DATA_BLOCKED: 12345\n client._handle_data_blocked_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.DATA_BLOCKED,\n Buffer(data=encode_uint_var(12345)),\n )\n \n===========changed ref 6===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_ack_frame_ecn(self):\n + client, client_transport = create_standalone_client()\n + \n - client = QuicConnection(is_client=True)\n client._handle_ack_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.ACK_ECN,\n Buffer(data=b\"\\x00\\x02\\x00\\x00\\x00\\x00\\x00\"),\n )\n "}}},{"rowIdx":1868,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_reset_stream_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<15>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_reset_stream_frame(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # client creates bidirectional stream 0\n<11> run(client.create_stream())\n<12> \n<13> # client receives RESET_STREAM\n<14> client._handle_reset_stream_frame(\n<15> tls.Epoch.ONE_RTT,\n<16> QuicFrameType.RESET_STREAM,\n<17> Buffer(data=binascii.unhexlify(\"001122000001\")),\n<18> )\n<19> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)\n \n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n _handle_path_response_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.packet\n QuicErrorCode(x: Union[str, bytes, bytearray], base: int)\n QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n at: tests.test_connection\n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n client_receive_context(client)\n \n create_transport(client, server)\n \n at: tests.test_connection.QuicConnectionTest.test_handle_path_response_frame_bad\n client = QuicConnection(is_client=True)\n \n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n \n===========unchanged ref 1===========\n assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]\n assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 2===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_path_response_frame(\n + self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n - self, epoch: tls.Epoch, frame_type: int, buf: Buffer\n ) -> None:\n \"\"\"\n Handle a PATH_RESPONSE frame.\n \"\"\"\n data = pull_bytes(buf, 8)\n + if data != context.network_path.challenge:\n - if data != self.__path_challenge:\n raise QuicConnectionError(\n error_code=QuicErrorCode.PROTOCOL_VIOLATION,\n frame_type=frame_type,\n reason_phrase=\"Response does not match challenge\",\n )\n + self.__logger.info(\"Network path %s validated\", context.network_path.addr)\n + context.network_path.is_validated = True\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_path_challenge_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # server sends PATH_CHALLENGE\n + network_path = server._network_paths[0]\n + network_path.is_validated = False\n + server._send_path_challenge(network_path)\n - server._send_path_challenge()\n + run(asyncio.sleep(0))\n + self.assertTrue(network_path.is_validated)\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_new_token_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives NEW_TOKEN\n client._handle_new_token_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.NEW_TOKEN,\n Buffer(data=binascii.unhexlify(\"080102030405060708\")),\n )\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_path_response_frame_bad(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # server receives unsollicited PATH_RESPONSE\n with self.assertRaises(QuicConnectionError) as cm:\n server._handle_path_response_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.PATH_RESPONSE,\n Buffer(data=b\"\\x11\\x22\\x33\\x44\\x55\\x66\\x77\\x88\"),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)\n \n===========changed ref 6===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_new_connection_id_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives NEW_CONNECTION_ID\n client._handle_new_connection_id_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.NEW_CONNECTION_ID,\n Buffer(\n data=binascii.unhexlify(\n \"02117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8\"\n )\n ),\n )\n "}}},{"rowIdx":1869,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_reset_stream_frame_send_only"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<16>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_reset_stream_frame_send_only(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # client creates unidirectional stream 2\n<11> run(client.create_stream(is_unidirectional=True))\n<12> \n<13> # client receives RESET_STREAM\n<14> with self.assertRaises(QuicConnectionError) as cm:\n<15> client._handle_reset_stream_frame(\n<16> tls.Epoch.ONE_RTT,\n<17> QuicFrameType.RESET_STREAM,\n<18> Buffer(data=binascii.unhexlify(\"021122000001\")),\n<19> )\n<20> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n<21> self.assertEqual(cm.exception.frame_type, QuicFrameType.RESET_STREAM)\n<22> self.assertEqual(cm.exception.reason_phrase, \"Stream is send-only\")\n<23> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]\n \n _handle_reset_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.packet\n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n at: binascii\n unhexlify(hexstr: _Ascii, /) -> bytes\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n client_receive_context(client)\n \n create_transport(client, server)\n \n at: tests.test_connection.QuicConnectionTest.test_handle_reset_stream_frame\n client = QuicConnection(is_client=True)\n \n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n at: tests.utils\n run(coro)\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_reset_stream_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates bidirectional stream 0\n run(client.create_stream())\n \n # client receives RESET_STREAM\n client._handle_reset_stream_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.RESET_STREAM,\n Buffer(data=binascii.unhexlify(\"001122000001\")),\n )\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_path_challenge_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # server sends PATH_CHALLENGE\n + network_path = server._network_paths[0]\n + network_path.is_validated = False\n + server._send_path_challenge(network_path)\n - server._send_path_challenge()\n + run(asyncio.sleep(0))\n + self.assertTrue(network_path.is_validated)\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_new_token_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives NEW_TOKEN\n client._handle_new_token_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.NEW_TOKEN,\n Buffer(data=binascii.unhexlify(\"080102030405060708\")),\n )\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_path_response_frame_bad(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # server receives unsollicited PATH_RESPONSE\n with self.assertRaises(QuicConnectionError) as cm:\n server._handle_path_response_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.PATH_RESPONSE,\n Buffer(data=b\"\\x11\\x22\\x33\\x44\\x55\\x66\\x77\\x88\"),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)\n \n===========changed ref 6===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_new_connection_id_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives NEW_CONNECTION_ID\n client._handle_new_connection_id_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.NEW_CONNECTION_ID,\n Buffer(\n data=binascii.unhexlify(\n \"02117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8\"\n )\n ),\n )\n "}}},{"rowIdx":1870,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_retire_connection_id_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<12>: client_receive_context(client),\n QuicFrameType.RETIRE_CONNECTION_ID,\n Buffer(data=b\"\\x02\"),\n tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b\"\\x02\")\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_retire_connection_id_frame(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # client receives RETIRE_CONNECTION_ID\n<11> client._handle_retire_connection_id_frame(\n<12> tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b\"\\x02\")\n<13> )\n<14> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)\n \n at: aioquic.connection.QuicConnection\n create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]\n \n _handle_reset_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.packet\n QuicErrorCode(x: Union[str, bytes, bytearray], base: int)\n QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n at: binascii\n unhexlify(hexstr: _Ascii, /) -> bytes\n \n at: tests.test_connection\n client_receive_context(client)\n \n create_transport(client, server)\n \n at: tests.test_connection.QuicConnectionTest.test_handle_reset_stream_frame_send_only\n client = QuicConnection(is_client=True)\n \n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n at: tests.utils\n run(coro)\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]\n assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_reset_stream_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates bidirectional stream 0\n run(client.create_stream())\n \n # client receives RESET_STREAM\n client._handle_reset_stream_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.RESET_STREAM,\n Buffer(data=binascii.unhexlify(\"001122000001\")),\n )\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_path_challenge_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # server sends PATH_CHALLENGE\n + network_path = server._network_paths[0]\n + network_path.is_validated = False\n + server._send_path_challenge(network_path)\n - server._send_path_challenge()\n + run(asyncio.sleep(0))\n + self.assertTrue(network_path.is_validated)\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_new_token_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives NEW_TOKEN\n client._handle_new_token_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.NEW_TOKEN,\n Buffer(data=binascii.unhexlify(\"080102030405060708\")),\n )\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_reset_stream_frame_send_only(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates unidirectional stream 2\n run(client.create_stream(is_unidirectional=True))\n \n # client receives RESET_STREAM\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_reset_stream_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.RESET_STREAM,\n Buffer(data=binascii.unhexlify(\"021122000001\")),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.RESET_STREAM)\n self.assertEqual(cm.exception.reason_phrase, \"Stream is send-only\")\n \n===========changed ref 6===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_path_response_frame_bad(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # server receives unsollicited PATH_RESPONSE\n with self.assertRaises(QuicConnectionError) as cm:\n server._handle_path_response_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.PATH_RESPONSE,\n Buffer(data=b\"\\x11\\x22\\x33\\x44\\x55\\x66\\x77\\x88\"),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)\n "}}},{"rowIdx":1871,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_stop_sending_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<15>: client_receive_context(client),\n QuicFrameType.STOP_SENDING,\n Buffer(data=b\"\\x00\\x11\\x22\"),\n tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b\"\\x00\\x11\\x22\")\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stop_sending_frame(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # client creates bidirectional stream 0\n<11> run(client.create_stream())\n<12> \n<13> # client receives STOP_SENDING\n<14> client._handle_stop_sending_frame(\n<15> tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b\"\\x00\\x11\\x22\")\n<16> )\n<17> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n _handle_retire_connection_id_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.packet\n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n client_receive_context(client)\n \n create_transport(client, server)\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_retire_connection_id_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives RETIRE_CONNECTION_ID\n client._handle_retire_connection_id_frame(\n + client_receive_context(client),\n + QuicFrameType.RETIRE_CONNECTION_ID,\n + Buffer(data=b\"\\x02\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b\"\\x02\")\n )\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_reset_stream_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates bidirectional stream 0\n run(client.create_stream())\n \n # client receives RESET_STREAM\n client._handle_reset_stream_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.RESET_STREAM,\n Buffer(data=binascii.unhexlify(\"001122000001\")),\n )\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_path_challenge_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # server sends PATH_CHALLENGE\n + network_path = server._network_paths[0]\n + network_path.is_validated = False\n + server._send_path_challenge(network_path)\n - server._send_path_challenge()\n + run(asyncio.sleep(0))\n + self.assertTrue(network_path.is_validated)\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_new_token_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives NEW_TOKEN\n client._handle_new_token_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.NEW_TOKEN,\n Buffer(data=binascii.unhexlify(\"080102030405060708\")),\n )\n \n===========changed ref 6===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_reset_stream_frame_send_only(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates unidirectional stream 2\n run(client.create_stream(is_unidirectional=True))\n \n # client receives RESET_STREAM\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_reset_stream_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.RESET_STREAM,\n Buffer(data=binascii.unhexlify(\"021122000001\")),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.RESET_STREAM)\n self.assertEqual(cm.exception.reason_phrase, \"Stream is send-only\")\n \n===========changed ref 7===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_path_response_frame_bad(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # server receives unsollicited PATH_RESPONSE\n with self.assertRaises(QuicConnectionError) as cm:\n server._handle_path_response_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.PATH_RESPONSE,\n Buffer(data=b\"\\x11\\x22\\x33\\x44\\x55\\x66\\x77\\x88\"),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)\n "}}},{"rowIdx":1872,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_stop_sending_frame_receive_only"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<16>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stop_sending_frame_receive_only(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # server creates unidirectional stream 3\n<11> run(server.create_stream(is_unidirectional=True))\n<12> \n<13> # client receives STOP_SENDING\n<14> with self.assertRaises(QuicConnectionError) as cm:\n<15> client._handle_stop_sending_frame(\n<16> tls.Epoch.ONE_RTT,\n<17> QuicFrameType.STOP_SENDING,\n<18> Buffer(data=b\"\\x03\\x11\\x22\"),\n<19> )\n<20> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n<21> self.assertEqual(cm.exception.frame_type, QuicFrameType.STOP_SENDING)\n<22> self.assertEqual(cm.exception.reason_phrase, \"Stream is receive-only\")\n<23> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]\n \n _handle_stop_sending_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.packet\n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n client_receive_context(client)\n \n create_transport(client, server)\n \n at: tests.utils\n run(coro)\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_retire_connection_id_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives RETIRE_CONNECTION_ID\n client._handle_retire_connection_id_frame(\n + client_receive_context(client),\n + QuicFrameType.RETIRE_CONNECTION_ID,\n + Buffer(data=b\"\\x02\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b\"\\x02\")\n )\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stop_sending_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates bidirectional stream 0\n run(client.create_stream())\n \n # client receives STOP_SENDING\n client._handle_stop_sending_frame(\n + client_receive_context(client),\n + QuicFrameType.STOP_SENDING,\n + Buffer(data=b\"\\x00\\x11\\x22\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b\"\\x00\\x11\\x22\")\n )\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_reset_stream_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates bidirectional stream 0\n run(client.create_stream())\n \n # client receives RESET_STREAM\n client._handle_reset_stream_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.RESET_STREAM,\n Buffer(data=binascii.unhexlify(\"001122000001\")),\n )\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_path_challenge_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # server sends PATH_CHALLENGE\n + network_path = server._network_paths[0]\n + network_path.is_validated = False\n + server._send_path_challenge(network_path)\n - server._send_path_challenge()\n + run(asyncio.sleep(0))\n + self.assertTrue(network_path.is_validated)\n \n===========changed ref 6===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_new_token_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives NEW_TOKEN\n client._handle_new_token_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.NEW_TOKEN,\n Buffer(data=binascii.unhexlify(\"080102030405060708\")),\n )\n \n===========changed ref 7===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_reset_stream_frame_send_only(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates unidirectional stream 2\n run(client.create_stream(is_unidirectional=True))\n \n # client receives RESET_STREAM\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_reset_stream_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.RESET_STREAM,\n Buffer(data=binascii.unhexlify(\"021122000001\")),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.RESET_STREAM)\n self.assertEqual(cm.exception.reason_phrase, \"Stream is send-only\")\n "}}},{"rowIdx":1873,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_stream_frame_over_max_data"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<18>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_over_max_data(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # artificially raise received data counter\n<11> client._local_max_data_used = client._local_max_data\n<12> \n<13> # client receives STREAM frame\n<14> frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF\n<15> stream_id = 1\n<16> with self.assertRaises(QuicConnectionError) as cm:\n<17> client._handle_stream_frame(\n<18> tls.Epoch.ONE_RTT,\n<19> frame_type,\n<20> Buffer(data=encode_uint_var(stream_id) + encode_uint_var(1)),\n<21> )\n<22> self.assertEqual(cm.exception.error_code, QuicErrorCode.FLOW_CONTROL_ERROR)\n<23> self.assertEqual(cm.exception.frame_type, frame_type)\n<24> self.assertEqual(cm.exception.reason_phrase, \"Over connection data limit\")\n<25> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)\n \n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]\n \n _handle_stop_sending_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.packet\n QuicErrorCode(x: Union[str, bytes, bytearray], base: int)\n QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n client_receive_context(client)\n \n create_transport(client, server)\n \n at: tests.test_connection.QuicConnectionTest.test_handle_stop_sending_frame_receive_only\n client = QuicConnection(is_client=True)\n \n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n \n===========unchanged ref 1===========\n at: tests.utils\n run(coro)\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]\n assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_retire_connection_id_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives RETIRE_CONNECTION_ID\n client._handle_retire_connection_id_frame(\n + client_receive_context(client),\n + QuicFrameType.RETIRE_CONNECTION_ID,\n + Buffer(data=b\"\\x02\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b\"\\x02\")\n )\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stop_sending_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates bidirectional stream 0\n run(client.create_stream())\n \n # client receives STOP_SENDING\n client._handle_stop_sending_frame(\n + client_receive_context(client),\n + QuicFrameType.STOP_SENDING,\n + Buffer(data=b\"\\x00\\x11\\x22\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b\"\\x00\\x11\\x22\")\n )\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_reset_stream_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates bidirectional stream 0\n run(client.create_stream())\n \n # client receives RESET_STREAM\n client._handle_reset_stream_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.RESET_STREAM,\n Buffer(data=binascii.unhexlify(\"001122000001\")),\n )\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stop_sending_frame_receive_only(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # server creates unidirectional stream 3\n run(server.create_stream(is_unidirectional=True))\n \n # client receives STOP_SENDING\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stop_sending_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.STOP_SENDING,\n Buffer(data=b\"\\x03\\x11\\x22\"),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.STOP_SENDING)\n self.assertEqual(cm.exception.reason_phrase, \"Stream is receive-only\")\n "}}},{"rowIdx":1874,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_stream_frame_over_max_stream_data"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<15>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_over_max_stream_data(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # client receives STREAM frame\n<11> frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF\n<12> stream_id = 1\n<13> with self.assertRaises(QuicConnectionError) as cm:\n<14> client._handle_stream_frame(\n<15> tls.Epoch.ONE_RTT,\n<16> frame_type,\n<17> Buffer(\n<18> data=encode_uint_var(stream_id)\n<19> + encode_uint_var(client._local_max_stream_data_bidi_remote + 1)\n<20> ),\n<21> )\n<22> self.assertEqual(cm.exception.error_code, QuicErrorCode.FLOW_CONTROL_ERROR)\n<23> self.assertEqual(cm.exception.frame_type, frame_type)\n<24> self.assertEqual(cm.exception.reason_phrase, \"Over stream data limit\")\n<25> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)\n \n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n _handle_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.connection.QuicConnection.__init__\n self._local_max_data = 1048576\n \n self._local_max_data_used = 0\n \n at: aioquic.connection.QuicConnection._handle_stream_frame\n self._local_max_data_used += newly_received\n \n at: aioquic.packet\n QuicErrorCode(x: Union[str, bytes, bytearray], base: int)\n QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)\n QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n encode_uint_var(v)\n \n \n===========unchanged ref 1===========\n client_receive_context(client)\n \n create_transport(client, server)\n \n at: tests.test_connection.QuicConnectionTest.test_handle_stream_frame_over_max_data\n client = QuicConnection(is_client=True)\n \n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]\n assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_retire_connection_id_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives RETIRE_CONNECTION_ID\n client._handle_retire_connection_id_frame(\n + client_receive_context(client),\n + QuicFrameType.RETIRE_CONNECTION_ID,\n + Buffer(data=b\"\\x02\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b\"\\x02\")\n )\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stop_sending_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates bidirectional stream 0\n run(client.create_stream())\n \n # client receives STOP_SENDING\n client._handle_stop_sending_frame(\n + client_receive_context(client),\n + QuicFrameType.STOP_SENDING,\n + Buffer(data=b\"\\x00\\x11\\x22\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b\"\\x00\\x11\\x22\")\n )\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_reset_stream_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates bidirectional stream 0\n run(client.create_stream())\n \n # client receives RESET_STREAM\n client._handle_reset_stream_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.RESET_STREAM,\n Buffer(data=binascii.unhexlify(\"001122000001\")),\n )\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_over_max_data(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # artificially raise received data counter\n client._local_max_data_used = client._local_max_data\n \n # client receives STREAM frame\n frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF\n stream_id = 1\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stream_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n frame_type,\n Buffer(data=encode_uint_var(stream_id) + encode_uint_var(1)),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.FLOW_CONTROL_ERROR)\n self.assertEqual(cm.exception.frame_type, frame_type)\n self.assertEqual(cm.exception.reason_phrase, \"Over connection data limit\")\n "}}},{"rowIdx":1875,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_stream_frame_over_max_streams"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<13>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_over_max_streams(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # client receives STREAM frame\n<11> with self.assertRaises(QuicConnectionError) as cm:\n<12> client._handle_stream_frame(\n<13> tls.Epoch.ONE_RTT,\n<14> QuicFrameType.STREAM_BASE,\n<15> Buffer(data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)),\n<16> )\n<17> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR)\n<18> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)\n<19> self.assertEqual(cm.exception.reason_phrase, \"Too many streams open\")\n<20> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)\n \n at: aioquic.connection.QuicConnection\n _handle_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.connection.QuicConnection.__init__\n self._local_max_stream_data_bidi_remote = 1048576\n \n at: aioquic.packet\n QuicErrorCode(x: Union[str, bytes, bytearray], base: int)\n QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)\n QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n at: tests.test_connection\n encode_uint_var(v)\n \n client_receive_context(client)\n \n create_transport(client, server)\n \n at: tests.test_connection.QuicConnectionTest.test_handle_stream_frame_over_max_stream_data\n client = QuicConnection(is_client=True)\n \n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n \n===========unchanged ref 1===========\n assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]\n assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_retire_connection_id_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives RETIRE_CONNECTION_ID\n client._handle_retire_connection_id_frame(\n + client_receive_context(client),\n + QuicFrameType.RETIRE_CONNECTION_ID,\n + Buffer(data=b\"\\x02\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b\"\\x02\")\n )\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stop_sending_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates bidirectional stream 0\n run(client.create_stream())\n \n # client receives STOP_SENDING\n client._handle_stop_sending_frame(\n + client_receive_context(client),\n + QuicFrameType.STOP_SENDING,\n + Buffer(data=b\"\\x00\\x11\\x22\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b\"\\x00\\x11\\x22\")\n )\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_over_max_stream_data(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives STREAM frame\n frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF\n stream_id = 1\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stream_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n frame_type,\n Buffer(\n data=encode_uint_var(stream_id)\n + encode_uint_var(client._local_max_stream_data_bidi_remote + 1)\n ),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.FLOW_CONTROL_ERROR)\n self.assertEqual(cm.exception.frame_type, frame_type)\n self.assertEqual(cm.exception.reason_phrase, \"Over stream data limit\")\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_reset_stream_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates bidirectional stream 0\n run(client.create_stream())\n \n # client receives RESET_STREAM\n client._handle_reset_stream_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.RESET_STREAM,\n Buffer(data=binascii.unhexlify(\"001122000001\")),\n )\n "}}},{"rowIdx":1876,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_stream_frame_send_only"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<16>: client_receive_context(client),\n QuicFrameType.STREAM_BASE,\n Buffer(data=b\"\\x02\"),\n tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b\"\\x02\")\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_send_only(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # client creates unidirectional stream 2\n<11> run(client.create_stream(is_unidirectional=True))\n<12> \n<13> # client receives STREAM frame\n<14> with self.assertRaises(QuicConnectionError) as cm:\n<15> client._handle_stream_frame(\n<16> tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b\"\\x02\")\n<17> )\n<18> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n<19> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)\n<20> self.assertEqual(cm.exception.reason_phrase, \"Stream is send-only\")\n<21> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)\n \n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n _handle_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.connection.QuicConnection.__init__\n self._local_max_stream_data_uni = 1048576\n \n at: aioquic.packet\n QuicErrorCode(x: Union[str, bytes, bytearray], base: int)\n QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n encode_uint_var(v)\n \n client_receive_context(client)\n \n create_transport(client, server)\n \n at: tests.test_connection.QuicConnectionTest.test_handle_stream_frame_over_max_streams\n client = QuicConnection(is_client=True)\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n \n===========unchanged ref 1===========\n assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]\n assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_over_max_streams(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives STREAM frame\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stream_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.STREAM_BASE,\n Buffer(data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)\n self.assertEqual(cm.exception.reason_phrase, \"Too many streams open\")\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_retire_connection_id_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives RETIRE_CONNECTION_ID\n client._handle_retire_connection_id_frame(\n + client_receive_context(client),\n + QuicFrameType.RETIRE_CONNECTION_ID,\n + Buffer(data=b\"\\x02\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b\"\\x02\")\n )\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stop_sending_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates bidirectional stream 0\n run(client.create_stream())\n \n # client receives STOP_SENDING\n client._handle_stop_sending_frame(\n + client_receive_context(client),\n + QuicFrameType.STOP_SENDING,\n + Buffer(data=b\"\\x00\\x11\\x22\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b\"\\x00\\x11\\x22\")\n )\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_over_max_stream_data(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives STREAM frame\n frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF\n stream_id = 1\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stream_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n frame_type,\n Buffer(\n data=encode_uint_var(stream_id)\n + encode_uint_var(client._local_max_stream_data_bidi_remote + 1)\n ),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.FLOW_CONTROL_ERROR)\n self.assertEqual(cm.exception.frame_type, frame_type)\n self.assertEqual(cm.exception.reason_phrase, \"Over stream data limit\")\n "}}},{"rowIdx":1877,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_stream_frame_wrong_initiator"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<13>: client_receive_context(client),\n QuicFrameType.STREAM_BASE,\n Buffer(data=b\"\\x00\"),\n tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b\"\\x00\")\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_wrong_initiator(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # client receives STREAM frame\n<11> with self.assertRaises(QuicConnectionError) as cm:\n<12> client._handle_stream_frame(\n<13> tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b\"\\x00\")\n<14> )\n<15> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n<16> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)\n<17> self.assertEqual(cm.exception.reason_phrase, \"Wrong stream initiator\")\n<18> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)\n \n at: aioquic.connection.QuicConnection\n create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]\n \n _handle_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.packet\n QuicErrorCode(x: Union[str, bytes, bytearray], base: int)\n QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n client_receive_context(client)\n \n create_transport(client, server)\n \n at: tests.test_connection.QuicConnectionTest.test_handle_stream_frame_send_only\n client = QuicConnection(is_client=True)\n \n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n at: tests.utils\n run(coro)\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n \n===========unchanged ref 1===========\n assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]\n assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_over_max_streams(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives STREAM frame\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stream_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.STREAM_BASE,\n Buffer(data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)\n self.assertEqual(cm.exception.reason_phrase, \"Too many streams open\")\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_send_only(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates unidirectional stream 2\n run(client.create_stream(is_unidirectional=True))\n \n # client receives STREAM frame\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stream_frame(\n + client_receive_context(client),\n + QuicFrameType.STREAM_BASE,\n + Buffer(data=b\"\\x02\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b\"\\x02\")\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)\n self.assertEqual(cm.exception.reason_phrase, \"Stream is send-only\")\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_retire_connection_id_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives RETIRE_CONNECTION_ID\n client._handle_retire_connection_id_frame(\n + client_receive_context(client),\n + QuicFrameType.RETIRE_CONNECTION_ID,\n + Buffer(data=b\"\\x02\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b\"\\x02\")\n )\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stop_sending_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates bidirectional stream 0\n run(client.create_stream())\n \n # client receives STOP_SENDING\n client._handle_stop_sending_frame(\n + client_receive_context(client),\n + QuicFrameType.STOP_SENDING,\n + Buffer(data=b\"\\x00\\x11\\x22\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b\"\\x00\\x11\\x22\")\n )\n "}}},{"rowIdx":1878,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_stream_data_blocked_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<15>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_data_blocked_frame(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # client creates bidirectional stream 0\n<11> run(client.create_stream())\n<12> \n<13> # client receives STREAM_DATA_BLOCKED\n<14> client._handle_stream_data_blocked_frame(\n<15> tls.Epoch.ONE_RTT,\n<16> QuicFrameType.STREAM_DATA_BLOCKED,\n<17> Buffer(data=b\"\\x00\\x01\"),\n<18> )\n<19> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)\n \n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n _handle_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.packet\n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n client_receive_context(client)\n \n create_transport(client, server)\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]\n assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_wrong_initiator(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives STREAM frame\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stream_frame(\n + client_receive_context(client),\n + QuicFrameType.STREAM_BASE,\n + Buffer(data=b\"\\x00\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b\"\\x00\")\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)\n self.assertEqual(cm.exception.reason_phrase, \"Wrong stream initiator\")\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_over_max_streams(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives STREAM frame\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stream_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.STREAM_BASE,\n Buffer(data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)\n self.assertEqual(cm.exception.reason_phrase, \"Too many streams open\")\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_send_only(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates unidirectional stream 2\n run(client.create_stream(is_unidirectional=True))\n \n # client receives STREAM frame\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stream_frame(\n + client_receive_context(client),\n + QuicFrameType.STREAM_BASE,\n + Buffer(data=b\"\\x02\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b\"\\x02\")\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)\n self.assertEqual(cm.exception.reason_phrase, \"Stream is send-only\")\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_retire_connection_id_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives RETIRE_CONNECTION_ID\n client._handle_retire_connection_id_frame(\n + client_receive_context(client),\n + QuicFrameType.RETIRE_CONNECTION_ID,\n + Buffer(data=b\"\\x02\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b\"\\x02\")\n )\n "}}},{"rowIdx":1879,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_stream_data_blocked_frame_send_only"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<16>: client_receive_context(client),\n tls.Epoch.ONE_RTT,\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_data_blocked_frame_send_only(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # client creates unidirectional stream 2\n<11> run(client.create_stream(is_unidirectional=True))\n<12> \n<13> # client receives STREAM_DATA_BLOCKED\n<14> with self.assertRaises(QuicConnectionError) as cm:\n<15> client._handle_stream_data_blocked_frame(\n<16> tls.Epoch.ONE_RTT,\n<17> QuicFrameType.STREAM_DATA_BLOCKED,\n<18> Buffer(data=b\"\\x02\\x01\"),\n<19> )\n<20> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n<21> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_DATA_BLOCKED)\n<22> self.assertEqual(cm.exception.reason_phrase, \"Stream is send-only\")\n<23> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]\n \n _handle_stream_data_blocked_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.packet\n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n client_receive_context(client)\n \n create_transport(client, server)\n \n at: tests.utils\n run(coro)\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_data_blocked_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates bidirectional stream 0\n run(client.create_stream())\n \n # client receives STREAM_DATA_BLOCKED\n client._handle_stream_data_blocked_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.STREAM_DATA_BLOCKED,\n Buffer(data=b\"\\x00\\x01\"),\n )\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_wrong_initiator(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives STREAM frame\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stream_frame(\n + client_receive_context(client),\n + QuicFrameType.STREAM_BASE,\n + Buffer(data=b\"\\x00\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b\"\\x00\")\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)\n self.assertEqual(cm.exception.reason_phrase, \"Wrong stream initiator\")\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_over_max_streams(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives STREAM frame\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stream_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.STREAM_BASE,\n Buffer(data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)\n self.assertEqual(cm.exception.reason_phrase, \"Too many streams open\")\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_send_only(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates unidirectional stream 2\n run(client.create_stream(is_unidirectional=True))\n \n # client receives STREAM frame\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stream_frame(\n + client_receive_context(client),\n + QuicFrameType.STREAM_BASE,\n + Buffer(data=b\"\\x02\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b\"\\x02\")\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)\n self.assertEqual(cm.exception.reason_phrase, \"Stream is send-only\")\n \n===========changed ref 6===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_retire_connection_id_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives RETIRE_CONNECTION_ID\n client._handle_retire_connection_id_frame(\n + client_receive_context(client),\n + QuicFrameType.RETIRE_CONNECTION_ID,\n + Buffer(data=b\"\\x02\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b\"\\x02\")\n )\n "}}},{"rowIdx":1880,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_streams_blocked_uni_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<12>: client_receive_context(client),\n QuicFrameType.STREAMS_BLOCKED_UNI,\n Buffer(data=b\"\\x00\"),\n tls.Epoch.ONE_RTT, QuicFrameType.STREAMS_BLOCKED_UNI, Buffer(data=b\"\\x00\")\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_streams_blocked_uni_frame(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # client receives STREAMS_BLOCKED_UNI: 0\n<11> client._handle_streams_blocked_frame(\n<12> tls.Epoch.ONE_RTT, QuicFrameType.STREAMS_BLOCKED_UNI, Buffer(data=b\"\\x00\")\n<13> )\n<14> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.connection\n QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)\n \n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n create_transport(client, server)\n \n at: tests.utils\n run(coro)\n \n at: unittest.case.TestCase\n assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]\n assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 1===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_data_blocked_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates bidirectional stream 0\n run(client.create_stream())\n \n # client receives STREAM_DATA_BLOCKED\n client._handle_stream_data_blocked_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.STREAM_DATA_BLOCKED,\n Buffer(data=b\"\\x00\\x01\"),\n )\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_data_blocked_frame_send_only(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates unidirectional stream 2\n run(client.create_stream(is_unidirectional=True))\n \n # client receives STREAM_DATA_BLOCKED\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stream_data_blocked_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.STREAM_DATA_BLOCKED,\n Buffer(data=b\"\\x02\\x01\"),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_DATA_BLOCKED)\n self.assertEqual(cm.exception.reason_phrase, \"Stream is send-only\")\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_wrong_initiator(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives STREAM frame\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stream_frame(\n + client_receive_context(client),\n + QuicFrameType.STREAM_BASE,\n + Buffer(data=b\"\\x00\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b\"\\x00\")\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)\n self.assertEqual(cm.exception.reason_phrase, \"Wrong stream initiator\")\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_over_max_streams(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives STREAM frame\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stream_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.STREAM_BASE,\n Buffer(data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)\n self.assertEqual(cm.exception.reason_phrase, \"Too many streams open\")\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_send_only(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates unidirectional stream 2\n run(client.create_stream(is_unidirectional=True))\n \n # client receives STREAM frame\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stream_frame(\n + client_receive_context(client),\n + QuicFrameType.STREAM_BASE,\n + Buffer(data=b\"\\x02\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b\"\\x02\")\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)\n self.assertEqual(cm.exception.reason_phrase, \"Stream is send-only\")\n "}}},{"rowIdx":1881,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_unknown_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"132d4d5ecfca530c38a7ab8c42212b6a375c02e1"},"commit_message":{"kind":"string","value":"[connection] pass network path to frame handlers"},"ground_truth":{"kind":"string","value":"<13>: client._payload_received(client_receive_context(client), b\"\\x1e\")\n client._payload_received(tls.Epoch.ONE_RTT, b\"\\x1e\")\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_unknown_frame(self):\n <0> client = QuicConnection(is_client=True)\n <1> \n <2> server = QuicConnection(\n <3> is_client=False,\n <4> certificate=SERVER_CERTIFICATE,\n <5> private_key=SERVER_PRIVATE_KEY,\n <6> )\n <7> \n <8> # perform handshake\n <9> client_transport, server_transport = create_transport(client, server)\n<10> \n<11> # client receives unknown frame\n<12> with self.assertRaises(QuicConnectionError) as cm:\n<13> client._payload_received(tls.Epoch.ONE_RTT, b\"\\x1e\")\n<14> self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)\n<15> self.assertEqual(cm.exception.frame_type, 0x1E)\n<16> self.assertEqual(cm.exception.reason_phrase, \"Unexpected frame type\")\n<17> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.packet\n QuicErrorCode(x: Union[str, bytes, bytearray], base: int)\n QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n client_receive_context(client)\n \n create_transport(client, server)\n \n at: tests.test_connection.QuicConnectionTest.test_handle_stream_data_blocked_frame_send_only\n client = QuicConnection(is_client=True)\n \n at: unittest.case.TestCase\n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + def client_receive_context(client):\n + return QuicReceiveContext(\n + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0]\n + )\n + \n===========changed ref 1===========\n # module: tests.test_connection\n def create_transport(client, server):\n client_transport = FakeTransport(CLIENT_ADDR)\n client_transport.target = server\n \n server_transport = FakeTransport(SERVER_ADDR)\n server_transport.target = client\n \n server.connection_made(server_transport)\n client.connection_made(client_transport)\n \n # like connect() but without waiting\n + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]\n - client._path = QuicNetworkPath(SERVER_ADDR)\n client._version = max(client.supported_versions)\n client._connect()\n \n return client_transport, server_transport\n \n===========changed ref 2===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_streams_blocked_uni_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives STREAMS_BLOCKED_UNI: 0\n client._handle_streams_blocked_frame(\n + client_receive_context(client),\n + QuicFrameType.STREAMS_BLOCKED_UNI,\n + Buffer(data=b\"\\x00\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.STREAMS_BLOCKED_UNI, Buffer(data=b\"\\x00\")\n )\n \n===========changed ref 3===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_data_blocked_frame(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates bidirectional stream 0\n run(client.create_stream())\n \n # client receives STREAM_DATA_BLOCKED\n client._handle_stream_data_blocked_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.STREAM_DATA_BLOCKED,\n Buffer(data=b\"\\x00\\x01\"),\n )\n \n===========changed ref 4===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_data_blocked_frame_send_only(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client creates unidirectional stream 2\n run(client.create_stream(is_unidirectional=True))\n \n # client receives STREAM_DATA_BLOCKED\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stream_data_blocked_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.STREAM_DATA_BLOCKED,\n Buffer(data=b\"\\x02\\x01\"),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_DATA_BLOCKED)\n self.assertEqual(cm.exception.reason_phrase, \"Stream is send-only\")\n \n===========changed ref 5===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_wrong_initiator(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives STREAM frame\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stream_frame(\n + client_receive_context(client),\n + QuicFrameType.STREAM_BASE,\n + Buffer(data=b\"\\x00\"),\n - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b\"\\x00\")\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)\n self.assertEqual(cm.exception.reason_phrase, \"Wrong stream initiator\")\n \n===========changed ref 6===========\n # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_stream_frame_over_max_streams(self):\n client = QuicConnection(is_client=True)\n server = QuicConnection(\n is_client=False,\n certificate=SERVER_CERTIFICATE,\n private_key=SERVER_PRIVATE_KEY,\n )\n \n # perform handshake\n client_transport, server_transport = create_transport(client, server)\n \n # client receives STREAM frame\n with self.assertRaises(QuicConnectionError) as cm:\n client._handle_stream_frame(\n + client_receive_context(client),\n - tls.Epoch.ONE_RTT,\n QuicFrameType.STREAM_BASE,\n Buffer(data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)),\n )\n self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR)\n self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)\n self.assertEqual(cm.exception.reason_phrase, \"Too many streams open\")\n "}}},{"rowIdx":1882,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection.datagram_received"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"097499d4523f0dba51c93294393db35c66d291a1"},"commit_message":{"kind":"string","value":"[connection] make handshake validate network path"},"ground_truth":{"kind":"string","value":""},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:\n <0> \"\"\"\n <1> Handle an incoming datagram.\n <2> \"\"\"\n <3> # stop handling packets when closing\n <4> if self.__state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:\n <5> return\n <6> \n <7> data = cast(bytes, data)\n <8> buf = Buffer(data=data)\n <9> while not buf.eof():\n<10> start_off = buf.tell()\n<11> header = pull_quic_header(buf, host_cid_length=len(self.host_cid))\n<12> \n<13> # check destination CID matches\n<14> if self.is_client and header.destination_cid != self.host_cid:\n<15> return\n<16> \n<17> # check protocol version\n<18> if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:\n<19> # version negotiation\n<20> versions = []\n<21> while not buf.eof():\n<22> versions.append(pull_uint32(buf))\n<23> common = set(self.supported_versions).intersection(versions)\n<24> if not common:\n<25> self.__logger.error(\"Could not find a common protocol version\")\n<26> return\n<27> self._version = QuicProtocolVersion(max(common))\n<28> self.__logger.info(\"Retrying with %s\", self._version)\n<29> self._connect()\n<30> return\n<31> elif (\n<32> header.version is not None\n<33> and header.version not in self.supported_versions\n<34> ):\n<35> # unsupported version\n<36> return\n<37> \n<38> if self.is_client and header.packet_type == PACKET_TYPE_RETRY:\n<39> # stateless retry\n<40> if (\n<41> header.destination_cid == self.host_cid\n<42> and header.original_destination_cid == self.peer_cid\n<43> ):\n<44> self.__logger.info(\"Performing stateless retry\")\n<45> self.peer_cid"},"context":{"kind":"string","value":"===========below chunk 0===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:\n # offset: 1\n self.peer_token = header.token\n self._connect()\n return\n \n network_path = self._find_network_path(addr)\n \n # server initialization\n if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT:\n assert (\n header.packet_type == PACKET_TYPE_INITIAL\n ), \"first packet must be INITIAL\"\n self._network_paths = [network_path]\n self._version = QuicProtocolVersion(header.version)\n self._initialize(header.destination_cid)\n \n # decrypt packet\n encrypted_off = buf.tell() - start_off\n end_off = buf.tell() + header.rest_length\n pull_bytes(buf, header.rest_length)\n \n epoch = get_epoch(header.packet_type)\n space = self.spaces[epoch]\n if not space.crypto.recv.is_valid():\n return\n try:\n plain_header, plain_payload, packet_number = space.crypto.decrypt_packet(\n data[start_off:end_off], encrypted_off\n )\n except CryptoError as exc:\n self.__logger.warning(exc)\n return\n \n if not self.peer_cid_set:\n self.peer_cid = header.source_cid\n self.peer_cid_set = True\n \n # update state\n if self.__state == QuicConnectionState.FIRSTFLIGHT:\n self._set_state(QuicConnectionState.CONNECTED)\n \n # update spin bit\n if (\n not is_long_header(plain_header[0])\n and packet_number > self._spin_highest_pn\n ):\n if self.is_client:\n self._spin_bit = not get_spin_bit(plain_header[0])\n else:\n self._spin_bit = get_spin_bit\n===========below chunk 1===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:\n # offset: 2\n not get_spin_bit(plain_header[0])\n else:\n self._spin_bit = get_spin_bit(plain_header[0])\n self._spin_highest_pn = packet_number\n \n # handle payload\n context = QuicReceiveContext(epoch=epoch, network_path=network_path)\n try:\n is_ack_only, is_probing = self._payload_received(context, plain_payload)\n except QuicConnectionError as exc:\n self.__logger.warning(exc)\n self.close(\n error_code=exc.error_code,\n frame_type=exc.frame_type,\n reason_phrase=exc.reason_phrase,\n )\n return\n \n # record packet as received\n network_path.bytes_received += buf.tell() - start_off\n space.ack_queue.add(packet_number)\n if not is_ack_only:\n self.send_ack[epoch] = True\n \n self._send_pending()\n \n \n===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n pull_bytes(buf: Buffer, length: int) -> bytes\n \n pull_uint32(buf: Buffer) -> int\n \n at: aioquic.buffer.Buffer\n eof() -> bool\n \n tell() -> int\n \n at: aioquic.connection\n NetworkAddress = Any\n \n get_epoch(packet_type: int) -> tls.Epoch\n \n QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)\n \n QuicConnectionState()\n \n QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath)\n \n at: aioquic.connection.PacketSpace.__init__\n self.crypto = CryptoPair()\n \n at: aioquic.connection.QuicConnection\n supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]\n \n close(error_code: int=QuicErrorCode.NO_ERROR, frame_type: Optional[int]=None, reason_phrase: str=\"\") -> None\n \n _connect() -> None\n \n _find_network_path(addr: NetworkAddress) -> QuicNetworkPath\n \n _initialize(peer_cid: bytes) -> None\n \n _payload_received(context: QuicReceiveContext, plain: bytes) -> Tuple[bool, bool]\n \n _set_state(state: QuicConnectionState) -> None\n \n at: aioquic.connection.QuicConnection.__init__\n self.is_client = is_client\n \n self.host_cid = os.urandom(8)\n \n self.peer_cid = os.urandom(8)\n \n self.peer_cid_set = False\n \n self.peer_token = b\"\"\n \n self.__logger = logger\n \n self._network_paths: List[QuicNetworkPath] = []\n \n self._spin_bit = False\n \n self._spin_highest_pn = 0\n \n self.__state = QuicConnectionState.FIRSTFLIGHT\n \n \n===========unchanged ref 1===========\n self._version: Optional[int] = None\n \n at: aioquic.connection.QuicConnection._initialize\n self.spaces = {\n tls.Epoch.INITIAL: PacketSpace(),\n tls.Epoch.HANDSHAKE: PacketSpace(),\n tls.Epoch.ONE_RTT: PacketSpace(),\n }\n \n at: aioquic.connection.QuicConnection._set_state\n self.__state = state\n \n at: aioquic.connection.QuicConnection.connect\n self._network_paths = [QuicNetworkPath(addr, is_validated=True)]\n \n self._version = max(self.supported_versions)\n \n at: aioquic.connection.QuicConnectionError.__init__\n self.error_code = error_code\n \n self.frame_type = frame_type\n \n self.reason_phrase = reason_phrase\n \n at: aioquic.connection.QuicNetworkPath\n addr: NetworkAddress\n \n bytes_received: int = 0\n \n bytes_sent: int = 0\n \n challenge: Optional[bytes] = None\n \n is_validated: bool = False\n \n at: aioquic.connection.QuicReceiveContext\n epoch: tls.Epoch\n \n network_path: QuicNetworkPath\n \n at: aioquic.crypto\n CryptoError(*args: object)\n \n at: aioquic.crypto.CryptoContext\n is_valid() -> bool\n \n at: aioquic.crypto.CryptoPair\n decrypt_packet(packet: bytes, encrypted_offset: int) -> Tuple[bytes, bytes, int]\n \n at: aioquic.crypto.CryptoPair.__init__\n self.recv = CryptoContext()\n \n at: aioquic.packet\n PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00\n \n PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30\n \n QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)\n QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n "}}},{"rowIdx":1883,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection._handle_path_response_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"097499d4523f0dba51c93294393db35c66d291a1"},"commit_message":{"kind":"string","value":"[connection] make handshake validate network path"},"ground_truth":{"kind":"string","value":"<10>: self.__logger.info(\n \"Network path %s validated by challenge\", context.network_path.addr\n self.__logger.info(\"Network path %s validated\", context.network_path.addr)\n<11>: )\n"},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_path_response_frame(\n self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n ) -> None:\n <0> \"\"\"\n <1> Handle a PATH_RESPONSE frame.\n <2> \"\"\"\n <3> data = pull_bytes(buf, 8)\n <4> if data != context.network_path.challenge:\n <5> raise QuicConnectionError(\n <6> error_code=QuicErrorCode.PROTOCOL_VIOLATION,\n <7> frame_type=frame_type,\n <8> reason_phrase=\"Response does not match challenge\",\n <9> )\n<10> self.__logger.info(\"Network path %s validated\", context.network_path.addr)\n<11> context.network_path.is_validated = True\n<12> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n pull_bytes(buf: Buffer, length: int) -> bytes\n \n at: aioquic.connection\n QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath)\n \n at: aioquic.connection.QuicConnection.__init__\n self._pending_flow_control: List[bytes] = []\n \n at: aioquic.connection.QuicConnection._write_application\n self._pending_flow_control = []\n \n at: aioquic.packet\n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n \n===========changed ref 0===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:\n \"\"\"\n Handle an incoming datagram.\n \"\"\"\n # stop handling packets when closing\n if self.__state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:\n return\n \n data = cast(bytes, data)\n buf = Buffer(data=data)\n while not buf.eof():\n start_off = buf.tell()\n header = pull_quic_header(buf, host_cid_length=len(self.host_cid))\n \n # check destination CID matches\n if self.is_client and header.destination_cid != self.host_cid:\n return\n \n # check protocol version\n if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:\n # version negotiation\n versions = []\n while not buf.eof():\n versions.append(pull_uint32(buf))\n common = set(self.supported_versions).intersection(versions)\n if not common:\n self.__logger.error(\"Could not find a common protocol version\")\n return\n self._version = QuicProtocolVersion(max(common))\n self.__logger.info(\"Retrying with %s\", self._version)\n self._connect()\n return\n elif (\n header.version is not None\n and header.version not in self.supported_versions\n ):\n # unsupported version\n return\n \n if self.is_client and header.packet_type == PACKET_TYPE_RETRY:\n # stateless retry\n if (\n header.destination_cid == self.host_cid\n and header.original_destination_cid == self.peer_cid\n ):\n self.__logger.info(\"Performing stateless retry\")\n self.peer_cid = header.source_cid\n self.peer_token = header.token\n self._connect()\n return\n \n network_path = self._find_network_path(addr)\n \n \n===========changed ref 1===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:\n # offset: 1\n token\n self._connect()\n return\n \n network_path = self._find_network_path(addr)\n \n # server initialization\n if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT:\n assert (\n header.packet_type == PACKET_TYPE_INITIAL\n ), \"first packet must be INITIAL\"\n self._network_paths = [network_path]\n self._version = QuicProtocolVersion(header.version)\n self._initialize(header.destination_cid)\n \n # decrypt packet\n encrypted_off = buf.tell() - start_off\n end_off = buf.tell() + header.rest_length\n pull_bytes(buf, header.rest_length)\n \n epoch = get_epoch(header.packet_type)\n space = self.spaces[epoch]\n if not space.crypto.recv.is_valid():\n return\n try:\n plain_header, plain_payload, packet_number = space.crypto.decrypt_packet(\n data[start_off:end_off], encrypted_off\n )\n except CryptoError as exc:\n self.__logger.warning(exc)\n return\n \n if not self.peer_cid_set:\n self.peer_cid = header.source_cid\n self.peer_cid_set = True\n \n # update state\n if self.__state == QuicConnectionState.FIRSTFLIGHT:\n self._set_state(QuicConnectionState.CONNECTED)\n \n # update spin bit\n if (\n not is_long_header(plain_header[0])\n and packet_number > self._spin_highest_pn\n ):\n if self.is_client:\n self._spin_bit = not get_spin_bit\n===========changed ref 2===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:\n # offset: 2\n _header[0])\n else:\n self._spin_bit = get_spin_bit(plain_header[0])\n self._spin_highest_pn = packet_number\n \n # handle payload\n context = QuicReceiveContext(epoch=epoch, network_path=network_path)\n try:\n is_ack_only, is_probing = self._payload_received(context, plain_payload)\n except QuicConnectionError as exc:\n self.__logger.warning(exc)\n self.close(\n error_code=exc.error_code,\n frame_type=exc.frame_type,\n reason_phrase=exc.reason_phrase,\n )\n return\n \n + # update network path\n + if not network_path.is_validated and epoch == tls.Epoch.HANDSHAKE:\n + self.__logger.info(\n + \"Network path %s validated by handshake\", network_path.addr\n + )\n + network_path.is_validated = True\n + network_path.bytes_received += buf.tell() - start_off\n + if network_path not in self._network_paths:\n + self._network_paths.append(network_path)\n + \n # record packet as received\n - network_path.bytes_received += buf.tell() - start_off\n space.ack_queue.add(packet_number)\n if not is_ack_only:\n self.send_ack[epoch] = True\n \n self._send_pending()\n "}}},{"rowIdx":1884,"cells":{"path":{"kind":"string","value":"aioquic.stream/QuicStream.get_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"3345b647aa10c8e418b8f2a8d115c22ec9b6e2dd"},"commit_message":{"kind":"string","value":"[stream] fix logic in error in stream flow control"},"ground_truth":{"kind":"string","value":"<10>: if size < 0 or (size == 0 and self._send_buffer):\n if size < 0 or (size == 0 and self._send_buffer and not self._send_eof):\n"},"main_code":{"kind":"string","value":" # module: aioquic.stream\n class QuicStream(asyncio.BaseTransport):\n def get_frame(self, size: int) -> Optional[QuicStreamFrame]:\n <0> \"\"\"\n <1> Get a frame of data to send.\n <2> \"\"\"\n <3> # check there is something to send\n <4> if self._send_complete or not self.has_data_to_send():\n <5> return None\n <6> \n <7> # apply flow control\n <8> if self.stream_id is not None:\n <9> size = min(size, self.max_stream_data_remote - self._send_start)\n<10> if size < 0 or (size == 0 and self._send_buffer and not self._send_eof):\n<11> return None\n<12> \n<13> # create frame\n<14> size = min(size, len(self._send_buffer))\n<15> frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)\n<16> self._send_buffer = self._send_buffer[size:]\n<17> self._send_start += size\n<18> \n<19> # if the buffer is empty and EOF was written, set the FIN bit\n<20> if self._send_eof and not self._send_buffer:\n<21> frame.fin = True\n<22> self._send_complete = True\n<23> \n<24> return frame\n<25> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.packet\n QuicStreamFrame(data: bytes=b\"\", fin: bool=False, offset: int=0)\n \n at: aioquic.packet.QuicStreamFrame\n data: bytes = b\"\"\n \n fin: bool = False\n \n offset: int = 0\n \n at: aioquic.stream.QuicStream\n has_data_to_send() -> bool\n \n at: aioquic.stream.QuicStream.__init__\n self.max_stream_data_remote = max_stream_data_remote\n \n self._send_buffer = bytearray()\n \n self._send_complete = False\n \n self._send_eof = False\n \n self._send_start = 0\n \n at: aioquic.stream.QuicStream.write\n self._send_buffer += data\n \n at: aioquic.stream.QuicStream.write_eof\n self._send_eof = True\n \n "}}},{"rowIdx":1885,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection.__init__"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"14f57afcdddd5d9e6f349050ac972d2c1b7a0bbf"},"commit_message":{"kind":"string","value":"[connection] send PATH_CHALLENGE on new paths"},"ground_truth":{"kind":"string","value":""},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n <0> if not is_client:\n <1> assert certificate is not None, \"SSL certificate is required\"\n <2> assert private_key is not None, \"SSL private key is required\"\n <3> \n <4> self.alpn_protocols = alpn_protocols\n <5> self.certificate = certificate\n <6> self.is_client = is_client\n <7> self.host_cid = os.urandom(8)\n <8> self.peer_cid = os.urandom(8)\n <9> self.peer_cid_set = False\n<10> self.peer_token = b\"\"\n<11> self.private_key = private_key\n<12> self.secrets_log_file = secrets_log_file\n<13> self.server_name = server_name\n<14> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}\n<15> \n<16> self.__close: Optional[Dict] = None\n<17> self.__connected = asyncio.Event()\n<18> self.__epoch = tls.Epoch.INITIAL\n<19> self._local_idle_timeout = 60000 # milliseconds\n<20> self._local_max_data = 1048576\n<21> self._local_max_data_used = 0\n<22> self._local_max_stream_data_bidi_local = 1048576\n<23> self._local_max_stream_data_bidi_remote = 1048576\n<24> self._local_max_stream_data_uni = 1048576\n<25> self._local_max_streams_bidi = 128\n<26> self._local_max_streams_uni = 128\n<27> self.__logger = logger\n<28> self.__path_challenge: Optional[bytes] = None\n<29> self._network_paths: List"},"context":{"kind":"string","value":"===========below chunk 0===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n # offset: 1\n self._pending_flow_control: List[bytes] = []\n self._remote_idle_timeout = 0 # milliseconds\n self._remote_max_data = 0\n self._remote_max_data_used = 0\n self._remote_max_stream_data_bidi_local = 0\n self._remote_max_stream_data_bidi_remote = 0\n self._remote_max_stream_data_uni = 0\n self._remote_max_streams_bidi = 0\n self._remote_max_streams_uni = 0\n self._spin_bit = False\n self._spin_highest_pn = 0\n self.__send_pending_task: Optional[asyncio.Handle] = None\n self.__state = QuicConnectionState.FIRSTFLIGHT\n self.__transport: Optional[asyncio.DatagramTransport] = None\n self._version: Optional[int] = None\n \n # callbacks\n self.stream_created_cb: Callable[\n [asyncio.StreamReader, asyncio.StreamWriter], None\n ] = lambda r, w: None\n \n # frame handlers\n self.__frame_handlers = [\n self._handle_padding_frame,\n self._handle_padding_frame,\n self._handle_ack_frame,\n self._handle_ack_frame,\n self._handle_reset_stream_frame,\n self._handle_stop_sending_frame,\n self._handle_crypto_frame,\n self._handle_new_token_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame\n===========below chunk 1===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n # offset: 2\n ,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_max_data_frame,\n self._handle_max_stream_data_frame,\n self._handle_max_streams_bidi_frame,\n self._handle_max_streams_uni_frame,\n self._handle_data_blocked_frame,\n self._handle_stream_data_blocked_frame,\n self._handle_streams_blocked_frame,\n self._handle_streams_blocked_frame,\n self._handle_new_connection_id_frame,\n self._handle_retire_connection_id_frame,\n self._handle_path_challenge_frame,\n self._handle_path_response_frame,\n self._handle_connection_close_frame,\n self._handle_connection_close_frame,\n ]\n \n \n===========unchanged ref 0===========\n at: aioquic.connection\n logger = logging.getLogger(\"quic\")\n \n QuicConnectionState()\n \n 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)\n \n at: aioquic.connection.QuicConnection\n supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]\n \n _handle_ack_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_connection_close_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_crypto_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_data_blocked_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_max_data_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_max_stream_data_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_max_streams_bidi_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_max_streams_uni_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_new_connection_id_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_new_token_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_padding_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n \n===========unchanged ref 1===========\n _handle_path_challenge_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n _handle_path_challenge_frame(self, context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_path_response_frame(self, context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n _handle_path_response_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_reset_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_retire_connection_id_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_stop_sending_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_stream_data_blocked_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n _handle_streams_blocked_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None\n \n at: aioquic.connection.QuicConnection._handle_crypto_frame\n self.__epoch = tls.Epoch.ONE_RTT\n self.__epoch = tls.Epoch.HANDSHAKE\n \n at: aioquic.connection.QuicConnection._handle_max_data_frame\n self._remote_max_data = max_data\n \n at: aioquic.connection.QuicConnection._handle_max_streams_bidi_frame\n self._remote_max_streams_bidi = max_streams\n \n at: aioquic.connection.QuicConnection._handle_max_streams_uni_frame\n self._remote_max_streams_uni = max_streams\n \n at: aioquic.connection.QuicConnection._handle_stream_frame\n self._local_max_data_used += newly_received\n \n "}}},{"rowIdx":1886,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection.datagram_received"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"14f57afcdddd5d9e6f349050ac972d2c1b7a0bbf"},"commit_message":{"kind":"string","value":"[connection] send PATH_CHALLENGE on new paths"},"ground_truth":{"kind":"string","value":""},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:\n <0> \"\"\"\n <1> Handle an incoming datagram.\n <2> \"\"\"\n <3> # stop handling packets when closing\n <4> if self.__state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:\n <5> return\n <6> \n <7> data = cast(bytes, data)\n <8> buf = Buffer(data=data)\n <9> while not buf.eof():\n<10> start_off = buf.tell()\n<11> header = pull_quic_header(buf, host_cid_length=len(self.host_cid))\n<12> \n<13> # check destination CID matches\n<14> if self.is_client and header.destination_cid != self.host_cid:\n<15> return\n<16> \n<17> # check protocol version\n<18> if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:\n<19> # version negotiation\n<20> versions = []\n<21> while not buf.eof():\n<22> versions.append(pull_uint32(buf))\n<23> common = set(self.supported_versions).intersection(versions)\n<24> if not common:\n<25> self.__logger.error(\"Could not find a common protocol version\")\n<26> return\n<27> self._version = QuicProtocolVersion(max(common))\n<28> self.__logger.info(\"Retrying with %s\", self._version)\n<29> self._connect()\n<30> return\n<31> elif (\n<32> header.version is not None\n<33> and header.version not in self.supported_versions\n<34> ):\n<35> # unsupported version\n<36> return\n<37> \n<38> if self.is_client and header.packet_type == PACKET_TYPE_RETRY:\n<39> # stateless retry\n<40> if (\n<41> header.destination_cid == self.host_cid\n<42> and header.original_destination_cid == self.peer_cid\n<43> ):\n<44> self.__logger.info(\"Performing stateless retry\")\n<45> self.peer_cid"},"context":{"kind":"string","value":"===========below chunk 0===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:\n # offset: 1\n self.peer_token = header.token\n self._connect()\n return\n \n network_path = self._find_network_path(addr)\n \n # server initialization\n if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT:\n assert (\n header.packet_type == PACKET_TYPE_INITIAL\n ), \"first packet must be INITIAL\"\n self._network_paths = [network_path]\n self._version = QuicProtocolVersion(header.version)\n self._initialize(header.destination_cid)\n \n # decrypt packet\n encrypted_off = buf.tell() - start_off\n end_off = buf.tell() + header.rest_length\n pull_bytes(buf, header.rest_length)\n \n epoch = get_epoch(header.packet_type)\n space = self.spaces[epoch]\n if not space.crypto.recv.is_valid():\n return\n try:\n plain_header, plain_payload, packet_number = space.crypto.decrypt_packet(\n data[start_off:end_off], encrypted_off\n )\n except CryptoError as exc:\n self.__logger.warning(exc)\n return\n \n if not self.peer_cid_set:\n self.peer_cid = header.source_cid\n self.peer_cid_set = True\n \n # update state\n if self.__state == QuicConnectionState.FIRSTFLIGHT:\n self._set_state(QuicConnectionState.CONNECTED)\n \n # update spin bit\n if (\n not is_long_header(plain_header[0])\n and packet_number > self._spin_highest_pn\n ):\n if self.is_client:\n self._spin_bit = not get_spin_bit(plain_header[0])\n else:\n self._spin_bit = get_spin_bit\n===========below chunk 1===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:\n # offset: 2\n not get_spin_bit(plain_header[0])\n else:\n self._spin_bit = get_spin_bit(plain_header[0])\n self._spin_highest_pn = packet_number\n \n # handle payload\n context = QuicReceiveContext(epoch=epoch, network_path=network_path)\n try:\n is_ack_only, is_probing = self._payload_received(context, plain_payload)\n except QuicConnectionError as exc:\n self.__logger.warning(exc)\n self.close(\n error_code=exc.error_code,\n frame_type=exc.frame_type,\n reason_phrase=exc.reason_phrase,\n )\n return\n \n # update network path\n if not network_path.is_validated and epoch == tls.Epoch.HANDSHAKE:\n self.__logger.info(\n \"Network path %s validated by handshake\", network_path.addr\n )\n network_path.is_validated = True\n network_path.bytes_received += buf.tell() - start_off\n if network_path not in self._network_paths:\n self._network_paths.append(network_path)\n \n # record packet as received\n space.ack_queue.add(packet_number)\n if not is_ack_only:\n self.send_ack[epoch] = True\n \n self._send_pending()\n \n \n===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n pull_bytes(buf: Buffer, length: int) -> bytes\n \n pull_uint32(buf: Buffer) -> int\n \n at: aioquic.buffer.Buffer\n eof() -> bool\n \n tell() -> int\n \n at: aioquic.connection\n NetworkAddress = Any\n \n get_epoch(packet_type: int) -> tls.Epoch\n \n QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)\n \n QuicConnectionState()\n \n QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath)\n \n at: aioquic.connection.PacketSpace.__init__\n self.crypto = CryptoPair()\n \n at: aioquic.connection.QuicConnection\n supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]\n \n close(error_code: int=QuicErrorCode.NO_ERROR, frame_type: Optional[int]=None, reason_phrase: str=\"\") -> None\n \n _connect() -> None\n \n _find_network_path(addr: NetworkAddress) -> QuicNetworkPath\n \n _initialize(peer_cid: bytes) -> None\n \n _payload_received(context: QuicReceiveContext, plain: bytes) -> Tuple[bool, bool]\n \n _set_state(state: QuicConnectionState) -> None\n \n at: aioquic.connection.QuicConnection.__init__\n self.is_client = is_client\n \n self.host_cid = os.urandom(8)\n \n self.peer_cid = os.urandom(8)\n \n self.peer_cid_set = False\n \n self.peer_token = b\"\"\n \n self.__logger = logger\n \n self._network_paths: List[QuicNetworkPath] = []\n \n self._spin_bit = False\n \n self._spin_highest_pn = 0\n \n self.__state = QuicConnectionState.FIRSTFLIGHT\n \n \n===========unchanged ref 1===========\n self._version: Optional[int] = None\n \n at: aioquic.connection.QuicConnection._initialize\n self.spaces = {\n tls.Epoch.INITIAL: PacketSpace(),\n tls.Epoch.HANDSHAKE: PacketSpace(),\n tls.Epoch.ONE_RTT: PacketSpace(),\n }\n \n at: aioquic.connection.QuicConnection._set_state\n self.__state = state\n \n at: aioquic.connection.QuicConnection.connect\n self._network_paths = [QuicNetworkPath(addr, is_validated=True)]\n \n self._version = max(self.supported_versions)\n \n at: aioquic.connection.QuicConnectionError.__init__\n self.error_code = error_code\n \n self.frame_type = frame_type\n \n self.reason_phrase = reason_phrase\n \n at: aioquic.connection.QuicNetworkPath\n addr: NetworkAddress\n \n bytes_received: int = 0\n \n bytes_sent: int = 0\n \n is_validated: bool = False\n \n local_challenge: Optional[bytes] = None\n \n remote_challenge: Optional[bytes] = None\n \n at: aioquic.connection.QuicReceiveContext\n epoch: tls.Epoch\n \n network_path: QuicNetworkPath\n \n at: aioquic.crypto\n CryptoError(*args: object)\n \n at: aioquic.crypto.CryptoContext\n is_valid() -> bool\n \n at: aioquic.crypto.CryptoPair\n decrypt_packet(packet: bytes, encrypted_offset: int) -> Tuple[bytes, bytes, int]\n \n at: aioquic.crypto.CryptoPair.__init__\n self.recv = CryptoContext()\n \n at: aioquic.packet\n PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00\n \n PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30\n \n "}}},{"rowIdx":1887,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection._handle_path_challenge_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"14f57afcdddd5d9e6f349050ac972d2c1b7a0bbf"},"commit_message":{"kind":"string","value":"[connection] send PATH_CHALLENGE on new paths"},"ground_truth":{"kind":"string","value":" <4>: context.network_path.remote_challenge = data\n self._pending_flow_control.append(bytes([QuicFrameType.PATH_RESPONSE]) + data)\n"},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_path_challenge_frame(\n self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n ) -> None:\n <0> \"\"\"\n <1> Handle a PATH_CHALLENGE frame.\n <2> \"\"\"\n <3> data = pull_bytes(buf, 8)\n <4> self._pending_flow_control.append(bytes([QuicFrameType.PATH_RESPONSE]) + data)\n <5> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath)\n \n \n===========changed ref 0===========\n # module: aioquic.connection\n @dataclass\n class QuicNetworkPath:\n addr: NetworkAddress\n bytes_received: int = 0\n bytes_sent: int = 0\n - challenge: Optional[bytes] = None\n is_validated: bool = False\n + local_challenge: Optional[bytes] = None\n + remote_challenge: Optional[bytes] = None\n \n===========changed ref 1===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n if not is_client:\n assert certificate is not None, \"SSL certificate is required\"\n assert private_key is not None, \"SSL private key is required\"\n \n self.alpn_protocols = alpn_protocols\n self.certificate = certificate\n self.is_client = is_client\n self.host_cid = os.urandom(8)\n self.peer_cid = os.urandom(8)\n self.peer_cid_set = False\n self.peer_token = b\"\"\n self.private_key = private_key\n self.secrets_log_file = secrets_log_file\n self.server_name = server_name\n self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}\n \n self.__close: Optional[Dict] = None\n self.__connected = asyncio.Event()\n self.__epoch = tls.Epoch.INITIAL\n self._local_idle_timeout = 60000 # milliseconds\n self._local_max_data = 1048576\n self._local_max_data_used = 0\n self._local_max_stream_data_bidi_local = 1048576\n self._local_max_stream_data_bidi_remote = 1048576\n self._local_max_stream_data_uni = 1048576\n self._local_max_streams_bidi = 128\n self._local_max_streams_uni = 128\n self.__logger = logger\n self.__path_challenge: Optional[bytes] = None\n self._network_paths: List[QuicNetworkPath] = []\n - self._pending_flow_control: List[bytes] = []\n self._remote\n===========changed ref 2===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n # offset: 1\n [QuicNetworkPath] = []\n - self._pending_flow_control: List[bytes] = []\n self._remote_idle_timeout = 0 # milliseconds\n self._remote_max_data = 0\n self._remote_max_data_used = 0\n self._remote_max_stream_data_bidi_local = 0\n self._remote_max_stream_data_bidi_remote = 0\n self._remote_max_stream_data_uni = 0\n self._remote_max_streams_bidi = 0\n self._remote_max_streams_uni = 0\n self._spin_bit = False\n self._spin_highest_pn = 0\n self.__send_pending_task: Optional[asyncio.Handle] = None\n self.__state = QuicConnectionState.FIRSTFLIGHT\n self.__transport: Optional[asyncio.DatagramTransport] = None\n self._version: Optional[int] = None\n \n # callbacks\n self.stream_created_cb: Callable[\n [asyncio.StreamReader, asyncio.StreamWriter], None\n ] = lambda r, w: None\n \n # frame handlers\n self.__frame_handlers = [\n self._handle_padding_frame,\n self._handle_padding_frame,\n self._handle_ack_frame,\n self._handle_ack_frame,\n self._handle_reset_stream_frame,\n self._handle_stop_sending_frame,\n self._handle_crypto_frame,\n self._handle_new_\n===========changed ref 3===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n # offset: 2\n frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_max_data_frame,\n self._handle_max_stream_data_frame,\n self._handle_max_streams_bidi_frame,\n self._handle_max_streams_uni_frame,\n self._handle_data_blocked_frame,\n self._handle_stream_data_blocked_frame,\n self._handle_streams_blocked_frame,\n self._handle_streams_blocked_frame,\n self._handle_new_connection_id_frame,\n self._handle_retire_connection_id_frame,\n self._handle_path_challenge_frame,\n self._handle_path_response_frame,\n self._handle_connection_close_frame,\n self._handle_connection_close_frame,\n ]\n "}}},{"rowIdx":1888,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection._handle_path_response_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"14f57afcdddd5d9e6f349050ac972d2c1b7a0bbf"},"commit_message":{"kind":"string","value":"[connection] send PATH_CHALLENGE on new paths"},"ground_truth":{"kind":"string","value":" <4>: if data != context.network_path.local_challenge:\n if data != context.network_path.challenge:\n"},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_path_response_frame(\n self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n ) -> None:\n <0> \"\"\"\n <1> Handle a PATH_RESPONSE frame.\n <2> \"\"\"\n <3> data = pull_bytes(buf, 8)\n <4> if data != context.network_path.challenge:\n <5> raise QuicConnectionError(\n <6> error_code=QuicErrorCode.PROTOCOL_VIOLATION,\n <7> frame_type=frame_type,\n <8> reason_phrase=\"Response does not match challenge\",\n <9> )\n<10> self.__logger.info(\n<11> \"Network path %s validated by challenge\", context.network_path.addr\n<12> )\n<13> context.network_path.is_validated = True\n<14> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n pull_bytes(buf: Buffer, length: int) -> bytes\n \n at: aioquic.connection\n QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)\n \n QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath)\n \n at: aioquic.connection.QuicNetworkPath\n local_challenge: Optional[bytes] = None\n \n remote_challenge: Optional[bytes] = None\n \n at: aioquic.connection.QuicReceiveContext\n network_path: QuicNetworkPath\n \n at: aioquic.packet\n QuicErrorCode(x: Union[str, bytes, bytearray], base: int)\n QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n \n===========changed ref 0===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_path_challenge_frame(\n self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n ) -> None:\n \"\"\"\n Handle a PATH_CHALLENGE frame.\n \"\"\"\n data = pull_bytes(buf, 8)\n + context.network_path.remote_challenge = data\n - self._pending_flow_control.append(bytes([QuicFrameType.PATH_RESPONSE]) + data)\n \n===========changed ref 1===========\n # module: aioquic.connection\n @dataclass\n class QuicNetworkPath:\n addr: NetworkAddress\n bytes_received: int = 0\n bytes_sent: int = 0\n - challenge: Optional[bytes] = None\n is_validated: bool = False\n + local_challenge: Optional[bytes] = None\n + remote_challenge: Optional[bytes] = None\n \n===========changed ref 2===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n if not is_client:\n assert certificate is not None, \"SSL certificate is required\"\n assert private_key is not None, \"SSL private key is required\"\n \n self.alpn_protocols = alpn_protocols\n self.certificate = certificate\n self.is_client = is_client\n self.host_cid = os.urandom(8)\n self.peer_cid = os.urandom(8)\n self.peer_cid_set = False\n self.peer_token = b\"\"\n self.private_key = private_key\n self.secrets_log_file = secrets_log_file\n self.server_name = server_name\n self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}\n \n self.__close: Optional[Dict] = None\n self.__connected = asyncio.Event()\n self.__epoch = tls.Epoch.INITIAL\n self._local_idle_timeout = 60000 # milliseconds\n self._local_max_data = 1048576\n self._local_max_data_used = 0\n self._local_max_stream_data_bidi_local = 1048576\n self._local_max_stream_data_bidi_remote = 1048576\n self._local_max_stream_data_uni = 1048576\n self._local_max_streams_bidi = 128\n self._local_max_streams_uni = 128\n self.__logger = logger\n self.__path_challenge: Optional[bytes] = None\n self._network_paths: List[QuicNetworkPath] = []\n - self._pending_flow_control: List[bytes] = []\n self._remote\n===========changed ref 3===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n # offset: 1\n [QuicNetworkPath] = []\n - self._pending_flow_control: List[bytes] = []\n self._remote_idle_timeout = 0 # milliseconds\n self._remote_max_data = 0\n self._remote_max_data_used = 0\n self._remote_max_stream_data_bidi_local = 0\n self._remote_max_stream_data_bidi_remote = 0\n self._remote_max_stream_data_uni = 0\n self._remote_max_streams_bidi = 0\n self._remote_max_streams_uni = 0\n self._spin_bit = False\n self._spin_highest_pn = 0\n self.__send_pending_task: Optional[asyncio.Handle] = None\n self.__state = QuicConnectionState.FIRSTFLIGHT\n self.__transport: Optional[asyncio.DatagramTransport] = None\n self._version: Optional[int] = None\n \n # callbacks\n self.stream_created_cb: Callable[\n [asyncio.StreamReader, asyncio.StreamWriter], None\n ] = lambda r, w: None\n \n # frame handlers\n self.__frame_handlers = [\n self._handle_padding_frame,\n self._handle_padding_frame,\n self._handle_ack_frame,\n self._handle_ack_frame,\n self._handle_reset_stream_frame,\n self._handle_stop_sending_frame,\n self._handle_crypto_frame,\n self._handle_new_\n===========changed ref 4===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n # offset: 2\n frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_max_data_frame,\n self._handle_max_stream_data_frame,\n self._handle_max_streams_bidi_frame,\n self._handle_max_streams_uni_frame,\n self._handle_data_blocked_frame,\n self._handle_stream_data_blocked_frame,\n self._handle_streams_blocked_frame,\n self._handle_streams_blocked_frame,\n self._handle_new_connection_id_frame,\n self._handle_retire_connection_id_frame,\n self._handle_path_challenge_frame,\n self._handle_path_response_frame,\n self._handle_connection_close_frame,\n self._handle_connection_close_frame,\n ]\n "}}},{"rowIdx":1889,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection._pending_datagrams"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"14f57afcdddd5d9e6f349050ac972d2c1b7a0bbf"},"commit_message":{"kind":"string","value":"[connection] send PATH_CHALLENGE on new paths"},"ground_truth":{"kind":"string","value":" <3>: yield from self._write_application(network_path)\n yield from self._write_application()\n"},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _pending_datagrams(self, network_path: QuicNetworkPath) -> Iterator[bytes]:\n - def _pending_datagrams(self) -> Iterator[bytes]:\n <0> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:\n <1> yield from self._write_handshake(epoch)\n <2> \n <3> yield from self._write_application()\n <4> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.connection.QuicConnection\n _push_crypto_data() -> None\n \n at: aioquic.connection.QuicConnection._payload_received\n is_ack_only = True\n is_ack_only = False\n \n is_probing = False\n is_probing = None\n is_probing = True\n \n \n===========changed ref 0===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_path_challenge_frame(\n self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n ) -> None:\n \"\"\"\n Handle a PATH_CHALLENGE frame.\n \"\"\"\n data = pull_bytes(buf, 8)\n + context.network_path.remote_challenge = data\n - self._pending_flow_control.append(bytes([QuicFrameType.PATH_RESPONSE]) + data)\n \n===========changed ref 1===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_path_response_frame(\n self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n ) -> None:\n \"\"\"\n Handle a PATH_RESPONSE frame.\n \"\"\"\n data = pull_bytes(buf, 8)\n + if data != context.network_path.local_challenge:\n - if data != context.network_path.challenge:\n raise QuicConnectionError(\n error_code=QuicErrorCode.PROTOCOL_VIOLATION,\n frame_type=frame_type,\n reason_phrase=\"Response does not match challenge\",\n )\n self.__logger.info(\n \"Network path %s validated by challenge\", context.network_path.addr\n )\n context.network_path.is_validated = True\n \n===========changed ref 2===========\n # module: aioquic.connection\n @dataclass\n class QuicNetworkPath:\n addr: NetworkAddress\n bytes_received: int = 0\n bytes_sent: int = 0\n - challenge: Optional[bytes] = None\n is_validated: bool = False\n + local_challenge: Optional[bytes] = None\n + remote_challenge: Optional[bytes] = None\n \n===========changed ref 3===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n if not is_client:\n assert certificate is not None, \"SSL certificate is required\"\n assert private_key is not None, \"SSL private key is required\"\n \n self.alpn_protocols = alpn_protocols\n self.certificate = certificate\n self.is_client = is_client\n self.host_cid = os.urandom(8)\n self.peer_cid = os.urandom(8)\n self.peer_cid_set = False\n self.peer_token = b\"\"\n self.private_key = private_key\n self.secrets_log_file = secrets_log_file\n self.server_name = server_name\n self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}\n \n self.__close: Optional[Dict] = None\n self.__connected = asyncio.Event()\n self.__epoch = tls.Epoch.INITIAL\n self._local_idle_timeout = 60000 # milliseconds\n self._local_max_data = 1048576\n self._local_max_data_used = 0\n self._local_max_stream_data_bidi_local = 1048576\n self._local_max_stream_data_bidi_remote = 1048576\n self._local_max_stream_data_uni = 1048576\n self._local_max_streams_bidi = 128\n self._local_max_streams_uni = 128\n self.__logger = logger\n self.__path_challenge: Optional[bytes] = None\n self._network_paths: List[QuicNetworkPath] = []\n - self._pending_flow_control: List[bytes] = []\n self._remote\n===========changed ref 4===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n # offset: 1\n [QuicNetworkPath] = []\n - self._pending_flow_control: List[bytes] = []\n self._remote_idle_timeout = 0 # milliseconds\n self._remote_max_data = 0\n self._remote_max_data_used = 0\n self._remote_max_stream_data_bidi_local = 0\n self._remote_max_stream_data_bidi_remote = 0\n self._remote_max_stream_data_uni = 0\n self._remote_max_streams_bidi = 0\n self._remote_max_streams_uni = 0\n self._spin_bit = False\n self._spin_highest_pn = 0\n self.__send_pending_task: Optional[asyncio.Handle] = None\n self.__state = QuicConnectionState.FIRSTFLIGHT\n self.__transport: Optional[asyncio.DatagramTransport] = None\n self._version: Optional[int] = None\n \n # callbacks\n self.stream_created_cb: Callable[\n [asyncio.StreamReader, asyncio.StreamWriter], None\n ] = lambda r, w: None\n \n # frame handlers\n self.__frame_handlers = [\n self._handle_padding_frame,\n self._handle_padding_frame,\n self._handle_ack_frame,\n self._handle_ack_frame,\n self._handle_reset_stream_frame,\n self._handle_stop_sending_frame,\n self._handle_crypto_frame,\n self._handle_new_\n===========changed ref 5===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n # offset: 2\n frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_stream_frame,\n self._handle_max_data_frame,\n self._handle_max_stream_data_frame,\n self._handle_max_streams_bidi_frame,\n self._handle_max_streams_uni_frame,\n self._handle_data_blocked_frame,\n self._handle_stream_data_blocked_frame,\n self._handle_streams_blocked_frame,\n self._handle_streams_blocked_frame,\n self._handle_new_connection_id_frame,\n self._handle_retire_connection_id_frame,\n self._handle_path_challenge_frame,\n self._handle_path_response_frame,\n self._handle_connection_close_frame,\n self._handle_connection_close_frame,\n ]\n "}}},{"rowIdx":1890,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection._send_pending"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"14f57afcdddd5d9e6f349050ac972d2c1b7a0bbf"},"commit_message":{"kind":"string","value":"[connection] send PATH_CHALLENGE on new paths"},"ground_truth":{"kind":"string","value":" <1>: for datagram in self._pending_datagrams(network_path):\n for datagram in self._pending_datagrams():\n"},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _send_pending(self) -> None:\n <0> network_path = self._network_paths[0]\n <1> for datagram in self._pending_datagrams():\n <2> self.__transport.sendto(datagram, network_path.addr)\n <3> network_path.bytes_sent += len(datagram)\n <4> self.__send_pending_task = None\n <5> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.connection.QuicConnection.__init__\n self.__send_pending_task: Optional[asyncio.Handle] = None\n \n self.__transport: Optional[asyncio.DatagramTransport] = None\n \n at: aioquic.connection.QuicConnection._send_pending\n network_path = self._network_paths[0]\n \n at: aioquic.connection.QuicConnection._send_soon\n self.__send_pending_task = loop.call_soon(self._send_pending)\n \n at: aioquic.connection.QuicConnection.connection_made\n self.__transport = cast(asyncio.DatagramTransport, transport)\n \n at: aioquic.connection.QuicNetworkPath\n addr: NetworkAddress\n \n bytes_sent: int = 0\n \n at: asyncio.transports.DatagramTransport\n __slots__ = ()\n \n sendto(data: Any, addr: Optional[_Address]=...) -> None\n \n \n===========changed ref 0===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _pending_datagrams(self, network_path: QuicNetworkPath) -> Iterator[bytes]:\n - def _pending_datagrams(self) -> Iterator[bytes]:\n for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:\n yield from self._write_handshake(epoch)\n \n + yield from self._write_application(network_path)\n - yield from self._write_application()\n \n===========changed ref 1===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n - def _send_path_challenge(self, network_path: QuicNetworkPath) -> None:\n - if network_path.challenge is None:\n - network_path.challenge = os.urandom(8)\n - self._pending_flow_control.append(\n - bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge\n - )\n - self._send_pending()\n - \n===========changed ref 2===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_path_challenge_frame(\n self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n ) -> None:\n \"\"\"\n Handle a PATH_CHALLENGE frame.\n \"\"\"\n data = pull_bytes(buf, 8)\n + context.network_path.remote_challenge = data\n - self._pending_flow_control.append(bytes([QuicFrameType.PATH_RESPONSE]) + data)\n \n===========changed ref 3===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_path_response_frame(\n self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n ) -> None:\n \"\"\"\n Handle a PATH_RESPONSE frame.\n \"\"\"\n data = pull_bytes(buf, 8)\n + if data != context.network_path.local_challenge:\n - if data != context.network_path.challenge:\n raise QuicConnectionError(\n error_code=QuicErrorCode.PROTOCOL_VIOLATION,\n frame_type=frame_type,\n reason_phrase=\"Response does not match challenge\",\n )\n self.__logger.info(\n \"Network path %s validated by challenge\", context.network_path.addr\n )\n context.network_path.is_validated = True\n \n===========changed ref 4===========\n # module: aioquic.connection\n @dataclass\n class QuicNetworkPath:\n addr: NetworkAddress\n bytes_received: int = 0\n bytes_sent: int = 0\n - challenge: Optional[bytes] = None\n is_validated: bool = False\n + local_challenge: Optional[bytes] = None\n + remote_challenge: Optional[bytes] = None\n \n===========changed ref 5===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n if not is_client:\n assert certificate is not None, \"SSL certificate is required\"\n assert private_key is not None, \"SSL private key is required\"\n \n self.alpn_protocols = alpn_protocols\n self.certificate = certificate\n self.is_client = is_client\n self.host_cid = os.urandom(8)\n self.peer_cid = os.urandom(8)\n self.peer_cid_set = False\n self.peer_token = b\"\"\n self.private_key = private_key\n self.secrets_log_file = secrets_log_file\n self.server_name = server_name\n self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}\n \n self.__close: Optional[Dict] = None\n self.__connected = asyncio.Event()\n self.__epoch = tls.Epoch.INITIAL\n self._local_idle_timeout = 60000 # milliseconds\n self._local_max_data = 1048576\n self._local_max_data_used = 0\n self._local_max_stream_data_bidi_local = 1048576\n self._local_max_stream_data_bidi_remote = 1048576\n self._local_max_stream_data_uni = 1048576\n self._local_max_streams_bidi = 128\n self._local_max_streams_uni = 128\n self.__logger = logger\n self.__path_challenge: Optional[bytes] = None\n self._network_paths: List[QuicNetworkPath] = []\n - self._pending_flow_control: List[bytes] = []\n self._remote\n===========changed ref 6===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def __init__(\n self,\n is_client: bool = True,\n certificate: Any = None,\n private_key: Any = None,\n secrets_log_file: TextIO = None,\n alpn_protocols: Optional[List[str]] = None,\n server_name: Optional[str] = None,\n ) -> None:\n # offset: 1\n [QuicNetworkPath] = []\n - self._pending_flow_control: List[bytes] = []\n self._remote_idle_timeout = 0 # milliseconds\n self._remote_max_data = 0\n self._remote_max_data_used = 0\n self._remote_max_stream_data_bidi_local = 0\n self._remote_max_stream_data_bidi_remote = 0\n self._remote_max_stream_data_uni = 0\n self._remote_max_streams_bidi = 0\n self._remote_max_streams_uni = 0\n self._spin_bit = False\n self._spin_highest_pn = 0\n self.__send_pending_task: Optional[asyncio.Handle] = None\n self.__state = QuicConnectionState.FIRSTFLIGHT\n self.__transport: Optional[asyncio.DatagramTransport] = None\n self._version: Optional[int] = None\n \n # callbacks\n self.stream_created_cb: Callable[\n [asyncio.StreamReader, asyncio.StreamWriter], None\n ] = lambda r, w: None\n \n # frame handlers\n self.__frame_handlers = [\n self._handle_padding_frame,\n self._handle_padding_frame,\n self._handle_ack_frame,\n self._handle_ack_frame,\n self._handle_reset_stream_frame,\n self._handle_stop_sending_frame,\n self._handle_crypto_frame,\n self._handle_new_"}}},{"rowIdx":1891,"cells":{"path":{"kind":"string","value":"aioquic.connection/QuicConnection._write_application"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"14f57afcdddd5d9e6f349050ac972d2c1b7a0bbf"},"commit_message":{"kind":"string","value":"[connection] send PATH_CHALLENGE on new paths"},"ground_truth":{"kind":"string","value":"<27>: # PATH CHALLENGE\n if (\n self.__epoch == tls.Epoch.ONE_RTT\n and not network_path.is_validated\n and network_path.local_challenge is None\n ):\n self.__logger.info(\n \"Network path %s sending challenge\", network_path.addr\n )\n network_path.local_challenge = os.urandom(8)\n push_uint_var(buf, QuicFrameType.PATH_CHALLENGE)\n push_bytes(buf, network_path.local_challenge)\n \n # PATH RESPONSE\n if network_path.remote_challenge is not None:\n push_uint_var(buf, QuicFrameType.PATH_RESPONSE)\n push_bytes(buf, network_path.remote_challenge)\n network_path.remote_challenge = None\n # FLOW CONTROL\n<28>: for control_frame in self._pending_flow_control:\n<29>: push_bytes(buf, control_frame)\n<30>: self._pending_flow_control = []\n"},"main_code":{"kind":"string","value":" # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _write_application(self, network_path: QuicNetworkPath) -> Iterator[bytes]:\n - def _write_application(self) -> Iterator[bytes]:\n <0> epoch = tls.Epoch.ONE_RTT\n <1> space = self.spaces[epoch]\n <2> if not space.crypto.send.is_valid():\n <3> return\n <4> \n <5> buf = Buffer(capacity=PACKET_MAX_SIZE)\n <6> capacity = buf.capacity - space.crypto.aead_tag_size\n <7> \n <8> while True:\n <9> # write header\n<10> push_uint8(\n<11> buf,\n<12> PACKET_FIXED_BIT\n<13> | (self._spin_bit << 5)\n<14> | (space.crypto.key_phase << 2)\n<15> | (PACKET_NUMBER_SEND_SIZE - 1),\n<16> )\n<17> push_bytes(buf, self.peer_cid)\n<18> push_uint16(buf, self.packet_number)\n<19> header_size = buf.tell()\n<20> \n<21> # ACK\n<22> if self.send_ack[epoch] and space.ack_queue:\n<23> push_uint_var(buf, QuicFrameType.ACK)\n<24> packet.push_ack_frame(buf, space.ack_queue, 0)\n<25> self.send_ack[epoch] = False\n<26> \n<27> # FLOW CONTROL\n<28> for control_frame in self._pending_flow_control:\n<29> push_bytes(buf, control_frame)\n<30> self._pending_flow_control = []\n<31> \n<32> # CLOSE\n<33> if self.__close and self.__epoch == epoch:\n<34> push_close(buf, **self.__close)\n<35> self.__close = None\n<36> \n<37> # STREAM\n<38> for stream_id, stream in self.streams.items():\n<39> if isinstance(stream_id, int):\n<40> # the frame data size is constrained by our peer's MAX_DATA and\n<41> # the space available in the current packet\n<42> frame_overhead"},"context":{"kind":"string","value":"===========below chunk 0===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _write_application(self, network_path: QuicNetworkPath) -> Iterator[bytes]:\n - def _write_application(self) -> Iterator[bytes]:\n # offset: 1\n 3\n + quic_uint_length(stream_id)\n + (\n quic_uint_length(stream._send_start)\n if stream._send_start\n else 0\n )\n )\n frame = stream.get_frame(\n min(\n capacity - buf.tell() - frame_overhead,\n self._remote_max_data - self._remote_max_data_used,\n )\n )\n \n if frame is not None:\n flags = QuicStreamFlag.LEN\n if frame.offset:\n flags |= QuicStreamFlag.OFF\n if frame.fin:\n flags |= QuicStreamFlag.FIN\n push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)\n with push_stream_frame(buf, 0, frame.offset):\n push_bytes(buf, frame.data)\n self._remote_max_data_used += len(frame.data)\n \n packet_size = buf.tell()\n if packet_size > header_size:\n # encrypt\n data = buf.data\n yield space.crypto.encrypt_packet(\n data[0:header_size], data[header_size:packet_size]\n )\n \n self.packet_number += 1\n buf.seek(0)\n else:\n break\n \n \n===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n push_bytes(buf: Buffer, v: bytes) -> None\n \n push_uint8(buf: Buffer, v: int) -> None\n \n push_uint16(buf: Buffer, v: int) -> None\n \n at: aioquic.buffer.Buffer\n tell() -> int\n \n at: aioquic.connection\n PACKET_MAX_SIZE = 1280\n \n push_close(buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None\n \n at: aioquic.connection.PacketSpace.__init__\n self.ack_queue = RangeSet()\n \n self.crypto = CryptoPair()\n \n at: aioquic.connection.QuicConnection.__init__\n self.peer_cid = os.urandom(8)\n \n self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}\n \n self.__close: Optional[Dict] = None\n \n self.__epoch = tls.Epoch.INITIAL\n \n self.__logger = logger\n \n self._remote_max_data = 0\n \n self._remote_max_data_used = 0\n \n self._spin_bit = False\n \n at: aioquic.connection.QuicConnection._handle_crypto_frame\n self.__epoch = tls.Epoch.ONE_RTT\n self.__epoch = tls.Epoch.HANDSHAKE\n \n at: aioquic.connection.QuicConnection._handle_max_data_frame\n self._remote_max_data = max_data\n \n at: aioquic.connection.QuicConnection._initialize\n self.send_ack = {\n tls.Epoch.INITIAL: False,\n tls.Epoch.HANDSHAKE: False,\n tls.Epoch.ONE_RTT: False,\n }\n \n self.packet_number = 0\n \n at: aioquic.connection.QuicConnection._write_application\n epoch = tls.Epoch.ONE_RTT\n \n space = self.spaces[epoch]\n \n \n===========unchanged ref 1===========\n self.packet_number += 1\n \n at: aioquic.connection.QuicConnection._write_handshake\n self.__close = None\n \n self.packet_number += 1\n \n at: aioquic.connection.QuicConnection.close\n self.__close = {\n \"error_code\": error_code,\n \"frame_type\": frame_type,\n \"reason_phrase\": reason_phrase,\n }\n \n at: aioquic.connection.QuicConnection.datagram_received\n self.peer_cid = header.source_cid\n \n self._spin_bit = not get_spin_bit(plain_header[0])\n self._spin_bit = get_spin_bit(plain_header[0])\n \n at: aioquic.connection.QuicNetworkPath\n addr: NetworkAddress\n \n is_validated: bool = False\n \n local_challenge: Optional[bytes] = None\n \n remote_challenge: Optional[bytes] = None\n \n at: aioquic.crypto.CryptoContext\n is_valid() -> bool\n \n at: aioquic.crypto.CryptoPair.__init__\n self.aead_tag_size = 16\n \n self.send = CryptoContext()\n \n at: aioquic.packet\n PACKET_FIXED_BIT = 0x40\n \n PACKET_NUMBER_SEND_SIZE = 2\n \n quic_uint_length(value: int) -> int\n \n push_uint_var(buf: Buffer, value: int) -> None\n \n QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n QuicFrameType(x: Union[str, bytes, bytearray], base: int)\n \n push_ack_frame(buf: Buffer, rangeset: RangeSet, delay: int) -> None\n \n QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)\n QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n push_stream_frame(buf: Buffer, stream_id: int, offset: int) -> Generator\n \n \n===========unchanged ref 2===========\n at: aioquic.packet.QuicStreamFrame\n data: bytes = b\"\"\n \n fin: bool = False\n \n offset: int = 0\n \n at: aioquic.stream.QuicStream\n get_frame(size: int) -> Optional[QuicStreamFrame]\n \n at: aioquic.stream.QuicStream.__init__\n self._send_start = 0\n \n at: aioquic.stream.QuicStream.get_frame\n self._send_start += size\n \n at: aioquic.tls\n Epoch()\n \n at: logging.Logger\n info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None\n \n at: os\n urandom(size: int, /) -> bytes\n \n \n===========changed ref 0===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _pending_datagrams(self, network_path: QuicNetworkPath) -> Iterator[bytes]:\n - def _pending_datagrams(self) -> Iterator[bytes]:\n for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:\n yield from self._write_handshake(epoch)\n \n + yield from self._write_application(network_path)\n - yield from self._write_application()\n \n===========changed ref 1===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n - def _send_path_challenge(self, network_path: QuicNetworkPath) -> None:\n - if network_path.challenge is None:\n - network_path.challenge = os.urandom(8)\n - self._pending_flow_control.append(\n - bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge\n - )\n - self._send_pending()\n - \n===========changed ref 2===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _send_pending(self) -> None:\n network_path = self._network_paths[0]\n + for datagram in self._pending_datagrams(network_path):\n - for datagram in self._pending_datagrams():\n self.__transport.sendto(datagram, network_path.addr)\n network_path.bytes_sent += len(datagram)\n self.__send_pending_task = None\n "}}},{"rowIdx":1892,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_path_challenge_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"14f57afcdddd5d9e6f349050ac972d2c1b7a0bbf"},"commit_message":{"kind":"string","value":"[connection] send PATH_CHALLENGE on new paths"},"ground_truth":{"kind":"string","value":"<10>: # client changes address and sends some data\n client_transport.local_addr = (\"1.2.3.4\", 2345)\n reader, writer = run(client.create_stream())\n writer.write(b\"01234567\")\n run(asyncio.sleep(0))\n \n # server sends PATH_CHALLENGE and receives PATH_RESPONSE\n # server sends PATH_CHALLENGE\n<12>: network_path.is_validated = False\n<13>: server._send_path_challenge(network_path)\n<14>: run(asyncio.sleep(0))\n<15>: self.assertTrue(network_path.is_validated)\n<16>: self.assertEqual(len(server._network_paths), 2)\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_path_challenge_frame(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # server sends PATH_CHALLENGE\n<11> network_path = server._network_paths[0]\n<12> network_path.is_validated = False\n<13> server._send_path_challenge(network_path)\n<14> run(asyncio.sleep(0))\n<15> self.assertTrue(network_path.is_validated)\n<16> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.connection\n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]\n \n create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]\n \n at: asyncio.streams.StreamWriter\n write(data: bytes) -> None\n \n at: asyncio.tasks\n sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n create_transport(client, server)\n \n at: tests.test_connection.FakeTransport.__init__\n self.local_addr = local_addr\n \n at: tests.utils\n run(coro)\n \n \n===========changed ref 0===========\n # module: tests.test_connection\n + CLIENT_ADDR = (\"1.2.3.4\", 1234)\n - CLIENT_ADDR = None\n \n + SERVER_ADDR = (\"2.3.4.5\", 4433)\n - SERVER_ADDR = None\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n===========changed ref 1===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _pending_datagrams(self, network_path: QuicNetworkPath) -> Iterator[bytes]:\n - def _pending_datagrams(self) -> Iterator[bytes]:\n for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:\n yield from self._write_handshake(epoch)\n \n + yield from self._write_application(network_path)\n - yield from self._write_application()\n \n===========changed ref 2===========\n # module: aioquic.connection\n @dataclass\n class QuicNetworkPath:\n addr: NetworkAddress\n bytes_received: int = 0\n bytes_sent: int = 0\n - challenge: Optional[bytes] = None\n is_validated: bool = False\n + local_challenge: Optional[bytes] = None\n + remote_challenge: Optional[bytes] = None\n \n===========changed ref 3===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_path_challenge_frame(\n self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n ) -> None:\n \"\"\"\n Handle a PATH_CHALLENGE frame.\n \"\"\"\n data = pull_bytes(buf, 8)\n + context.network_path.remote_challenge = data\n - self._pending_flow_control.append(bytes([QuicFrameType.PATH_RESPONSE]) + data)\n \n===========changed ref 4===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n - def _send_path_challenge(self, network_path: QuicNetworkPath) -> None:\n - if network_path.challenge is None:\n - network_path.challenge = os.urandom(8)\n - self._pending_flow_control.append(\n - bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge\n - )\n - self._send_pending()\n - \n===========changed ref 5===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _send_pending(self) -> None:\n network_path = self._network_paths[0]\n + for datagram in self._pending_datagrams(network_path):\n - for datagram in self._pending_datagrams():\n self.__transport.sendto(datagram, network_path.addr)\n network_path.bytes_sent += len(datagram)\n self.__send_pending_task = None\n \n===========changed ref 6===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n def _handle_path_response_frame(\n self, context: QuicReceiveContext, frame_type: int, buf: Buffer\n ) -> None:\n \"\"\"\n Handle a PATH_RESPONSE frame.\n \"\"\"\n data = pull_bytes(buf, 8)\n + if data != context.network_path.local_challenge:\n - if data != context.network_path.challenge:\n raise QuicConnectionError(\n error_code=QuicErrorCode.PROTOCOL_VIOLATION,\n frame_type=frame_type,\n reason_phrase=\"Response does not match challenge\",\n )\n self.__logger.info(\n \"Network path %s validated by challenge\", context.network_path.addr\n )\n context.network_path.is_validated = True\n \n===========changed ref 7===========\n # module: aioquic.connection\n class QuicConnection(asyncio.DatagramProtocol):\n + def _write_application(self, network_path: QuicNetworkPath) -> Iterator[bytes]:\n - def _write_application(self) -> Iterator[bytes]:\n epoch = tls.Epoch.ONE_RTT\n space = self.spaces[epoch]\n if not space.crypto.send.is_valid():\n return\n \n buf = Buffer(capacity=PACKET_MAX_SIZE)\n capacity = buf.capacity - space.crypto.aead_tag_size\n \n while True:\n # write header\n push_uint8(\n buf,\n PACKET_FIXED_BIT\n | (self._spin_bit << 5)\n | (space.crypto.key_phase << 2)\n | (PACKET_NUMBER_SEND_SIZE - 1),\n )\n push_bytes(buf, self.peer_cid)\n push_uint16(buf, self.packet_number)\n header_size = buf.tell()\n \n # ACK\n if self.send_ack[epoch] and space.ack_queue:\n push_uint_var(buf, QuicFrameType.ACK)\n packet.push_ack_frame(buf, space.ack_queue, 0)\n self.send_ack[epoch] = False\n \n + # PATH CHALLENGE\n + if (\n + self.__epoch == tls.Epoch.ONE_RTT\n + and not network_path.is_validated\n + and network_path.local_challenge is None\n + ):\n + self.__logger.info(\n + \"Network path %s sending challenge\", network_path.addr\n + )\n + network_path.local_challenge = os.urandom(8)\n + push_uint_var(buf, QuicFrameType.PATH_CHALLENGE)\n + push_bytes(buf, network_path.local_challenge)\n + \n + # PATH RESPONSE\n + if network_path.remote_challenge is not None:\n + push_uint_var(buf, QuicFrameType.PATH_RESPONSE"}}},{"rowIdx":1893,"cells":{"path":{"kind":"string","value":"examples.server/serve_http_request"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"b449464680b19d13aacef09d10bb2101591a3ee5"},"commit_message":{"kind":"string","value":"[examples] add some more routes to demo server for interop"},"ground_truth":{"kind":"string","value":" <5>: if request == b\"GET /\\r\\n\" or request == \"GET /index.html\\r\\n\":\n if request == b\"GET /\\r\\n\":\n <7>: elif request == b\"GET /5000000\\r\\n\":\n writer.write(os.urandom(5000000))\n elif request == b\"GET /10000000\\r\\n\":\n writer.write(os.urandom(10000000))\n"},"main_code":{"kind":"string","value":" # module: examples.server\n def serve_http_request(reader, writer):\n <0> \"\"\"\n <1> Serve an HTTP/0.9 request.\n <2> \"\"\"\n <3> request = await reader.read()\n <4> \n <5> if request == b\"GET /\\r\\n\":\n <6> writer.write(TEMPLATE.format(content=\"It works!\").encode(\"utf8\"))\n <7> else:\n <8> writer.write(\n <9> TEMPLATE.format(content=\"The document could not be found.\").encode(\"utf8\")\n<10> )\n<11> \n<12> writer.write_eof()\n<13> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: examples.server\n TEMPLATE = \"\"\"\n \n \n \n aioquic\n \n \n

Welcome to aioquic

\n

{content}/p>\n \n \n \"\"\"\n \n at: os\n urandom(size: int, /) -> bytes\n \n "}}},{"rowIdx":1894,"cells":{"path":{"kind":"string","value":"tests.test_connection/QuicConnectionTest.test_handle_path_challenge_frame"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"71bd40578916ed4e36048c2a7da1d9658244d2a2"},"commit_message":{"kind":"string","value":"[tests] fix flake8 error"},"ground_truth":{"kind":"string","value":"<17>: network_path = server._network_paths[0]\n"},"main_code":{"kind":"string","value":" # module: tests.test_connection\n class QuicConnectionTest(TestCase):\n def test_handle_path_challenge_frame(self):\n <0> client = QuicConnection(is_client=True)\n <1> server = QuicConnection(\n <2> is_client=False,\n <3> certificate=SERVER_CERTIFICATE,\n <4> private_key=SERVER_PRIVATE_KEY,\n <5> )\n <6> \n <7> # perform handshake\n <8> client_transport, server_transport = create_transport(client, server)\n <9> \n<10> # client changes address and sends some data\n<11> client_transport.local_addr = (\"1.2.3.4\", 2345)\n<12> reader, writer = run(client.create_stream())\n<13> writer.write(b\"01234567\")\n<14> run(asyncio.sleep(0))\n<15> \n<16> # server sends PATH_CHALLENGE and receives PATH_RESPONSE\n<17> network_path = server._network_paths[0]\n<18> self.assertEqual(len(server._network_paths), 2)\n<19> \n<20> # check new path\n<21> self.assertEqual(server._network_paths[0].addr, (\"1.2.3.4\", 2345))\n<22> self.assertTrue(server._network_paths[0].is_validated)\n<23> \n<24> # check old path\n<25> self.assertEqual(server._network_paths[1].addr, (\"1.2.3.4\", 1234))\n<26> self.assertTrue(server._network_paths[1].is_validated)\n<27> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.connection\n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]\n \n create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]\n \n at: aioquic.connection.QuicConnection.__init__\n self._network_paths: List[QuicNetworkPath] = []\n \n at: aioquic.connection.QuicConnection.connect\n self._network_paths = [QuicNetworkPath(addr, is_validated=True)]\n \n at: aioquic.connection.QuicConnection.datagram_received\n self._network_paths = [network_path]\n \n at: aioquic.connection.QuicNetworkPath\n addr: NetworkAddress\n \n bytes_received: int = 0\n \n bytes_sent: int = 0\n \n is_validated: bool = False\n \n local_challenge: Optional[bytes] = None\n \n remote_challenge: Optional[bytes] = None\n \n at: asyncio.streams.StreamWriter\n write(data: bytes) -> None\n \n at: asyncio.tasks\n sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]\n \n at: tests.test_connection\n SERVER_CERTIFICATE = x509.load_pem_x509_certificate(\n load(\"ssl_cert.pem\"), backend=default_backend()\n )\n \n SERVER_PRIVATE_KEY = serialization.load_pem_private_key(\n load(\"ssl_key.pem\"), password=None, backend=default_backend()\n )\n \n create_transport(client, server)\n \n at: tests.test_connection.FakeTransport.__init__\n self.local_addr = local_addr\n \n \n===========unchanged ref 1===========\n at: tests.utils\n run(coro)\n \n at: unittest.case.TestCase\n failureException: Type[BaseException]\n \n longMessage: bool\n \n maxDiff: Optional[int]\n \n _testMethodName: str\n \n _testMethodDoc: str\n \n assertEqual(first: Any, second: Any, msg: Any=...) -> None\n \n assertTrue(expr: Any, msg: Any=...) -> None\n \n "}}},{"rowIdx":1895,"cells":{"path":{"kind":"string","value":"examples.server/QuicServerProtocol.__init__"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"04bd90cd0c36e80d68adfc2d0adac3fabd6cbae6"},"commit_message":{"kind":"string","value":"[examples] add optional stateless retry to server"},"ground_truth":{"kind":"string","value":" <2>: self._retry_key = None\n"},"main_code":{"kind":"string","value":" # module: examples.server\n class QuicServerProtocol(asyncio.DatagramProtocol):\n + def __init__(self, retry=False, **kwargs):\n - def __init__(self, **kwargs):\n <0> self._connections = {}\n <1> self._kwargs = kwargs\n <2> self._transport = None\n <3> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: asyncio.protocols\n DatagramProtocol()\n \n "}}},{"rowIdx":1896,"cells":{"path":{"kind":"string","value":"examples.server/QuicServerProtocol.datagram_received"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"04bd90cd0c36e80d68adfc2d0adac3fabd6cbae6"},"commit_message":{"kind":"string","value":"[examples] add optional stateless retry to server"},"ground_truth":{"kind":"string","value":"<20>: # stateless retry\n if self._retry_key is not None:\n retry_message = str(addr).encode(\"ascii\")\n if not header.token:\n logger.info(\"Sending retry to %s\" % (addr,))\n retry_token = self._retry_key.sign(\n retry_message,\n padding.PSS(\n mgf=padding.MGF1(hashes.SHA256()),\n salt_length=padding.PSS.MAX_LENGTH,\n ),\n hashes.SHA256(),\n )\n self._transport.sendto(\n encode_quic_retry(\n version=header.version,\n source_cid=os.urandom(8),\n destination_cid=header.source_cid,\n original_destination_cid=header.destination_cid,\n retry_token=retry_token,\n ),\n addr,"},"main_code":{"kind":"string","value":" # module: examples.server\n class QuicServerProtocol(asyncio.DatagramProtocol):\n def datagram_received(self, datagram, addr):\n <0> buf = Buffer(data=datagram)\n <1> header = pull_quic_header(buf, host_cid_length=8)\n <2> \n <3> # version negotiation\n <4> if (\n <5> header.version is not None\n <6> and header.version not in QuicConnection.supported_versions\n <7> ):\n <8> self._transport.sendto(\n <9> encode_quic_version_negotiation(\n<10> source_cid=header.destination_cid,\n<11> destination_cid=header.source_cid,\n<12> supported_versions=QuicConnection.supported_versions,\n<13> ),\n<14> addr,\n<15> )\n<16> return\n<17> \n<18> connection = self._connections.get(header.destination_cid, None)\n<19> if connection is None and header.packet_type == PACKET_TYPE_INITIAL:\n<20> # create new connection\n<21> connection = QuicConnection(is_client=False, **self._kwargs)\n<22> connection.connection_made(self._transport)\n<23> connection.stream_created_cb = self.stream_created\n<24> self._connections[connection.host_cid] = connection\n<25> logger.info(\"%s New connection from %s\" % (connection_id(connection), addr))\n<26> \n<27> if connection is not None:\n<28> connection.datagram_received(datagram, addr)\n<29> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.connection\n QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)\n \n at: aioquic.connection.QuicConnection\n supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]\n \n at: aioquic.packet\n PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00\n \n pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader\n \n encode_quic_version_negotiation(source_cid: bytes, destination_cid: bytes, supported_versions: List[QuicProtocolVersion]) -> bytes\n \n at: aioquic.packet.QuicHeader\n version: Optional[int]\n \n packet_type: int\n \n destination_cid: bytes\n \n source_cid: bytes\n \n original_destination_cid: bytes = b\"\"\n \n token: bytes = b\"\"\n \n rest_length: int = 0\n \n at: asyncio.protocols.BaseProtocol\n __slots__ = ()\n \n connection_made(self, transport: transports.BaseTransport) -> None\n \n at: asyncio.protocols.DatagramProtocol\n __slots__ = ()\n \n datagram_received(self, data: bytes, addr: Tuple[str, int]) -> None\n \n at: examples.server.QuicServerProtocol.__init__\n self._connections = {}\n \n self._transport = None\n \n at: typing.Mapping\n get(key: _KT, default: Union[_VT_co, _T]) -> Union[_VT_co, _T]\n get(key: _KT) -> Optional[_VT_co]\n \n \n===========changed ref 0===========\n # module: examples.server\n class QuicServerProtocol(asyncio.DatagramProtocol):\n + def __init__(self, retry=False, **kwargs):\n - def __init__(self, **kwargs):\n self._connections = {}\n self._kwargs = kwargs\n + self._retry_key = None\n self._transport = None\n "}}},{"rowIdx":1897,"cells":{"path":{"kind":"string","value":"aioquic.tls/decode_public_key"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"fbaa66415943136a608862f4d998c245d216b21e"},"commit_message":{"kind":"string","value":"[tls] add support for X25519"},"ground_truth":{"kind":"string","value":" <0>: if key_share[0] == Group.X25519:\n return x25519.X25519PublicKey.from_public_bytes(key_share[1])\n"},"main_code":{"kind":"string","value":" # module: aioquic.tls\n + def decode_public_key(\n + key_share: KeyShareEntry\n + ) -> Union[ec.EllipticCurvePublicKey, x25519.X25519PublicKey]:\n - def decode_public_key(key_share: KeyShareEntry) -> ec.EllipticCurvePublicKey:\n <0> return ec.EllipticCurvePublicKey.from_encoded_point(\n <1> GROUP_TO_CURVE[key_share[0]](), key_share[1]\n <2> )\n <3> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.tls\n Group(x: Union[str, bytes, bytearray], base: int)\n Group(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n KeyShareEntry = Tuple[Group, bytes]\n \n "}}},{"rowIdx":1898,"cells":{"path":{"kind":"string","value":"aioquic.tls/encode_public_key"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"fbaa66415943136a608862f4d998c245d216b21e"},"commit_message":{"kind":"string","value":"[tls] add support for X25519"},"ground_truth":{"kind":"string","value":" <0>: if isinstance(public_key, x25519.X25519PublicKey):\n return (Group.X25519, public_key.public_bytes(Encoding.Raw, PublicFormat.Raw))\n"},"main_code":{"kind":"string","value":" # module: aioquic.tls\n + def encode_public_key(\n + public_key: Union[ec.EllipticCurvePublicKey, x25519.X25519PublicKey]\n + ) -> KeyShareEntry:\n - def encode_public_key(public_key: ec.EllipticCurvePublicKey) -> KeyShareEntry:\n <0> return (\n <1> CURVE_TO_GROUP[public_key.curve.__class__],\n <2> public_key.public_bytes(Encoding.X962, PublicFormat.UncompressedPoint),\n <3> )\n <4> \n "},"context":{"kind":"string","value":"===========unchanged ref 0===========\n at: aioquic.tls\n GROUP_TO_CURVE = {\n Group.SECP256R1: ec.SECP256R1,\n Group.SECP384R1: ec.SECP384R1,\n Group.SECP521R1: ec.SECP521R1,\n }\n \n \n===========changed ref 0===========\n # module: aioquic.tls\n + def decode_public_key(\n + key_share: KeyShareEntry\n + ) -> Union[ec.EllipticCurvePublicKey, x25519.X25519PublicKey]:\n - def decode_public_key(key_share: KeyShareEntry) -> ec.EllipticCurvePublicKey:\n + if key_share[0] == Group.X25519:\n + return x25519.X25519PublicKey.from_public_bytes(key_share[1])\n return ec.EllipticCurvePublicKey.from_encoded_point(\n GROUP_TO_CURVE[key_share[0]](), key_share[1]\n )\n "}}},{"rowIdx":1899,"cells":{"path":{"kind":"string","value":"aioquic.tls/Context.__init__"},"type":{"kind":"string","value":"Modified"},"project":{"kind":"string","value":"aiortc~aioquic"},"commit_hash":{"kind":"string","value":"fbaa66415943136a608862f4d998c245d216b21e"},"commit_message":{"kind":"string","value":"[tls] add support for X25519"},"ground_truth":{"kind":"string","value":"<26>: self._supported_groups = [Group.SECP256R1]\n<35>: self._ec_private_key: Optional[ec.EllipticCurvePrivateKey] = None\n self._x25519_private_key: Optional[x25519.X25519PrivateKey] = None\n \n"},"main_code":{"kind":"string","value":" # module: aioquic.tls\n class Context:\n def __init__(self, is_client: bool, logger: logging.Logger = None):\n <0> self.alpn_protocols: Optional[List[str]] = None\n <1> self.certificate: Optional[x509.Certificate] = None\n <2> self.certificate_private_key: Optional[\n <3> Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]\n <4> ] = None\n <5> self.handshake_extensions: List[Extension] = []\n <6> self.is_client = is_client\n <7> self.key_schedule: Optional[KeySchedule] = None\n <8> self.received_extensions: List[Extension] = []\n <9> self.server_name: Optional[str] = None\n<10> self.update_traffic_key_cb: Callable[\n<11> [Direction, Epoch, bytes], None\n<12> ] = lambda d, e, s: None\n<13> \n<14> self._cipher_suites = [\n<15> CipherSuite.AES_256_GCM_SHA384,\n<16> CipherSuite.AES_128_GCM_SHA256,\n<17> CipherSuite.CHACHA20_POLY1305_SHA256,\n<18> ]\n<19> self._compression_methods = [CompressionMethod.NULL]\n<20> self._key_exchange_modes = [KeyExchangeMode.PSK_DHE_KE]\n<21> self._signature_algorithms = [\n<22> SignatureAlgorithm.RSA_PSS_RSAE_SHA256,\n<23> SignatureAlgorithm.RSA_PKCS1_SHA256,\n<24> SignatureAlgorithm.RSA_PKCS1_SHA1,\n<25> ]\n<26> self._supported_versions = [TLS_VERSION_1_3]\n<27> \n<28> self._key_schedule_proxy: Optional[KeyScheduleProxy] = None\n<29> self._peer_certificate: Optional[x509.Certificate] = None\n<30> self._receive_buffer = b\"\"\n<31> self._enc_key: Optional[bytes] = None\n<32> self._dec_key: Optional[bytes] = None\n<33> self.__logger = logger\n<34> \n<35> if is_client:\n "},"context":{"kind":"string","value":"===========below chunk 0===========\n # module: aioquic.tls\n class Context:\n def __init__(self, is_client: bool, logger: logging.Logger = None):\n # offset: 1\n self.session_id = os.urandom(32)\n self.private_key = ec.generate_private_key(\n ec.SECP256R1(), default_backend()\n )\n self.state = State.CLIENT_HANDSHAKE_START\n else:\n self.client_random = None\n self.session_id = None\n self.private_key = None\n self.state = State.SERVER_EXPECT_CLIENT_HELLO\n \n \n===========unchanged ref 0===========\n at: aioquic.buffer\n Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)\n \n at: aioquic.buffer.Buffer\n data_slice(start: int, end: int) -> bytes\n \n tell() -> int\n \n at: aioquic.tls\n TLS_VERSION_1_3 = 0x0304\n \n Direction()\n \n Epoch()\n \n CipherSuite(x: Union[str, bytes, bytearray], base: int)\n CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n CompressionMethod(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n CompressionMethod(x: Union[str, bytes, bytearray], base: int)\n \n Group(x: Union[str, bytes, bytearray], base: int)\n Group(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n KeyExchangeMode(x: Union[str, bytes, bytearray], base: int)\n KeyExchangeMode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n SignatureAlgorithm(x: Union[str, bytes, bytearray], base: int)\n SignatureAlgorithm(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)\n \n Extension = Tuple[int, bytes]\n \n KeySchedule(cipher_suite: CipherSuite)\n \n KeyScheduleProxy(cipher_suites: List[CipherSuite])\n \n at: aioquic.tls.Context._client_handle_certificate\n self._peer_certificate = x509.load_der_x509_certificate(\n certificate.certificates[0][0], backend=default_backend()\n )\n \n at: aioquic.tls.Context._client_handle_encrypted_extensions\n self.received_extensions = encrypted_extensions.other_extensions\n \n at: aioquic.tls.Context._client_handle_finished\n self._enc_key = next_enc_key\n \n \n===========unchanged ref 1===========\n at: aioquic.tls.Context._client_handle_hello\n self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)\n \n at: aioquic.tls.Context._client_send_hello\n self._ec_private_key = ec.generate_private_key(\n GROUP_TO_CURVE[Group.SECP256R1](), default_backend()\n )\n \n self._x25519_private_key = x25519.X25519PrivateKey.generate()\n \n self._key_schedule_proxy = KeyScheduleProxy(hello.cipher_suites)\n \n at: aioquic.tls.Context._server_handle_finished\n self._dec_key = self._next_dec_key\n \n at: aioquic.tls.Context._server_handle_hello\n self.received_extensions = peer_hello.other_extensions\n \n self.key_schedule = KeySchedule(cipher_suite)\n \n self._x25519_private_key = x25519.X25519PrivateKey.generate()\n \n self._ec_private_key = ec.generate_private_key(\n GROUP_TO_CURVE[key_share[0]](), default_backend()\n )\n \n at: aioquic.tls.Context._setup_traffic_protection\n self._enc_key = key\n \n self._dec_key = key\n \n at: aioquic.tls.Context.handle_message\n self._receive_buffer += input_data\n self._receive_buffer = self._receive_buffer[message_length:]\n \n at: aioquic.tls.KeySchedule\n update_hash(data: bytes) -> None\n \n at: aioquic.tls.KeyScheduleProxy\n update_hash(data: bytes) -> None\n \n at: logging\n Logger(name: str, level: _Level=...)\n \n at: typing\n Callable = _CallableType(collections.abc.Callable, 2)\n \n List = _alias(list, 1, inst=False, name='List')\n \n Generator = _alias(collections.abc.Generator, 3)\n \n \n===========changed ref 0===========\n # module: aioquic.tls\n + def decode_public_key(\n + key_share: KeyShareEntry\n + ) -> Union[ec.EllipticCurvePublicKey, x25519.X25519PublicKey]:\n - def decode_public_key(key_share: KeyShareEntry) -> ec.EllipticCurvePublicKey:\n + if key_share[0] == Group.X25519:\n + return x25519.X25519PublicKey.from_public_bytes(key_share[1])\n return ec.EllipticCurvePublicKey.from_encoded_point(\n GROUP_TO_CURVE[key_share[0]](), key_share[1]\n )\n \n===========changed ref 1===========\n # module: aioquic.tls\n + def encode_public_key(\n + public_key: Union[ec.EllipticCurvePublicKey, x25519.X25519PublicKey]\n + ) -> KeyShareEntry:\n - def encode_public_key(public_key: ec.EllipticCurvePublicKey) -> KeyShareEntry:\n + if isinstance(public_key, x25519.X25519PublicKey):\n + return (Group.X25519, public_key.public_bytes(Encoding.Raw, PublicFormat.Raw))\n return (\n CURVE_TO_GROUP[public_key.curve.__class__],\n public_key.public_bytes(Encoding.X962, PublicFormat.UncompressedPoint),\n )\n "}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":18,"numItemsPerPage":100,"numTotalItems":7800,"offset":1800,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc1NjkwNDg4OCwic3ViIjoiL2RhdGFzZXRzL2tyYWFsZmFyL0NvZWRpdG9yLXByb2Nlc3NlZC1kZW1vMiIsImV4cCI6MTc1NjkwODQ4OCwiaXNzIjoiaHR0cHM6Ly9odWdnaW5nZmFjZS5jbyJ9.J9hPZeWvQAWilkRDQ8a_RZrMj7tnHJrQrSMxnmDWRPidzTwZ1dFGfMwmPM9K8T52P_XK2lS12OScrKmYHSBgCA","displayUrls":true},"discussionsStats":{"closed":0,"open":1,"total":1},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">

path
stringlengths
9
117
type
stringclasses
2 values
project
stringclasses
10 values
commit_hash
stringlengths
40
40
commit_message
stringlengths
1
137
ground_truth
stringlengths
0
2.74k
main_code
stringlengths
102
3.37k
context
stringlengths
0
14.7k
aioquic.connection/QuicConnection.connection_made
Modified
aiortc~aioquic
f12180ae527f69ee085df5007a46d26154ced102
[connection] make QuicConnection.connect() trigger handshake
<0>:<del> """ <1>:<del> Inform the connection of the transport used to send data. This object <2>:<del> must have a ``sendto`` method which accepts a datagram to send. <3>:<add> self.__transport = cast(asyncio.DatagramTransport, transport) <4>:<del> Calling :meth:`connection_made` on a client starts the TLS handshake. <5>:<del> """ <6>:<del> self.__transport = transport <7>:<del> if self.is_client: <8>:<del> self._version = max(self.supported_versions) <9>:<del> self._connect() <10>:<del>
# module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def connection_made(self, transport: asyncio.BaseTransport) -> None: - def connection_made(self, transport: asyncio.DatagramTransport) -> None: <0> """ <1> Inform the connection of the transport used to send data. This object <2> must have a ``sendto`` method which accepts a datagram to send. <3> <4> Calling :meth:`connection_made` on a client starts the TLS handshake. <5> """ <6> self.__transport = transport <7> if self.is_client: <8> self._version = max(self.supported_versions) <9> self._connect() <10>
===========unchanged ref 0=========== at: aioquic.connection.QuicConnection.__init__ self.stream_created_cb: Callable[ [asyncio.StreamReader, asyncio.StreamWriter], None ] = lambda r, w: None at: aioquic.connection.QuicConnection.create_stream stream_id += 4 stream_id = (int(is_unidirectional) << 1) | int(not self.is_client) max_stream_data_local = 0 max_stream_data_local = self._local_max_stream_data_bidi_local max_stream_data_remote = self._remote_max_stream_data_bidi_remote max_stream_data_remote = self._remote_max_stream_data_uni 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, ) at: aioquic.stream.QuicStream.__init__ self.reader = asyncio.StreamReader() self.reader = None self.writer = None self.writer = asyncio.StreamWriter(self, None, self.reader, None) ===========changed ref 0=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def connect(self, addr: Any) -> None: - def connect(self) -> None: """ + Initiate the TLS handshake and wait for it to complete. - Wait for the TLS handshake to complete. """ + self._peer_addr = addr + self._version = max(self.supported_versions) + self._connect() await self.__connected.wait()
aioquic.connection/QuicConnection.datagram_received
Modified
aiortc~aioquic
f12180ae527f69ee085df5007a46d26154ced102
[connection] make QuicConnection.connect() trigger handshake
<3>:<del> buf = Buffer(data=data) <4>:<del> <9>:<add> data = cast(bytes, data) <add> buf = Buffer(data=data)
# module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: - def datagram_received(self, data: bytes, addr: Any) -> None: <0> """ <1> Handle an incoming datagram. <2> """ <3> buf = Buffer(data=data) <4> <5> # stop handling packets when closing <6> if self.__state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]: <7> return <8> <9> while not buf.eof(): <10> start_off = buf.tell() <11> header = pull_quic_header(buf, host_cid_length=len(self.host_cid)) <12> <13> # check destination CID matches <14> if self.is_client and header.destination_cid != self.host_cid: <15> return <16> <17> # check protocol version <18> if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION: <19> # version negotiation <20> versions = [] <21> while not buf.eof(): <22> versions.append(pull_uint32(buf)) <23> common = set(self.supported_versions).intersection(versions) <24> if not common: <25> self.__logger.error("Could not find a common protocol version") <26> return <27> self._version = QuicProtocolVersion(max(common)) <28> self.__logger.info("Retrying with %s", self._version) <29> self._connect() <30> return <31> elif ( <32> header.version is not None <33> and header.version not in self.supported_versions <34> ): <35> # unsupported version <36> return <37> <38> if self.is_client and header.packet_type == PACKET_TYPE_RETRY: <39> # stateless retry <40> if ( <41> header.destination_cid == self.host_cid <42> and header.original_destination_cid == self.peer_cid <43> ): <44> </s>
===========below chunk 0=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: - def datagram_received(self, data: bytes, addr: Any) -> None: # offset: 1 self.peer_cid = header.source_cid self.peer_token = header.token self._connect() return # server initialization if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT: assert ( header.packet_type == PACKET_TYPE_INITIAL ), "first packet must be INITIAL" self._peer_addr = addr self._version = QuicProtocolVersion(header.version) self._initialize(header.destination_cid) # decrypt packet encrypted_off = buf.tell() - start_off end_off = buf.tell() + header.rest_length pull_bytes(buf, header.rest_length) epoch = get_epoch(header.packet_type) space = self.spaces[epoch] if not space.crypto.recv.is_valid(): return try: plain_header, plain_payload, packet_number = space.crypto.decrypt_packet( data[start_off:end_off], encrypted_off ) except CryptoError as exc: self.__logger.warning(exc) return if not self.peer_cid_set: self.peer_cid = header.source_cid self.peer_cid_set = True # update state if self.__state == QuicConnectionState.FIRSTFLIGHT: self._set_state(QuicConnectionState.CONNECTED) # update spin bit if ( not is_long_header(plain_header[0]) and packet_number > self._spin_highest_pn ): if self.is_client: self._spin_bit = not get_spin_bit(plain</s> ===========below chunk 1=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: - def datagram_received(self, data: bytes, addr: Any) -> None: # offset: 2 <s>pn ): if self.is_client: self._spin_bit = not get_spin_bit(plain_header[0]) else: self._spin_bit = get_spin_bit(plain_header[0]) self._spin_highest_pn = packet_number # handle payload try: is_ack_only = self._payload_received(epoch, plain_payload) except QuicConnectionError as exc: self.__logger.warning(exc) self.close( error_code=exc.error_code, frame_type=exc.frame_type, reason_phrase=exc.reason_phrase, ) return # record packet as received space.ack_queue.add(packet_number) if not is_ack_only: self.send_ack[epoch] = True self._send_pending() ===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) pull_bytes(buf: Buffer, length: int) -> bytes pull_uint32(buf: Buffer) -> int at: aioquic.buffer.Buffer eof() -> bool tell() -> int at: aioquic.connection get_epoch(packet_type: int) -> tls.Epoch QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) QuicConnectionState() at: aioquic.connection.PacketSpace.__init__ self.crypto = CryptoPair() at: aioquic.connection.QuicConnection supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20] close(error_code: int=QuicErrorCode.NO_ERROR, frame_type: Optional[int]=None, reason_phrase: str="") -> None _connect() -> None _initialize(peer_cid: bytes) -> None _payload_received(epoch: tls.Epoch, plain: bytes) -> bool _set_state(state: QuicConnectionState) -> None at: aioquic.connection.QuicConnection.__init__ self.is_client = is_client self.host_cid = os.urandom(8) self.peer_cid = os.urandom(8) self.peer_cid_set = False self.peer_token = b"" self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} self.__logger = logger self._peer_addr: Optional[Any] = None self._spin_bit = False self._spin_highest_pn = 0 self.__state = QuicConnectionState.FIRSTFLIGHT self.__transport: Optional[asyncio.DatagramTransport] = None self._version: Optional[int] = None ===========unchanged ref 1=========== at: aioquic.connection.QuicConnection._initialize self.spaces = { tls.Epoch.INITIAL: PacketSpace(), tls.Epoch.HANDSHAKE: PacketSpace(), tls.Epoch.ONE_RTT: PacketSpace(), } at: aioquic.connection.QuicConnection._set_state self.__state = state at: aioquic.connection.QuicConnection.connect self._peer_addr = addr self._version = max(self.supported_versions) at: aioquic.connection.QuicConnectionError.__init__ self.error_code = error_code self.frame_type = frame_type self.reason_phrase = reason_phrase at: aioquic.crypto CryptoError(*args: object) at: aioquic.crypto.CryptoContext is_valid() -> bool at: aioquic.crypto.CryptoPair decrypt_packet(packet: bytes, encrypted_offset: int) -> Tuple[bytes, bytes, int] at: aioquic.crypto.CryptoPair.__init__ self.recv = CryptoContext() at: aioquic.packet PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00 PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30 QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int) QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) get_spin_bit(first_byte: int) -> bool is_long_header(first_byte: int) -> bool pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader at: aioquic.packet.QuicHeader version: Optional[int] packet_type: int destination_cid: bytes source_cid: bytes original_destination_cid: bytes = b""
tests.test_connection/create_standalone_client
Modified
aiortc~aioquic
f12180ae527f69ee085df5007a46d26154ced102
[connection] make QuicConnection.connect() trigger handshake
<3>:<add> <add> client._peer_addr = SERVER_ADDR <add> client._version = max(client.supported_versions) <add> client._connect() <add>
# module: tests.test_connection def create_standalone_client(): <0> client = QuicConnection(is_client=True) <1> client_transport = FakeTransport(CLIENT_ADDR) <2> client.connection_made(client_transport) <3> return client, client_transport <4>
===========unchanged ref 0=========== at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20] connection_made(transport: asyncio.BaseTransport) -> None at: tests.test_connection CLIENT_ADDR = None FakeTransport(local_addr) ===========changed ref 0=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def connection_made(self, transport: asyncio.BaseTransport) -> None: - def connection_made(self, transport: asyncio.DatagramTransport) -> None: - """ - Inform the connection of the transport used to send data. This object - must have a ``sendto`` method which accepts a datagram to send. + self.__transport = cast(asyncio.DatagramTransport, transport) - Calling :meth:`connection_made` on a client starts the TLS handshake. - """ - self.__transport = transport - if self.is_client: - self._version = max(self.supported_versions) - self._connect() - ===========changed ref 1=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def connect(self, addr: Any) -> None: - def connect(self) -> None: """ + Initiate the TLS handshake and wait for it to complete. - Wait for the TLS handshake to complete. """ + self._peer_addr = addr + self._version = max(self.supported_versions) + self._connect() await self.__connected.wait() ===========changed ref 2=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: - def datagram_received(self, data: bytes, addr: Any) -> None: """ Handle an incoming datagram. """ - buf = Buffer(data=data) - # 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 if self.is_client and header.destination_cid != self.host_cid: 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.__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 ): self.__logger.info("Performing stateless retry") self.peer_cid =</s> ===========changed ref 3=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: - def datagram_received(self, data: bytes, addr: Any) -> None: # offset: 1 <s>.peer_cid ): self.__logger.info("Performing stateless retry") self.peer_cid = header.source_cid self.peer_token = header.token self._connect() return # server initialization if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT: assert ( header.packet_type == PACKET_TYPE_INITIAL ), "first packet must be INITIAL" self._peer_addr = addr self._version = QuicProtocolVersion(header.version) self._initialize(header.destination_cid) # decrypt packet encrypted_off = buf.tell() - start_off end_off = buf.tell() + header.rest_length pull_bytes(buf, header.rest_length) epoch = get_epoch(header.packet_type) space = self.spaces[epoch] if not space.crypto.recv.is_valid(): return try: plain_header, plain_payload, packet_number = space.crypto.decrypt_packet( data[start_off:end_off], encrypted_off ) except CryptoError as exc: self.__logger.warning(exc) return if not self.peer_cid_set: self.peer_cid = header.source_cid self.peer_cid_set = True # update state if self.__state == QuicConnectionState.FIRSTFLIGHT: self._set_state(QuicConnectionState.CONNECTED) # update spin bit if ( not</s> ===========changed ref 4=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: - def datagram_received(self, data: bytes, addr: Any) -> None: # offset: 2 <s>long_header(plain_header[0]) and packet_number > self._spin_highest_pn ): if self.is_client: self._spin_bit = not get_spin_bit(plain_header[0]) else: self._spin_bit = get_spin_bit(plain_header[0]) self._spin_highest_pn = packet_number # handle payload try: is_ack_only = self._payload_received(epoch, plain_payload) except QuicConnectionError as exc: self.__logger.warning(exc) self.close( error_code=exc.error_code, frame_type=exc.frame_type, reason_phrase=exc.reason_phrase, ) return # record packet as received space.ack_queue.add(packet_number) if not is_ack_only: self.send_ack[epoch] = True self._send_pending()
tests.test_connection/create_transport
Modified
aiortc~aioquic
f12180ae527f69ee085df5007a46d26154ced102
[connection] make QuicConnection.connect() trigger handshake
<9>:<add> client._peer_addr = SERVER_ADDR <add> client._version = max(client.supported_versions) <add> client._connect() <add>
# module: tests.test_connection def create_transport(client, server): <0> client_transport = FakeTransport(CLIENT_ADDR) <1> client_transport.target = server <2> <3> server_transport = FakeTransport(SERVER_ADDR) <4> server_transport.target = client <5> <6> server.connection_made(server_transport) <7> client.connection_made(client_transport) <8> <9> return client_transport, server_transport <10>
===========unchanged ref 0=========== at: aioquic.connection.QuicConnection _connect() -> None at: tests.test_connection CLIENT_ADDR = None SERVER_ADDR = None FakeTransport(local_addr) at: tests.test_connection.FakeTransport sent = 0 target = None at: tests.test_connection.create_standalone_client client = QuicConnection(is_client=True) client_transport = FakeTransport(CLIENT_ADDR) ===========changed ref 0=========== # module: tests.test_connection def create_standalone_client(): client = QuicConnection(is_client=True) client_transport = FakeTransport(CLIENT_ADDR) client.connection_made(client_transport) + + client._peer_addr = SERVER_ADDR + client._version = max(client.supported_versions) + client._connect() + return client, client_transport ===========changed ref 1=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def connect(self, addr: Any) -> None: - def connect(self) -> None: """ + Initiate the TLS handshake and wait for it to complete. - Wait for the TLS handshake to complete. """ + self._peer_addr = addr + self._version = max(self.supported_versions) + self._connect() await self.__connected.wait() ===========changed ref 2=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def connection_made(self, transport: asyncio.BaseTransport) -> None: - def connection_made(self, transport: asyncio.DatagramTransport) -> None: - """ - Inform the connection of the transport used to send data. This object - must have a ``sendto`` method which accepts a datagram to send. + self.__transport = cast(asyncio.DatagramTransport, transport) - Calling :meth:`connection_made` on a client starts the TLS handshake. - """ - self.__transport = transport - if self.is_client: - self._version = max(self.supported_versions) - self._connect() - ===========changed ref 3=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: - def datagram_received(self, data: bytes, addr: Any) -> None: """ Handle an incoming datagram. """ - buf = Buffer(data=data) - # 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 if self.is_client and header.destination_cid != self.host_cid: 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.__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 ): self.__logger.info("Performing stateless retry") self.peer_cid =</s> ===========changed ref 4=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: - def datagram_received(self, data: bytes, addr: Any) -> None: # offset: 1 <s>.peer_cid ): self.__logger.info("Performing stateless retry") self.peer_cid = header.source_cid self.peer_token = header.token self._connect() return # server initialization if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT: assert ( header.packet_type == PACKET_TYPE_INITIAL ), "first packet must be INITIAL" self._peer_addr = addr self._version = QuicProtocolVersion(header.version) self._initialize(header.destination_cid) # decrypt packet encrypted_off = buf.tell() - start_off end_off = buf.tell() + header.rest_length pull_bytes(buf, header.rest_length) epoch = get_epoch(header.packet_type) space = self.spaces[epoch] if not space.crypto.recv.is_valid(): return try: plain_header, plain_payload, packet_number = space.crypto.decrypt_packet( data[start_off:end_off], encrypted_off ) except CryptoError as exc: self.__logger.warning(exc) return if not self.peer_cid_set: self.peer_cid = header.source_cid self.peer_cid_set = True # update state if self.__state == QuicConnectionState.FIRSTFLIGHT: self._set_state(QuicConnectionState.CONNECTED) # update spin bit if ( not</s> ===========changed ref 5=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: - def datagram_received(self, data: bytes, addr: Any) -> None: # offset: 2 <s>long_header(plain_header[0]) and packet_number > self._spin_highest_pn ): if self.is_client: self._spin_bit = not get_spin_bit(plain_header[0]) else: self._spin_bit = get_spin_bit(plain_header[0]) self._spin_highest_pn = packet_number # handle payload try: is_ack_only = self._payload_received(epoch, plain_payload) except QuicConnectionError as exc: self.__logger.warning(exc) self.close( error_code=exc.error_code, frame_type=exc.frame_type, reason_phrase=exc.reason_phrase, ) return # record packet as received space.ack_queue.add(packet_number) if not is_ack_only: self.send_ack[epoch] = True self._send_pending()
tests.test_connection/QuicConnectionTest._test_connect_with_version
Modified
aiortc~aioquic
f12180ae527f69ee085df5007a46d26154ced102
[connection] make QuicConnection.connect() trigger handshake
<14>:<del> run(client.connect())
# module: tests.test_connection class QuicConnectionTest(TestCase): def _test_connect_with_version(self, client_versions, server_versions): <0> client = QuicConnection(is_client=True) <1> client.supported_versions = client_versions <2> <3> server = QuicConnection( <4> is_client=False, <5> certificate=SERVER_CERTIFICATE, <6> private_key=SERVER_PRIVATE_KEY, <7> ) <8> server.supported_versions = server_versions <9> <10> # perform handshake <11> client_transport, server_transport = create_transport(client, server) <12> self.assertEqual(client_transport.sent, 4) <13> self.assertEqual(server_transport.sent, 4) <14> run(client.connect()) <15> <16> # send data over stream <17> client_reader, client_writer = client.create_stream() <18> client_writer.write(b"ping") <19> run(asyncio.sleep(0)) <20> self.assertEqual(client_transport.sent, 5) <21> self.assertEqual(server_transport.sent, 5) <22> <23> # FIXME: needs an API <24> server_reader, server_writer = ( <25> server.streams[0].reader, <26> server.streams[0].writer, <27> ) <28> self.assertEqual(run(server_reader.read(1024)), b"ping") <29> server_writer.write(b"pong") <30> run(asyncio.sleep(0)) <31> self.assertEqual(client_transport.sent, 6) <32> self.assertEqual(server_transport.sent, 6) <33> <34> # client receives pong <35> self.assertEqual(run(client_reader.read(1024)), b"pong") <36> <37> # client writes EOF <38> client_writer.write_eof() <39> run(asyncio.sleep(0)) <40> self.assertEqual(client_transport.sent, 7) <41> self.assertEqual(server_transport.sent, 7) <42> <43> </s>
===========below chunk 0=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def _test_connect_with_version(self, client_versions, server_versions): # offset: 1 self.assertEqual(run(server_reader.read()), b"") ===========unchanged ref 0=========== at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20] create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] _connect() -> None at: aioquic.connection.QuicConnection.__init__ self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} self._peer_addr: Optional[Any] = None self._version: Optional[int] = None at: aioquic.connection.QuicConnection.connect self._peer_addr = addr self._version = max(self.supported_versions) at: aioquic.connection.QuicConnection.datagram_received self._version = QuicProtocolVersion(header.version) self._version = QuicProtocolVersion(max(common)) self._peer_addr = addr at: aioquic.stream.QuicStream.__init__ self.reader = asyncio.StreamReader() self.reader = None self.writer = None self.writer = asyncio.StreamWriter(self, None, self.reader, None) at: asyncio.streams.StreamReader _source_traceback = None read(n: int=...) -> bytes at: asyncio.streams.StreamWriter write(data: bytes) -> None at: asyncio.tasks sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T] at: tests.test_connection SERVER_ADDR = None ===========unchanged ref 1=========== SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) create_transport(client, server) at: tests.test_connection.FakeTransport.sendto self.sent += 1 at: tests.test_connection.create_transport client_transport = FakeTransport(CLIENT_ADDR) server_transport = FakeTransport(SERVER_ADDR) at: tests.utils run(coro) at: unittest.case TestCase(methodName: str=...) at: unittest.case.TestCase failureException: Type[BaseException] longMessage: bool maxDiff: Optional[int] _testMethodName: str _testMethodDoc: str assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) + client._peer_addr = SERVER_ADDR + client._version = max(client.supported_versions) + client._connect() + return client_transport, server_transport ===========changed ref 1=========== # module: tests.test_connection def create_standalone_client(): client = QuicConnection(is_client=True) client_transport = FakeTransport(CLIENT_ADDR) client.connection_made(client_transport) + + client._peer_addr = SERVER_ADDR + client._version = max(client.supported_versions) + client._connect() + return client, client_transport ===========changed ref 2=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def connect(self, addr: Any) -> None: - def connect(self) -> None: """ + Initiate the TLS handshake and wait for it to complete. - Wait for the TLS handshake to complete. """ + self._peer_addr = addr + self._version = max(self.supported_versions) + self._connect() await self.__connected.wait() ===========changed ref 3=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def connection_made(self, transport: asyncio.BaseTransport) -> None: - def connection_made(self, transport: asyncio.DatagramTransport) -> None: - """ - Inform the connection of the transport used to send data. This object - must have a ``sendto`` method which accepts a datagram to send. + self.__transport = cast(asyncio.DatagramTransport, transport) - Calling :meth:`connection_made` on a client starts the TLS handshake. - """ - self.__transport = transport - if self.is_client: - self._version = max(self.supported_versions) - self._connect() - ===========changed ref 4=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: - def datagram_received(self, data: bytes, addr: Any) -> None: """ Handle an incoming datagram. """ - buf = Buffer(data=data) - # 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 if self.is_client and header.destination_cid != self.host_cid: 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.__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 ): self.__logger.info("Performing stateless retry") self.peer_cid =</s>
tests.test_connection/QuicConnectionTest.test_connection_lost
Modified
aiortc~aioquic
f12180ae527f69ee085df5007a46d26154ced102
[connection] make QuicConnection.connect() trigger handshake
<11>:<del> run(client.connect())
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> self.assertEqual(client_transport.sent, 4) <10> self.assertEqual(server_transport.sent, 4) <11> run(client.connect()) <12> <13> # send data over stream <14> client_reader, client_writer = client.create_stream() <15> client_writer.write(b"ping") <16> run(asyncio.sleep(0)) <17> self.assertEqual(client_transport.sent, 5) <18> self.assertEqual(server_transport.sent, 5) <19> <20> # break connection <21> client.connection_lost(None) <22> self.assertEqual(run(client_reader.read()), b"") <23>
===========unchanged ref 0=========== at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] at: asyncio.streams.StreamWriter write(data: bytes) -> None at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) create_transport(client, server) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) + client._peer_addr = SERVER_ADDR + client._version = max(client.supported_versions) + client._connect() + return client_transport, server_transport ===========changed ref 1=========== # module: tests.test_connection def create_standalone_client(): client = QuicConnection(is_client=True) client_transport = FakeTransport(CLIENT_ADDR) client.connection_made(client_transport) + + client._peer_addr = SERVER_ADDR + client._version = max(client.supported_versions) + client._connect() + return client, client_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def _test_connect_with_version(self, client_versions, server_versions): client = QuicConnection(is_client=True) client.supported_versions = client_versions server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) server.supported_versions = server_versions # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) - run(client.connect()) # send data over stream client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # FIXME: needs an API server_reader, server_writer = ( server.streams[0].reader, server.streams[0].writer, ) self.assertEqual(run(server_reader.read(1024)), b"ping") server_writer.write(b"pong") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 6) self.assertEqual(server_transport.sent, 6) # client receives pong self.assertEqual(run(client_reader.read(1024)), b"pong") # client writes EOF client_writer.write_eof() run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 7) self.assertEqual(server_transport.sent, 7) # server receives EOF self.assertEqual(run(server_reader.read()), b"") ===========changed ref 3=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def connect(self, addr: Any) -> None: - def connect(self) -> None: """ + Initiate the TLS handshake and wait for it to complete. - Wait for the TLS handshake to complete. """ + self._peer_addr = addr + self._version = max(self.supported_versions) + self._connect() await self.__connected.wait() ===========changed ref 4=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def connection_made(self, transport: asyncio.BaseTransport) -> None: - def connection_made(self, transport: asyncio.DatagramTransport) -> None: - """ - Inform the connection of the transport used to send data. This object - must have a ``sendto`` method which accepts a datagram to send. + self.__transport = cast(asyncio.DatagramTransport, transport) - Calling :meth:`connection_made` on a client starts the TLS handshake. - """ - self.__transport = transport - if self.is_client: - self._version = max(self.supported_versions) - self._connect() - ===========changed ref 5=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: - def datagram_received(self, data: bytes, addr: Any) -> None: """ Handle an incoming datagram. """ - buf = Buffer(data=data) - # 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 if self.is_client and header.destination_cid != self.host_cid: 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.__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 ): self.__logger.info("Performing stateless retry") self.peer_cid =</s>
tests.test_connection/QuicConnectionTest.test_connection_lost_with_exception
Modified
aiortc~aioquic
f12180ae527f69ee085df5007a46d26154ced102
[connection] make QuicConnection.connect() trigger handshake
<11>:<del> run(client.connect())
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost_with_exception(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> self.assertEqual(client_transport.sent, 4) <10> self.assertEqual(server_transport.sent, 4) <11> run(client.connect()) <12> <13> # send data over stream <14> client_reader, client_writer = client.create_stream() <15> client_writer.write(b"ping") <16> run(asyncio.sleep(0)) <17> self.assertEqual(client_transport.sent, 5) <18> self.assertEqual(server_transport.sent, 5) <19> <20> # break connection <21> exc = Exception("some error") <22> client.connection_lost(exc) <23> with self.assertRaises(Exception) as cm: <24> run(client_reader.read()) <25> self.assertEqual(cm.exception, exc) <26>
===========unchanged ref 0=========== at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] connection_lost(exc: Exception) -> None at: asyncio.streams.StreamReader read(n: int=...) -> bytes at: asyncio.streams.StreamWriter write(data: bytes) -> None at: asyncio.tasks sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T] at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) create_transport(client, server) at: tests.test_connection.QuicConnectionTest.test_connection_lost client = QuicConnection(is_client=True) client_transport, server_transport = create_transport(client, server) client_transport, server_transport = create_transport(client, server) client_reader, client_writer = client.create_stream() at: tests.utils run(coro) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) + client._peer_addr = SERVER_ADDR + client._version = max(client.supported_versions) + client._connect() + return client_transport, server_transport ===========changed ref 1=========== # module: tests.test_connection def create_standalone_client(): client = QuicConnection(is_client=True) client_transport = FakeTransport(CLIENT_ADDR) client.connection_made(client_transport) + + client._peer_addr = SERVER_ADDR + client._version = max(client.supported_versions) + client._connect() + return client, client_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) - run(client.connect()) # send data over stream client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # break connection client.connection_lost(None) self.assertEqual(run(client_reader.read()), b"") ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def _test_connect_with_version(self, client_versions, server_versions): client = QuicConnection(is_client=True) client.supported_versions = client_versions server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) server.supported_versions = server_versions # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) - run(client.connect()) # send data over stream client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # FIXME: needs an API server_reader, server_writer = ( server.streams[0].reader, server.streams[0].writer, ) self.assertEqual(run(server_reader.read(1024)), b"ping") server_writer.write(b"pong") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 6) self.assertEqual(server_transport.sent, 6) # client receives pong self.assertEqual(run(client_reader.read(1024)), b"pong") # client writes EOF client_writer.write_eof() run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 7) self.assertEqual(server_transport.sent, 7) # server receives EOF self.assertEqual(run(server_reader.read()), b"") ===========changed ref 4=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def connect(self, addr: Any) -> None: - def connect(self) -> None: """ + Initiate the TLS handshake and wait for it to complete. - Wait for the TLS handshake to complete. """ + self._peer_addr = addr + self._version = max(self.supported_versions) + self._connect() await self.__connected.wait() ===========changed ref 5=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def connection_made(self, transport: asyncio.BaseTransport) -> None: - def connection_made(self, transport: asyncio.DatagramTransport) -> None: - """ - Inform the connection of the transport used to send data. This object - must have a ``sendto`` method which accepts a datagram to send. + self.__transport = cast(asyncio.DatagramTransport, transport) - Calling :meth:`connection_made` on a client starts the TLS handshake. - """ - self.__transport = transport - if self.is_client: - self._version = max(self.supported_versions) - self._connect() -
examples.client/run
Modified
aiortc~aioquic
f12180ae527f69ee085df5007a46d26154ced102
[connection] make QuicConnection.connect() trigger handshake
<9>:<add> await protocol.connect(None) <del> await protocol.connect()
# module: examples.client def run(host, port, **kwargs): <0> # if host is not an IP address, pass it to enable SNI <1> try: <2> ipaddress.ip_address(host) <3> except ValueError: <4> kwargs["server_name"] = host <5> <6> _, protocol = await loop.create_datagram_endpoint( <7> lambda: QuicConnection(is_client=True, **kwargs), remote_addr=(host, port) <8> ) <9> await protocol.connect() <10> <11> # perform HTTP/0.9 request <12> reader, writer = protocol.create_stream() <13> writer.write(b"GET /\r\n") <14> writer.write_eof() <15> <16> response = await reader.read() <17> print(response.decode("utf8")) <18> <19> # close connection <20> protocol.close() <21>
===========unchanged ref 0=========== at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: asyncio.events.AbstractEventLoop create_datagram_endpoint(protocol_factory: _ProtocolFactory, local_addr: Optional[Tuple[str, int]]=..., remote_addr: Optional[Tuple[str, int]]=..., *, family: int=..., proto: int=..., flags: int=..., reuse_address: Optional[bool]=..., reuse_port: Optional[bool]=..., allow_broadcast: Optional[bool]=..., sock: Optional[socket]=...) -> _TransProtPair at: examples.client loop = asyncio.get_event_loop() at: ipaddress ip_address(address: object) -> Any ===========changed ref 0=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def connect(self, addr: Any) -> None: - def connect(self) -> None: """ + Initiate the TLS handshake and wait for it to complete. - Wait for the TLS handshake to complete. """ + self._peer_addr = addr + self._version = max(self.supported_versions) + self._connect() await self.__connected.wait() ===========changed ref 1=========== # module: tests.test_connection def create_standalone_client(): client = QuicConnection(is_client=True) client_transport = FakeTransport(CLIENT_ADDR) client.connection_made(client_transport) + + client._peer_addr = SERVER_ADDR + client._version = max(client.supported_versions) + client._connect() + return client, client_transport ===========changed ref 2=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) + client._peer_addr = SERVER_ADDR + client._version = max(client.supported_versions) + client._connect() + return client_transport, server_transport ===========changed ref 3=========== # module: aioquic.connection + class QuicConnection(asyncio.DatagramProtocol): - class QuicConnection: + def connection_made(self, transport: asyncio.BaseTransport) -> None: - def connection_made(self, transport: asyncio.DatagramTransport) -> None: - """ - Inform the connection of the transport used to send data. This object - must have a ``sendto`` method which accepts a datagram to send. + self.__transport = cast(asyncio.DatagramTransport, transport) - Calling :meth:`connection_made` on a client starts the TLS handshake. - """ - self.__transport = transport - if self.is_client: - self._version = max(self.supported_versions) - self._connect() - ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) - run(client.connect()) # send data over stream client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # break connection client.connection_lost(None) self.assertEqual(run(client_reader.read()), b"") ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost_with_exception(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) - run(client.connect()) # send data over stream client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # break connection exc = Exception("some error") client.connection_lost(exc) with self.assertRaises(Exception) as cm: run(client_reader.read()) self.assertEqual(cm.exception, exc) ===========changed ref 6=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def _test_connect_with_version(self, client_versions, server_versions): client = QuicConnection(is_client=True) client.supported_versions = client_versions server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) server.supported_versions = server_versions # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) - run(client.connect()) # send data over stream client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # FIXME: needs an API server_reader, server_writer = ( server.streams[0].reader, server.streams[0].writer, ) self.assertEqual(run(server_reader.read(1024)), b"ping") server_writer.write(b"pong") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 6) self.assertEqual(server_transport.sent, 6) # client receives pong self.assertEqual(run(client_reader.read(1024)), b"pong") # client writes EOF client_writer.write_eof() run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 7) self.assertEqual(server_transport.sent, 7) # server receives EOF self.assertEqual(run(server_reader.read()), b"")
examples.client/run
Modified
aiortc~aioquic
88b1747ed851c97e47a7cc857e25bd1ded33618a
[client] offer a high-level API to create a client
<0>:<add> async with aioquic.connect(host, port, **kwargs) as connection: <add> # perform HTTP/0.9 request <add> reader, writer = connection.create_stream() <add> writer.write(b"GET /\r\n") <add> writer.write_eof() <del> # if host is not an IP address, pass it to enable SNI <1>:<del> try: <2>:<del> ipaddress.ip_address(host) <3>:<del> except ValueError: <4>:<del> kwargs["server_name"] = host <6>:<del> _, protocol = await loop.create_datagram_endpoint( <7>:<del> lambda: QuicConnection(is_client=True, **kwargs), remote_addr=(host, port) <8>:<del> ) <9>:<del> await protocol.connect(None) <10>:<add> response = await reader.read() <add> print(response.decode("utf8")) <11>:<del> # perform HTTP/0.9 request <12>:<del> reader, writer = protocol.create_stream() <13>:<del> writer.write(b"GET /\r\n") <14>:<del> writer.write_eof() <15>:<del> <16>:<del> response = await reader.read() <17>:<del> print(response.decode("utf8")) <18>:<del> <19>:<del> # close connection <20>:<del> protocol.close() <21>:<del>
# module: examples.client def run(host, port, **kwargs): <0> # if host is not an IP address, pass it to enable SNI <1> try: <2> ipaddress.ip_address(host) <3> except ValueError: <4> kwargs["server_name"] = host <5> <6> _, protocol = await loop.create_datagram_endpoint( <7> lambda: QuicConnection(is_client=True, **kwargs), remote_addr=(host, port) <8> ) <9> await protocol.connect(None) <10> <11> # perform HTTP/0.9 request <12> reader, writer = protocol.create_stream() <13> writer.write(b"GET /\r\n") <14> writer.write_eof() <15> <16> response = await reader.read() <17> print(response.decode("utf8")) <18> <19> # close connection <20> protocol.close() <21>
===========unchanged ref 0=========== at: argparse ArgumentParser(prog: Optional[str]=..., usage: Optional[str]=..., description: Optional[str]=..., epilog: Optional[str]=..., parents: Sequence[ArgumentParser]=..., formatter_class: _FormatterClass=..., prefix_chars: str=..., fromfile_prefix_chars: Optional[str]=..., argument_default: Any=..., conflict_handler: str=..., add_help: bool=..., allow_abbrev: bool=...) at: argparse.ArgumentParser parse_args(args: Optional[Sequence[Text]], namespace: None) -> Namespace parse_args(args: Optional[Sequence[Text]]=...) -> Namespace parse_args(*, namespace: None) -> Namespace parse_args(args: Optional[Sequence[Text]], namespace: _N) -> _N parse_args(*, namespace: _N) -> _N at: argparse._ActionsContainer add_argument(*name_or_flags: Text, action: Union[Text, Type[Action]]=..., nargs: Union[int, Text]=..., const: Any=..., default: Any=..., type: Union[Callable[[Text], _T], Callable[[str], _T], FileType]=..., choices: Iterable[_T]=..., required: bool=..., help: Optional[Text]=..., metavar: Optional[Union[Text, Tuple[Text, ...]]]=..., dest: Optional[Text]=..., version: Text=..., **kwargs: Any) -> Action at: logging INFO = 20 basicConfig(*, filename: Optional[StrPath]=..., filemode: str=..., format: str=..., datefmt: Optional[str]=..., style: str=..., level: Optional[_Level]=..., stream: Optional[IO[str]]=..., handlers: Optional[Iterable[Handler]]=...) -> None ===========changed ref 0=========== + # module: aioquic.client + + ===========changed ref 1=========== + # module: aioquic.client + __all__ = ["connect"] + ===========changed ref 2=========== + # module: aioquic.client + @asynccontextmanager + async def connect( + host: str, + port: int, + *, + alpn_protocols: Optional[List[str]] = None, + secrets_log_file: TextIO = None, + ) -> AsyncGenerator[QuicConnection, None]: + """ + Connect to a QUIC server at the given `host` and `port`. + + :meth:`connect()` returns an awaitable. Awaiting it yields a + :class:`~aioquic.QuicConnection` which can be used to create streams. + + :param: alpn_protocols: a list of ALPN protocols to offer in the ClientHello. + :param: secrets_log_file: a file-like object in which to log traffic secrets. This is useful + to analyze traffic captures with Wireshark. + """ + loop = asyncio.get_event_loop() + + # if host is not an IP address, pass it to enable SNI + try: + ipaddress.ip_address(host) + server_name = None + except ValueError: + server_name = host + + # lookup remote address + infos = await loop.getaddrinfo(host, port, type=socket.SOCK_DGRAM) + addr = infos[0][4] + if len(addr) == 2: + addr = ("::ffff:" + addr[0], addr[1], 0, 0) + + # connect + _, protocol = await loop.create_datagram_endpoint( + lambda: QuicConnection( + alpn_protocols=alpn_protocols, is_client=True, server_name=server_name + ), + local_addr=("::", 0), + ) + protocol = cast(QuicConnection, protocol) + await protocol.connect(addr) + try: + yield protocol + finally: + protocol.close() +
tests.test_connection/QuicConnectionTest._test_connect_with_version
Modified
aiortc~aioquic
3a616c000e74d2f48c1fad5b186893690ea5a898
[connection] make create_stream() as coroutine
<16>:<add> client_reader, client_writer = run(client.create_stream()) <del> client_reader, client_writer = client.create_stream()
# module: tests.test_connection class QuicConnectionTest(TestCase): def _test_connect_with_version(self, client_versions, server_versions): <0> client = QuicConnection(is_client=True) <1> client.supported_versions = client_versions <2> <3> server = QuicConnection( <4> is_client=False, <5> certificate=SERVER_CERTIFICATE, <6> private_key=SERVER_PRIVATE_KEY, <7> ) <8> server.supported_versions = server_versions <9> <10> # perform handshake <11> client_transport, server_transport = create_transport(client, server) <12> self.assertEqual(client_transport.sent, 4) <13> self.assertEqual(server_transport.sent, 4) <14> <15> # send data over stream <16> client_reader, client_writer = client.create_stream() <17> client_writer.write(b"ping") <18> run(asyncio.sleep(0)) <19> self.assertEqual(client_transport.sent, 5) <20> self.assertEqual(server_transport.sent, 5) <21> <22> # FIXME: needs an API <23> server_reader, server_writer = ( <24> server.streams[0].reader, <25> server.streams[0].writer, <26> ) <27> self.assertEqual(run(server_reader.read(1024)), b"ping") <28> server_writer.write(b"pong") <29> run(asyncio.sleep(0)) <30> self.assertEqual(client_transport.sent, 6) <31> self.assertEqual(server_transport.sent, 6) <32> <33> # client receives pong <34> self.assertEqual(run(client_reader.read(1024)), b"pong") <35> <36> # client writes EOF <37> client_writer.write_eof() <38> run(asyncio.sleep(0)) <39> self.assertEqual(client_transport.sent, 7) <40> self.assertEqual(server_transport.sent, 7) <41> <42> # server receives EOF <43> self</s>
===========below chunk 0=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def _test_connect_with_version(self, client_versions, server_versions): # offset: 1 ===========unchanged ref 0=========== at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20] create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] at: aioquic.connection.QuicConnection.__init__ self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} at: aioquic.stream.QuicStream.__init__ self.reader = asyncio.StreamReader() self.reader = None self.writer = None self.writer = asyncio.StreamWriter(self, None, self.reader, None) at: asyncio.streams.StreamReader _source_traceback = None read(n: int=...) -> bytes at: asyncio.streams.StreamWriter write(data: bytes) -> None write_eof() -> None at: asyncio.tasks sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T] at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) create_transport(client, server) at: tests.test_connection.FakeTransport.sendto self.sent += 1 at: tests.utils run(coro) at: unittest.case.TestCase failureException: Type[BaseException] longMessage: bool maxDiff: Optional[int] ===========unchanged ref 1=========== _testMethodName: str _testMethodDoc: str assertEqual(first: Any, second: Any, msg: Any=...) -> None
tests.test_connection/QuicConnectionTest.test_connection_lost
Modified
aiortc~aioquic
3a616c000e74d2f48c1fad5b186893690ea5a898
[connection] make create_stream() as coroutine
<13>:<add> client_reader, client_writer = run(client.create_stream()) <del> client_reader, client_writer = client.create_stream()
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> self.assertEqual(client_transport.sent, 4) <10> self.assertEqual(server_transport.sent, 4) <11> <12> # send data over stream <13> client_reader, client_writer = client.create_stream() <14> client_writer.write(b"ping") <15> run(asyncio.sleep(0)) <16> self.assertEqual(client_transport.sent, 5) <17> self.assertEqual(server_transport.sent, 5) <18> <19> # break connection <20> client.connection_lost(None) <21> self.assertEqual(run(client_reader.read()), b"") <22>
===========unchanged ref 0=========== at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] connection_lost(exc: Exception) -> None at: asyncio.streams.StreamReader read(n: int=...) -> bytes at: asyncio.streams.StreamWriter write(data: bytes) -> None at: asyncio.tasks sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T] at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) create_transport(client, server) at: tests.utils run(coro) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def _test_connect_with_version(self, client_versions, server_versions): client = QuicConnection(is_client=True) client.supported_versions = client_versions server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) server.supported_versions = server_versions # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) # send data over stream + client_reader, client_writer = run(client.create_stream()) - client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # FIXME: needs an API server_reader, server_writer = ( server.streams[0].reader, server.streams[0].writer, ) self.assertEqual(run(server_reader.read(1024)), b"ping") server_writer.write(b"pong") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 6) self.assertEqual(server_transport.sent, 6) # client receives pong self.assertEqual(run(client_reader.read(1024)), b"pong") # client writes EOF client_writer.write_eof() run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 7) self.assertEqual(server_transport.sent, 7) # server receives EOF self.assertEqual(run(server_reader.read()), b"")
tests.test_connection/QuicConnectionTest.test_connection_lost_with_exception
Modified
aiortc~aioquic
3a616c000e74d2f48c1fad5b186893690ea5a898
[connection] make create_stream() as coroutine
<13>:<add> client_reader, client_writer = run(client.create_stream()) <del> client_reader, client_writer = client.create_stream()
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost_with_exception(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> self.assertEqual(client_transport.sent, 4) <10> self.assertEqual(server_transport.sent, 4) <11> <12> # send data over stream <13> client_reader, client_writer = client.create_stream() <14> client_writer.write(b"ping") <15> run(asyncio.sleep(0)) <16> self.assertEqual(client_transport.sent, 5) <17> self.assertEqual(server_transport.sent, 5) <18> <19> # break connection <20> exc = Exception("some error") <21> client.connection_lost(exc) <22> with self.assertRaises(Exception) as cm: <23> run(client_reader.read()) <24> self.assertEqual(cm.exception, exc) <25>
===========unchanged ref 0=========== at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] connection_lost(exc: Exception) -> None at: asyncio.streams.StreamWriter write(data: bytes) -> None at: asyncio.tasks sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T] at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) create_transport(client, server) at: tests.utils run(coro) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E] assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None at: unittest.case._AssertRaisesContext.__exit__ self.exception = exc_value.with_traceback(None) ===========changed ref 0=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) # send data over stream + client_reader, client_writer = run(client.create_stream()) - client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # break connection client.connection_lost(None) self.assertEqual(run(client_reader.read()), b"") ===========changed ref 1=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def _test_connect_with_version(self, client_versions, server_versions): client = QuicConnection(is_client=True) client.supported_versions = client_versions server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) server.supported_versions = server_versions # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) # send data over stream + client_reader, client_writer = run(client.create_stream()) - client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # FIXME: needs an API server_reader, server_writer = ( server.streams[0].reader, server.streams[0].writer, ) self.assertEqual(run(server_reader.read(1024)), b"ping") server_writer.write(b"pong") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 6) self.assertEqual(server_transport.sent, 6) # client receives pong self.assertEqual(run(client_reader.read(1024)), b"pong") # client writes EOF client_writer.write_eof() run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 7) self.assertEqual(server_transport.sent, 7) # server receives EOF self.assertEqual(run(server_reader.read()), b"")
tests.test_connection/QuicConnectionTest.test_create_stream
Modified
aiortc~aioquic
3a616c000e74d2f48c1fad5b186893690ea5a898
[connection] make create_stream() as coroutine
<11>:<add> reader, writer = run(client.create_stream()) <del> reader, writer = client.create_stream() <15>:<add> reader, writer = run(client.create_stream()) <del> reader, writer = client.create_stream() <18>:<add> reader, writer = run(client.create_stream(is_unidirectional=True)) <del> reader, writer = client.create_stream(is_unidirectional=True) <21>:<add> reader, writer = run(client.create_stream(is_unidirectional=True)) <del> reader, writer = client.create_stream(is_unidirectional=True) <25>:<add> reader, writer = run(server.create_stream()) <del> reader, writer = server.create_stream() <28>:<add> reader, writer = run(server.create_stream()) <del> reader, writer = server.create_stream() <31>:<add> reader, writer = run(server.create_stream(is_unidirectional=True)) <del> reader, writer = server.create_stream(is_unidirectional=True) <34>:<add> reader, writer = run(server.create_stream(is_unidirectional=True)) <del> reader, writer = server.create_stream(is_unidirectional=True)
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_create_stream(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client <11> reader, writer = client.create_stream() <12> self.assertEqual(writer.get_extra_info("stream_id"), 0) <13> self.assertIsNotNone(writer.get_extra_info("connection")) <14> <15> reader, writer = client.create_stream() <16> self.assertEqual(writer.get_extra_info("stream_id"), 4) <17> <18> reader, writer = client.create_stream(is_unidirectional=True) <19> self.assertEqual(writer.get_extra_info("stream_id"), 2) <20> <21> reader, writer = client.create_stream(is_unidirectional=True) <22> self.assertEqual(writer.get_extra_info("stream_id"), 6) <23> <24> # server <25> reader, writer = server.create_stream() <26> self.assertEqual(writer.get_extra_info("stream_id"), 1) <27> <28> reader, writer = server.create_stream() <29> self.assertEqual(writer.get_extra_info("stream_id"), 5) <30> <31> reader, writer = server.create_stream(is_unidirectional=True) <32> self.assertEqual(writer.get_extra_info("stream_id"), 3) <33> <34> reader, writer = server.create_stream(is_unidirectional=True) <35> self.assertEqual(writer.get_extra_info("stream_id"), 7) <36>
===========unchanged ref 0=========== at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) create_transport(client, server) at: tests.utils run(coro) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None assertIsNotNone(obj: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost_with_exception(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) # send data over stream + client_reader, client_writer = run(client.create_stream()) - client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # break connection exc = Exception("some error") client.connection_lost(exc) with self.assertRaises(Exception) as cm: run(client_reader.read()) self.assertEqual(cm.exception, exc) ===========changed ref 1=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) # send data over stream + client_reader, client_writer = run(client.create_stream()) - client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # break connection client.connection_lost(None) self.assertEqual(run(client_reader.read()), b"") ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def _test_connect_with_version(self, client_versions, server_versions): client = QuicConnection(is_client=True) client.supported_versions = client_versions server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) server.supported_versions = server_versions # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) # send data over stream + client_reader, client_writer = run(client.create_stream()) - client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # FIXME: needs an API server_reader, server_writer = ( server.streams[0].reader, server.streams[0].writer, ) self.assertEqual(run(server_reader.read(1024)), b"ping") server_writer.write(b"pong") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 6) self.assertEqual(server_transport.sent, 6) # client receives pong self.assertEqual(run(client_reader.read(1024)), b"pong") # client writes EOF client_writer.write_eof() run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 7) self.assertEqual(server_transport.sent, 7) # server receives EOF self.assertEqual(run(server_reader.read()), b"")
tests.test_connection/QuicConnectionTest.test_handle_max_stream_data_frame
Modified
aiortc~aioquic
3a616c000e74d2f48c1fad5b186893690ea5a898
[connection] make create_stream() as coroutine
<11>:<add> reader, writer = run(client.create_stream()) <add> stream = writer.transport <del> stream = client.create_stream()[1].transport
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_stream_data_frame(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client creates bidirectional stream 0 <11> stream = client.create_stream()[1].transport <12> self.assertEqual(stream.max_stream_data_remote, 1048576) <13> <14> # client receives MAX_STREAM_DATA raising limit <15> client._handle_max_stream_data_frame( <16> tls.Epoch.ONE_RTT, <17> QuicFrameType.MAX_STREAM_DATA, <18> Buffer(data=b"\x00" + encode_uint_var(1048577)), <19> ) <20> self.assertEqual(stream.max_stream_data_remote, 1048577) <21> <22> # client receives MAX_STREAM_DATA lowering limit <23> client._handle_max_stream_data_frame( <24> tls.Epoch.ONE_RTT, <25> QuicFrameType.MAX_STREAM_DATA, <26> Buffer(data=b"\x00" + encode_uint_var(1048575)), <27> ) <28> self.assertEqual(stream.max_stream_data_remote, 1048577) <29>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] _handle_max_stream_data_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: aioquic.tls Epoch() at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) encode_uint_var(v) create_transport(client, server) at: tests.utils run(coro) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost_with_exception(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) # send data over stream + client_reader, client_writer = run(client.create_stream()) - client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # break connection exc = Exception("some error") client.connection_lost(exc) with self.assertRaises(Exception) as cm: run(client_reader.read()) self.assertEqual(cm.exception, exc) ===========changed ref 1=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) # send data over stream + client_reader, client_writer = run(client.create_stream()) - client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # break connection client.connection_lost(None) self.assertEqual(run(client_reader.read()), b"") ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_create_stream(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client + reader, writer = run(client.create_stream()) - reader, writer = client.create_stream() self.assertEqual(writer.get_extra_info("stream_id"), 0) self.assertIsNotNone(writer.get_extra_info("connection")) + reader, writer = run(client.create_stream()) - reader, writer = client.create_stream() self.assertEqual(writer.get_extra_info("stream_id"), 4) + reader, writer = run(client.create_stream(is_unidirectional=True)) - reader, writer = client.create_stream(is_unidirectional=True) self.assertEqual(writer.get_extra_info("stream_id"), 2) + reader, writer = run(client.create_stream(is_unidirectional=True)) - reader, writer = client.create_stream(is_unidirectional=True) self.assertEqual(writer.get_extra_info("stream_id"), 6) # server + reader, writer = run(server.create_stream()) - reader, writer = server.create_stream() self.assertEqual(writer.get_extra_info("stream_id"), 1) + reader, writer = run(server.create_stream()) - reader, writer = server.create_stream() self.assertEqual(writer.get_extra_info("stream_id"), 5) + reader, writer = run(server.create_stream(is_unidirectional=True)) - reader, writer = server.create_stream(is_</s> ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_create_stream(self): # offset: 1 <s>(server.create_stream(is_unidirectional=True)) - reader, writer = server.create_stream(is_unidirectional=True) self.assertEqual(writer.get_extra_info("stream_id"), 3) + reader, writer = run(server.create_stream(is_unidirectional=True)) - reader, writer = server.create_stream(is_unidirectional=True) self.assertEqual(writer.get_extra_info("stream_id"), 7)
tests.test_connection/QuicConnectionTest.test_handle_max_stream_data_frame_receive_only
Modified
aiortc~aioquic
3a616c000e74d2f48c1fad5b186893690ea5a898
[connection] make create_stream() as coroutine
<11>:<add> run(server.create_stream(is_unidirectional=True)) <del> server.create_stream(is_unidirectional=True)
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_stream_data_frame_receive_only(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # server creates unidirectional stream 3 <11> server.create_stream(is_unidirectional=True) <12> <13> # client receives MAX_STREAM_DATA: 3, 1 <14> with self.assertRaises(QuicConnectionError) as cm: <15> client._handle_max_stream_data_frame( <16> tls.Epoch.ONE_RTT, <17> QuicFrameType.MAX_STREAM_DATA, <18> Buffer(data=b"\x03\x01"), <19> ) <20> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) <21> self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA) <22> self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only") <23>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] _handle_max_stream_data_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicErrorCode(x: Union[str, bytes, bytearray], base: int) QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: aioquic.tls Epoch() at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) create_transport(client, server) at: tests.utils run(coro) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========unchanged ref 1=========== assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E] assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None at: unittest.case._AssertRaisesContext.__exit__ self.exception = exc_value.with_traceback(None) ===========changed ref 0=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_stream_data_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 + reader, writer = run(client.create_stream()) + stream = writer.transport - stream = client.create_stream()[1].transport self.assertEqual(stream.max_stream_data_remote, 1048576) # client receives MAX_STREAM_DATA raising limit client._handle_max_stream_data_frame( tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x00" + encode_uint_var(1048577)), ) self.assertEqual(stream.max_stream_data_remote, 1048577) # client receives MAX_STREAM_DATA lowering limit client._handle_max_stream_data_frame( tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x00" + encode_uint_var(1048575)), ) self.assertEqual(stream.max_stream_data_remote, 1048577) ===========changed ref 1=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost_with_exception(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) # send data over stream + client_reader, client_writer = run(client.create_stream()) - client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # break connection exc = Exception("some error") client.connection_lost(exc) with self.assertRaises(Exception) as cm: run(client_reader.read()) self.assertEqual(cm.exception, exc) ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) # send data over stream + client_reader, client_writer = run(client.create_stream()) - client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # break connection client.connection_lost(None) self.assertEqual(run(client_reader.read()), b"")
tests.test_connection/QuicConnectionTest.test_handle_reset_stream_frame
Modified
aiortc~aioquic
3a616c000e74d2f48c1fad5b186893690ea5a898
[connection] make create_stream() as coroutine
<11>:<add> run(client.create_stream()) <del> client.create_stream()
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client creates bidirectional stream 0 <11> client.create_stream() <12> <13> # client receives RESET_STREAM <14> client._handle_reset_stream_frame( <15> tls.Epoch.ONE_RTT, <16> QuicFrameType.RESET_STREAM, <17> Buffer(data=binascii.unhexlify("001122000001")), <18> ) <19>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] _handle_reset_stream_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: aioquic.tls Epoch() at: binascii unhexlify(hexstr: _Ascii, /) -> bytes at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) create_transport(client, server) at: tests.utils run(coro) ===========changed ref 0=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_stream_data_frame_receive_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server creates unidirectional stream 3 + run(server.create_stream(is_unidirectional=True)) - server.create_stream(is_unidirectional=True) # client receives MAX_STREAM_DATA: 3, 1 with self.assertRaises(QuicConnectionError) as cm: client._handle_max_stream_data_frame( tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x03\x01"), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA) self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only") ===========changed ref 1=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_stream_data_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 + reader, writer = run(client.create_stream()) + stream = writer.transport - stream = client.create_stream()[1].transport self.assertEqual(stream.max_stream_data_remote, 1048576) # client receives MAX_STREAM_DATA raising limit client._handle_max_stream_data_frame( tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x00" + encode_uint_var(1048577)), ) self.assertEqual(stream.max_stream_data_remote, 1048577) # client receives MAX_STREAM_DATA lowering limit client._handle_max_stream_data_frame( tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x00" + encode_uint_var(1048575)), ) self.assertEqual(stream.max_stream_data_remote, 1048577) ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost_with_exception(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) # send data over stream + client_reader, client_writer = run(client.create_stream()) - client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # break connection exc = Exception("some error") client.connection_lost(exc) with self.assertRaises(Exception) as cm: run(client_reader.read()) self.assertEqual(cm.exception, exc) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) # send data over stream + client_reader, client_writer = run(client.create_stream()) - client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # break connection client.connection_lost(None) self.assertEqual(run(client_reader.read()), b"")
tests.test_connection/QuicConnectionTest.test_handle_reset_stream_frame_send_only
Modified
aiortc~aioquic
3a616c000e74d2f48c1fad5b186893690ea5a898
[connection] make create_stream() as coroutine
<11>:<add> run(client.create_stream(is_unidirectional=True)) <del> client.create_stream(is_unidirectional=True)
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame_send_only(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client creates unidirectional stream 2 <11> client.create_stream(is_unidirectional=True) <12> <13> # client receives RESET_STREAM <14> with self.assertRaises(QuicConnectionError) as cm: <15> client._handle_reset_stream_frame( <16> tls.Epoch.ONE_RTT, <17> QuicFrameType.RESET_STREAM, <18> Buffer(data=binascii.unhexlify("021122000001")), <19> ) <20> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) <21> self.assertEqual(cm.exception.frame_type, QuicFrameType.RESET_STREAM) <22> self.assertEqual(cm.exception.reason_phrase, "Stream is send-only") <23>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] _handle_reset_stream_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicErrorCode(x: Union[str, bytes, bytearray], base: int) QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: aioquic.tls Epoch() at: binascii unhexlify(hexstr: _Ascii, /) -> bytes at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) create_transport(client, server) at: tests.utils run(coro) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========unchanged ref 1=========== assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E] assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None at: unittest.case._AssertRaisesContext.__exit__ self.exception = exc_value.with_traceback(None) ===========changed ref 0=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 + run(client.create_stream()) - client.create_stream() # client receives RESET_STREAM client._handle_reset_stream_frame( tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("001122000001")), ) ===========changed ref 1=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_stream_data_frame_receive_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server creates unidirectional stream 3 + run(server.create_stream(is_unidirectional=True)) - server.create_stream(is_unidirectional=True) # client receives MAX_STREAM_DATA: 3, 1 with self.assertRaises(QuicConnectionError) as cm: client._handle_max_stream_data_frame( tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x03\x01"), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA) self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only") ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_stream_data_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 + reader, writer = run(client.create_stream()) + stream = writer.transport - stream = client.create_stream()[1].transport self.assertEqual(stream.max_stream_data_remote, 1048576) # client receives MAX_STREAM_DATA raising limit client._handle_max_stream_data_frame( tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x00" + encode_uint_var(1048577)), ) self.assertEqual(stream.max_stream_data_remote, 1048577) # client receives MAX_STREAM_DATA lowering limit client._handle_max_stream_data_frame( tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x00" + encode_uint_var(1048575)), ) self.assertEqual(stream.max_stream_data_remote, 1048577) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost_with_exception(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) # send data over stream + client_reader, client_writer = run(client.create_stream()) - client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # break connection exc = Exception("some error") client.connection_lost(exc) with self.assertRaises(Exception) as cm: run(client_reader.read()) self.assertEqual(cm.exception, exc)
tests.test_connection/QuicConnectionTest.test_handle_stop_sending_frame
Modified
aiortc~aioquic
3a616c000e74d2f48c1fad5b186893690ea5a898
[connection] make create_stream() as coroutine
<11>:<add> run(client.create_stream()) <del> client.create_stream()
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stop_sending_frame(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client creates bidirectional stream 0 <11> client.create_stream() <12> <13> # client receives STOP_SENDING <14> client._handle_stop_sending_frame( <15> tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b"\x00\x11\x22") <16> ) <17>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] _handle_stop_sending_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: aioquic.tls Epoch() at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) create_transport(client, server) at: tests.utils run(coro) ===========changed ref 0=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 + run(client.create_stream()) - client.create_stream() # client receives RESET_STREAM client._handle_reset_stream_frame( tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("001122000001")), ) ===========changed ref 1=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame_send_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates unidirectional stream 2 + run(client.create_stream(is_unidirectional=True)) - client.create_stream(is_unidirectional=True) # client receives RESET_STREAM with self.assertRaises(QuicConnectionError) as cm: client._handle_reset_stream_frame( tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("021122000001")), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.RESET_STREAM) self.assertEqual(cm.exception.reason_phrase, "Stream is send-only") ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_stream_data_frame_receive_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server creates unidirectional stream 3 + run(server.create_stream(is_unidirectional=True)) - server.create_stream(is_unidirectional=True) # client receives MAX_STREAM_DATA: 3, 1 with self.assertRaises(QuicConnectionError) as cm: client._handle_max_stream_data_frame( tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x03\x01"), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA) self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only") ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_stream_data_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 + reader, writer = run(client.create_stream()) + stream = writer.transport - stream = client.create_stream()[1].transport self.assertEqual(stream.max_stream_data_remote, 1048576) # client receives MAX_STREAM_DATA raising limit client._handle_max_stream_data_frame( tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x00" + encode_uint_var(1048577)), ) self.assertEqual(stream.max_stream_data_remote, 1048577) # client receives MAX_STREAM_DATA lowering limit client._handle_max_stream_data_frame( tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x00" + encode_uint_var(1048575)), ) self.assertEqual(stream.max_stream_data_remote, 1048577) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost_with_exception(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) # send data over stream + client_reader, client_writer = run(client.create_stream()) - client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # break connection exc = Exception("some error") client.connection_lost(exc) with self.assertRaises(Exception) as cm: run(client_reader.read()) self.assertEqual(cm.exception, exc)
tests.test_connection/QuicConnectionTest.test_handle_stop_sending_frame_receive_only
Modified
aiortc~aioquic
3a616c000e74d2f48c1fad5b186893690ea5a898
[connection] make create_stream() as coroutine
<11>:<add> run(server.create_stream(is_unidirectional=True)) <del> server.create_stream(is_unidirectional=True)
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stop_sending_frame_receive_only(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # server creates unidirectional stream 3 <11> server.create_stream(is_unidirectional=True) <12> <13> # client receives STOP_SENDING <14> with self.assertRaises(QuicConnectionError) as cm: <15> client._handle_stop_sending_frame( <16> tls.Epoch.ONE_RTT, <17> QuicFrameType.STOP_SENDING, <18> Buffer(data=b"\x03\x11\x22"), <19> ) <20> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) <21> self.assertEqual(cm.exception.frame_type, QuicFrameType.STOP_SENDING) <22> self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only") <23>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] _handle_stop_sending_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicErrorCode(x: Union[str, bytes, bytearray], base: int) QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: aioquic.tls Epoch() at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) create_transport(client, server) at: tests.utils run(coro) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========unchanged ref 1=========== assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E] assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None ===========changed ref 0=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stop_sending_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 + run(client.create_stream()) - client.create_stream() # client receives STOP_SENDING client._handle_stop_sending_frame( tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b"\x00\x11\x22") ) ===========changed ref 1=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 + run(client.create_stream()) - client.create_stream() # client receives RESET_STREAM client._handle_reset_stream_frame( tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("001122000001")), ) ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame_send_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates unidirectional stream 2 + run(client.create_stream(is_unidirectional=True)) - client.create_stream(is_unidirectional=True) # client receives RESET_STREAM with self.assertRaises(QuicConnectionError) as cm: client._handle_reset_stream_frame( tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("021122000001")), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.RESET_STREAM) self.assertEqual(cm.exception.reason_phrase, "Stream is send-only") ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_stream_data_frame_receive_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server creates unidirectional stream 3 + run(server.create_stream(is_unidirectional=True)) - server.create_stream(is_unidirectional=True) # client receives MAX_STREAM_DATA: 3, 1 with self.assertRaises(QuicConnectionError) as cm: client._handle_max_stream_data_frame( tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x03\x01"), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA) self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only") ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_stream_data_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 + reader, writer = run(client.create_stream()) + stream = writer.transport - stream = client.create_stream()[1].transport self.assertEqual(stream.max_stream_data_remote, 1048576) # client receives MAX_STREAM_DATA raising limit client._handle_max_stream_data_frame( tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x00" + encode_uint_var(1048577)), ) self.assertEqual(stream.max_stream_data_remote, 1048577) # client receives MAX_STREAM_DATA lowering limit client._handle_max_stream_data_frame( tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x00" + encode_uint_var(1048575)), ) self.assertEqual(stream.max_stream_data_remote, 1048577)
tests.test_connection/QuicConnectionTest.test_handle_stream_frame_send_only
Modified
aiortc~aioquic
3a616c000e74d2f48c1fad5b186893690ea5a898
[connection] make create_stream() as coroutine
<11>:<add> run(client.create_stream(is_unidirectional=True)) <del> client.create_stream(is_unidirectional=True)
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_send_only(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client creates unidirectional stream 2 <11> client.create_stream(is_unidirectional=True) <12> <13> # client receives STREAM frame <14> with self.assertRaises(QuicConnectionError) as cm: <15> client._handle_stream_frame( <16> tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b"\x02") <17> ) <18> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) <19> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) <20> self.assertEqual(cm.exception.reason_phrase, "Stream is send-only") <21>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] _handle_stream_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicErrorCode(x: Union[str, bytes, bytearray], base: int) QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: aioquic.tls Epoch() at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) create_transport(client, server) at: tests.utils run(coro) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========unchanged ref 1=========== assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E] assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None ===========changed ref 0=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stop_sending_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 + run(client.create_stream()) - client.create_stream() # client receives STOP_SENDING client._handle_stop_sending_frame( tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b"\x00\x11\x22") ) ===========changed ref 1=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 + run(client.create_stream()) - client.create_stream() # client receives RESET_STREAM client._handle_reset_stream_frame( tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("001122000001")), ) ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stop_sending_frame_receive_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server creates unidirectional stream 3 + run(server.create_stream(is_unidirectional=True)) - server.create_stream(is_unidirectional=True) # client receives STOP_SENDING with self.assertRaises(QuicConnectionError) as cm: client._handle_stop_sending_frame( tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b"\x03\x11\x22"), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STOP_SENDING) self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only") ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame_send_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates unidirectional stream 2 + run(client.create_stream(is_unidirectional=True)) - client.create_stream(is_unidirectional=True) # client receives RESET_STREAM with self.assertRaises(QuicConnectionError) as cm: client._handle_reset_stream_frame( tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("021122000001")), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.RESET_STREAM) self.assertEqual(cm.exception.reason_phrase, "Stream is send-only") ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_stream_data_frame_receive_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server creates unidirectional stream 3 + run(server.create_stream(is_unidirectional=True)) - server.create_stream(is_unidirectional=True) # client receives MAX_STREAM_DATA: 3, 1 with self.assertRaises(QuicConnectionError) as cm: client._handle_max_stream_data_frame( tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x03\x01"), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA) self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only")
tests.test_connection/QuicConnectionTest.test_handle_stream_data_blocked_frame
Modified
aiortc~aioquic
3a616c000e74d2f48c1fad5b186893690ea5a898
[connection] make create_stream() as coroutine
<11>:<add> run(client.create_stream()) <del> client.create_stream()
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_data_blocked_frame(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client creates bidirectional stream 0 <11> client.create_stream() <12> <13> # client receives STREAM_DATA_BLOCKED <14> client._handle_stream_data_blocked_frame( <15> tls.Epoch.ONE_RTT, <16> QuicFrameType.STREAM_DATA_BLOCKED, <17> Buffer(data=b"\x00\x01"), <18> ) <19>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] _handle_stream_data_blocked_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: aioquic.tls Epoch() at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) create_transport(client, server) at: tests.utils run(coro) ===========changed ref 0=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_send_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates unidirectional stream 2 + run(client.create_stream(is_unidirectional=True)) - client.create_stream(is_unidirectional=True) # client receives STREAM frame with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b"\x02") ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) self.assertEqual(cm.exception.reason_phrase, "Stream is send-only") ===========changed ref 1=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stop_sending_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 + run(client.create_stream()) - client.create_stream() # client receives STOP_SENDING client._handle_stop_sending_frame( tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b"\x00\x11\x22") ) ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 + run(client.create_stream()) - client.create_stream() # client receives RESET_STREAM client._handle_reset_stream_frame( tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("001122000001")), ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stop_sending_frame_receive_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server creates unidirectional stream 3 + run(server.create_stream(is_unidirectional=True)) - server.create_stream(is_unidirectional=True) # client receives STOP_SENDING with self.assertRaises(QuicConnectionError) as cm: client._handle_stop_sending_frame( tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b"\x03\x11\x22"), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STOP_SENDING) self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only") ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame_send_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates unidirectional stream 2 + run(client.create_stream(is_unidirectional=True)) - client.create_stream(is_unidirectional=True) # client receives RESET_STREAM with self.assertRaises(QuicConnectionError) as cm: client._handle_reset_stream_frame( tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("021122000001")), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.RESET_STREAM) self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
tests.test_connection/QuicConnectionTest.test_handle_stream_data_blocked_frame_send_only
Modified
aiortc~aioquic
3a616c000e74d2f48c1fad5b186893690ea5a898
[connection] make create_stream() as coroutine
<11>:<add> run(client.create_stream(is_unidirectional=True)) <del> client.create_stream(is_unidirectional=True)
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_data_blocked_frame_send_only(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client creates unidirectional stream 2 <11> client.create_stream(is_unidirectional=True) <12> <13> # client receives STREAM_DATA_BLOCKED <14> with self.assertRaises(QuicConnectionError) as cm: <15> client._handle_stream_data_blocked_frame( <16> tls.Epoch.ONE_RTT, <17> QuicFrameType.STREAM_DATA_BLOCKED, <18> Buffer(data=b"\x02\x01"), <19> ) <20> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) <21> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_DATA_BLOCKED) <22> self.assertEqual(cm.exception.reason_phrase, "Stream is send-only") <23>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] _handle_stream_data_blocked_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicErrorCode(x: Union[str, bytes, bytearray], base: int) QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: aioquic.tls Epoch() at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) create_transport(client, server) at: tests.utils run(coro) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========unchanged ref 1=========== assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E] assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None ===========changed ref 0=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_data_blocked_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 + run(client.create_stream()) - client.create_stream() # client receives STREAM_DATA_BLOCKED client._handle_stream_data_blocked_frame( tls.Epoch.ONE_RTT, QuicFrameType.STREAM_DATA_BLOCKED, Buffer(data=b"\x00\x01"), ) ===========changed ref 1=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_send_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates unidirectional stream 2 + run(client.create_stream(is_unidirectional=True)) - client.create_stream(is_unidirectional=True) # client receives STREAM frame with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b"\x02") ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) self.assertEqual(cm.exception.reason_phrase, "Stream is send-only") ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stop_sending_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 + run(client.create_stream()) - client.create_stream() # client receives STOP_SENDING client._handle_stop_sending_frame( tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b"\x00\x11\x22") ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 + run(client.create_stream()) - client.create_stream() # client receives RESET_STREAM client._handle_reset_stream_frame( tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("001122000001")), ) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stop_sending_frame_receive_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server creates unidirectional stream 3 + run(server.create_stream(is_unidirectional=True)) - server.create_stream(is_unidirectional=True) # client receives STOP_SENDING with self.assertRaises(QuicConnectionError) as cm: client._handle_stop_sending_frame( tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b"\x03\x11\x22"), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STOP_SENDING) self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only")
examples.client/run
Modified
aiortc~aioquic
3a616c000e74d2f48c1fad5b186893690ea5a898
[connection] make create_stream() as coroutine
<2>:<add> reader, writer = await connection.create_stream() <del> reader, writer = connection.create_stream()
# module: examples.client def run(host, port, **kwargs): <0> async with aioquic.connect(host, port, **kwargs) as connection: <1> # perform HTTP/0.9 request <2> reader, writer = connection.create_stream() <3> writer.write(b"GET /\r\n") <4> writer.write_eof() <5> <6> response = await reader.read() <7> print(response.decode("utf8")) <8>
===========unchanged ref 0=========== at: aioquic.client connect(host: str, port: int, *, alpn_protocols: Optional[List[str]]=None, secrets_log_file: TextIO=None) -> AsyncGenerator[QuicConnection, None] at: aioquic.connection.QuicConnection supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20] create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] ===========changed ref 0=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stop_sending_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 + run(client.create_stream()) - client.create_stream() # client receives STOP_SENDING client._handle_stop_sending_frame( tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b"\x00\x11\x22") ) ===========changed ref 1=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 + run(client.create_stream()) - client.create_stream() # client receives RESET_STREAM client._handle_reset_stream_frame( tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("001122000001")), ) ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_data_blocked_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 + run(client.create_stream()) - client.create_stream() # client receives STREAM_DATA_BLOCKED client._handle_stream_data_blocked_frame( tls.Epoch.ONE_RTT, QuicFrameType.STREAM_DATA_BLOCKED, Buffer(data=b"\x00\x01"), ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) # send data over stream + client_reader, client_writer = run(client.create_stream()) - client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # break connection client.connection_lost(None) self.assertEqual(run(client_reader.read()), b"") ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_send_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates unidirectional stream 2 + run(client.create_stream(is_unidirectional=True)) - client.create_stream(is_unidirectional=True) # client receives STREAM frame with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b"\x02") ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) self.assertEqual(cm.exception.reason_phrase, "Stream is send-only") ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_connection_lost_with_exception(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client_transport.sent, 4) self.assertEqual(server_transport.sent, 4) # send data over stream + client_reader, client_writer = run(client.create_stream()) - client_reader, client_writer = client.create_stream() client_writer.write(b"ping") run(asyncio.sleep(0)) self.assertEqual(client_transport.sent, 5) self.assertEqual(server_transport.sent, 5) # break connection exc = Exception("some error") client.connection_lost(exc) with self.assertRaises(Exception) as cm: run(client_reader.read()) self.assertEqual(cm.exception, exc) ===========changed ref 6=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame_send_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates unidirectional stream 2 + run(client.create_stream(is_unidirectional=True)) - client.create_stream(is_unidirectional=True) # client receives RESET_STREAM with self.assertRaises(QuicConnectionError) as cm: client._handle_reset_stream_frame( tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("021122000001")), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.RESET_STREAM) self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
aioquic.connection/QuicConnection.__init__
Modified
aiortc~aioquic
71277af8c6d827afa8421c892431ffda49864e24
[connection] add a QuicNetworkPath class
<29>:<add> self._path: Optional[QuicNetworkPath] = None <del> self._peer_addr: Optional
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: <0> if not is_client: <1> assert certificate is not None, "SSL certificate is required" <2> assert private_key is not None, "SSL private key is required" <3> <4> self.alpn_protocols = alpn_protocols <5> self.certificate = certificate <6> self.is_client = is_client <7> self.host_cid = os.urandom(8) <8> self.peer_cid = os.urandom(8) <9> self.peer_cid_set = False <10> self.peer_token = b"" <11> self.private_key = private_key <12> self.secrets_log_file = secrets_log_file <13> self.server_name = server_name <14> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} <15> <16> self.__close: Optional[Dict] = None <17> self.__connected = asyncio.Event() <18> self.__epoch = tls.Epoch.INITIAL <19> self._local_idle_timeout = 60000 # milliseconds <20> self._local_max_data = 1048576 <21> self._local_max_data_used = 0 <22> self._local_max_stream_data_bidi_local = 1048576 <23> self._local_max_stream_data_bidi_remote = 1048576 <24> self._local_max_stream_data_uni = 1048576 <25> self._local_max_streams_bidi = 128 <26> self._local_max_streams_uni = 128 <27> self.__logger = logger <28> self.__path_challenge: Optional[bytes] = None <29> self._peer_addr: Optional</s>
===========below chunk 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: # offset: 1 self._pending_flow_control: List[bytes] = [] self._remote_idle_timeout = 0 # milliseconds self._remote_max_data = 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._spin_bit = 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 # callbacks self.stream_created_cb: Callable[ [asyncio.StreamReader, asyncio.StreamWriter], None ] = lambda r, w: None # frame handlers self.__frame_handlers = [ self._handle_padding_frame, self._handle_padding_frame, self._handle_ack_frame, self._handle_ack_frame, self._handle_reset_stream_frame, self._handle_stop_sending_frame, self._handle_crypto_frame, self._handle_new_token_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, </s> ===========below chunk 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: # offset: 2 <s> self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_max_data_frame, self._handle_max_stream_data_frame, self._handle_max_streams_bidi_frame, self._handle_max_streams_uni_frame, self._handle_data_blocked_frame, self._handle_stream_data_blocked_frame, self._handle_streams_blocked_frame, self._handle_streams_blocked_frame, self._handle_new_connection_id_frame, self._handle_retire_connection_id_frame, self._handle_path_challenge_frame, self._handle_path_response_frame, self._handle_connection_close_frame, self._handle_connection_close_frame, ] ===========unchanged ref 0=========== at: aioquic.connection logger = logging.getLogger("quic") QuicConnectionState() QuicNetworkPath(addr: Any) at: aioquic.connection.QuicConnection _handle_ack_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_crypto_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_data_blocked_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_max_data_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_max_stream_data_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_max_streams_bidi_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_max_streams_uni_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_new_token_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_padding_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_reset_stream_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_stop_sending_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_stream_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None at: aioquic.connection.QuicConnection._handle_crypto_frame self.__epoch = tls.Epoch.ONE_RTT self.__epoch = tls.Epoch.HANDSHAKE at: aioquic.connection.QuicConnection._handle_max_data_frame self._remote_max_data = max_data ===========unchanged ref 1=========== at: aioquic.connection.QuicConnection._handle_max_streams_bidi_frame self._remote_max_streams_bidi = max_streams at: aioquic.connection.QuicConnection._handle_max_streams_uni_frame self._remote_max_streams_uni = max_streams at: aioquic.connection.QuicConnection._handle_stream_frame self._local_max_data_used += newly_received at: aioquic.connection.QuicConnection._parse_transport_parameters self._remote_idle_timeout = quic_transport_parameters.idle_timeout at: aioquic.connection.QuicConnection._send_path_challenge self.__path_challenge = os.urandom(8) at: aioquic.connection.QuicConnection._send_pending self.__send_pending_task = None at: aioquic.connection.QuicConnection._send_soon self.__send_pending_task = loop.call_soon(self._send_pending) at: aioquic.connection.QuicConnection._set_state self.__state = state at: aioquic.connection.QuicConnection._write_application self._pending_flow_control = [] self.__close = None at: aioquic.connection.QuicConnection._write_handshake self.__close = None at: aioquic.connection.QuicConnection.close self.__close = { "error_code": error_code, "frame_type": frame_type, "reason_phrase": reason_phrase, } at: aioquic.connection.QuicConnection.connect self._path = QuicNetworkPath(addr) self._version = max(self.supported_versions) at: aioquic.connection.QuicConnection.connection_made self.__transport = cast(asyncio.DatagramTransport, transport)
aioquic.connection/QuicConnection.connect
Modified
aiortc~aioquic
71277af8c6d827afa8421c892431ffda49864e24
[connection] add a QuicNetworkPath class
<3>:<add> self._path = QuicNetworkPath(addr) <del> self._peer_addr = addr
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def connect(self, addr: Any) -> None: <0> """ <1> Initiate the TLS handshake and wait for it to complete. <2> """ <3> self._peer_addr = addr <4> self._version = max(self.supported_versions) <5> self._connect() <6> await self.__connected.wait() <7>
===========unchanged ref 0=========== at: aioquic.connection QuicConnectionState() maybe_connection_error(error_code: int, frame_type: Optional[int], reason_phrase: str) -> Optional[QuicConnectionError] at: aioquic.connection.QuicConnection connection_lost(exc: Exception) -> None _set_state(state: QuicConnectionState) -> None ===========changed ref 0=========== # module: aioquic.connection + class QuicNetworkPath: + def __init__(self, addr: Any) -> None: + self.addr = addr + ===========changed ref 1=========== # module: aioquic.connection + class QuicNetworkPath: + addr: Any + bytes_received = 0 + bytes_sent = 0 + is_validated = False + ===========changed ref 2=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: if not is_client: assert certificate is not None, "SSL certificate is required" assert private_key is not None, "SSL private key is required" self.alpn_protocols = alpn_protocols self.certificate = certificate self.is_client = is_client self.host_cid = os.urandom(8) self.peer_cid = os.urandom(8) self.peer_cid_set = False self.peer_token = b"" self.private_key = private_key self.secrets_log_file = secrets_log_file self.server_name = server_name self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} self.__close: Optional[Dict] = None self.__connected = asyncio.Event() self.__epoch = tls.Epoch.INITIAL 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 = logger self.__path_challenge: Optional[bytes] = None + self._path: Optional[QuicNetworkPath] = None - self._peer_addr: Optional[Any] = None self._pending_flow_</s> ===========changed ref 3=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: # offset: 1 <s>QuicNetworkPath] = None - self._peer_addr: Optional[Any] = None self._pending_flow_control: List[bytes] = [] self._remote_idle_timeout = 0 # milliseconds self._remote_max_data = 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._spin_bit = 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 # callbacks self.stream_created_cb: Callable[ [asyncio.StreamReader, asyncio.StreamWriter], None ] = lambda r, w: None # frame handlers self.__frame_handlers = [ self._handle_padding_frame, self._handle_padding_frame, self._handle_ack_frame, self._handle_ack_frame, self._handle_reset_stream_frame, self._handle_stop_sending_frame, self._handle_crypto_frame, self._handle_new_</s> ===========changed ref 4=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: # offset: 2 <s>frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_max_data_frame, self._handle_max_stream_data_frame, self._handle_max_streams_bidi_frame, self._handle_max_streams_uni_frame, self._handle_data_blocked_frame, self._handle_stream_data_blocked_frame, self._handle_streams_blocked_frame, self._handle_streams_blocked_frame, self._handle_new_connection_id_frame, self._handle_retire_connection_id_frame, self._handle_path_challenge_frame, self._handle_path_response_frame, self._handle_connection_close_frame, self._handle_connection_close_frame, ]
aioquic.connection/QuicConnection.datagram_received
Modified
aiortc~aioquic
71277af8c6d827afa8421c892431ffda49864e24
[connection] add a QuicNetworkPath class
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: <0> """ <1> Handle an incoming datagram. <2> """ <3> # stop handling packets when closing <4> if self.__state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]: <5> return <6> <7> data = cast(bytes, data) <8> buf = Buffer(data=data) <9> while not buf.eof(): <10> start_off = buf.tell() <11> header = pull_quic_header(buf, host_cid_length=len(self.host_cid)) <12> <13> # check destination CID matches <14> if self.is_client and header.destination_cid != self.host_cid: <15> return <16> <17> # check protocol version <18> if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION: <19> # version negotiation <20> versions = [] <21> while not buf.eof(): <22> versions.append(pull_uint32(buf)) <23> common = set(self.supported_versions).intersection(versions) <24> if not common: <25> self.__logger.error("Could not find a common protocol version") <26> return <27> self._version = QuicProtocolVersion(max(common)) <28> self.__logger.info("Retrying with %s", self._version) <29> self._connect() <30> return <31> elif ( <32> header.version is not None <33> and header.version not in self.supported_versions <34> ): <35> # unsupported version <36> return <37> <38> if self.is_client and header.packet_type == PACKET_TYPE_RETRY: <39> # stateless retry <40> if ( <41> header.destination_cid == self.host_cid <42> and header.original_destination_cid == self.peer_cid <43> ): <44> self.__logger.info("Performing stateless retry") <45> self.peer_cid =</s>
===========below chunk 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: # offset: 1 self.peer_token = header.token self._connect() return # server initialization if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT: assert ( header.packet_type == PACKET_TYPE_INITIAL ), "first packet must be INITIAL" self._peer_addr = addr self._version = QuicProtocolVersion(header.version) self._initialize(header.destination_cid) # decrypt packet encrypted_off = buf.tell() - start_off end_off = buf.tell() + header.rest_length pull_bytes(buf, header.rest_length) epoch = get_epoch(header.packet_type) space = self.spaces[epoch] if not space.crypto.recv.is_valid(): return try: plain_header, plain_payload, packet_number = space.crypto.decrypt_packet( data[start_off:end_off], encrypted_off ) except CryptoError as exc: self.__logger.warning(exc) return if not self.peer_cid_set: self.peer_cid = header.source_cid self.peer_cid_set = True # update state if self.__state == QuicConnectionState.FIRSTFLIGHT: self._set_state(QuicConnectionState.CONNECTED) # update spin bit if ( not is_long_header(plain_header[0]) and packet_number > self._spin_highest_pn ): if self.is_client: self._spin_bit = not get_spin_bit(plain_header[0]) else: self._spin_bit = get_spin_bit(plain_header[0]) self._spin_highest_pn = packet_number </s> ===========below chunk 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: # offset: 2 <s>_bit = get_spin_bit(plain_header[0]) self._spin_highest_pn = packet_number # handle payload try: is_ack_only = self._payload_received(epoch, plain_payload) except QuicConnectionError as exc: self.__logger.warning(exc) self.close( error_code=exc.error_code, frame_type=exc.frame_type, reason_phrase=exc.reason_phrase, ) return # record packet as received space.ack_queue.add(packet_number) if not is_ack_only: self.send_ack[epoch] = True self._send_pending() ===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) pull_bytes(buf: Buffer, length: int) -> bytes pull_uint32(buf: Buffer) -> int at: aioquic.buffer.Buffer eof() -> bool tell() -> int at: aioquic.connection get_epoch(packet_type: int) -> tls.Epoch QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) QuicConnectionState() QuicNetworkPath(addr: Any) at: aioquic.connection.PacketSpace.__init__ self.crypto = CryptoPair() at: aioquic.connection.QuicConnection supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20] close(error_code: int=QuicErrorCode.NO_ERROR, frame_type: Optional[int]=None, reason_phrase: str="") -> None _connect() -> None _initialize(peer_cid: bytes) -> None _payload_received(epoch: tls.Epoch, plain: bytes) -> Tuple[bool, bool] _payload_received(self, epoch: tls.Epoch, plain: bytes) -> Tuple[bool, bool] _set_state(state: QuicConnectionState) -> None at: aioquic.connection.QuicConnection.__init__ self.is_client = is_client self.host_cid = os.urandom(8) self.peer_cid = os.urandom(8) self.peer_cid_set = False self.peer_token = b"" self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} self.__logger = logger self._path: Optional[QuicNetworkPath] = None self._spin_bit = False self._spin_highest_pn = 0 ===========unchanged ref 1=========== self.__state = QuicConnectionState.FIRSTFLIGHT self.__transport: Optional[asyncio.DatagramTransport] = None self._version: Optional[int] = None at: aioquic.connection.QuicConnection._initialize self.spaces = { tls.Epoch.INITIAL: PacketSpace(), tls.Epoch.HANDSHAKE: PacketSpace(), tls.Epoch.ONE_RTT: PacketSpace(), } at: aioquic.connection.QuicConnection._set_state self.__state = state at: aioquic.connection.QuicConnection.connect self._path = QuicNetworkPath(addr) self._version = max(self.supported_versions) at: aioquic.connection.QuicConnectionError.__init__ self.error_code = error_code self.frame_type = frame_type at: aioquic.crypto CryptoError(*args: object) at: aioquic.crypto.CryptoContext is_valid() -> bool at: aioquic.crypto.CryptoPair decrypt_packet(packet: bytes, encrypted_offset: int) -> Tuple[bytes, bytes, int] at: aioquic.crypto.CryptoPair.__init__ self.recv = CryptoContext() at: aioquic.packet PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00 PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30 QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int) QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) get_spin_bit(first_byte: int) -> bool is_long_header(first_byte: int) -> bool pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader at: aioquic.packet.QuicHeader version: Optional[int]
aioquic.connection/QuicConnection._payload_received
Modified
aiortc~aioquic
71277af8c6d827afa8421c892431ffda49864e24
[connection] add a QuicNetworkPath class
<3>:<add> is_probing = None <11>:<add> <add> if frame_type not in [ <add> QuicFrameType.PATH_CHALLENGE, <add> QuicFrameType.PATH_RESPONSE, <add> QuicFrameType.PADDING, <add> QuicFrameType.NEW_CONNECTION_ID, <add> ]: <add> is_probing = False <add> elif is_probing is None: <add> is_probing = True <23>:<add> return is_ack_only, bool(is_probing) <del> return is_ack_only
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> Tuple[bool, bool]: - def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool: <0> buf = Buffer(data=plain) <1> <2> is_ack_only = True <3> while not buf.eof(): <4> frame_type = pull_uint_var(buf) <5> if frame_type not in [ <6> QuicFrameType.ACK, <7> QuicFrameType.ACK_ECN, <8> QuicFrameType.PADDING, <9> ]: <10> is_ack_only = False <11> <12> if frame_type < len(self.__frame_handlers): <13> self.__frame_handlers[frame_type](epoch, frame_type, buf) <14> else: <15> raise QuicConnectionError( <16> error_code=QuicErrorCode.PROTOCOL_VIOLATION, <17> frame_type=frame_type, <18> reason_phrase="Unexpected frame type", <19> ) <20> <21> self._push_crypto_data() <22> <23> return is_ack_only <24>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.buffer.Buffer eof() -> bool at: aioquic.connection.QuicConnection _get_or_create_stream(frame_type: int, stream_id: int) -> QuicStream at: aioquic.connection.QuicConnection._handle_stream_data_blocked_frame stream_id = pull_uint_var(buf) at: aioquic.packet pull_uint_var(buf: Buffer) -> int QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: aioquic.tls Epoch() at: typing Tuple = _TupleType(tuple, -1, inst=False, name='Tuple') ===========changed ref 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def connect(self, addr: Any) -> None: """ Initiate the TLS handshake and wait for it to complete. """ + self._path = QuicNetworkPath(addr) - self._peer_addr = addr self._version = max(self.supported_versions) self._connect() await self.__connected.wait() ===========changed ref 1=========== # module: aioquic.connection + class QuicNetworkPath: + def __init__(self, addr: Any) -> None: + self.addr = addr + ===========changed ref 2=========== # module: aioquic.connection + class QuicNetworkPath: + addr: Any + bytes_received = 0 + bytes_sent = 0 + is_validated = False + ===========changed ref 3=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def datagram_received(self, data: Union[bytes, Text], addr: Any) -> 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 if self.is_client and header.destination_cid != self.host_cid: 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.__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 ): self.__logger.info("Performing stateless retry") self.peer_cid = header.source_cid self.peer_token = header.token self._connect() return # server initialization if not self.is_client and self.__state == Qu</s> ===========changed ref 4=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: # offset: 1 <s> self._connect() return # server initialization if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT: assert ( header.packet_type == PACKET_TYPE_INITIAL ), "first packet must be INITIAL" + self._path = QuicNetworkPath(addr) - self._peer_addr = addr self._version = QuicProtocolVersion(header.version) self._initialize(header.destination_cid) # decrypt packet encrypted_off = buf.tell() - start_off end_off = buf.tell() + header.rest_length pull_bytes(buf, header.rest_length) epoch = get_epoch(header.packet_type) space = self.spaces[epoch] if not space.crypto.recv.is_valid(): return try: plain_header, plain_payload, packet_number = space.crypto.decrypt_packet( data[start_off:end_off], encrypted_off ) except CryptoError as exc: self.__logger.warning(exc) return if not self.peer_cid_set: self.peer_cid = header.source_cid self.peer_cid_set = True # update state if self.__state == QuicConnectionState.FIRSTFLIGHT: self._set_state(QuicConnectionState.CONNECTED) # update spin bit if ( not is_long_header(plain_header[0]) and packet_number > self._spin_highest_pn ): if self.is_client: self._spin_bit = not get_spin_bit(plain_header[0]) </s> ===========changed ref 5=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: # offset: 2 <s>: self._spin_bit = get_spin_bit(plain_header[0]) self._spin_highest_pn = packet_number # handle payload try: + is_ack_only, is_probing = self._payload_received(epoch, plain_payload) - is_ack_only = self._payload_received(epoch, plain_payload) except QuicConnectionError as exc: self.__logger.warning(exc) self.close( error_code=exc.error_code, frame_type=exc.frame_type, reason_phrase=exc.reason_phrase, ) return # record packet as received + self._path.bytes_received += buf.tell() - start_off space.ack_queue.add(packet_number) if not is_ack_only: self.send_ack[epoch] = True self._send_pending()
aioquic.connection/QuicConnection._send_pending
Modified
aiortc~aioquic
71277af8c6d827afa8421c892431ffda49864e24
[connection] add a QuicNetworkPath class
<1>:<add> self.__transport.sendto(datagram, self._path.addr) <del> self.__transport.sendto(datagram, self._peer_addr) <2>:<add> self._path.bytes_sent += len(datagram)
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _send_pending(self) -> None: <0> for datagram in self._pending_datagrams(): <1> self.__transport.sendto(datagram, self._peer_addr) <2> self.__send_pending_task = None <3>
===========unchanged ref 0=========== at: aioquic.connection.QuicConnection _push_crypto_data() -> None at: aioquic.connection.QuicConnection._payload_received is_ack_only = True is_ack_only = False is_probing = False is_probing = None is_probing = True ===========changed ref 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> Tuple[bool, bool]: - def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool: buf = Buffer(data=plain) is_ack_only = True + is_probing = None while not buf.eof(): frame_type = pull_uint_var(buf) if frame_type not in [ QuicFrameType.ACK, QuicFrameType.ACK_ECN, QuicFrameType.PADDING, ]: is_ack_only = False + + 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 if frame_type < len(self.__frame_handlers): self.__frame_handlers[frame_type](epoch, frame_type, buf) else: raise QuicConnectionError( error_code=QuicErrorCode.PROTOCOL_VIOLATION, frame_type=frame_type, reason_phrase="Unexpected frame type", ) self._push_crypto_data() + return is_ack_only, bool(is_probing) - return is_ack_only ===========changed ref 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def connect(self, addr: Any) -> None: """ Initiate the TLS handshake and wait for it to complete. """ + self._path = QuicNetworkPath(addr) - self._peer_addr = addr self._version = max(self.supported_versions) self._connect() await self.__connected.wait() ===========changed ref 2=========== # module: aioquic.connection + class QuicNetworkPath: + def __init__(self, addr: Any) -> None: + self.addr = addr + ===========changed ref 3=========== # module: aioquic.connection + class QuicNetworkPath: + addr: Any + bytes_received = 0 + bytes_sent = 0 + is_validated = False + ===========changed ref 4=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def datagram_received(self, data: Union[bytes, Text], addr: Any) -> 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 if self.is_client and header.destination_cid != self.host_cid: 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.__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 ): self.__logger.info("Performing stateless retry") self.peer_cid = header.source_cid self.peer_token = header.token self._connect() return # server initialization if not self.is_client and self.__state == Qu</s> ===========changed ref 5=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: # offset: 1 <s> self._connect() return # server initialization if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT: assert ( header.packet_type == PACKET_TYPE_INITIAL ), "first packet must be INITIAL" + self._path = QuicNetworkPath(addr) - self._peer_addr = addr self._version = QuicProtocolVersion(header.version) self._initialize(header.destination_cid) # decrypt packet encrypted_off = buf.tell() - start_off end_off = buf.tell() + header.rest_length pull_bytes(buf, header.rest_length) epoch = get_epoch(header.packet_type) space = self.spaces[epoch] if not space.crypto.recv.is_valid(): return try: plain_header, plain_payload, packet_number = space.crypto.decrypt_packet( data[start_off:end_off], encrypted_off ) except CryptoError as exc: self.__logger.warning(exc) return if not self.peer_cid_set: self.peer_cid = header.source_cid self.peer_cid_set = True # update state if self.__state == QuicConnectionState.FIRSTFLIGHT: self._set_state(QuicConnectionState.CONNECTED) # update spin bit if ( not is_long_header(plain_header[0]) and packet_number > self._spin_highest_pn ): if self.is_client: self._spin_bit = not get_spin_bit(plain_header[0]) </s> ===========changed ref 6=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: # offset: 2 <s>: self._spin_bit = get_spin_bit(plain_header[0]) self._spin_highest_pn = packet_number # handle payload try: + is_ack_only, is_probing = self._payload_received(epoch, plain_payload) - is_ack_only = self._payload_received(epoch, plain_payload) except QuicConnectionError as exc: self.__logger.warning(exc) self.close( error_code=exc.error_code, frame_type=exc.frame_type, reason_phrase=exc.reason_phrase, ) return # record packet as received + self._path.bytes_received += buf.tell() - start_off space.ack_queue.add(packet_number) if not is_ack_only: self.send_ack[epoch] = True self._send_pending()
tests.test_connection/create_standalone_client
Modified
aiortc~aioquic
71277af8c6d827afa8421c892431ffda49864e24
[connection] add a QuicNetworkPath class
<4>:<add> # like connect() but without waiting <add> client._path = QuicNetworkPath(SERVER_ADDR) <del> client._peer_addr = SERVER_ADDR
# module: tests.test_connection def create_standalone_client(): <0> client = QuicConnection(is_client=True) <1> client_transport = FakeTransport(CLIENT_ADDR) <2> client.connection_made(client_transport) <3> <4> client._peer_addr = SERVER_ADDR <5> client._version = max(client.supported_versions) <6> client._connect() <7> <8> return client, client_transport <9>
===========unchanged ref 0=========== at: aioquic.connection QuicNetworkPath(addr: Any) QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20] connection_made(transport: asyncio.BaseTransport) -> None _connect() -> None at: aioquic.connection.QuicConnection.__init__ self._path: Optional[QuicNetworkPath] = None self._version: Optional[int] = None at: aioquic.connection.QuicConnection.connect self._path = QuicNetworkPath(addr) self._version = max(self.supported_versions) at: aioquic.connection.QuicConnection.datagram_received self._version = QuicProtocolVersion(header.version) self._version = QuicProtocolVersion(max(common)) self._path = QuicNetworkPath(addr) at: tests.test_connection CLIENT_ADDR = None SERVER_ADDR = None FakeTransport(local_addr) ===========changed ref 0=========== # module: aioquic.connection + class QuicNetworkPath: + addr: Any + bytes_received = 0 + bytes_sent = 0 + is_validated = False + ===========changed ref 1=========== # module: aioquic.connection + class QuicNetworkPath: + def __init__(self, addr: Any) -> None: + self.addr = addr + ===========changed ref 2=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def connect(self, addr: Any) -> None: """ Initiate the TLS handshake and wait for it to complete. """ + self._path = QuicNetworkPath(addr) - self._peer_addr = addr self._version = max(self.supported_versions) self._connect() await self.__connected.wait() ===========changed ref 3=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _send_pending(self) -> None: for datagram in self._pending_datagrams(): + self.__transport.sendto(datagram, self._path.addr) - self.__transport.sendto(datagram, self._peer_addr) + self._path.bytes_sent += len(datagram) self.__send_pending_task = None ===========changed ref 4=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> Tuple[bool, bool]: - def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool: buf = Buffer(data=plain) is_ack_only = True + is_probing = None while not buf.eof(): frame_type = pull_uint_var(buf) if frame_type not in [ QuicFrameType.ACK, QuicFrameType.ACK_ECN, QuicFrameType.PADDING, ]: is_ack_only = False + + 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 if frame_type < len(self.__frame_handlers): self.__frame_handlers[frame_type](epoch, frame_type, buf) else: raise QuicConnectionError( error_code=QuicErrorCode.PROTOCOL_VIOLATION, frame_type=frame_type, reason_phrase="Unexpected frame type", ) self._push_crypto_data() + return is_ack_only, bool(is_probing) - return is_ack_only ===========changed ref 5=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: if not is_client: assert certificate is not None, "SSL certificate is required" assert private_key is not None, "SSL private key is required" self.alpn_protocols = alpn_protocols self.certificate = certificate self.is_client = is_client self.host_cid = os.urandom(8) self.peer_cid = os.urandom(8) self.peer_cid_set = False self.peer_token = b"" self.private_key = private_key self.secrets_log_file = secrets_log_file self.server_name = server_name self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} self.__close: Optional[Dict] = None self.__connected = asyncio.Event() self.__epoch = tls.Epoch.INITIAL 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 = logger self.__path_challenge: Optional[bytes] = None + self._path: Optional[QuicNetworkPath] = None - self._peer_addr: Optional[Any] = None self._pending_flow_</s>
tests.test_connection/create_transport
Modified
aiortc~aioquic
71277af8c6d827afa8421c892431ffda49864e24
[connection] add a QuicNetworkPath class
<9>:<add> # like connect() but without waiting <add> client._path = QuicNetworkPath(SERVER_ADDR) <del> client._peer_addr = SERVER_ADDR
# module: tests.test_connection def create_transport(client, server): <0> client_transport = FakeTransport(CLIENT_ADDR) <1> client_transport.target = server <2> <3> server_transport = FakeTransport(SERVER_ADDR) <4> server_transport.target = client <5> <6> server.connection_made(server_transport) <7> client.connection_made(client_transport) <8> <9> client._peer_addr = SERVER_ADDR <10> client._version = max(client.supported_versions) <11> client._connect() <12> <13> return client_transport, server_transport <14>
===========unchanged ref 0=========== at: aioquic.connection QuicNetworkPath(addr: Any) at: aioquic.connection.QuicConnection supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20] connection_made(transport: asyncio.BaseTransport) -> None _connect() -> None at: aioquic.connection.QuicConnection.__init__ self._path: Optional[QuicNetworkPath] = None self._version: Optional[int] = None at: aioquic.connection.QuicConnection.connect self._path = QuicNetworkPath(addr) self._version = max(self.supported_versions) at: aioquic.connection.QuicConnection.datagram_received self._version = QuicProtocolVersion(header.version) self._version = QuicProtocolVersion(max(common)) self._path = QuicNetworkPath(addr) at: tests.test_connection CLIENT_ADDR = None SERVER_ADDR = None FakeTransport(local_addr) at: tests.test_connection.FakeTransport sent = 0 target = None ===========changed ref 0=========== # module: aioquic.connection + class QuicNetworkPath: + addr: Any + bytes_received = 0 + bytes_sent = 0 + is_validated = False + ===========changed ref 1=========== # module: tests.test_connection def create_standalone_client(): client = QuicConnection(is_client=True) client_transport = FakeTransport(CLIENT_ADDR) client.connection_made(client_transport) + # like connect() but without waiting + client._path = QuicNetworkPath(SERVER_ADDR) - client._peer_addr = SERVER_ADDR client._version = max(client.supported_versions) client._connect() return client, client_transport ===========changed ref 2=========== # module: aioquic.connection + class QuicNetworkPath: + def __init__(self, addr: Any) -> None: + self.addr = addr + ===========changed ref 3=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def connect(self, addr: Any) -> None: """ Initiate the TLS handshake and wait for it to complete. """ + self._path = QuicNetworkPath(addr) - self._peer_addr = addr self._version = max(self.supported_versions) self._connect() await self.__connected.wait() ===========changed ref 4=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _send_pending(self) -> None: for datagram in self._pending_datagrams(): + self.__transport.sendto(datagram, self._path.addr) - self.__transport.sendto(datagram, self._peer_addr) + self._path.bytes_sent += len(datagram) self.__send_pending_task = None ===========changed ref 5=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> Tuple[bool, bool]: - def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool: buf = Buffer(data=plain) is_ack_only = True + is_probing = None while not buf.eof(): frame_type = pull_uint_var(buf) if frame_type not in [ QuicFrameType.ACK, QuicFrameType.ACK_ECN, QuicFrameType.PADDING, ]: is_ack_only = False + + 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 if frame_type < len(self.__frame_handlers): self.__frame_handlers[frame_type](epoch, frame_type, buf) else: raise QuicConnectionError( error_code=QuicErrorCode.PROTOCOL_VIOLATION, frame_type=frame_type, reason_phrase="Unexpected frame type", ) self._push_crypto_data() + return is_ack_only, bool(is_probing) - return is_ack_only ===========changed ref 6=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: if not is_client: assert certificate is not None, "SSL certificate is required" assert private_key is not None, "SSL private key is required" self.alpn_protocols = alpn_protocols self.certificate = certificate self.is_client = is_client self.host_cid = os.urandom(8) self.peer_cid = os.urandom(8) self.peer_cid_set = False self.peer_token = b"" self.private_key = private_key self.secrets_log_file = secrets_log_file self.server_name = server_name self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} self.__close: Optional[Dict] = None self.__connected = asyncio.Event() self.__epoch = tls.Epoch.INITIAL 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 = logger self.__path_challenge: Optional[bytes] = None + self._path: Optional[QuicNetworkPath] = None - self._peer_addr: Optional[Any] = None self._pending_flow_</s>
aioquic.crypto/CryptoContext.decrypt_packet
Modified
aiortc~aioquic
558847dfee9374f73872ecb4ee6894a4231908a9
[packet] move PACKET_NUMBER_MAX_SIZE constant
<4>:<add> sample_offset = encrypted_offset + PACKET_NUMBER_MAX_SIZE <del> sample_offset = encrypted_offset + MAX_PN_SIZE
# module: aioquic.crypto class CryptoContext: def decrypt_packet( self, packet: bytes, encrypted_offset: int ) -> Tuple[bytes, bytes, int, bool]: <0> assert self.is_valid(), "Decryption key is not available" <1> <2> # header protection <3> packet = bytearray(packet) <4> sample_offset = encrypted_offset + MAX_PN_SIZE <5> sample = packet[sample_offset : sample_offset + SAMPLE_SIZE] <6> mask = self.header_protection_mask(sample) <7> <8> if is_long_header(packet[0]): <9> # long header <10> packet[0] ^= mask[0] & 0x0F <11> else: <12> # short header <13> packet[0] ^= mask[0] & 0x1F <14> <15> pn_length = (packet[0] & 0x03) + 1 <16> for i in range(pn_length): <17> packet[encrypted_offset + i] ^= mask[1 + i] <18> pn = packet[encrypted_offset : encrypted_offset + pn_length] <19> plain_header = bytes(packet[: encrypted_offset + pn_length]) <20> <21> # detect key phase change <22> crypto = self <23> if not is_long_header(packet[0]): <24> key_phase = (packet[0] & 4) >> 2 <25> if key_phase != self.key_phase: <26> crypto = self.next_key_phase() <27> <28> # payload protection <29> nonce = bytearray(len(crypto.iv) - pn_length) + bytearray(pn) <30> for i in range(len(crypto.iv)): <31> nonce[i] ^= crypto.iv[i] <32> try: <33> payload = crypto.aead.decrypt( <34> nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header <35> ) <36> except InvalidTag: <37> raise CryptoError("Payload decryption failed") <38> <39> # packet number <40> packet_number = 0 <41> for i in range</s>
===========below chunk 0=========== # module: aioquic.crypto class CryptoContext: def decrypt_packet( self, packet: bytes, encrypted_offset: int ) -> Tuple[bytes, bytes, int, bool]: # offset: 1 packet_number = (packet_number << 8) | pn[i] return plain_header, payload, packet_number, crypto != self ===========unchanged ref 0=========== at: aioquic.crypto SAMPLE_SIZE = 16 CryptoError(*args: object) at: aioquic.crypto.CryptoContext header_protection_mask(sample: bytes) -> bytes is_valid() -> bool next_key_phase() -> CryptoContext at: aioquic.crypto.CryptoContext.__init__ self.iv: Optional[bytes] self.key_phase = key_phase at: aioquic.crypto.CryptoContext.apply_key_phase self.iv = crypto.iv self.key_phase = crypto.key_phase at: aioquic.crypto.CryptoContext.setup key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret) at: aioquic.crypto.CryptoContext.teardown self.iv = None at: aioquic.packet PACKET_NUMBER_MAX_SIZE = 4 is_long_header(first_byte: int) -> bool at: typing Tuple = _TupleType(tuple, -1, inst=False, name='Tuple') ===========changed ref 0=========== # module: aioquic.crypto INITIAL_CIPHER_SUITE = CipherSuite.AES_128_GCM_SHA256 INITIAL_SALT = binascii.unhexlify("ef4fb0abb47470c41befcf8031334fae485e09a0") - MAX_PN_SIZE = 4 SAMPLE_SIZE = 16 ===========changed ref 1=========== # module: aioquic.packet PACKET_LONG_HEADER = 0x80 PACKET_FIXED_BIT = 0x40 PACKET_SPIN_BIT = 0x20 PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00 PACKET_TYPE_0RTT = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x10 PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20 PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30 PACKET_TYPE_MASK = 0xF0 + PACKET_NUMBER_MAX_SIZE = 4 PACKET_NUMBER_SEND_SIZE = 2 UINT_VAR_FORMATS = [ (pull_uint8, push_uint8, 0x3F), (pull_uint16, push_uint16, 0x3FFF), (pull_uint32, push_uint32, 0x3FFFFFFF), (pull_uint64, push_uint64, 0x3FFFFFFFFFFFFFFF), ]
aioquic.crypto/CryptoContext.encrypt_packet
Modified
aiortc~aioquic
558847dfee9374f73872ecb4ee6894a4231908a9
[packet] move PACKET_NUMBER_MAX_SIZE constant
<13>:<add> sample_offset = PACKET_NUMBER_MAX_SIZE - pn_length <del> sample_offset = MAX_PN_SIZE - pn_length
# module: aioquic.crypto class CryptoContext: def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes: <0> assert self.is_valid(), "Encryption key is not available" <1> <2> pn_length = (plain_header[0] & 0x03) + 1 <3> pn_offset = len(plain_header) - pn_length <4> pn = plain_header[pn_offset : pn_offset + pn_length] <5> <6> # payload protection <7> nonce = bytearray(len(self.iv) - pn_length) + bytearray(pn) <8> for i in range(len(self.iv)): <9> nonce[i] ^= self.iv[i] <10> protected_payload = self.aead.encrypt(nonce, plain_payload, plain_header) <11> <12> # header protection <13> sample_offset = MAX_PN_SIZE - pn_length <14> sample = protected_payload[sample_offset : sample_offset + SAMPLE_SIZE] <15> mask = self.header_protection_mask(sample) <16> <17> packet = bytearray(plain_header + protected_payload) <18> if is_long_header(packet[0]): <19> # long header <20> packet[0] ^= mask[0] & 0x0F <21> else: <22> # short header <23> packet[0] ^= mask[0] & 0x1F <24> <25> for i in range(pn_length): <26> packet[pn_offset + i] ^= mask[1 + i] <27> <28> return bytes(packet) <29>
===========unchanged ref 0=========== at: aioquic.crypto SAMPLE_SIZE = 16 at: aioquic.crypto.CryptoContext header_protection_mask(sample: bytes) -> bytes is_valid() -> bool at: aioquic.crypto.CryptoContext.__init__ self.aead: Optional[Any] self.iv: Optional[bytes] at: aioquic.crypto.CryptoContext.apply_key_phase self.aead = crypto.aead self.iv = crypto.iv at: aioquic.crypto.CryptoContext.setup key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret) self.aead = cipher_suite_aead(cipher_suite, key) at: aioquic.crypto.CryptoContext.teardown self.aead = None self.iv = None at: aioquic.packet PACKET_NUMBER_MAX_SIZE = 4 is_long_header(first_byte: int) -> bool ===========changed ref 0=========== # module: aioquic.crypto INITIAL_CIPHER_SUITE = CipherSuite.AES_128_GCM_SHA256 INITIAL_SALT = binascii.unhexlify("ef4fb0abb47470c41befcf8031334fae485e09a0") - MAX_PN_SIZE = 4 SAMPLE_SIZE = 16 ===========changed ref 1=========== # module: aioquic.crypto class CryptoContext: def decrypt_packet( self, packet: bytes, encrypted_offset: int ) -> Tuple[bytes, bytes, int, bool]: assert self.is_valid(), "Decryption key is not available" # header protection packet = bytearray(packet) + sample_offset = encrypted_offset + PACKET_NUMBER_MAX_SIZE - sample_offset = encrypted_offset + MAX_PN_SIZE sample = packet[sample_offset : sample_offset + SAMPLE_SIZE] mask = self.header_protection_mask(sample) if is_long_header(packet[0]): # long header packet[0] ^= mask[0] & 0x0F else: # short header packet[0] ^= mask[0] & 0x1F pn_length = (packet[0] & 0x03) + 1 for i in range(pn_length): packet[encrypted_offset + i] ^= mask[1 + i] pn = packet[encrypted_offset : encrypted_offset + pn_length] plain_header = bytes(packet[: encrypted_offset + pn_length]) # detect key phase change crypto = self if not is_long_header(packet[0]): key_phase = (packet[0] & 4) >> 2 if key_phase != self.key_phase: crypto = self.next_key_phase() # payload protection nonce = bytearray(len(crypto.iv) - pn_length) + bytearray(pn) for i in range(len(crypto.iv)): nonce[i] ^= crypto.iv[i] try: payload = crypto.aead.decrypt( nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header ) except InvalidTag: raise CryptoError("Payload decryption failed") # packet number packet_number = 0 for i in range(pn_length): packet_number = (packet_number << 8) | pn[i</s> ===========changed ref 2=========== # module: aioquic.crypto class CryptoContext: def decrypt_packet( self, packet: bytes, encrypted_offset: int ) -> Tuple[bytes, bytes, int, bool]: # offset: 1 <s> = 0 for i in range(pn_length): packet_number = (packet_number << 8) | pn[i] return plain_header, payload, packet_number, crypto != self ===========changed ref 3=========== # module: aioquic.packet PACKET_LONG_HEADER = 0x80 PACKET_FIXED_BIT = 0x40 PACKET_SPIN_BIT = 0x20 PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00 PACKET_TYPE_0RTT = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x10 PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20 PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30 PACKET_TYPE_MASK = 0xF0 + PACKET_NUMBER_MAX_SIZE = 4 PACKET_NUMBER_SEND_SIZE = 2 UINT_VAR_FORMATS = [ (pull_uint8, push_uint8, 0x3F), (pull_uint16, push_uint16, 0x3FFF), (pull_uint32, push_uint32, 0x3FFFFFFF), (pull_uint64, push_uint64, 0x3FFFFFFFFFFFFFFF), ]
examples.server/serve_http_request
Modified
aiortc~aioquic
c87cd489101fd51b54381bb892d58d54f2a33748
[examples] make server return more data
<6>:<add> writer.write(TEMPLATE.format(content="It works!").encode("utf8")) <del> writer.write(b"It works!\r\n") <8>:<add> writer.write( <add> TEMPLATE.format(content="The document could not be found.").encode("utf8") <add> ) <del> writer.write(b"Not found\r\n")
# module: examples.server def serve_http_request(reader, writer): <0> """ <1> Serve an HTTP/0.9 request. <2> """ <3> request = await reader.read() <4> <5> if request == b"GET /\r\n": <6> writer.write(b"It works!\r\n") <7> else: <8> writer.write(b"Not found\r\n") <9> <10> writer.write_eof() <11>
===========unchanged ref 0=========== at: aioquic.connection.QuicConnection.__init__ self.host_cid = os.urandom(8) at: binascii hexlify(data: bytes, sep: Union[str, bytes]=..., bytes_per_sep: int=...) -> bytes ===========changed ref 0=========== # module: examples.server logger = logging.getLogger("server") + TEMPLATE = """<!DOCTYPE html> + <html> + <head> + <meta charset="utf-8"/> + <title>aioquic</title> + </head> + <body> + <h1>Welcome to aioquic</h1> + <p>{content}/p> + </body> + </html> + """ +
aioquic.stream/QuicStream.get_frame
Modified
aiortc~aioquic
135636bd74280024db5dae53ddbcf8193e201b27
[stream] do not send more data than MAX_STREAM_DATA allows
<6>:<add> <add> # flow control <add> if self.stream_id is not None: <add> size = min(size, self.max_stream_data_remote - self._send_start) <add>
# module: aioquic.stream class QuicStream: def get_frame(self, size: int) -> QuicStreamFrame: <0> """ <1> Get a frame of data to send. <2> """ <3> assert not self._send_complete, "cannot call get_frame() after completion" <4> <5> size = min(size, len(self._send_buffer)) <6> frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start) <7> self._send_buffer = self._send_buffer[size:] <8> self._send_start += size <9> <10> # if the buffer is empty and EOF was written, set the FIN bit <11> if self._send_eof and not self._send_buffer: <12> frame.fin = True <13> self._send_complete = True <14> <15> return frame <16>
===========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.stream.QuicStream.__init__ self.max_stream_data_remote = max_stream_data_remote self._send_buffer = bytearray() self._send_complete = False self._send_start = 0 at: aioquic.stream.QuicStream.get_frame self._send_complete = True at: aioquic.stream.QuicStream.write self._send_buffer += data
aioquic.connection/QuicConnection._write_application
Modified
aiortc~aioquic
135636bd74280024db5dae53ddbcf8193e201b27
[stream] do not send more data than MAX_STREAM_DATA allows
<38>:<add> if ( <add> isinstance(stream_id, int) <add> and stream.has_data_to_send() <del> if isinstance(stream_id, int) and stream.has_data_to_send(): <39>:<add> and not stream.is_blocked() <add> ):
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _write_application(self) -> Iterator[bytes]: <0> epoch = tls.Epoch.ONE_RTT <1> space = self.spaces[epoch] <2> if not space.crypto.send.is_valid(): <3> return <4> <5> buf = Buffer(capacity=PACKET_MAX_SIZE) <6> <7> while True: <8> # write header <9> push_uint8( <10> buf, <11> PACKET_FIXED_BIT <12> | (self._spin_bit << 5) <13> | (space.crypto.key_phase << 2) <14> | (PACKET_NUMBER_SEND_SIZE - 1), <15> ) <16> push_bytes(buf, self.peer_cid) <17> push_uint16(buf, self.packet_number) <18> header_size = buf.tell() <19> <20> # ACK <21> if self.send_ack[epoch] and space.ack_queue: <22> push_uint_var(buf, QuicFrameType.ACK) <23> packet.push_ack_frame(buf, space.ack_queue, 0) <24> self.send_ack[epoch] = False <25> <26> # FLOW CONTROL <27> for control_frame in self._pending_flow_control: <28> push_bytes(buf, control_frame) <29> self._pending_flow_control = [] <30> <31> # CLOSE <32> if self.__close and self.__epoch == epoch: <33> push_close(buf, **self.__close) <34> self.__close = None <35> <36> # STREAM <37> for stream_id, stream in self.streams.items(): <38> if isinstance(stream_id, int) and stream.has_data_to_send(): <39> frame = stream.get_frame( <40> PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6 <41> ) <42> flags = QuicStreamFlag.LEN <43> if frame.offset: <44> flags |= QuicStream</s>
===========below chunk 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _write_application(self) -> Iterator[bytes]: # offset: 1 if frame.fin: flags |= QuicStreamFlag.FIN push_uint_var(buf, QuicFrameType.STREAM_BASE | flags) with push_stream_frame(buf, 0, frame.offset): push_bytes(buf, frame.data) packet_size = buf.tell() if packet_size > header_size: # encrypt data = buf.data yield space.crypto.encrypt_packet( data[0:header_size], data[header_size:packet_size] ) self.packet_number += 1 buf.seek(0) else: break ===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) push_bytes(buf: Buffer, v: bytes) -> None push_uint8(buf: Buffer, v: int) -> None push_uint16(buf: Buffer, v: int) -> None at: aioquic.buffer.Buffer tell() -> int at: aioquic.connection PACKET_MAX_SIZE = 1280 push_close(buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None at: aioquic.connection.PacketSpace.__init__ self.ack_queue = RangeSet() self.crypto = CryptoPair() at: aioquic.connection.QuicConnection supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20] at: aioquic.connection.QuicConnection.__init__ self.peer_cid = os.urandom(8) self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} self.__close: Optional[Dict] = None self.__epoch = tls.Epoch.INITIAL self._pending_flow_control: List[bytes] = [] self._spin_bit = 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.send_ack = { tls.Epoch.INITIAL: False, tls.Epoch.HANDSHAKE: False, tls.Epoch.ONE_RTT: False, } self.spaces = { tls.Epoch.INITIAL: PacketSpace(), tls.Epoch.HANDSHAKE: PacketSpace(), tls.Epoch.ONE_RTT: PacketSpace(), } self.packet_number = 0 ===========unchanged ref 1=========== at: aioquic.connection.QuicConnection._write_application self.packet_number += 1 at: aioquic.connection.QuicConnection._write_handshake self.__close = None self.packet_number += 1 at: aioquic.connection.QuicConnection.close self.__close = { "error_code": error_code, "frame_type": frame_type, "reason_phrase": reason_phrase, } at: aioquic.connection.QuicConnection.datagram_received self.peer_cid = header.source_cid self._spin_bit = not get_spin_bit(plain_header[0]) self._spin_bit = get_spin_bit(plain_header[0]) at: aioquic.crypto.CryptoContext is_valid() -> bool at: aioquic.crypto.CryptoPair encrypt_packet(plain_header: bytes, plain_payload: bytes) -> bytes at: aioquic.crypto.CryptoPair.__init__ self.aead_tag_size = 16 self.send = CryptoContext() at: aioquic.packet PACKET_FIXED_BIT = 0x40 PACKET_NUMBER_SEND_SIZE = 2 push_uint_var(buf: Buffer, value: int) -> None QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) push_ack_frame(buf: Buffer, rangeset: RangeSet, delay: int) -> None QuicStreamFlag(x: Union[str, bytes, bytearray], base: int) QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) push_stream_frame(buf: Buffer, stream_id: int, offset: int) -> Generator at: aioquic.packet.QuicStreamFrame data: bytes = b"" ===========unchanged ref 2=========== fin: bool = False offset: int = 0 at: aioquic.stream.QuicStream get_frame(size: int) -> QuicStreamFrame has_data_to_send() -> bool is_blocked() at: aioquic.tls Epoch() at: typing Iterator = _alias(collections.abc.Iterator, 1) ===========changed ref 0=========== # module: aioquic.stream class QuicStream: + def is_blocked(self): + """ + Returns True if there is data to send but the peer's MAX_STREAM_DATA + prevents us from sending it. + """ + return self._send_buffer and self._send_start >= self.max_stream_data_remote + ===========changed ref 1=========== # module: aioquic.stream class QuicStream: def get_frame(self, size: int) -> QuicStreamFrame: """ Get a frame of data to send. """ assert not self._send_complete, "cannot call get_frame() after completion" size = min(size, len(self._send_buffer)) + + # flow control + if self.stream_id is not None: + size = min(size, self.max_stream_data_remote - self._send_start) + frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start) self._send_buffer = self._send_buffer[size:] self._send_start += size # if the buffer is empty and EOF was written, set the FIN bit if self._send_eof and not self._send_buffer: frame.fin = True self._send_complete = True return frame
tests.test_stream/QuicStreamTest.test_send_data
Modified
aiortc~aioquic
135636bd74280024db5dae53ddbcf8193e201b27
[stream] do not send more data than MAX_STREAM_DATA allows
<0>:<add> stream = QuicStream(stream_id=0, max_stream_data_remote=512) <del> stream = QuicStream() <3>:<add> self.assertFalse(stream.is_blocked()) <6>:<add> self.assertFalse(stream.is_blocked()) <11>:<add> self.assertFalse(stream.is_blocked()) <16>:<add> self.assertFalse(stream.is_blocked())
# module: tests.test_stream class QuicStreamTest(TestCase): def test_send_data(self): <0> stream = QuicStream() <1> <2> self.assertFalse(stream.has_data_to_send()) <3> stream.write(b"0123456789012345") <4> <5> self.assertTrue(stream.has_data_to_send()) <6> frame = stream.get_frame(8) <7> self.assertEqual(frame.data, b"01234567") <8> self.assertEqual(frame.offset, 0) <9> <10> self.assertTrue(stream.has_data_to_send()) <11> frame = stream.get_frame(8) <12> self.assertEqual(frame.data, b"89012345") <13> self.assertEqual(frame.offset, 8) <14> <15> self.assertFalse(stream.has_data_to_send()) <16>
===========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(size: int) -> QuicStreamFrame has_data_to_send() -> bool is_blocked() write(data: bytes) -> None at: unittest.case.TestCase failureException: Type[BaseException] longMessage: bool maxDiff: Optional[int] _testMethodName: str _testMethodDoc: str assertEqual(first: Any, second: Any, msg: Any=...) -> None assertTrue(expr: Any, msg: Any=...) -> None assertFalse(expr: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: aioquic.stream class QuicStream: + def is_blocked(self): + """ + Returns True if there is data to send but the peer's MAX_STREAM_DATA + prevents us from sending it. + """ + return self._send_buffer and self._send_start >= self.max_stream_data_remote + ===========changed ref 1=========== # module: aioquic.stream class QuicStream: def get_frame(self, size: int) -> QuicStreamFrame: """ Get a frame of data to send. """ assert not self._send_complete, "cannot call get_frame() after completion" size = min(size, len(self._send_buffer)) + + # flow control + if self.stream_id is not None: + size = min(size, self.max_stream_data_remote - self._send_start) + frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start) self._send_buffer = self._send_buffer[size:] self._send_start += size # if the buffer is empty and EOF was written, set the FIN bit if self._send_eof and not self._send_buffer: frame.fin = True self._send_complete = True return frame ===========changed ref 2=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _write_application(self) -> Iterator[bytes]: epoch = tls.Epoch.ONE_RTT space = self.spaces[epoch] if not space.crypto.send.is_valid(): return buf = Buffer(capacity=PACKET_MAX_SIZE) while True: # write header push_uint8( buf, PACKET_FIXED_BIT | (self._spin_bit << 5) | (space.crypto.key_phase << 2) | (PACKET_NUMBER_SEND_SIZE - 1), ) push_bytes(buf, self.peer_cid) push_uint16(buf, self.packet_number) header_size = buf.tell() # ACK if self.send_ack[epoch] and space.ack_queue: push_uint_var(buf, QuicFrameType.ACK) packet.push_ack_frame(buf, space.ack_queue, 0) self.send_ack[epoch] = False # FLOW CONTROL for control_frame in self._pending_flow_control: push_bytes(buf, control_frame) self._pending_flow_control = [] # CLOSE if self.__close and self.__epoch == epoch: push_close(buf, **self.__close) self.__close = None # STREAM for stream_id, stream in self.streams.items(): + if ( + isinstance(stream_id, int) + and stream.has_data_to_send() - if isinstance(stream_id, int) and stream.has_data_to_send(): + and not stream.is_blocked() + ): frame = stream.get_frame( PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6 ) flags = QuicStreamFlag.LEN if frame.offset: flags |= Qu</s> ===========changed ref 3=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _write_application(self) -> Iterator[bytes]: # offset: 1 <s>tag_size - 6 ) 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, 0, frame.offset): push_bytes(buf, frame.data) packet_size = buf.tell() if packet_size > header_size: # encrypt data = buf.data yield space.crypto.encrypt_packet( data[0:header_size], data[header_size:packet_size] ) self.packet_number += 1 buf.seek(0) else: break
tests.test_stream/QuicStreamTest.test_send_data_and_fin
Modified
aiortc~aioquic
135636bd74280024db5dae53ddbcf8193e201b27
[stream] do not send more data than MAX_STREAM_DATA allows
<0>:<add> stream = QuicStream(stream_id=0, max_stream_data_remote=512) <del> stream = QuicStream() <5>:<add> self.assertFalse(stream.is_blocked()) <11>:<add> self.assertFalse(stream.is_blocked()) <17>:<add> self.assertFalse(stream.is_blocked())
# module: tests.test_stream class QuicStreamTest(TestCase): def test_send_data_and_fin(self): <0> stream = QuicStream() <1> stream.write(b"0123456789012345") <2> stream.write_eof() <3> <4> self.assertTrue(stream.has_data_to_send()) <5> frame = stream.get_frame(8) <6> self.assertEqual(frame.data, b"01234567") <7> self.assertEqual(frame.offset, 0) <8> self.assertFalse(frame.fin) <9> <10> self.assertTrue(stream.has_data_to_send()) <11> frame = stream.get_frame(8) <12> self.assertEqual(frame.data, b"89012345") <13> self.assertEqual(frame.offset, 8) <14> self.assertTrue(frame.fin) <15> <16> self.assertFalse(stream.has_data_to_send()) <17>
===========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(size: int) -> QuicStreamFrame has_data_to_send() -> bool is_blocked() write(data: bytes) -> None write_eof() -> None at: tests.test_stream.QuicStreamTest.test_send_data stream = QuicStream(stream_id=0, max_stream_data_remote=512) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None assertTrue(expr: Any, msg: Any=...) -> None assertFalse(expr: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: aioquic.stream class QuicStream: + def is_blocked(self): + """ + Returns True if there is data to send but the peer's MAX_STREAM_DATA + prevents us from sending it. + """ + return self._send_buffer and self._send_start >= self.max_stream_data_remote + ===========changed ref 1=========== # module: aioquic.stream class QuicStream: def get_frame(self, size: int) -> QuicStreamFrame: """ Get a frame of data to send. """ assert not self._send_complete, "cannot call get_frame() after completion" size = min(size, len(self._send_buffer)) + + # flow control + if self.stream_id is not None: + size = min(size, self.max_stream_data_remote - self._send_start) + frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start) self._send_buffer = self._send_buffer[size:] self._send_start += size # if the buffer is empty and EOF was written, set the FIN bit if self._send_eof and not self._send_buffer: frame.fin = True self._send_complete = True return frame ===========changed ref 2=========== # module: tests.test_stream class QuicStreamTest(TestCase): def test_send_data(self): + stream = QuicStream(stream_id=0, max_stream_data_remote=512) - stream = QuicStream() self.assertFalse(stream.has_data_to_send()) + self.assertFalse(stream.is_blocked()) stream.write(b"0123456789012345") self.assertTrue(stream.has_data_to_send()) + self.assertFalse(stream.is_blocked()) frame = stream.get_frame(8) self.assertEqual(frame.data, b"01234567") self.assertEqual(frame.offset, 0) self.assertTrue(stream.has_data_to_send()) + self.assertFalse(stream.is_blocked()) frame = stream.get_frame(8) self.assertEqual(frame.data, b"89012345") self.assertEqual(frame.offset, 8) self.assertFalse(stream.has_data_to_send()) + self.assertFalse(stream.is_blocked()) ===========changed ref 3=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _write_application(self) -> Iterator[bytes]: epoch = tls.Epoch.ONE_RTT space = self.spaces[epoch] if not space.crypto.send.is_valid(): return buf = Buffer(capacity=PACKET_MAX_SIZE) while True: # write header push_uint8( buf, PACKET_FIXED_BIT | (self._spin_bit << 5) | (space.crypto.key_phase << 2) | (PACKET_NUMBER_SEND_SIZE - 1), ) push_bytes(buf, self.peer_cid) push_uint16(buf, self.packet_number) header_size = buf.tell() # ACK if self.send_ack[epoch] and space.ack_queue: push_uint_var(buf, QuicFrameType.ACK) packet.push_ack_frame(buf, space.ack_queue, 0) self.send_ack[epoch] = False # FLOW CONTROL for control_frame in self._pending_flow_control: push_bytes(buf, control_frame) self._pending_flow_control = [] # CLOSE if self.__close and self.__epoch == epoch: push_close(buf, **self.__close) self.__close = None # STREAM for stream_id, stream in self.streams.items(): + if ( + isinstance(stream_id, int) + and stream.has_data_to_send() - if isinstance(stream_id, int) and stream.has_data_to_send(): + and not stream.is_blocked() + ): frame = stream.get_frame( PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6 ) flags = QuicStreamFlag.LEN if frame.offset: flags |= Qu</s> ===========changed ref 4=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _write_application(self) -> Iterator[bytes]: # offset: 1 <s>tag_size - 6 ) 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, 0, frame.offset): push_bytes(buf, frame.data) packet_size = buf.tell() if packet_size > header_size: # encrypt data = buf.data yield space.crypto.encrypt_packet( data[0:header_size], data[header_size:packet_size] ) self.packet_number += 1 buf.seek(0) else: break
tests.test_stream/QuicStreamTest.test_send_fin_only
Modified
aiortc~aioquic
135636bd74280024db5dae53ddbcf8193e201b27
[stream] do not send more data than MAX_STREAM_DATA allows
<0>:<add> stream = QuicStream(stream_id=0, max_stream_data_remote=512) <del> stream = QuicStream()
# module: tests.test_stream class QuicStreamTest(TestCase): def test_send_fin_only(self): <0> stream = QuicStream() <1> self.assertFalse(stream.has_data_to_send()) <2> <3> stream.write_eof() <4> self.assertTrue(stream.has_data_to_send()) <5> frame = stream.get_frame(8) <6> self.assertEqual(frame.data, b"") <7> self.assertEqual(frame.offset, 0) <8> self.assertTrue(frame.fin) <9>
===========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 has_data_to_send() -> bool is_blocked() at: tests.test_stream.QuicStreamTest.test_send_data_and_fin stream = QuicStream(stream_id=0, max_stream_data_remote=512) frame = stream.get_frame(8) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None assertTrue(expr: Any, msg: Any=...) -> None assertFalse(expr: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: aioquic.stream class QuicStream: + def is_blocked(self): + """ + Returns True if there is data to send but the peer's MAX_STREAM_DATA + prevents us from sending it. + """ + return self._send_buffer and self._send_start >= self.max_stream_data_remote + ===========changed ref 1=========== # module: tests.test_stream class QuicStreamTest(TestCase): def test_send_data_and_fin(self): + stream = QuicStream(stream_id=0, max_stream_data_remote=512) - stream = QuicStream() stream.write(b"0123456789012345") stream.write_eof() self.assertTrue(stream.has_data_to_send()) + self.assertFalse(stream.is_blocked()) frame = stream.get_frame(8) self.assertEqual(frame.data, b"01234567") self.assertEqual(frame.offset, 0) self.assertFalse(frame.fin) self.assertTrue(stream.has_data_to_send()) + self.assertFalse(stream.is_blocked()) frame = stream.get_frame(8) self.assertEqual(frame.data, b"89012345") self.assertEqual(frame.offset, 8) self.assertTrue(frame.fin) self.assertFalse(stream.has_data_to_send()) + self.assertFalse(stream.is_blocked()) ===========changed ref 2=========== # module: tests.test_stream class QuicStreamTest(TestCase): def test_send_data(self): + stream = QuicStream(stream_id=0, max_stream_data_remote=512) - stream = QuicStream() self.assertFalse(stream.has_data_to_send()) + self.assertFalse(stream.is_blocked()) stream.write(b"0123456789012345") self.assertTrue(stream.has_data_to_send()) + self.assertFalse(stream.is_blocked()) frame = stream.get_frame(8) self.assertEqual(frame.data, b"01234567") self.assertEqual(frame.offset, 0) self.assertTrue(stream.has_data_to_send()) + self.assertFalse(stream.is_blocked()) frame = stream.get_frame(8) self.assertEqual(frame.data, b"89012345") self.assertEqual(frame.offset, 8) self.assertFalse(stream.has_data_to_send()) + self.assertFalse(stream.is_blocked()) ===========changed ref 3=========== # module: aioquic.stream class QuicStream: def get_frame(self, size: int) -> QuicStreamFrame: """ Get a frame of data to send. """ assert not self._send_complete, "cannot call get_frame() after completion" size = min(size, len(self._send_buffer)) + + # flow control + if self.stream_id is not None: + size = min(size, self.max_stream_data_remote - self._send_start) + frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start) self._send_buffer = self._send_buffer[size:] self._send_start += size # if the buffer is empty and EOF was written, set the FIN bit if self._send_eof and not self._send_buffer: frame.fin = True self._send_complete = True return frame ===========changed ref 4=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _write_application(self) -> Iterator[bytes]: epoch = tls.Epoch.ONE_RTT space = self.spaces[epoch] if not space.crypto.send.is_valid(): return buf = Buffer(capacity=PACKET_MAX_SIZE) while True: # write header push_uint8( buf, PACKET_FIXED_BIT | (self._spin_bit << 5) | (space.crypto.key_phase << 2) | (PACKET_NUMBER_SEND_SIZE - 1), ) push_bytes(buf, self.peer_cid) push_uint16(buf, self.packet_number) header_size = buf.tell() # ACK if self.send_ack[epoch] and space.ack_queue: push_uint_var(buf, QuicFrameType.ACK) packet.push_ack_frame(buf, space.ack_queue, 0) self.send_ack[epoch] = False # FLOW CONTROL for control_frame in self._pending_flow_control: push_bytes(buf, control_frame) self._pending_flow_control = [] # CLOSE if self.__close and self.__epoch == epoch: push_close(buf, **self.__close) self.__close = None # STREAM for stream_id, stream in self.streams.items(): + if ( + isinstance(stream_id, int) + and stream.has_data_to_send() - if isinstance(stream_id, int) and stream.has_data_to_send(): + and not stream.is_blocked() + ): frame = stream.get_frame( PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6 ) flags = QuicStreamFlag.LEN if frame.offset: flags |= Qu</s> ===========changed ref 5=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _write_application(self) -> Iterator[bytes]: # offset: 1 <s>tag_size - 6 ) 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, 0, frame.offset): push_bytes(buf, frame.data) packet_size = buf.tell() if packet_size > header_size: # encrypt data = buf.data yield space.crypto.encrypt_packet( data[0:header_size], data[header_size:packet_size] ) self.packet_number += 1 buf.seek(0) else: break
aioquic.stream/QuicStream.get_frame
Modified
aiortc~aioquic
cbc648c0974daa5a3f98f850527ac8d4981a6648
[connection] rework some size calculations, honour peer's MAX_DATA
<3>:<add> # check there is something to send <add> if self._send_complete or not self.has_data_to_send(): <add> return None <del> assert not self._send_complete, "cannot call get_frame() after completion" <5>:<del> size = min(size, len(self._send_buffer)) <6>:<del> <7>:<add> # apply flow control <del> # flow control <10>:<add> if size < 0 or (size == 0 and self._send_buffer and not self._send_eof): <add> return None <11>:<add> # create frame <add> size = min(size, len(self._send_buffer))
# module: aioquic.stream + class QuicStream(asyncio.BaseTransport): - class QuicStream: + def get_frame(self, size: int) -> Optional[QuicStreamFrame]: - def get_frame(self, size: int) -> QuicStreamFrame: <0> """ <1> Get a frame of data to send. <2> """ <3> assert not self._send_complete, "cannot call get_frame() after completion" <4> <5> size = min(size, len(self._send_buffer)) <6> <7> # flow control <8> if self.stream_id is not None: <9> size = min(size, self.max_stream_data_remote - self._send_start) <10> <11> frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start) <12> self._send_buffer = self._send_buffer[size:] <13> self._send_start += size <14> <15> # if the buffer is empty and EOF was written, set the FIN bit <16> if self._send_eof and not self._send_buffer: <17> frame.fin = True <18> self._send_complete = True <19> <20> return frame <21>
===========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.stream.QuicStream has_data_to_send(self) -> bool has_data_to_send() -> bool at: aioquic.stream.QuicStream.__init__ self.max_stream_data_remote = max_stream_data_remote self._send_buffer = bytearray() self._send_complete = False self._send_eof = False self._send_start = 0 at: aioquic.stream.QuicStream.get_frame self._send_complete = True at: aioquic.stream.QuicStream.write self._send_buffer += data at: aioquic.stream.QuicStream.write_eof self._send_eof = True ===========changed ref 0=========== # module: aioquic.packet + def quic_uint_length(value: int) -> int: + """ + Returns the number of bytes required to encode the given value + as a QUIC variable-length unsigned integer. + """ + for i, (_, _, mask) in enumerate(UINT_VAR_FORMATS): + if value <= mask: + return 2 ** i + raise ValueError("Integer is too big for a variable-length integer") +
aioquic.stream/QuicStream.is_blocked
Modified
aiortc~aioquic
cbc648c0974daa5a3f98f850527ac8d4981a6648
[connection] rework some size calculations, honour peer's MAX_DATA
<4>:<add> return ( <add> bool(self._send_buffer) and self._send_start >= self.max_stream_data_remote <del> return self._send_buffer and self._send_start >= self.max_stream_data_remote <5>:<add> )
# module: aioquic.stream + class QuicStream(asyncio.BaseTransport): - class QuicStream: + def is_blocked(self) -> bool: - def is_blocked(self): <0> """ <1> Returns True if there is data to send but the peer's MAX_STREAM_DATA <2> prevents us from sending it. <3> """ <4> return self._send_buffer and self._send_start >= self.max_stream_data_remote <5>
===========unchanged ref 0=========== at: aioquic.stream.QuicStream.__init__ self._send_buffer = bytearray() self._send_complete = False self._send_eof = False at: aioquic.stream.QuicStream.get_frame self._send_buffer = self._send_buffer[size:] self._send_complete = True at: aioquic.stream.QuicStream.write self._send_buffer += data at: aioquic.stream.QuicStream.write_eof self._send_eof = True ===========changed ref 0=========== # module: aioquic.stream + class QuicStream(asyncio.BaseTransport): - class QuicStream: + def get_frame(self, size: int) -> Optional[QuicStreamFrame]: - def get_frame(self, size: int) -> QuicStreamFrame: """ Get a frame of data to send. """ + # check there is something to send + if self._send_complete or not self.has_data_to_send(): + return None - assert not self._send_complete, "cannot call get_frame() after completion" - size = min(size, len(self._send_buffer)) - + # apply flow control - # flow control if self.stream_id is not None: size = min(size, self.max_stream_data_remote - self._send_start) + if size < 0 or (size == 0 and self._send_buffer and not self._send_eof): + return None + # create frame + size = min(size, len(self._send_buffer)) frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start) self._send_buffer = self._send_buffer[size:] self._send_start += size # if the buffer is empty and EOF was written, set the FIN bit if self._send_eof and not self._send_buffer: frame.fin = True self._send_complete = True return frame ===========changed ref 1=========== # module: aioquic.packet + def quic_uint_length(value: int) -> int: + """ + Returns the number of bytes required to encode the given value + as a QUIC variable-length unsigned integer. + """ + for i, (_, _, mask) in enumerate(UINT_VAR_FORMATS): + if value <= mask: + return 2 ** i + raise ValueError("Integer is too big for a variable-length integer") +
aioquic.connection/QuicConnection.__init__
Modified
aiortc~aioquic
cbc648c0974daa5a3f98f850527ac8d4981a6648
[connection] rework some size calculations, honour peer's MAX_DATA
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: <0> if not is_client: <1> assert certificate is not None, "SSL certificate is required" <2> assert private_key is not None, "SSL private key is required" <3> <4> self.alpn_protocols = alpn_protocols <5> self.certificate = certificate <6> self.is_client = is_client <7> self.host_cid = os.urandom(8) <8> self.peer_cid = os.urandom(8) <9> self.peer_cid_set = False <10> self.peer_token = b"" <11> self.private_key = private_key <12> self.secrets_log_file = secrets_log_file <13> self.server_name = server_name <14> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} <15> <16> self.__close: Optional[Dict] = None <17> self.__connected = asyncio.Event() <18> self.__epoch = tls.Epoch.INITIAL <19> self._local_idle_timeout = 60000 # milliseconds <20> self._local_max_data = 1048576 <21> self._local_max_data_used = 0 <22> self._local_max_stream_data_bidi_local = 1048576 <23> self._local_max_stream_data_bidi_remote = 1048576 <24> self._local_max_stream_data_uni = 1048576 <25> self._local_max_streams_bidi = 128 <26> self._local_max_streams_uni = 128 <27> self.__logger = logger <28> self.__path_challenge: Optional[bytes] = None <29> self._path: Optional[Qu</s>
===========below chunk 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: # offset: 1 self._pending_flow_control: List[bytes] = [] self._remote_idle_timeout = 0 # milliseconds self._remote_max_data = 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._spin_bit = 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 # callbacks self.stream_created_cb: Callable[ [asyncio.StreamReader, asyncio.StreamWriter], None ] = lambda r, w: None # frame handlers self.__frame_handlers = [ self._handle_padding_frame, self._handle_padding_frame, self._handle_ack_frame, self._handle_ack_frame, self._handle_reset_stream_frame, self._handle_stop_sending_frame, self._handle_crypto_frame, self._handle_new_token_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, </s> ===========below chunk 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: # offset: 2 <s> self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_max_data_frame, self._handle_max_stream_data_frame, self._handle_max_streams_bidi_frame, self._handle_max_streams_uni_frame, self._handle_data_blocked_frame, self._handle_stream_data_blocked_frame, self._handle_streams_blocked_frame, self._handle_streams_blocked_frame, self._handle_new_connection_id_frame, self._handle_retire_connection_id_frame, self._handle_path_challenge_frame, self._handle_path_response_frame, self._handle_connection_close_frame, self._handle_connection_close_frame, ] ===========unchanged ref 0=========== at: aioquic.connection logger = logging.getLogger("quic") QuicConnectionState() QuicNetworkPath(addr: Any) at: aioquic.connection.QuicConnection supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20] _handle_ack_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_connection_close_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_crypto_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_data_blocked_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_max_data_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_max_stream_data_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_max_streams_bidi_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_max_streams_uni_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_new_connection_id_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_new_token_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_padding_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_path_challenge_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_path_response_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_reset_stream_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None ===========unchanged ref 1=========== _handle_retire_connection_id_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_stop_sending_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_stream_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_stream_data_blocked_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None _handle_streams_blocked_frame(epoch: tls.Epoch, frame_type: int, buf: Buffer) -> None at: aioquic.connection.QuicConnection._handle_crypto_frame self.__epoch = tls.Epoch.ONE_RTT self.__epoch = tls.Epoch.HANDSHAKE at: aioquic.connection.QuicConnection._handle_max_data_frame self._remote_max_data = max_data at: aioquic.connection.QuicConnection._handle_max_streams_bidi_frame self._remote_max_streams_bidi = max_streams at: aioquic.connection.QuicConnection._handle_max_streams_uni_frame self._remote_max_streams_uni = max_streams at: aioquic.connection.QuicConnection._handle_stream_frame self._local_max_data_used += newly_received at: aioquic.connection.QuicConnection._parse_transport_parameters self._remote_idle_timeout = quic_transport_parameters.idle_timeout at: aioquic.connection.QuicConnection._send_path_challenge self.__path_challenge = os.urandom(8) at: aioquic.connection.QuicConnection._send_pending self.__send_pending_task = None at: aioquic.connection.QuicConnection._send_soon self.__send_pending_task = loop.call_soon(self._send_pending)
aioquic.connection/QuicConnection._write_application
Modified
aiortc~aioquic
cbc648c0974daa5a3f98f850527ac8d4981a6648
[connection] rework some size calculations, honour peer's MAX_DATA
<6>:<add> capacity = buf.capacity - space.crypto.aead_tag_size <38>:<del> if ( <39>:<add> if isinstance(stream_id, int): <del> isinstance(stream_id, int) <40>:<add> # the frame data size is constrained by our peer's MAX_DATA and <add> # the space available in the current packet <add> frame_overhead = ( <add> 3 <add> + quic_uint_length(stream_id) <add> + ( <add> quic_uint_length(stream._send_start) <add> if stream._send_start <add> else 0 <add> ) <del> and stream.has_data_to_send() <41>:<del> and not stream.is_blocked() <42>:<add> ) <del> ): <44>:<add> min( <add> capacity - buf.tell() - frame_overhead, <add> self._remote_max_data - self._remote_max_data_used, <add> ) <del> PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6 <46>:<add> <add> if frame is not None: <add> flags = QuicStreamFlag.LEN <del> flags
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _write_application(self) -> Iterator[bytes]: <0> epoch = tls.Epoch.ONE_RTT <1> space = self.spaces[epoch] <2> if not space.crypto.send.is_valid(): <3> return <4> <5> buf = Buffer(capacity=PACKET_MAX_SIZE) <6> <7> while True: <8> # write header <9> push_uint8( <10> buf, <11> PACKET_FIXED_BIT <12> | (self._spin_bit << 5) <13> | (space.crypto.key_phase << 2) <14> | (PACKET_NUMBER_SEND_SIZE - 1), <15> ) <16> push_bytes(buf, self.peer_cid) <17> push_uint16(buf, self.packet_number) <18> header_size = buf.tell() <19> <20> # ACK <21> if self.send_ack[epoch] and space.ack_queue: <22> push_uint_var(buf, QuicFrameType.ACK) <23> packet.push_ack_frame(buf, space.ack_queue, 0) <24> self.send_ack[epoch] = False <25> <26> # FLOW CONTROL <27> for control_frame in self._pending_flow_control: <28> push_bytes(buf, control_frame) <29> self._pending_flow_control = [] <30> <31> # CLOSE <32> if self.__close and self.__epoch == epoch: <33> push_close(buf, **self.__close) <34> self.__close = None <35> <36> # STREAM <37> for stream_id, stream in self.streams.items(): <38> if ( <39> isinstance(stream_id, int) <40> and stream.has_data_to_send() <41> and not stream.is_blocked() <42> ): <43> frame = stream.get_frame( <44> PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6 <45> ) <46> flags</s>
===========below chunk 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _write_application(self) -> Iterator[bytes]: # offset: 1 if frame.offset: flags |= QuicStreamFlag.OFF if frame.fin: flags |= QuicStreamFlag.FIN push_uint_var(buf, QuicFrameType.STREAM_BASE | flags) with push_stream_frame(buf, 0, frame.offset): push_bytes(buf, frame.data) packet_size = buf.tell() if packet_size > header_size: # encrypt data = buf.data yield space.crypto.encrypt_packet( data[0:header_size], data[header_size:packet_size] ) self.packet_number += 1 buf.seek(0) else: break ===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) push_bytes(buf: Buffer, v: bytes) -> None push_uint8(buf: Buffer, v: int) -> None push_uint16(buf: Buffer, v: int) -> None at: aioquic.buffer.Buffer tell() -> int at: aioquic.connection PACKET_MAX_SIZE = 1280 push_close(buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None at: aioquic.connection.PacketSpace.__init__ self.ack_queue = RangeSet() self.crypto = CryptoPair() at: aioquic.connection.QuicConnection.__init__ self.peer_cid = os.urandom(8) self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} self.__close: Optional[Dict] = None self.__epoch = tls.Epoch.INITIAL self._pending_flow_control: List[bytes] = [] self._remote_max_data = 0 self._remote_max_data_used = 0 self._spin_bit = False 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.tls = tls.Context(is_client=self.is_client, logger=self.__logger) self.send_ack = { tls.Epoch.INITIAL: False, tls.Epoch.HANDSHAKE: False, tls.Epoch.ONE_RTT: False, } ===========unchanged ref 1=========== self.spaces = { tls.Epoch.INITIAL: PacketSpace(), tls.Epoch.HANDSHAKE: PacketSpace(), tls.Epoch.ONE_RTT: PacketSpace(), } self.packet_number = 0 at: aioquic.connection.QuicConnection._update_traffic_key crypto = self.spaces[epoch].crypto at: aioquic.connection.QuicConnection._write_application self._remote_max_data_used += len(frame.data) self.packet_number += 1 at: aioquic.connection.QuicConnection._write_handshake self.__close = None self.packet_number += 1 at: aioquic.connection.QuicConnection.close self.__close = { "error_code": error_code, "frame_type": frame_type, "reason_phrase": reason_phrase, } at: aioquic.connection.QuicConnection.datagram_received self.peer_cid = header.source_cid self._spin_bit = not get_spin_bit(plain_header[0]) self._spin_bit = get_spin_bit(plain_header[0]) at: aioquic.crypto.CryptoContext is_valid() -> bool setup(cipher_suite: CipherSuite, secret: bytes) -> None at: aioquic.crypto.CryptoPair.__init__ self.aead_tag_size = 16 self.recv = CryptoContext() self.send = CryptoContext() at: aioquic.packet PACKET_FIXED_BIT = 0x40 PACKET_NUMBER_SEND_SIZE = 2 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) ===========unchanged ref 2=========== push_ack_frame(buf: Buffer, rangeset: RangeSet, delay: int) -> None QuicStreamFlag(x: Union[str, bytes, bytearray], base: int) QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) at: aioquic.packet.QuicStreamFrame data: bytes = b"" fin: bool = False offset: int = 0 at: aioquic.stream.QuicStream get_frame(size: int) -> Optional[QuicStreamFrame] at: aioquic.stream.QuicStream.__init__ self._send_start = 0 at: aioquic.stream.QuicStream.get_frame self._send_start += size at: aioquic.tls Epoch() at: aioquic.tls.Context.__init__ self.key_schedule: Optional[KeySchedule] = None at: aioquic.tls.Context._client_handle_hello self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite) at: aioquic.tls.Context._server_handle_hello self.key_schedule = KeySchedule(cipher_suite) at: aioquic.tls.KeySchedule.__init__ self.cipher_suite = cipher_suite at: typing Iterator = _alias(collections.abc.Iterator, 1) ===========changed ref 0=========== # module: aioquic.packet + def quic_uint_length(value: int) -> int: + """ + Returns the number of bytes required to encode the given value + as a QUIC variable-length unsigned integer. + """ + for i, (_, _, mask) in enumerate(UINT_VAR_FORMATS): + if value <= mask: + return 2 ** i + raise ValueError("Integer is too big for a variable-length integer") +
aioquic.connection/QuicConnection._write_handshake
Modified
aiortc~aioquic
cbc648c0974daa5a3f98f850527ac8d4981a6648
[connection] rework some size calculations, honour peer's MAX_DATA
<5>:<add> capacity = buf.capacity - space.crypto.aead_tag_size <36>:<add> # CRYPTO <37>:<del> if stream.has_data_to_send(): <38>:<del> # CRYPTO <39>:<del> frame = stream.get_frame( <40>:<del> PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 4 <41>:<del> ) <42>:<add> frame_overhead = 3 + quic_uint_length(stream._send_start) <add> frame = stream.get_frame(capacity - buf.tell() - frame_overhead) <add> if frame is not None:
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]: <0> space = self.spaces[epoch] <1> if not space.crypto.send.is_valid(): <2> return <3> <4> buf = Buffer(capacity=PACKET_MAX_SIZE) <5> <6> while True: <7> if epoch == tls.Epoch.INITIAL: <8> packet_type = PACKET_TYPE_INITIAL <9> else: <10> packet_type = PACKET_TYPE_HANDSHAKE <11> <12> # write header <13> push_quic_header( <14> buf, <15> QuicHeader( <16> version=self._version, <17> packet_type=packet_type | (PACKET_NUMBER_SEND_SIZE - 1), <18> destination_cid=self.peer_cid, <19> source_cid=self.host_cid, <20> token=self.peer_token, <21> ), <22> ) <23> header_size = buf.tell() <24> <25> # ACK <26> if self.send_ack[epoch] and space.ack_queue: <27> push_uint_var(buf, QuicFrameType.ACK) <28> packet.push_ack_frame(buf, space.ack_queue, 0) <29> self.send_ack[epoch] = False <30> <31> # CLOSE <32> if self.__close and self.__epoch == epoch: <33> push_close(buf, **self.__close) <34> self.__close = None <35> <36> stream = self.streams[epoch] <37> if stream.has_data_to_send(): <38> # CRYPTO <39> frame = stream.get_frame( <40> PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 4 <41> ) <42> push_uint_var(buf, QuicFrameType.CRYPTO) <43> with packet.push_crypto_frame(buf, frame.offset): <44> push_bytes(buf, frame.data)</s>
===========below chunk 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]: # offset: 1 # PADDING if epoch == tls.Epoch.INITIAL and self.is_client: push_bytes( buf, bytes( PACKET_MAX_SIZE - space.crypto.aead_tag_size - buf.tell() ), ) packet_size = buf.tell() if packet_size > header_size: # finalize length buf.seek(header_size - PACKET_NUMBER_SEND_SIZE - 2) length = packet_size - header_size + 2 + space.crypto.aead_tag_size push_uint16(buf, length | 0x4000) push_uint16(buf, self.packet_number) buf.seek(packet_size) # encrypt data = buf.data yield space.crypto.encrypt_packet( data[0:header_size], data[header_size:packet_size] ) self.packet_number += 1 buf.seek(0) else: break ===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) push_bytes(buf: Buffer, v: bytes) -> None push_uint16(buf: Buffer, v: int) -> None at: aioquic.buffer.Buffer seek(pos: int) -> None tell() -> int at: aioquic.connection PACKET_MAX_SIZE = 1280 push_close(buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None at: aioquic.connection.PacketSpace.__init__ self.ack_queue = RangeSet() self.crypto = CryptoPair() at: aioquic.connection.QuicConnection.__init__ self.is_client = is_client self.host_cid = os.urandom(8) self.peer_cid = os.urandom(8) self.peer_token = b"" self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} self.__close: Optional[Dict] = None self.__epoch = tls.Epoch.INITIAL self._remote_max_data_used = 0 self._version: Optional[int] = None at: aioquic.connection.QuicConnection._handle_crypto_frame self.__epoch = tls.Epoch.ONE_RTT self.__epoch = tls.Epoch.HANDSHAKE at: aioquic.connection.QuicConnection._initialize self.send_ack = { tls.Epoch.INITIAL: False, tls.Epoch.HANDSHAKE: False, tls.Epoch.ONE_RTT: False, } self.spaces = { tls.Epoch.INITIAL: PacketSpace(), tls.Epoch.HANDSHAKE: PacketSpace(), tls.Epoch.ONE_RTT: PacketSpace(), } self.packet_number = 0 ===========unchanged ref 1=========== at: aioquic.connection.QuicConnection._write_application space = self.spaces[epoch] buf = Buffer(capacity=PACKET_MAX_SIZE) header_size = buf.tell() self.__close = None frame = stream.get_frame( min( capacity - buf.tell() - frame_overhead, self._remote_max_data - self._remote_max_data_used, ) ) at: aioquic.connection.QuicConnection._write_handshake self.packet_number += 1 at: aioquic.connection.QuicConnection.close self.__close = { "error_code": error_code, "frame_type": frame_type, "reason_phrase": reason_phrase, } at: aioquic.connection.QuicConnection.connect self._version = max(self.supported_versions) 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 at: aioquic.crypto.CryptoContext is_valid() -> bool at: aioquic.crypto.CryptoPair encrypt_packet(plain_header: bytes, plain_payload: bytes) -> bytes at: aioquic.crypto.CryptoPair.__init__ self.aead_tag_size = 16 self.send = CryptoContext() at: aioquic.packet PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00 PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20 PACKET_NUMBER_SEND_SIZE = 2 ===========unchanged ref 2=========== QuicHeader(version: Optional[int], packet_type: int, destination_cid: bytes, source_cid: bytes, original_destination_cid: bytes=b"", token: bytes=b"", rest_length: int=0) quic_uint_length(value: int) -> int push_uint_var(buf: Buffer, value: int) -> None push_quic_header(buf: Buffer, header: QuicHeader) -> None QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) push_ack_frame(buf: Buffer, rangeset: RangeSet, delay: int) -> None push_crypto_frame(buf: Buffer, offset: int=0) -> Generator at: aioquic.packet.QuicHeader version: Optional[int] packet_type: int destination_cid: bytes source_cid: bytes original_destination_cid: bytes = b"" token: bytes = b"" rest_length: int = 0 at: aioquic.packet.QuicStreamFrame data: bytes = b"" offset: int = 0 at: aioquic.stream.QuicStream get_frame(size: int) -> Optional[QuicStreamFrame] at: aioquic.stream.QuicStream.__init__ self._send_start = 0 at: aioquic.stream.QuicStream.get_frame self._send_start += size at: aioquic.tls Epoch() at: typing Iterator = _alias(collections.abc.Iterator, 1) ===========changed ref 0=========== # module: aioquic.packet + def quic_uint_length(value: int) -> int: + """ + Returns the number of bytes required to encode the given value + as a QUIC variable-length unsigned integer. + """ + for i, (_, _, mask) in enumerate(UINT_VAR_FORMATS): + if value <= mask: + return 2 ** i + raise ValueError("Integer is too big for a variable-length integer") +
tests.test_stream/QuicStreamTest.test_send_data
Modified
aiortc~aioquic
cbc648c0974daa5a3f98f850527ac8d4981a6648
[connection] rework some size calculations, honour peer's MAX_DATA
<2>:<add> # nothing to send yet <4>:<add> frame = stream.get_frame(8) <add> self.assertIsNone(frame) <add> <add> # write data, send a chunk <5>:<del> <10>:<add> self.assertFalse(frame.fin) <12>:<add> # send another chunk <16>:<add> self.assertFalse(frame.fin) <18>:<add> # nothing more to send <20>:<add> frame = stream.get_frame(8) <add> self.assertIsNone(frame)
# 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> self.assertFalse(stream.has_data_to_send()) <3> self.assertFalse(stream.is_blocked()) <4> stream.write(b"0123456789012345") <5> <6> self.assertTrue(stream.has_data_to_send()) <7> self.assertFalse(stream.is_blocked()) <8> frame = stream.get_frame(8) <9> self.assertEqual(frame.data, b"01234567") <10> self.assertEqual(frame.offset, 0) <11> <12> self.assertTrue(stream.has_data_to_send()) <13> self.assertFalse(stream.is_blocked()) <14> frame = stream.get_frame(8) <15> self.assertEqual(frame.data, b"89012345") <16> self.assertEqual(frame.offset, 8) <17> <18> self.assertFalse(stream.has_data_to_send()) <19> self.assertFalse(stream.is_blocked()) <20>
===========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(size: int) -> Optional[QuicStreamFrame] has_data_to_send() -> bool is_blocked() -> bool write(data: bytes) -> None at: unittest.case.TestCase failureException: Type[BaseException] longMessage: bool maxDiff: Optional[int] _testMethodName: str _testMethodDoc: str assertEqual(first: Any, second: Any, msg: Any=...) -> None assertTrue(expr: Any, msg: Any=...) -> None assertFalse(expr: Any, msg: Any=...) -> None assertIsNone(obj: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: aioquic.stream + class QuicStream(asyncio.BaseTransport): - class QuicStream: + def is_blocked(self) -> bool: - def is_blocked(self): """ Returns True if there is data to send but the peer's MAX_STREAM_DATA prevents us from sending it. """ + return ( + bool(self._send_buffer) and self._send_start >= self.max_stream_data_remote - return self._send_buffer and self._send_start >= self.max_stream_data_remote + ) ===========changed ref 1=========== # module: aioquic.stream + class QuicStream(asyncio.BaseTransport): - class QuicStream: + def get_frame(self, size: int) -> Optional[QuicStreamFrame]: - def get_frame(self, size: int) -> QuicStreamFrame: """ Get a frame of data to send. """ + # check there is something to send + if self._send_complete or not self.has_data_to_send(): + return None - assert not self._send_complete, "cannot call get_frame() after completion" - size = min(size, len(self._send_buffer)) - + # apply flow control - # flow control if self.stream_id is not None: size = min(size, self.max_stream_data_remote - self._send_start) + if size < 0 or (size == 0 and self._send_buffer and not self._send_eof): + return None + # create frame + size = min(size, len(self._send_buffer)) frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start) self._send_buffer = self._send_buffer[size:] self._send_start += size # if the buffer is empty and EOF was written, set the FIN bit if self._send_eof and not self._send_buffer: frame.fin = True self._send_complete = True return frame ===========changed ref 2=========== # module: aioquic.packet + def quic_uint_length(value: int) -> int: + """ + Returns the number of bytes required to encode the given value + as a QUIC variable-length unsigned integer. + """ + for i, (_, _, mask) in enumerate(UINT_VAR_FORMATS): + if value <= mask: + return 2 ** i + raise ValueError("Integer is too big for a variable-length integer") + ===========changed ref 3=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]: space = self.spaces[epoch] if not space.crypto.send.is_valid(): return buf = Buffer(capacity=PACKET_MAX_SIZE) + capacity = buf.capacity - space.crypto.aead_tag_size while True: if epoch == tls.Epoch.INITIAL: packet_type = PACKET_TYPE_INITIAL else: packet_type = PACKET_TYPE_HANDSHAKE # write header push_quic_header( buf, QuicHeader( version=self._version, packet_type=packet_type | (PACKET_NUMBER_SEND_SIZE - 1), destination_cid=self.peer_cid, source_cid=self.host_cid, token=self.peer_token, ), ) header_size = buf.tell() # ACK if self.send_ack[epoch] and space.ack_queue: push_uint_var(buf, QuicFrameType.ACK) packet.push_ack_frame(buf, space.ack_queue, 0) self.send_ack[epoch] = False # CLOSE if self.__close and self.__epoch == epoch: push_close(buf, **self.__close) self.__close = None + # CRYPTO stream = self.streams[epoch] - if stream.has_data_to_send(): - # CRYPTO - frame = stream.get_frame( - PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 4 - ) + frame_overhead = 3 + quic_uint_length(stream._send_start) + frame = stream.get_frame(capacity - buf.tell() - frame_overhead) + if frame is not None: push_uint_</s> ===========changed ref 4=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]: # offset: 1 <s>frame(capacity - buf.tell() - 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) # PADDING if epoch == tls.Epoch.INITIAL and self.is_client: - push_bytes( - buf, - bytes( - PACKET_MAX_SIZE - space.crypto.aead_tag_size - buf.tell() - ), - ) + push_bytes(buf, bytes(capacity - buf.tell())) packet_size = buf.tell() if packet_size > header_size: # finalize length buf.seek(header_size - PACKET_NUMBER_SEND_SIZE - 2) length = packet_size - header_size + 2 + space.crypto.aead_tag_size push_uint16(buf, length | 0x4000) push_uint16(buf, self.packet_number) buf.seek(packet_size) # encrypt data = buf.data yield space.crypto.encrypt_packet( data[0:header_size], data[header_size:packet_size] ) self.packet_number += 1 buf.seek(0) else: break
tests.test_stream/QuicStreamTest.test_send_data_and_fin
Modified
aiortc~aioquic
cbc648c0974daa5a3f98f850527ac8d4981a6648
[connection] rework some size calculations, honour peer's MAX_DATA
<1>:<add> <add> # nothing to send yet <add> self.assertFalse(stream.has_data_to_send()) <add> self.assertFalse(stream.is_blocked()) <add> frame = stream.get_frame(8) <add> self.assertIsNone(frame) <add> <add> # write data and EOF, send a chunk <3>:<del> <8>:<add> self.assertFalse(frame.fin) <9>:<del> self.assertFalse(frame.fin) <11>:<add> # send another chunk <15>:<add> self.assertTrue(frame.fin) <16>:<del> self.assertTrue(frame.fin) <18>:<add> # nothing more to send <20>:<add> frame = stream.get_frame(8) <add> self.assertIsNone(frame)
# 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> stream.write(b"0123456789012345") <2> stream.write_eof() <3> <4> self.assertTrue(stream.has_data_to_send()) <5> self.assertFalse(stream.is_blocked()) <6> frame = stream.get_frame(8) <7> self.assertEqual(frame.data, b"01234567") <8> self.assertEqual(frame.offset, 0) <9> self.assertFalse(frame.fin) <10> <11> self.assertTrue(stream.has_data_to_send()) <12> self.assertFalse(stream.is_blocked()) <13> frame = stream.get_frame(8) <14> self.assertEqual(frame.data, b"89012345") <15> self.assertEqual(frame.offset, 8) <16> self.assertTrue(frame.fin) <17> <18> self.assertFalse(stream.has_data_to_send()) <19> self.assertFalse(stream.is_blocked()) <20>
===========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(size: int) -> Optional[QuicStreamFrame] has_data_to_send() -> bool is_blocked() -> bool write(data: bytes) -> None at: tests.test_stream.QuicStreamTest.test_send_data stream = QuicStream(stream_id=0, max_stream_data_remote=512) at: unittest.case.TestCase 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): - class QuicStream: + def is_blocked(self) -> bool: - def is_blocked(self): """ Returns True if there is data to send but the peer's MAX_STREAM_DATA prevents us from sending it. """ + return ( + bool(self._send_buffer) and self._send_start >= self.max_stream_data_remote - return self._send_buffer and self._send_start >= self.max_stream_data_remote + ) ===========changed ref 1=========== # module: aioquic.stream + class QuicStream(asyncio.BaseTransport): - class QuicStream: + def get_frame(self, size: int) -> Optional[QuicStreamFrame]: - def get_frame(self, size: int) -> QuicStreamFrame: """ Get a frame of data to send. """ + # check there is something to send + if self._send_complete or not self.has_data_to_send(): + return None - assert not self._send_complete, "cannot call get_frame() after completion" - size = min(size, len(self._send_buffer)) - + # apply flow control - # flow control if self.stream_id is not None: size = min(size, self.max_stream_data_remote - self._send_start) + if size < 0 or (size == 0 and self._send_buffer and not self._send_eof): + return None + # create frame + size = min(size, len(self._send_buffer)) frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start) self._send_buffer = self._send_buffer[size:] self._send_start += size # if the buffer is empty and EOF was written, set the FIN bit if self._send_eof and not self._send_buffer: frame.fin = True self._send_complete = True return frame ===========changed ref 2=========== # module: tests.test_stream class QuicStreamTest(TestCase): def test_send_data(self): stream = QuicStream(stream_id=0, max_stream_data_remote=512) + # nothing to send yet self.assertFalse(stream.has_data_to_send()) self.assertFalse(stream.is_blocked()) + frame = stream.get_frame(8) + self.assertIsNone(frame) + + # write data, send a chunk stream.write(b"0123456789012345") - self.assertTrue(stream.has_data_to_send()) 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.assertTrue(stream.has_data_to_send()) 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) + # nothing more to send self.assertFalse(stream.has_data_to_send()) self.assertFalse(stream.is_blocked()) + frame = stream.get_frame(8) + self.assertIsNone(frame) ===========changed ref 3=========== # module: aioquic.packet + def quic_uint_length(value: int) -> int: + """ + Returns the number of bytes required to encode the given value + as a QUIC variable-length unsigned integer. + """ + for i, (_, _, mask) in enumerate(UINT_VAR_FORMATS): + if value <= mask: + return 2 ** i + raise ValueError("Integer is too big for a variable-length integer") + ===========changed ref 4=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]: space = self.spaces[epoch] if not space.crypto.send.is_valid(): return buf = Buffer(capacity=PACKET_MAX_SIZE) + capacity = buf.capacity - space.crypto.aead_tag_size while True: if epoch == tls.Epoch.INITIAL: packet_type = PACKET_TYPE_INITIAL else: packet_type = PACKET_TYPE_HANDSHAKE # write header push_quic_header( buf, QuicHeader( version=self._version, packet_type=packet_type | (PACKET_NUMBER_SEND_SIZE - 1), destination_cid=self.peer_cid, source_cid=self.host_cid, token=self.peer_token, ), ) header_size = buf.tell() # ACK if self.send_ack[epoch] and space.ack_queue: push_uint_var(buf, QuicFrameType.ACK) packet.push_ack_frame(buf, space.ack_queue, 0) self.send_ack[epoch] = False # CLOSE if self.__close and self.__epoch == epoch: push_close(buf, **self.__close) self.__close = None + # CRYPTO stream = self.streams[epoch] - if stream.has_data_to_send(): - # CRYPTO - frame = stream.get_frame( - PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 4 - ) + frame_overhead = 3 + quic_uint_length(stream._send_start) + frame = stream.get_frame(capacity - buf.tell() - frame_overhead) + if frame is not None: push_uint_</s>
tests.test_stream/QuicStreamTest.test_send_blocked
Modified
aiortc~aioquic
cbc648c0974daa5a3f98f850527ac8d4981a6648
[connection] rework some size calculations, honour peer's MAX_DATA
<2>:<add> # nothing to send yet <4>:<add> frame = stream.get_frame(8) <add> self.assertIsNone(frame) <add> <add> # write data, send a chunk <5>:<del> <10>:<add> self.assertFalse(frame.fin) <12>:<add> # send is limited by peer <16>:<add> self.assertFalse(frame.fin) <18>:<add> # unable to send, blocked <20>:<add> frame = stream.get_frame(8) <add> self.assertIsNone(frame)
# 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> self.assertFalse(stream.has_data_to_send()) <3> self.assertFalse(stream.is_blocked()) <4> stream.write(b"0123456789012345") <5> <6> self.assertTrue(stream.has_data_to_send()) <7> self.assertFalse(stream.is_blocked()) <8> frame = stream.get_frame(8) <9> self.assertEqual(frame.data, b"01234567") <10> self.assertEqual(frame.offset, 0) <11> <12> self.assertTrue(stream.has_data_to_send()) <13> self.assertFalse(stream.is_blocked()) <14> frame = stream.get_frame(8) <15> self.assertEqual(frame.data, b"8901") <16> self.assertEqual(frame.offset, 8) <17> <18> self.assertTrue(stream.has_data_to_send()) <19> self.assertTrue(stream.is_blocked()) <20>
===========unchanged ref 0=========== at: aioquic.stream.QuicStream get_frame(size: int) -> Optional[QuicStreamFrame] has_data_to_send() -> bool is_blocked() -> bool at: tests.test_stream.QuicStreamTest.test_send_data_and_fin stream = QuicStream(stream_id=0, max_stream_data_remote=512) 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): - class QuicStream: + def is_blocked(self) -> bool: - def is_blocked(self): """ Returns True if there is data to send but the peer's MAX_STREAM_DATA prevents us from sending it. """ + return ( + bool(self._send_buffer) and self._send_start >= self.max_stream_data_remote - return self._send_buffer and self._send_start >= self.max_stream_data_remote + ) ===========changed ref 1=========== # module: aioquic.stream + class QuicStream(asyncio.BaseTransport): - class QuicStream: + def get_frame(self, size: int) -> Optional[QuicStreamFrame]: - def get_frame(self, size: int) -> QuicStreamFrame: """ Get a frame of data to send. """ + # check there is something to send + if self._send_complete or not self.has_data_to_send(): + return None - assert not self._send_complete, "cannot call get_frame() after completion" - size = min(size, len(self._send_buffer)) - + # apply flow control - # flow control if self.stream_id is not None: size = min(size, self.max_stream_data_remote - self._send_start) + if size < 0 or (size == 0 and self._send_buffer and not self._send_eof): + return None + # create frame + size = min(size, len(self._send_buffer)) frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start) self._send_buffer = self._send_buffer[size:] self._send_start += size # if the buffer is empty and EOF was written, set the FIN bit if self._send_eof and not self._send_buffer: frame.fin = True self._send_complete = True return frame ===========changed ref 2=========== # module: tests.test_stream class QuicStreamTest(TestCase): def test_send_data(self): stream = QuicStream(stream_id=0, max_stream_data_remote=512) + # nothing to send yet self.assertFalse(stream.has_data_to_send()) self.assertFalse(stream.is_blocked()) + frame = stream.get_frame(8) + self.assertIsNone(frame) + + # write data, send a chunk stream.write(b"0123456789012345") - self.assertTrue(stream.has_data_to_send()) 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.assertTrue(stream.has_data_to_send()) 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) + # nothing more to send self.assertFalse(stream.has_data_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_and_fin(self): stream = QuicStream(stream_id=0, max_stream_data_remote=512) + + # nothing to send yet + self.assertFalse(stream.has_data_to_send()) + 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.assertTrue(stream.has_data_to_send()) 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.assertFalse(frame.fin) + # send another chunk self.assertTrue(stream.has_data_to_send()) 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) - self.assertTrue(frame.fin) + # nothing more to send self.assertFalse(stream.has_data_to_send()) self.assertFalse(stream.is_blocked()) + frame = stream.get_frame(8) + self.assertIsNone(frame) ===========changed ref 4=========== # module: aioquic.packet + def quic_uint_length(value: int) -> int: + """ + Returns the number of bytes required to encode the given value + as a QUIC variable-length unsigned integer. + """ + for i, (_, _, mask) in enumerate(UINT_VAR_FORMATS): + if value <= mask: + return 2 ** i + raise ValueError("Integer is too big for a variable-length integer") +
tests.test_stream/QuicStreamTest.test_send_fin_only
Modified
aiortc~aioquic
cbc648c0974daa5a3f98f850527ac8d4981a6648
[connection] rework some size calculations, honour peer's MAX_DATA
<1>:<add> <add> # nothing to send yet <2>:<add> self.assertFalse(stream.is_blocked()) <add> frame = stream.get_frame(8) <add> self.assertIsNone(frame) <3>:<add> # write EOF <5>:<add> self.assertFalse(stream.is_blocked()) <7>:<add> self.assertTrue(frame.fin) <8>:<del> self.assertTrue(frame.fin)
# 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> self.assertFalse(stream.has_data_to_send()) <2> <3> stream.write_eof() <4> self.assertTrue(stream.has_data_to_send()) <5> frame = stream.get_frame(8) <6> self.assertEqual(frame.data, b"") <7> self.assertEqual(frame.offset, 0) <8> self.assertTrue(frame.fin) <9>
===========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(size: int) -> Optional[QuicStreamFrame] has_data_to_send() -> bool is_blocked() -> bool write(data: bytes) -> None at: unittest.case.TestCase assertFalse(expr: Any, msg: Any=...) -> None assertIsNone(obj: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: aioquic.stream + class QuicStream(asyncio.BaseTransport): - class QuicStream: + def is_blocked(self) -> bool: - def is_blocked(self): """ Returns True if there is data to send but the peer's MAX_STREAM_DATA prevents us from sending it. """ + return ( + bool(self._send_buffer) and self._send_start >= self.max_stream_data_remote - return self._send_buffer and self._send_start >= self.max_stream_data_remote + ) ===========changed ref 1=========== # module: aioquic.stream + class QuicStream(asyncio.BaseTransport): - class QuicStream: + def get_frame(self, size: int) -> Optional[QuicStreamFrame]: - def get_frame(self, size: int) -> QuicStreamFrame: """ Get a frame of data to send. """ + # check there is something to send + if self._send_complete or not self.has_data_to_send(): + return None - assert not self._send_complete, "cannot call get_frame() after completion" - size = min(size, len(self._send_buffer)) - + # apply flow control - # flow control if self.stream_id is not None: size = min(size, self.max_stream_data_remote - self._send_start) + if size < 0 or (size == 0 and self._send_buffer and not self._send_eof): + return None + # create frame + size = min(size, len(self._send_buffer)) frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start) self._send_buffer = self._send_buffer[size:] self._send_start += size # if the buffer is empty and EOF was written, set the FIN bit if self._send_eof and not self._send_buffer: frame.fin = True self._send_complete = True return frame ===========changed ref 2=========== # module: tests.test_stream class QuicStreamTest(TestCase): def test_send_blocked(self): stream = QuicStream(stream_id=0, max_stream_data_remote=12) + # nothing to send yet self.assertFalse(stream.has_data_to_send()) self.assertFalse(stream.is_blocked()) + frame = stream.get_frame(8) + self.assertIsNone(frame) + + # write data, send a chunk stream.write(b"0123456789012345") - self.assertTrue(stream.has_data_to_send()) 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 is limited by peer self.assertTrue(stream.has_data_to_send()) self.assertFalse(stream.is_blocked()) frame = stream.get_frame(8) self.assertEqual(frame.data, b"8901") + self.assertFalse(frame.fin) self.assertEqual(frame.offset, 8) + # unable to send, blocked self.assertTrue(stream.has_data_to_send()) self.assertTrue(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_id=0, max_stream_data_remote=512) + # nothing to send yet self.assertFalse(stream.has_data_to_send()) self.assertFalse(stream.is_blocked()) + frame = stream.get_frame(8) + self.assertIsNone(frame) + + # write data, send a chunk stream.write(b"0123456789012345") - self.assertTrue(stream.has_data_to_send()) 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.assertTrue(stream.has_data_to_send()) 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) + # nothing more to send self.assertFalse(stream.has_data_to_send()) self.assertFalse(stream.is_blocked()) + frame = stream.get_frame(8) + self.assertIsNone(frame) ===========changed ref 4=========== # module: tests.test_stream class QuicStreamTest(TestCase): def test_send_data_and_fin(self): stream = QuicStream(stream_id=0, max_stream_data_remote=512) + + # nothing to send yet + self.assertFalse(stream.has_data_to_send()) + 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.assertTrue(stream.has_data_to_send()) 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.assertFalse(frame.fin) + # send another chunk self.assertTrue(stream.has_data_to_send()) 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) - self.assertTrue(frame.fin) + # nothing more to send self.assertFalse(stream.has_data_to_send()) self.assertFalse(stream.is_blocked()) + frame = stream.get_frame(8) + self.assertIsNone(frame) ===========changed ref 5=========== # module: aioquic.packet + def quic_uint_length(value: int) -> int: + """ + Returns the number of bytes required to encode the given value + as a QUIC variable-length unsigned integer. + """ + for i, (_, _, mask) in enumerate(UINT_VAR_FORMATS): + if value <= mask: + return 2 ** i + raise ValueError("Integer is too big for a variable-length integer") +
aioquic.connection/QuicConnection.__init__
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<29>:<add> self._network_paths: List[QuicNetworkPath] = [] <del> self._path: Optional[Qu
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: <0> if not is_client: <1> assert certificate is not None, "SSL certificate is required" <2> assert private_key is not None, "SSL private key is required" <3> <4> self.alpn_protocols = alpn_protocols <5> self.certificate = certificate <6> self.is_client = is_client <7> self.host_cid = os.urandom(8) <8> self.peer_cid = os.urandom(8) <9> self.peer_cid_set = False <10> self.peer_token = b"" <11> self.private_key = private_key <12> self.secrets_log_file = secrets_log_file <13> self.server_name = server_name <14> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} <15> <16> self.__close: Optional[Dict] = None <17> self.__connected = asyncio.Event() <18> self.__epoch = tls.Epoch.INITIAL <19> self._local_idle_timeout = 60000 # milliseconds <20> self._local_max_data = 1048576 <21> self._local_max_data_used = 0 <22> self._local_max_stream_data_bidi_local = 1048576 <23> self._local_max_stream_data_bidi_remote = 1048576 <24> self._local_max_stream_data_uni = 1048576 <25> self._local_max_streams_bidi = 128 <26> self._local_max_streams_uni = 128 <27> self.__logger = logger <28> self.__path_challenge: Optional[bytes] = None <29> self._path: Optional[Qu</s>
===========below chunk 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: # offset: 1 self._pending_flow_control: List[bytes] = [] 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_bidi = 0 self._remote_max_streams_uni = 0 self._spin_bit = 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 # callbacks self.stream_created_cb: Callable[ [asyncio.StreamReader, asyncio.StreamWriter], None ] = lambda r, w: None # frame handlers self.__frame_handlers = [ self._handle_padding_frame, self._handle_padding_frame, self._handle_ack_frame, self._handle_ack_frame, self._handle_reset_stream_frame, self._handle_stop_sending_frame, self._handle_crypto_frame, self._handle_new_token_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame</s> ===========below chunk 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: # offset: 2 <s>, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_max_data_frame, self._handle_max_stream_data_frame, self._handle_max_streams_bidi_frame, self._handle_max_streams_uni_frame, self._handle_data_blocked_frame, self._handle_stream_data_blocked_frame, self._handle_streams_blocked_frame, self._handle_streams_blocked_frame, self._handle_new_connection_id_frame, self._handle_retire_connection_id_frame, self._handle_path_challenge_frame, self._handle_path_response_frame, self._handle_connection_close_frame, self._handle_connection_close_frame, ] ===========unchanged ref 0=========== at: aioquic.connection logger = logging.getLogger("quic") QuicConnectionState() QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, challenge: Optional[bytes]=None, is_validated: bool=False) at: aioquic.connection.QuicConnection _handle_ack_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_crypto_frame(self, context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_crypto_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_max_data_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_max_stream_data_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_max_streams_bidi_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_max_streams_uni_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_new_token_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_new_token_frame(self, context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_padding_frame(self, context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_padding_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_reset_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_stop_sending_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None ===========unchanged ref 1=========== _handle_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.connection.QuicConnection._handle_crypto_frame self.__epoch = tls.Epoch.ONE_RTT self.__epoch = tls.Epoch.HANDSHAKE at: aioquic.connection.QuicConnection._handle_max_data_frame self._remote_max_data = max_data at: aioquic.connection.QuicConnection._handle_max_streams_bidi_frame self._remote_max_streams_bidi = max_streams at: aioquic.connection.QuicConnection._handle_max_streams_uni_frame self._remote_max_streams_uni = max_streams at: aioquic.connection.QuicConnection._handle_stream_frame self._local_max_data_used += newly_received at: aioquic.connection.QuicConnection._parse_transport_parameters self._remote_idle_timeout = quic_transport_parameters.idle_timeout at: aioquic.connection.QuicConnection._send_pending self.__send_pending_task = None at: aioquic.connection.QuicConnection._send_soon self.__send_pending_task = loop.call_soon(self._send_pending) at: aioquic.connection.QuicConnection._set_state self.__state = state at: aioquic.connection.QuicConnection._write_application self._pending_flow_control = [] self.__close = None self._remote_max_data_used += len(frame.data) at: aioquic.connection.QuicConnection._write_handshake self.__close = None at: aioquic.connection.QuicConnection.close self.__close = { "error_code": error_code, "frame_type": frame_type, "reason_phrase": reason_phrase, }
aioquic.connection/QuicConnection.connect
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<3>:<add> self._network_paths = [QuicNetworkPath(addr, is_validated=True)] <del> self._path = QuicNetworkPath(addr)
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def connect(self, addr: NetworkAddress) -> None: - def connect(self, addr: Any) -> None: <0> """ <1> Initiate the TLS handshake and wait for it to complete. <2> """ <3> self._path = QuicNetworkPath(addr) <4> self._version = max(self.supported_versions) <5> self._connect() <6> await self.__connected.wait() <7>
===========unchanged ref 0=========== at: aioquic.connection QuicConnectionState() maybe_connection_error(error_code: int, frame_type: Optional[int], reason_phrase: str) -> Optional[QuicConnectionError] at: aioquic.connection.QuicConnection connection_lost(exc: Exception) -> None _set_state(state: QuicConnectionState) -> None ===========changed ref 0=========== # module: aioquic.connection + @dataclass + class QuicReceiveContext: + epoch: tls.Epoch + network_path: QuicNetworkPath + ===========changed ref 1=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: - def __init__(self, addr: Any) -> None: - self.addr = addr - ===========changed ref 2=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + def can_send(self, size: int) -> bool: + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received + ===========changed ref 3=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + addr: NetworkAddress - addr: Any + bytes_received: int = 0 - bytes_received = 0 + bytes_sent: int = 0 - bytes_sent = 0 + challenge: Optional[bytes] = None + is_validated: bool = False - is_validated = False ===========changed ref 4=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: if not is_client: assert certificate is not None, "SSL certificate is required" assert private_key is not None, "SSL private key is required" self.alpn_protocols = alpn_protocols self.certificate = certificate self.is_client = is_client self.host_cid = os.urandom(8) self.peer_cid = os.urandom(8) self.peer_cid_set = False self.peer_token = b"" self.private_key = private_key self.secrets_log_file = secrets_log_file self.server_name = server_name self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} self.__close: Optional[Dict] = None self.__connected = asyncio.Event() self.__epoch = tls.Epoch.INITIAL 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 = logger self.__path_challenge: Optional[bytes] = None + self._network_paths: List[QuicNetworkPath] = [] - self._path: Optional[QuicNetworkPath] = None self._pending</s> ===========changed ref 5=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: # offset: 1 <s> List[QuicNetworkPath] = [] - self._path: Optional[QuicNetworkPath] = None self._pending_flow_control: List[bytes] = [] 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_bidi = 0 self._remote_max_streams_uni = 0 self._spin_bit = 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 # callbacks self.stream_created_cb: Callable[ [asyncio.StreamReader, asyncio.StreamWriter], None ] = lambda r, w: None # frame handlers self.__frame_handlers = [ self._handle_padding_frame, self._handle_padding_frame, self._handle_ack_frame, self._handle_ack_frame, self._handle_reset_stream_frame, self._handle_stop_sending_frame, </s> ===========changed ref 6=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: # offset: 2 <s>handle_crypto_frame, self._handle_new_token_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_max_data_frame, self._handle_max_stream_data_frame, self._handle_max_streams_bidi_frame, self._handle_max_streams_uni_frame, self._handle_data_blocked_frame, self._handle_stream_data_blocked_frame, self._handle_streams_blocked_frame, self._handle_streams_blocked_frame, self._handle_new_connection_id_frame, self._handle_retire_connection_id_frame, self._handle_path_challenge_frame, self._handle_path_response_frame, self._handle_connection_close_frame, self._handle_connection_close_frame, ]
aioquic.connection/QuicConnection.datagram_received
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None: - def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: <0> """ <1> Handle an incoming datagram. <2> """ <3> # stop handling packets when closing <4> if self.__state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]: <5> return <6> <7> data = cast(bytes, data) <8> buf = Buffer(data=data) <9> while not buf.eof(): <10> start_off = buf.tell() <11> header = pull_quic_header(buf, host_cid_length=len(self.host_cid)) <12> <13> # check destination CID matches <14> if self.is_client and header.destination_cid != self.host_cid: <15> return <16> <17> # check protocol version <18> if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION: <19> # version negotiation <20> versions = [] <21> while not buf.eof(): <22> versions.append(pull_uint32(buf)) <23> common = set(self.supported_versions).intersection(versions) <24> if not common: <25> self.__logger.error("Could not find a common protocol version") <26> return <27> self._version = QuicProtocolVersion(max(common)) <28> self.__logger.info("Retrying with %s", self._version) <29> self._connect() <30> return <31> elif ( <32> header.version is not None <33> and header.version not in self.supported_versions <34> ): <35> # unsupported version <36> return <37> <38> if self.is_client and header.packet_type == PACKET_TYPE_RETRY: <39> # stateless retry <40> if ( <41> header.destination_cid == self.host_cid <42> and header.original_destination_cid == self.peer_cid </s>
===========below chunk 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None: - def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: # offset: 1 self.__logger.info("Performing stateless retry") self.peer_cid = header.source_cid self.peer_token = header.token self._connect() return # server initialization if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT: assert ( header.packet_type == PACKET_TYPE_INITIAL ), "first packet must be INITIAL" self._path = QuicNetworkPath(addr) self._version = QuicProtocolVersion(header.version) self._initialize(header.destination_cid) # decrypt packet encrypted_off = buf.tell() - start_off end_off = buf.tell() + header.rest_length pull_bytes(buf, header.rest_length) epoch = get_epoch(header.packet_type) space = self.spaces[epoch] if not space.crypto.recv.is_valid(): return try: plain_header, plain_payload, packet_number = space.crypto.decrypt_packet( data[start_off:end_off], encrypted_off ) except CryptoError as exc: self.__logger.warning(exc) return if not self.peer_cid_set: self.peer_cid = header.source_cid self.peer_cid_set = True # update state if self.__state == QuicConnectionState.FIRSTFLIGHT: self._set_state(QuicConnectionState.CONNECTED) # update spin bit if ( not is_long_header(plain_header[0]) and packet_number > self._spin_highest_pn ): if self.is_client: </s> ===========below chunk 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None: - def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: # offset: 2 <s>]) and packet_number > self._spin_highest_pn ): if self.is_client: self._spin_bit = not get_spin_bit(plain_header[0]) else: self._spin_bit = get_spin_bit(plain_header[0]) self._spin_highest_pn = packet_number # handle payload try: is_ack_only, is_probing = self._payload_received(epoch, plain_payload) except QuicConnectionError as exc: self.__logger.warning(exc) self.close( error_code=exc.error_code, frame_type=exc.frame_type, reason_phrase=exc.reason_phrase, ) return # record packet as received self._path.bytes_received += buf.tell() - start_off space.ack_queue.add(packet_number) if not is_ack_only: self.send_ack[epoch] = True self._send_pending() ===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) pull_bytes(buf: Buffer, length: int) -> bytes pull_uint32(buf: Buffer) -> int at: aioquic.buffer.Buffer eof() -> bool tell() -> int at: aioquic.connection NetworkAddress = Any get_epoch(packet_type: int) -> tls.Epoch QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) QuicConnectionState() QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath) at: aioquic.connection.PacketSpace.__init__ self.crypto = CryptoPair() at: aioquic.connection.QuicConnection supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20] _connect() -> None _find_network_path(addr: NetworkAddress) -> QuicNetworkPath _initialize(peer_cid: bytes) -> None _payload_received(context: QuicReceiveContext, plain: bytes) -> Tuple[bool, bool] _payload_received(self, context: QuicReceiveContext, plain: bytes) -> Tuple[bool, bool] _set_state(state: QuicConnectionState) -> None at: aioquic.connection.QuicConnection.__init__ self.is_client = is_client self.host_cid = os.urandom(8) self.peer_cid = os.urandom(8) self.peer_cid_set = False self.peer_token = b"" self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} self.__logger = logger self._network_paths: List[QuicNetworkPath] = [] self._spin_bit = False self._spin_highest_pn = 0 ===========unchanged ref 1=========== self.__state = QuicConnectionState.FIRSTFLIGHT self.__transport: Optional[asyncio.DatagramTransport] = None self._version: Optional[int] = None at: aioquic.connection.QuicConnection._initialize self.spaces = { tls.Epoch.INITIAL: PacketSpace(), tls.Epoch.HANDSHAKE: PacketSpace(), tls.Epoch.ONE_RTT: PacketSpace(), } at: aioquic.connection.QuicConnection._set_state self.__state = state at: aioquic.connection.QuicConnection.connect self._network_paths = [QuicNetworkPath(addr, is_validated=True)] self._version = max(self.supported_versions) at: aioquic.connection.QuicConnection.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, ) at: aioquic.connection.QuicReceiveContext epoch: tls.Epoch network_path: QuicNetworkPath at: aioquic.crypto CryptoError(*args: object) at: aioquic.crypto.CryptoContext is_valid() -> bool at: aioquic.crypto.CryptoPair decrypt_packet(packet: bytes, encrypted_offset: int) -> Tuple[bytes, bytes, int] at: aioquic.crypto.CryptoPair.__init__ self.recv = CryptoContext() at: aioquic.packet PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00 PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30
aioquic.connection/QuicConnection._handle_crypto_frame
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<3>:<add> stream = self.streams[context.epoch] <del> stream = self.streams[epoch]
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_crypto_frame( + self, context: QuicReceiveContext, frame_type: int, buf: Buffer - self, epoch: tls.Epoch, frame_type: int, buf: Buffer ) -> None: <0> """ <1> Handle a CRYPTO frame. <2> """ <3> stream = self.streams[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> # update current epoch <18> if self.tls.state in [ <19> tls.State.CLIENT_POST_HANDSHAKE, <20> tls.State.SERVER_POST_HANDSHAKE, <21> ]: <22> if not self.__connected.is_set(): <23> # parse transport parameters <24> for ext_type, ext_data in self.tls.received_extensions: <25> if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS: <26> self._parse_transport_parameters(ext_data) <27> break <28> self.__connected.set() <29> self.__epoch = tls.Epoch.ONE_RTT <30> else: <31> self.__epoch = tls.Epoch.HANDSHAKE <32>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnectionState() QuicReceiveContext(epoch: tls.Epoch, 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 _set_state(state: QuicConnectionState) -> None at: aioquic.connection.QuicConnection.__init__ self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} self.__logger = logger at: aioquic.connection.QuicReceiveContext epoch: tls.Epoch at: aioquic.packet pull_uint_var(buf: Buffer) -> int QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) pull_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 at: logging.Logger info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None ===========changed ref 0=========== # module: aioquic.connection + @dataclass + class QuicReceiveContext: + epoch: tls.Epoch + network_path: QuicNetworkPath + ===========changed ref 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath: + # check existing network paths + for idx, network_path in enumerate(self._network_paths): + if network_path.addr == addr: + return network_path + + # new network path + network_path = QuicNetworkPath(addr) + self.__logger.info("Network path %s discovered", network_path.addr) + return network_path + ===========changed ref 2=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def connect(self, addr: NetworkAddress) -> None: - def connect(self, addr: Any) -> None: """ Initiate the TLS handshake and wait for it to complete. """ + self._network_paths = [QuicNetworkPath(addr, is_validated=True)] - self._path = QuicNetworkPath(addr) self._version = max(self.supported_versions) self._connect() await self.__connected.wait() ===========changed ref 3=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: - def __init__(self, addr: Any) -> None: - self.addr = addr - ===========changed ref 4=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + def can_send(self, size: int) -> bool: + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received + ===========changed ref 5=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + addr: NetworkAddress - addr: Any + bytes_received: int = 0 - bytes_received = 0 + bytes_sent: int = 0 - bytes_sent = 0 + challenge: Optional[bytes] = None + is_validated: bool = False - is_validated = False ===========changed ref 6=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None: - def datagram_received(self, data: Union[bytes, Text], addr: Any) -> 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 if self.is_client and header.destination_cid != self.host_cid: 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.__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 ): self.__logger.info("Performing stateless retry") self.peer_cid = header.source_cid self.peer_token = header.token </s> ===========changed ref 7=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None: - def datagram_received(self, data: Union[bytes, Text], addr: Any) -> None: # offset: 1 <s> stateless retry") self.peer_cid = header.source_cid self.peer_token = header.token self._connect() return + network_path = self._find_network_path(addr) + # server initialization if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT: assert ( header.packet_type == PACKET_TYPE_INITIAL ), "first packet must be INITIAL" + self._network_paths = [network_path] - self._path = QuicNetworkPath(addr) self._version = QuicProtocolVersion(header.version) self._initialize(header.destination_cid) # decrypt packet encrypted_off = buf.tell() - start_off end_off = buf.tell() + header.rest_length pull_bytes(buf, header.rest_length) epoch = get_epoch(header.packet_type) space = self.spaces[epoch] if not space.crypto.recv.is_valid(): return try: plain_header, plain_payload, packet_number = space.crypto.decrypt_packet( data[start_off:end_off], encrypted_off ) except CryptoError as exc: self.__logger.warning(exc) return if not self.peer_cid_set: self.peer_cid = header.source_cid self.peer_cid_set = True # update state if self.__state == QuicConnectionState.FIRSTFLIGHT: self._set_state(QuicConnectionState</s>
aioquic.connection/QuicConnection._handle_path_response_frame
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<4>:<add> if data != context.network_path.challenge: <del> if data != self.__path_challenge: <10>:<add> self.__logger.info("Network path %s validated", context.network_path.addr) <add> context.network_path.is_validated = True
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_path_response_frame( + self, context: QuicReceiveContext, frame_type: int, buf: Buffer - self, epoch: tls.Epoch, frame_type: int, buf: Buffer ) -> None: <0> """ <1> Handle a PATH_RESPONSE frame. <2> """ <3> data = pull_bytes(buf, 8) <4> if data != self.__path_challenge: <5> raise QuicConnectionError( <6> error_code=QuicErrorCode.PROTOCOL_VIOLATION, <7> frame_type=frame_type, <8> reason_phrase="Response does not match challenge", <9> ) <10>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath) at: aioquic.packet pull_new_token_frame(buf: Buffer) -> bytes pull_new_connection_id_frame(buf: Buffer) -> Tuple[int, bytes, bytes] ===========changed ref 0=========== # module: aioquic.connection + @dataclass + class QuicReceiveContext: + epoch: tls.Epoch + network_path: QuicNetworkPath + ===========changed ref 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath: + # check existing network paths + for idx, network_path in enumerate(self._network_paths): + if network_path.addr == addr: + return network_path + + # new network path + network_path = QuicNetworkPath(addr) + self.__logger.info("Network path %s discovered", network_path.addr) + return network_path + ===========changed ref 2=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_crypto_frame( + self, context: QuicReceiveContext, frame_type: int, buf: Buffer - self, epoch: tls.Epoch, frame_type: int, buf: Buffer ) -> None: """ Handle a CRYPTO frame. """ + stream = self.streams[context.epoch] - stream = self.streams[epoch] stream.add_frame(packet.pull_crypto_frame(buf)) data = stream.pull_data() if data: # pass data to TLS layer try: self.tls.handle_message(data, self.send_buffer) except tls.Alert as exc: raise QuicConnectionError( error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description), frame_type=QuicFrameType.CRYPTO, reason_phrase=str(exc), ) # update current epoch if self.tls.state in [ tls.State.CLIENT_POST_HANDSHAKE, tls.State.SERVER_POST_HANDSHAKE, ]: if not self.__connected.is_set(): # parse transport parameters for ext_type, ext_data in self.tls.received_extensions: if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS: self._parse_transport_parameters(ext_data) break self.__connected.set() self.__epoch = tls.Epoch.ONE_RTT else: self.__epoch = tls.Epoch.HANDSHAKE ===========changed ref 3=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def connect(self, addr: NetworkAddress) -> None: - def connect(self, addr: Any) -> None: """ Initiate the TLS handshake and wait for it to complete. """ + self._network_paths = [QuicNetworkPath(addr, is_validated=True)] - self._path = QuicNetworkPath(addr) self._version = max(self.supported_versions) self._connect() await self.__connected.wait() ===========changed ref 4=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: - def __init__(self, addr: Any) -> None: - self.addr = addr - ===========changed ref 5=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + def can_send(self, size: int) -> bool: + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received + ===========changed ref 6=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + addr: NetworkAddress - addr: Any + bytes_received: int = 0 - bytes_received = 0 + bytes_sent: int = 0 - bytes_sent = 0 + challenge: Optional[bytes] = None + is_validated: bool = False - is_validated = False ===========changed ref 7=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None: - def datagram_received(self, data: Union[bytes, Text], addr: Any) -> 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 if self.is_client and header.destination_cid != self.host_cid: 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.__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 ): self.__logger.info("Performing stateless retry") self.peer_cid = header.source_cid self.peer_token = header.token </s>
aioquic.connection/QuicConnection._payload_received
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<24>:<add> self.__frame_handlers[frame_type](context, frame_type, buf) <del> self.__frame_handlers[frame_type](epoch, frame_type, buf)
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _payload_received( + self, context: QuicReceiveContext, plain: bytes + ) -> Tuple[bool, bool]: - def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> Tuple[bool, bool]: <0> buf = Buffer(data=plain) <1> <2> is_ack_only = True <3> is_probing = None <4> while not buf.eof(): <5> frame_type = pull_uint_var(buf) <6> if frame_type not in [ <7> QuicFrameType.ACK, <8> QuicFrameType.ACK_ECN, <9> QuicFrameType.PADDING, <10> ]: <11> is_ack_only = False <12> <13> if frame_type not in [ <14> QuicFrameType.PATH_CHALLENGE, <15> QuicFrameType.PATH_RESPONSE, <16> QuicFrameType.PADDING, <17> QuicFrameType.NEW_CONNECTION_ID, <18> ]: <19> is_probing = False <20> elif is_probing is None: <21> is_probing = True <22> <23> if frame_type < len(self.__frame_handlers): <24> self.__frame_handlers[frame_type](epoch, frame_type, buf) <25> else: <26> raise QuicConnectionError( <27> error_code=QuicErrorCode.PROTOCOL_VIOLATION, <28> frame_type=frame_type, <29> reason_phrase="Unexpected frame type", <30> ) <31> <32> self._push_crypto_data() <33> <34> return is_ack_only, bool(is_probing) <35>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath) at: aioquic.connection.QuicConnection _assert_stream_can_receive(frame_type: int, stream_id: int) -> None _get_or_create_stream(frame_type: int, stream_id: int) -> QuicStream at: aioquic.connection.QuicConnection.__init__ self._local_max_data_used = 0 at: aioquic.connection.QuicConnection._handle_stream_frame frame = QuicStreamFrame( offset=offset, data=pull_bytes(buf, length), fin=bool(flags & QuicStreamFlag.FIN), ) stream = self._get_or_create_stream(frame_type, stream_id) newly_received = max(0, offset + length - stream._recv_highest) at: aioquic.packet pull_uint_var(buf: Buffer) -> int at: aioquic.stream.QuicStream add_frame(frame: QuicStreamFrame) -> None at: typing Tuple = _TupleType(tuple, -1, inst=False, name='Tuple') ===========changed ref 0=========== # module: aioquic.connection + @dataclass + class QuicReceiveContext: + epoch: tls.Epoch + network_path: QuicNetworkPath + ===========changed ref 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_path_response_frame( + self, context: QuicReceiveContext, frame_type: int, buf: Buffer - self, epoch: tls.Epoch, frame_type: int, buf: Buffer ) -> None: """ Handle a PATH_RESPONSE frame. """ data = pull_bytes(buf, 8) + if data != context.network_path.challenge: - if data != self.__path_challenge: raise QuicConnectionError( error_code=QuicErrorCode.PROTOCOL_VIOLATION, frame_type=frame_type, reason_phrase="Response does not match challenge", ) + self.__logger.info("Network path %s validated", context.network_path.addr) + context.network_path.is_validated = True ===========changed ref 2=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath: + # check existing network paths + for idx, network_path in enumerate(self._network_paths): + if network_path.addr == addr: + return network_path + + # new network path + network_path = QuicNetworkPath(addr) + self.__logger.info("Network path %s discovered", network_path.addr) + return network_path + ===========changed ref 3=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_crypto_frame( + self, context: QuicReceiveContext, frame_type: int, buf: Buffer - self, epoch: tls.Epoch, frame_type: int, buf: Buffer ) -> None: """ Handle a CRYPTO frame. """ + stream = self.streams[context.epoch] - stream = self.streams[epoch] stream.add_frame(packet.pull_crypto_frame(buf)) data = stream.pull_data() if data: # pass data to TLS layer try: self.tls.handle_message(data, self.send_buffer) except tls.Alert as exc: raise QuicConnectionError( error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description), frame_type=QuicFrameType.CRYPTO, reason_phrase=str(exc), ) # update current epoch if self.tls.state in [ tls.State.CLIENT_POST_HANDSHAKE, tls.State.SERVER_POST_HANDSHAKE, ]: if not self.__connected.is_set(): # parse transport parameters for ext_type, ext_data in self.tls.received_extensions: if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS: self._parse_transport_parameters(ext_data) break self.__connected.set() self.__epoch = tls.Epoch.ONE_RTT else: self.__epoch = tls.Epoch.HANDSHAKE ===========changed ref 4=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def connect(self, addr: NetworkAddress) -> None: - def connect(self, addr: Any) -> None: """ Initiate the TLS handshake and wait for it to complete. """ + self._network_paths = [QuicNetworkPath(addr, is_validated=True)] - self._path = QuicNetworkPath(addr) self._version = max(self.supported_versions) self._connect() await self.__connected.wait() ===========changed ref 5=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: - def __init__(self, addr: Any) -> None: - self.addr = addr - ===========changed ref 6=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + def can_send(self, size: int) -> bool: + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received + ===========changed ref 7=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + addr: NetworkAddress - addr: Any + bytes_received: int = 0 - bytes_received = 0 + bytes_sent: int = 0 - bytes_sent = 0 + challenge: Optional[bytes] = None + is_validated: bool = False - is_validated = False
aioquic.connection/QuicConnection._send_path_challenge
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<0>:<add> if network_path.challenge is None: <add> network_path.challenge = os.urandom(8) <del> self.__path_challenge = os.urandom(8) <2>:<add> bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge <del> bytes([QuicFrameType.PATH_CHALLENGE]) + self.__path_challenge
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _send_path_challenge(self, network_path: QuicNetworkPath) -> None: - def _send_path_challenge(self) -> None: <0> self.__path_challenge = os.urandom(8) <1> self._pending_flow_control.append( <2> bytes([QuicFrameType.PATH_CHALLENGE]) + self.__path_challenge <3> ) <4> self._send_pending() <5>
===========unchanged ref 0=========== at: aioquic.packet QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) ===========changed ref 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_path_response_frame( + self, context: QuicReceiveContext, frame_type: int, buf: Buffer - self, epoch: tls.Epoch, frame_type: int, buf: Buffer ) -> None: """ Handle a PATH_RESPONSE frame. """ data = pull_bytes(buf, 8) + if data != context.network_path.challenge: - if data != self.__path_challenge: raise QuicConnectionError( error_code=QuicErrorCode.PROTOCOL_VIOLATION, frame_type=frame_type, reason_phrase="Response does not match challenge", ) + self.__logger.info("Network path %s validated", context.network_path.addr) + context.network_path.is_validated = True ===========changed ref 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _payload_received( + self, context: QuicReceiveContext, plain: bytes + ) -> Tuple[bool, bool]: - def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> Tuple[bool, bool]: buf = Buffer(data=plain) is_ack_only = True is_probing = None while not buf.eof(): frame_type = pull_uint_var(buf) if frame_type not in [ QuicFrameType.ACK, QuicFrameType.ACK_ECN, QuicFrameType.PADDING, ]: is_ack_only = False 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 if frame_type < len(self.__frame_handlers): + self.__frame_handlers[frame_type](context, frame_type, buf) - self.__frame_handlers[frame_type](epoch, frame_type, buf) else: raise QuicConnectionError( error_code=QuicErrorCode.PROTOCOL_VIOLATION, frame_type=frame_type, reason_phrase="Unexpected frame type", ) self._push_crypto_data() return is_ack_only, bool(is_probing) ===========changed ref 2=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath: + # check existing network paths + for idx, network_path in enumerate(self._network_paths): + if network_path.addr == addr: + return network_path + + # new network path + network_path = QuicNetworkPath(addr) + self.__logger.info("Network path %s discovered", network_path.addr) + return network_path + ===========changed ref 3=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_crypto_frame( + self, context: QuicReceiveContext, frame_type: int, buf: Buffer - self, epoch: tls.Epoch, frame_type: int, buf: Buffer ) -> None: """ Handle a CRYPTO frame. """ + stream = self.streams[context.epoch] - stream = self.streams[epoch] stream.add_frame(packet.pull_crypto_frame(buf)) data = stream.pull_data() if data: # pass data to TLS layer try: self.tls.handle_message(data, self.send_buffer) except tls.Alert as exc: raise QuicConnectionError( error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description), frame_type=QuicFrameType.CRYPTO, reason_phrase=str(exc), ) # update current epoch if self.tls.state in [ tls.State.CLIENT_POST_HANDSHAKE, tls.State.SERVER_POST_HANDSHAKE, ]: if not self.__connected.is_set(): # parse transport parameters for ext_type, ext_data in self.tls.received_extensions: if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS: self._parse_transport_parameters(ext_data) break self.__connected.set() self.__epoch = tls.Epoch.ONE_RTT else: self.__epoch = tls.Epoch.HANDSHAKE ===========changed ref 4=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def connect(self, addr: NetworkAddress) -> None: - def connect(self, addr: Any) -> None: """ Initiate the TLS handshake and wait for it to complete. """ + self._network_paths = [QuicNetworkPath(addr, is_validated=True)] - self._path = QuicNetworkPath(addr) self._version = max(self.supported_versions) self._connect() await self.__connected.wait() ===========changed ref 5=========== # module: aioquic.connection + @dataclass + class QuicReceiveContext: + epoch: tls.Epoch + network_path: QuicNetworkPath + ===========changed ref 6=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: - def __init__(self, addr: Any) -> None: - self.addr = addr - ===========changed ref 7=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + def can_send(self, size: int) -> bool: + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received + ===========changed ref 8=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + addr: NetworkAddress - addr: Any + bytes_received: int = 0 - bytes_received = 0 + bytes_sent: int = 0 - bytes_sent = 0 + challenge: Optional[bytes] = None + is_validated: bool = False - is_validated = False
aioquic.connection/QuicConnection._send_pending
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<0>:<add> network_path = self._network_paths[0] <1>:<add> self.__transport.sendto(datagram, network_path.addr) <del> self.__transport.sendto(datagram, self._path.addr) <2>:<add> network_path.bytes_sent += len(datagram) <del> self._path.bytes_sent += len(datagram)
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _send_pending(self) -> None: <0> for datagram in self._pending_datagrams(): <1> self.__transport.sendto(datagram, self._path.addr) <2> self._path.bytes_sent += len(datagram) <3> self.__send_pending_task = None <4>
===========unchanged ref 0=========== at: aioquic.connection QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) at: aioquic.connection.QuicConnection.__init__ self.__frame_handlers = [ self._handle_padding_frame, self._handle_padding_frame, self._handle_ack_frame, self._handle_ack_frame, self._handle_reset_stream_frame, self._handle_stop_sending_frame, self._handle_crypto_frame, self._handle_new_token_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_max_data_frame, self._handle_max_stream_data_frame, self._handle_max_streams_bidi_frame, self._handle_max_streams_uni_frame, self._handle_data_blocked_frame, self._handle_stream_data_blocked_frame, self._handle_streams_blocked_frame, self._handle_streams_blocked_frame, self._handle_new_connection_id_frame, self._handle_retire_connection_id_frame, self._handle_path_challenge_frame, self._handle_path_response_frame, self._handle_connection_close_frame, self._handle_connection_close_frame, ] at: aioquic.connection.QuicConnection._payload_received buf = Buffer(data=plain) frame_type = pull_uint_var(buf) at: aioquic.packet QuicErrorCode(x: Union[str, bytes, bytearray], base: int) QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) ===========changed ref 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _send_path_challenge(self, network_path: QuicNetworkPath) -> None: - def _send_path_challenge(self) -> None: + if network_path.challenge is None: + network_path.challenge = os.urandom(8) - self.__path_challenge = os.urandom(8) self._pending_flow_control.append( + bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge - bytes([QuicFrameType.PATH_CHALLENGE]) + self.__path_challenge ) self._send_pending() ===========changed ref 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_path_response_frame( + self, context: QuicReceiveContext, frame_type: int, buf: Buffer - self, epoch: tls.Epoch, frame_type: int, buf: Buffer ) -> None: """ Handle a PATH_RESPONSE frame. """ data = pull_bytes(buf, 8) + if data != context.network_path.challenge: - if data != self.__path_challenge: raise QuicConnectionError( error_code=QuicErrorCode.PROTOCOL_VIOLATION, frame_type=frame_type, reason_phrase="Response does not match challenge", ) + self.__logger.info("Network path %s validated", context.network_path.addr) + context.network_path.is_validated = True ===========changed ref 2=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _payload_received( + self, context: QuicReceiveContext, plain: bytes + ) -> Tuple[bool, bool]: - def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> Tuple[bool, bool]: buf = Buffer(data=plain) is_ack_only = True is_probing = None while not buf.eof(): frame_type = pull_uint_var(buf) if frame_type not in [ QuicFrameType.ACK, QuicFrameType.ACK_ECN, QuicFrameType.PADDING, ]: is_ack_only = False 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 if frame_type < len(self.__frame_handlers): + self.__frame_handlers[frame_type](context, frame_type, buf) - self.__frame_handlers[frame_type](epoch, frame_type, buf) else: raise QuicConnectionError( error_code=QuicErrorCode.PROTOCOL_VIOLATION, frame_type=frame_type, reason_phrase="Unexpected frame type", ) self._push_crypto_data() return is_ack_only, bool(is_probing) ===========changed ref 3=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath: + # check existing network paths + for idx, network_path in enumerate(self._network_paths): + if network_path.addr == addr: + return network_path + + # new network path + network_path = QuicNetworkPath(addr) + self.__logger.info("Network path %s discovered", network_path.addr) + return network_path + ===========changed ref 4=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_crypto_frame( + self, context: QuicReceiveContext, frame_type: int, buf: Buffer - self, epoch: tls.Epoch, frame_type: int, buf: Buffer ) -> None: """ Handle a CRYPTO frame. """ + stream = self.streams[context.epoch] - stream = self.streams[epoch] stream.add_frame(packet.pull_crypto_frame(buf)) data = stream.pull_data() if data: # pass data to TLS layer try: self.tls.handle_message(data, self.send_buffer) except tls.Alert as exc: raise QuicConnectionError( error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description), frame_type=QuicFrameType.CRYPTO, reason_phrase=str(exc), ) # update current epoch if self.tls.state in [ tls.State.CLIENT_POST_HANDSHAKE, tls.State.SERVER_POST_HANDSHAKE, ]: if not self.__connected.is_set(): # parse transport parameters for ext_type, ext_data in self.tls.received_extensions: if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS: self._parse_transport_parameters(ext_data) break self.__connected.set() self.__epoch = tls.Epoch.ONE_RTT else: self.__epoch = tls.Epoch.HANDSHAKE
tests.test_connection/create_standalone_client
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<5>:<add> client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] <del> client._path = QuicNetworkPath(SERVER_ADDR)
# module: tests.test_connection def create_standalone_client(): <0> client = QuicConnection(is_client=True) <1> client_transport = FakeTransport(CLIENT_ADDR) <2> client.connection_made(client_transport) <3> <4> # like connect() but without waiting <5> client._path = QuicNetworkPath(SERVER_ADDR) <6> client._version = max(client.supported_versions) <7> client._connect() <8> <9> return client, client_transport <10>
===========unchanged ref 0=========== at: aioquic.connection QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath) at: aioquic.connection.QuicConnection.__init__ self._network_paths: List[QuicNetworkPath] = [] at: aioquic.connection.QuicConnection.connect self._network_paths = [QuicNetworkPath(addr, is_validated=True)] at: aioquic.connection.QuicConnection.datagram_received self._network_paths = [network_path] at: aioquic.connection.QuicReceiveContext epoch: tls.Epoch network_path: QuicNetworkPath at: aioquic.tls Epoch() at: tests.test_connection.FakeTransport sent = 0 target = None at: tests.test_connection.FakeTransport.__init__ self.local_addr = local_addr ===========changed ref 0=========== # module: aioquic.connection + @dataclass + class QuicReceiveContext: + epoch: tls.Epoch + network_path: QuicNetworkPath + ===========changed ref 1=========== # module: aioquic.connection + NetworkAddress = Any ===========changed ref 2=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: - def __init__(self, addr: Any) -> None: - self.addr = addr - ===========changed ref 3=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + def can_send(self, size: int) -> bool: + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received + ===========changed ref 4=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + addr: NetworkAddress - addr: Any + bytes_received: int = 0 - bytes_received = 0 + bytes_sent: int = 0 - bytes_sent = 0 + challenge: Optional[bytes] = None + is_validated: bool = False - is_validated = False ===========changed ref 5=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def connect(self, addr: NetworkAddress) -> None: - def connect(self, addr: Any) -> None: """ Initiate the TLS handshake and wait for it to complete. """ + self._network_paths = [QuicNetworkPath(addr, is_validated=True)] - self._path = QuicNetworkPath(addr) self._version = max(self.supported_versions) self._connect() await self.__connected.wait() ===========changed ref 6=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath: + # check existing network paths + for idx, network_path in enumerate(self._network_paths): + if network_path.addr == addr: + return network_path + + # new network path + network_path = QuicNetworkPath(addr) + self.__logger.info("Network path %s discovered", network_path.addr) + return network_path + ===========changed ref 7=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _send_pending(self) -> None: + network_path = self._network_paths[0] for datagram in self._pending_datagrams(): + self.__transport.sendto(datagram, network_path.addr) - self.__transport.sendto(datagram, self._path.addr) + network_path.bytes_sent += len(datagram) - self._path.bytes_sent += len(datagram) self.__send_pending_task = None ===========changed ref 8=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _send_path_challenge(self, network_path: QuicNetworkPath) -> None: - def _send_path_challenge(self) -> None: + if network_path.challenge is None: + network_path.challenge = os.urandom(8) - self.__path_challenge = os.urandom(8) self._pending_flow_control.append( + bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge - bytes([QuicFrameType.PATH_CHALLENGE]) + self.__path_challenge ) self._send_pending() ===========changed ref 9=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_path_response_frame( + self, context: QuicReceiveContext, frame_type: int, buf: Buffer - self, epoch: tls.Epoch, frame_type: int, buf: Buffer ) -> None: """ Handle a PATH_RESPONSE frame. """ data = pull_bytes(buf, 8) + if data != context.network_path.challenge: - if data != self.__path_challenge: raise QuicConnectionError( error_code=QuicErrorCode.PROTOCOL_VIOLATION, frame_type=frame_type, reason_phrase="Response does not match challenge", ) + self.__logger.info("Network path %s validated", context.network_path.addr) + context.network_path.is_validated = True ===========changed ref 10=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _payload_received( + self, context: QuicReceiveContext, plain: bytes + ) -> Tuple[bool, bool]: - def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> Tuple[bool, bool]: buf = Buffer(data=plain) is_ack_only = True is_probing = None while not buf.eof(): frame_type = pull_uint_var(buf) if frame_type not in [ QuicFrameType.ACK, QuicFrameType.ACK_ECN, QuicFrameType.PADDING, ]: is_ack_only = False 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 if frame_type < len(self.__frame_handlers): + self.__frame_handlers[frame_type](context, frame_type, buf) - self.__frame_handlers[frame_type](epoch, frame_type, buf) else: raise QuicConnectionError( error_code=QuicErrorCode.PROTOCOL_VIOLATION, frame_type=frame_type, reason_phrase="Unexpected frame type", ) self._push_crypto_data() return is_ack_only, bool(is_probing)
tests.test_connection/create_transport
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<10>:<add> client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] <del> client._path = QuicNetworkPath(SERVER_ADDR)
# module: tests.test_connection def create_transport(client, server): <0> client_transport = FakeTransport(CLIENT_ADDR) <1> client_transport.target = server <2> <3> server_transport = FakeTransport(SERVER_ADDR) <4> server_transport.target = client <5> <6> server.connection_made(server_transport) <7> client.connection_made(client_transport) <8> <9> # like connect() but without waiting <10> client._path = QuicNetworkPath(SERVER_ADDR) <11> client._version = max(client.supported_versions) <12> client._connect() <13> <14> return client_transport, server_transport <15>
===========unchanged ref 0=========== at: aioquic.connection QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, challenge: Optional[bytes]=None, is_validated: bool=False) at: aioquic.connection.QuicConnection supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20] connection_made(transport: asyncio.BaseTransport) -> None _connect() -> None at: aioquic.connection.QuicConnection.__init__ self._network_paths: List[QuicNetworkPath] = [] self._version: Optional[int] = None at: aioquic.connection.QuicConnection.connect self._network_paths = [QuicNetworkPath(addr, is_validated=True)] self._version = max(self.supported_versions) at: aioquic.connection.QuicConnection.datagram_received self._version = QuicProtocolVersion(header.version) self._version = QuicProtocolVersion(max(common)) self._network_paths = [network_path] at: aioquic.connection.QuicNetworkPath addr: NetworkAddress bytes_received: int = 0 bytes_sent: int = 0 challenge: Optional[bytes] = None is_validated: bool = False at: tests.test_connection CLIENT_ADDR = None SERVER_ADDR = None FakeTransport(local_addr) at: tests.test_connection.FakeTransport target = None at: tests.test_connection.create_standalone_client client = QuicConnection(is_client=True) ===========changed ref 0=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + addr: NetworkAddress - addr: Any + bytes_received: int = 0 - bytes_received = 0 + bytes_sent: int = 0 - bytes_sent = 0 + challenge: Optional[bytes] = None + is_validated: bool = False - is_validated = False ===========changed ref 1=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 2=========== # module: tests.test_connection def create_standalone_client(): client = QuicConnection(is_client=True) client_transport = FakeTransport(CLIENT_ADDR) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client, client_transport ===========changed ref 3=========== # module: aioquic.connection + NetworkAddress = Any ===========changed ref 4=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: - def __init__(self, addr: Any) -> None: - self.addr = addr - ===========changed ref 5=========== # module: aioquic.connection + @dataclass + class QuicReceiveContext: + epoch: tls.Epoch + network_path: QuicNetworkPath + ===========changed ref 6=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + def can_send(self, size: int) -> bool: + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received + ===========changed ref 7=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def connect(self, addr: NetworkAddress) -> None: - def connect(self, addr: Any) -> None: """ Initiate the TLS handshake and wait for it to complete. """ + self._network_paths = [QuicNetworkPath(addr, is_validated=True)] - self._path = QuicNetworkPath(addr) self._version = max(self.supported_versions) self._connect() await self.__connected.wait() ===========changed ref 8=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath: + # check existing network paths + for idx, network_path in enumerate(self._network_paths): + if network_path.addr == addr: + return network_path + + # new network path + network_path = QuicNetworkPath(addr) + self.__logger.info("Network path %s discovered", network_path.addr) + return network_path + ===========changed ref 9=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _send_pending(self) -> None: + network_path = self._network_paths[0] for datagram in self._pending_datagrams(): + self.__transport.sendto(datagram, network_path.addr) - self.__transport.sendto(datagram, self._path.addr) + network_path.bytes_sent += len(datagram) - self._path.bytes_sent += len(datagram) self.__send_pending_task = None ===========changed ref 10=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _send_path_challenge(self, network_path: QuicNetworkPath) -> None: - def _send_path_challenge(self) -> None: + if network_path.challenge is None: + network_path.challenge = os.urandom(8) - self.__path_challenge = os.urandom(8) self._pending_flow_control.append( + bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge - bytes([QuicFrameType.PATH_CHALLENGE]) + self.__path_challenge ) self._send_pending() ===========changed ref 11=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_path_response_frame( + self, context: QuicReceiveContext, frame_type: int, buf: Buffer - self, epoch: tls.Epoch, frame_type: int, buf: Buffer ) -> None: """ Handle a PATH_RESPONSE frame. """ data = pull_bytes(buf, 8) + if data != context.network_path.challenge: - if data != self.__path_challenge: raise QuicConnectionError( error_code=QuicErrorCode.PROTOCOL_VIOLATION, frame_type=frame_type, reason_phrase="Response does not match challenge", ) + self.__logger.info("Network path %s validated", context.network_path.addr) + context.network_path.is_validated = True
tests.test_connection/QuicConnectionTest.test_handle_ack_frame_ecn
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<0>:<add> client, client_transport = create_standalone_client() <add> <del> client = QuicConnection(is_client=True) <2>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT,
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_ack_frame_ecn(self): <0> client = QuicConnection(is_client=True) <1> client._handle_ack_frame( <2> tls.Epoch.ONE_RTT, <3> QuicFrameType.ACK_ECN, <4> Buffer(data=b"\x00\x02\x00\x00\x00\x00\x00"), <5> ) <6>
===========unchanged ref 0=========== at: aioquic.connection.QuicConnection.__init__ self.peer_cid = os.urandom(8) at: aioquic.connection.QuicConnection.datagram_received self.peer_cid = header.source_cid at: tests.test_connection SERVER_ADDR = None at: tests.test_connection.FakeTransport.sendto self.sent += 1 at: tests.test_connection.QuicConnectionTest.test_datagram_received_retry_wrong_destination_cid client, client_transport = create_standalone_client() client, client_transport = create_standalone_client() at: unittest.case.TestCase failureException: Type[BaseException] longMessage: bool maxDiff: Optional[int] _testMethodName: str _testMethodDoc: str assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_standalone_client(): client = QuicConnection(is_client=True) client_transport = FakeTransport(CLIENT_ADDR) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client, client_transport ===========changed ref 2=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 3=========== # module: aioquic.connection + NetworkAddress = Any ===========changed ref 4=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: - def __init__(self, addr: Any) -> None: - self.addr = addr - ===========changed ref 5=========== # module: aioquic.connection + @dataclass + class QuicReceiveContext: + epoch: tls.Epoch + network_path: QuicNetworkPath + ===========changed ref 6=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + def can_send(self, size: int) -> bool: + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received + ===========changed ref 7=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + addr: NetworkAddress - addr: Any + bytes_received: int = 0 - bytes_received = 0 + bytes_sent: int = 0 - bytes_sent = 0 + challenge: Optional[bytes] = None + is_validated: bool = False - is_validated = False ===========changed ref 8=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def connect(self, addr: NetworkAddress) -> None: - def connect(self, addr: Any) -> None: """ Initiate the TLS handshake and wait for it to complete. """ + self._network_paths = [QuicNetworkPath(addr, is_validated=True)] - self._path = QuicNetworkPath(addr) self._version = max(self.supported_versions) self._connect() await self.__connected.wait() ===========changed ref 9=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath: + # check existing network paths + for idx, network_path in enumerate(self._network_paths): + if network_path.addr == addr: + return network_path + + # new network path + network_path = QuicNetworkPath(addr) + self.__logger.info("Network path %s discovered", network_path.addr) + return network_path + ===========changed ref 10=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _send_pending(self) -> None: + network_path = self._network_paths[0] for datagram in self._pending_datagrams(): + self.__transport.sendto(datagram, network_path.addr) - self.__transport.sendto(datagram, self._path.addr) + network_path.bytes_sent += len(datagram) - self._path.bytes_sent += len(datagram) self.__send_pending_task = None ===========changed ref 11=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _send_path_challenge(self, network_path: QuicNetworkPath) -> None: - def _send_path_challenge(self) -> None: + if network_path.challenge is None: + network_path.challenge = os.urandom(8) - self.__path_challenge = os.urandom(8) self._pending_flow_control.append( + bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge - bytes([QuicFrameType.PATH_CHALLENGE]) + self.__path_challenge ) self._send_pending() ===========changed ref 12=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_path_response_frame( + self, context: QuicReceiveContext, frame_type: int, buf: Buffer - self, epoch: tls.Epoch, frame_type: int, buf: Buffer ) -> None: """ Handle a PATH_RESPONSE frame. """ data = pull_bytes(buf, 8) + if data != context.network_path.challenge: - if data != self.__path_challenge: raise QuicConnectionError( error_code=QuicErrorCode.PROTOCOL_VIOLATION, frame_type=frame_type, reason_phrase="Response does not match challenge", ) + self.__logger.info("Network path %s validated", context.network_path.addr) + context.network_path.is_validated = True
tests.test_connection/QuicConnectionTest.test_handle_data_blocked_frame
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<12>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT,
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_data_blocked_frame(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client receives DATA_BLOCKED: 12345 <11> client._handle_data_blocked_frame( <12> tls.Epoch.ONE_RTT, <13> QuicFrameType.DATA_BLOCKED, <14> Buffer(data=encode_uint_var(12345)), <15> ) <16>
===========unchanged ref 0=========== at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection close(error_code: int=QuicErrorCode.NO_ERROR, frame_type: Optional[int]=None, reason_phrase: str="") -> None at: aioquic.packet QuicErrorCode(x: Union[str, bytes, bytearray], base: int) QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) create_transport(client, server) at: tests.test_connection.FakeTransport.sendto self.sent += 1 at: tests.test_connection.QuicConnectionTest.test_handle_connection_close_frame_app client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 1=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_ack_frame_ecn(self): + client, client_transport = create_standalone_client() + - client = QuicConnection(is_client=True) client._handle_ack_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.ACK_ECN, Buffer(data=b"\x00\x02\x00\x00\x00\x00\x00"), ) ===========changed ref 2=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 3=========== # module: tests.test_connection def create_standalone_client(): client = QuicConnection(is_client=True) client_transport = FakeTransport(CLIENT_ADDR) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client, client_transport ===========changed ref 4=========== # module: aioquic.connection + NetworkAddress = Any ===========changed ref 5=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: - def __init__(self, addr: Any) -> None: - self.addr = addr - ===========changed ref 6=========== # module: aioquic.connection + @dataclass + class QuicReceiveContext: + epoch: tls.Epoch + network_path: QuicNetworkPath + ===========changed ref 7=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + def can_send(self, size: int) -> bool: + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received + ===========changed ref 8=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + addr: NetworkAddress - addr: Any + bytes_received: int = 0 - bytes_received = 0 + bytes_sent: int = 0 - bytes_sent = 0 + challenge: Optional[bytes] = None + is_validated: bool = False - is_validated = False ===========changed ref 9=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def connect(self, addr: NetworkAddress) -> None: - def connect(self, addr: Any) -> None: """ Initiate the TLS handshake and wait for it to complete. """ + self._network_paths = [QuicNetworkPath(addr, is_validated=True)] - self._path = QuicNetworkPath(addr) self._version = max(self.supported_versions) self._connect() await self.__connected.wait() ===========changed ref 10=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath: + # check existing network paths + for idx, network_path in enumerate(self._network_paths): + if network_path.addr == addr: + return network_path + + # new network path + network_path = QuicNetworkPath(addr) + self.__logger.info("Network path %s discovered", network_path.addr) + return network_path + ===========changed ref 11=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _send_pending(self) -> None: + network_path = self._network_paths[0] for datagram in self._pending_datagrams(): + self.__transport.sendto(datagram, network_path.addr) - self.__transport.sendto(datagram, self._path.addr) + network_path.bytes_sent += len(datagram) - self._path.bytes_sent += len(datagram) self.__send_pending_task = None ===========changed ref 12=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _send_path_challenge(self, network_path: QuicNetworkPath) -> None: - def _send_path_challenge(self) -> None: + if network_path.challenge is None: + network_path.challenge = os.urandom(8) - self.__path_challenge = os.urandom(8) self._pending_flow_control.append( + bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge - bytes([QuicFrameType.PATH_CHALLENGE]) + self.__path_challenge ) self._send_pending() ===========changed ref 13=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_path_response_frame( + self, context: QuicReceiveContext, frame_type: int, buf: Buffer - self, epoch: tls.Epoch, frame_type: int, buf: Buffer ) -> None: """ Handle a PATH_RESPONSE frame. """ data = pull_bytes(buf, 8) + if data != context.network_path.challenge: - if data != self.__path_challenge: raise QuicConnectionError( error_code=QuicErrorCode.PROTOCOL_VIOLATION, frame_type=frame_type, reason_phrase="Response does not match challenge", ) + self.__logger.info("Network path %s validated", context.network_path.addr) + context.network_path.is_validated = True
tests.test_connection/QuicConnectionTest.test_handle_max_data_frame
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<13>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT,
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_data_frame(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> self.assertEqual(client._remote_max_data, 1048576) <10> <11> # client receives MAX_DATA raising limit <12> client._handle_max_data_frame( <13> tls.Epoch.ONE_RTT, <14> QuicFrameType.MAX_DATA, <15> Buffer(data=encode_uint_var(1048577)), <16> ) <17> self.assertEqual(client._remote_max_data, 1048577) <18>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection _handle_data_blocked_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) encode_uint_var(v) client_receive_context(client) create_transport(client, server) at: tests.test_connection.QuicConnectionTest.test_handle_data_blocked_frame client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_data_blocked_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives DATA_BLOCKED: 12345 client._handle_data_blocked_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.DATA_BLOCKED, Buffer(data=encode_uint_var(12345)), ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_ack_frame_ecn(self): + client, client_transport = create_standalone_client() + - client = QuicConnection(is_client=True) client._handle_ack_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.ACK_ECN, Buffer(data=b"\x00\x02\x00\x00\x00\x00\x00"), ) ===========changed ref 4=========== # module: tests.test_connection def create_standalone_client(): client = QuicConnection(is_client=True) client_transport = FakeTransport(CLIENT_ADDR) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client, client_transport ===========changed ref 5=========== # module: aioquic.connection + NetworkAddress = Any ===========changed ref 6=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: - def __init__(self, addr: Any) -> None: - self.addr = addr - ===========changed ref 7=========== # module: aioquic.connection + @dataclass + class QuicReceiveContext: + epoch: tls.Epoch + network_path: QuicNetworkPath + ===========changed ref 8=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + def can_send(self, size: int) -> bool: + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received + ===========changed ref 9=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + addr: NetworkAddress - addr: Any + bytes_received: int = 0 - bytes_received = 0 + bytes_sent: int = 0 - bytes_sent = 0 + challenge: Optional[bytes] = None + is_validated: bool = False - is_validated = False ===========changed ref 10=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def connect(self, addr: NetworkAddress) -> None: - def connect(self, addr: Any) -> None: """ Initiate the TLS handshake and wait for it to complete. """ + self._network_paths = [QuicNetworkPath(addr, is_validated=True)] - self._path = QuicNetworkPath(addr) self._version = max(self.supported_versions) self._connect() await self.__connected.wait() ===========changed ref 11=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _find_network_path(self, addr: NetworkAddress) -> QuicNetworkPath: + # check existing network paths + for idx, network_path in enumerate(self._network_paths): + if network_path.addr == addr: + return network_path + + # new network path + network_path = QuicNetworkPath(addr) + self.__logger.info("Network path %s discovered", network_path.addr) + return network_path + ===========changed ref 12=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _send_pending(self) -> None: + network_path = self._network_paths[0] for datagram in self._pending_datagrams(): + self.__transport.sendto(datagram, network_path.addr) - self.__transport.sendto(datagram, self._path.addr) + network_path.bytes_sent += len(datagram) - self._path.bytes_sent += len(datagram) self.__send_pending_task = None ===========changed ref 13=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _send_path_challenge(self, network_path: QuicNetworkPath) -> None: - def _send_path_challenge(self) -> None: + if network_path.challenge is None: + network_path.challenge = os.urandom(8) - self.__path_challenge = os.urandom(8) self._pending_flow_control.append( + bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge - bytes([QuicFrameType.PATH_CHALLENGE]) + self.__path_challenge ) self._send_pending()
tests.test_connection/QuicConnectionTest.test_handle_max_stream_data_frame
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<17>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT, <25>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT,
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_stream_data_frame(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client creates bidirectional stream 0 <11> reader, writer = run(client.create_stream()) <12> stream = writer.transport <13> self.assertEqual(stream.max_stream_data_remote, 1048576) <14> <15> # client receives MAX_STREAM_DATA raising limit <16> client._handle_max_stream_data_frame( <17> tls.Epoch.ONE_RTT, <18> QuicFrameType.MAX_STREAM_DATA, <19> Buffer(data=b"\x00" + encode_uint_var(1048577)), <20> ) <21> self.assertEqual(stream.max_stream_data_remote, 1048577) <22> <23> # client receives MAX_STREAM_DATA lowering limit <24> client._handle_max_stream_data_frame( <25> tls.Epoch.ONE_RTT, <26> QuicFrameType.MAX_STREAM_DATA, <27> Buffer(data=b"\x00" + encode_uint_var(1048575)), <28> ) <29> self.assertEqual(stream.max_stream_data_remote, 1048577) <30>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] _handle_max_data_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_max_stream_data_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.connection.QuicConnection.__init__ self._remote_max_data = 0 at: aioquic.connection.QuicConnection._handle_max_data_frame self._remote_max_data = max_data at: aioquic.packet QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) encode_uint_var(v) client_receive_context(client) create_transport(client, server) at: tests.test_connection.QuicConnectionTest.test_handle_max_data_frame client = QuicConnection(is_client=True) ===========unchanged ref 1=========== server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) at: tests.utils run(coro) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_data_blocked_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives DATA_BLOCKED: 12345 client._handle_data_blocked_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.DATA_BLOCKED, Buffer(data=encode_uint_var(12345)), ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_ack_frame_ecn(self): + client, client_transport = create_standalone_client() + - client = QuicConnection(is_client=True) client._handle_ack_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.ACK_ECN, Buffer(data=b"\x00\x02\x00\x00\x00\x00\x00"), ) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_data_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client._remote_max_data, 1048576) # client receives MAX_DATA raising limit client._handle_max_data_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.MAX_DATA, Buffer(data=encode_uint_var(1048577)), ) self.assertEqual(client._remote_max_data, 1048577) ===========changed ref 5=========== # module: tests.test_connection def create_standalone_client(): client = QuicConnection(is_client=True) client_transport = FakeTransport(CLIENT_ADDR) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client, client_transport ===========changed ref 6=========== # module: aioquic.connection + NetworkAddress = Any ===========changed ref 7=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: - def __init__(self, addr: Any) -> None: - self.addr = addr - ===========changed ref 8=========== # module: aioquic.connection + @dataclass + class QuicReceiveContext: + epoch: tls.Epoch + network_path: QuicNetworkPath + ===========changed ref 9=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + def can_send(self, size: int) -> bool: + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received + ===========changed ref 10=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + addr: NetworkAddress - addr: Any + bytes_received: int = 0 - bytes_received = 0 + bytes_sent: int = 0 - bytes_sent = 0 + challenge: Optional[bytes] = None + is_validated: bool = False - is_validated = False ===========changed ref 11=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def connect(self, addr: NetworkAddress) -> None: - def connect(self, addr: Any) -> None: """ Initiate the TLS handshake and wait for it to complete. """ + self._network_paths = [QuicNetworkPath(addr, is_validated=True)] - self._path = QuicNetworkPath(addr) self._version = max(self.supported_versions) self._connect() await self.__connected.wait()
tests.test_connection/QuicConnectionTest.test_handle_max_stream_data_frame_receive_only
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<16>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT,
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_stream_data_frame_receive_only(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # server creates unidirectional stream 3 <11> run(server.create_stream(is_unidirectional=True)) <12> <13> # client receives MAX_STREAM_DATA: 3, 1 <14> with self.assertRaises(QuicConnectionError) as cm: <15> client._handle_max_stream_data_frame( <16> tls.Epoch.ONE_RTT, <17> QuicFrameType.MAX_STREAM_DATA, <18> Buffer(data=b"\x03\x01"), <19> ) <20> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) <21> self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA) <22> self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only") <23>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection _handle_max_stream_data_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) encode_uint_var(v) client_receive_context(client) create_transport(client, server) at: tests.test_connection.QuicConnectionTest.test_handle_max_stream_data_frame client = QuicConnection(is_client=True) stream = writer.transport at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_data_blocked_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives DATA_BLOCKED: 12345 client._handle_data_blocked_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.DATA_BLOCKED, Buffer(data=encode_uint_var(12345)), ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_ack_frame_ecn(self): + client, client_transport = create_standalone_client() + - client = QuicConnection(is_client=True) client._handle_ack_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.ACK_ECN, Buffer(data=b"\x00\x02\x00\x00\x00\x00\x00"), ) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_data_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client._remote_max_data, 1048576) # client receives MAX_DATA raising limit client._handle_max_data_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.MAX_DATA, Buffer(data=encode_uint_var(1048577)), ) self.assertEqual(client._remote_max_data, 1048577) ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_stream_data_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 reader, writer = run(client.create_stream()) stream = writer.transport self.assertEqual(stream.max_stream_data_remote, 1048576) # client receives MAX_STREAM_DATA raising limit client._handle_max_stream_data_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x00" + encode_uint_var(1048577)), ) self.assertEqual(stream.max_stream_data_remote, 1048577) # client receives MAX_STREAM_DATA lowering limit client._handle_max_stream_data_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x00" + encode_uint_var(1048575)), ) self.assertEqual(stream.max_stream_data_remote, 1048577) ===========changed ref 6=========== # module: tests.test_connection def create_standalone_client(): client = QuicConnection(is_client=True) client_transport = FakeTransport(CLIENT_ADDR) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client, client_transport ===========changed ref 7=========== # module: aioquic.connection + NetworkAddress = Any ===========changed ref 8=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: - def __init__(self, addr: Any) -> None: - self.addr = addr - ===========changed ref 9=========== # module: aioquic.connection + @dataclass + class QuicReceiveContext: + epoch: tls.Epoch + network_path: QuicNetworkPath + ===========changed ref 10=========== # module: aioquic.connection + @dataclass class QuicNetworkPath: + def can_send(self, size: int) -> bool: + return self.is_validated or (self.bytes_sent + size) <= 3 * self.bytes_received +
tests.test_connection/QuicConnectionTest.test_handle_max_streams_bidi_frame
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<13>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT, <21>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT,
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_streams_bidi_frame(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> self.assertEqual(client._remote_max_streams_bidi, 128) <10> <11> # client receives MAX_STREAMS_BIDI raising limit <12> client._handle_max_streams_bidi_frame( <13> tls.Epoch.ONE_RTT, <14> QuicFrameType.MAX_STREAMS_BIDI, <15> Buffer(data=encode_uint_var(129)), <16> ) <17> self.assertEqual(client._remote_max_streams_bidi, 129) <18> <19> # client receives MAX_STREAMS_BIDI lowering limit <20> client._handle_max_streams_bidi_frame( <21> tls.Epoch.ONE_RTT, <22> QuicFrameType.MAX_STREAMS_BIDI, <23> Buffer(data=encode_uint_var(127)), <24> ) <25> self.assertEqual(client._remote_max_streams_bidi, 129) <26>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection _handle_max_stream_data_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_max_streams_bidi_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.connection.QuicConnection.__init__ self._remote_max_streams_bidi = 0 at: aioquic.connection.QuicConnection._handle_max_streams_bidi_frame self._remote_max_streams_bidi = max_streams at: aioquic.packet QuicErrorCode(x: Union[str, bytes, bytearray], base: int) QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) client_receive_context(client) create_transport(client, server) ===========unchanged ref 1=========== at: tests.test_connection.QuicConnectionTest.test_handle_max_stream_data_frame_receive_only client = QuicConnection(is_client=True) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E] assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None at: unittest.case._AssertRaisesContext.__exit__ self.exception = exc_value.with_traceback(None) ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_data_blocked_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives DATA_BLOCKED: 12345 client._handle_data_blocked_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.DATA_BLOCKED, Buffer(data=encode_uint_var(12345)), ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_ack_frame_ecn(self): + client, client_transport = create_standalone_client() + - client = QuicConnection(is_client=True) client._handle_ack_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.ACK_ECN, Buffer(data=b"\x00\x02\x00\x00\x00\x00\x00"), ) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_data_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client._remote_max_data, 1048576) # client receives MAX_DATA raising limit client._handle_max_data_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.MAX_DATA, Buffer(data=encode_uint_var(1048577)), ) self.assertEqual(client._remote_max_data, 1048577) ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_stream_data_frame_receive_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server creates unidirectional stream 3 run(server.create_stream(is_unidirectional=True)) # client receives MAX_STREAM_DATA: 3, 1 with self.assertRaises(QuicConnectionError) as cm: client._handle_max_stream_data_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x03\x01"), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA) self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only")
tests.test_connection/QuicConnectionTest.test_handle_max_streams_uni_frame
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<13>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT, <21>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT,
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_streams_uni_frame(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> self.assertEqual(client._remote_max_streams_uni, 128) <10> <11> # client receives MAX_STREAMS_UNI raising limit <12> client._handle_max_streams_uni_frame( <13> tls.Epoch.ONE_RTT, <14> QuicFrameType.MAX_STREAMS_UNI, <15> Buffer(data=encode_uint_var(129)), <16> ) <17> self.assertEqual(client._remote_max_streams_uni, 129) <18> <19> # client receives MAX_STREAMS_UNI raising limit <20> client._handle_max_streams_uni_frame( <21> tls.Epoch.ONE_RTT, <22> QuicFrameType.MAX_STREAMS_UNI, <23> Buffer(data=encode_uint_var(127)), <24> ) <25> self.assertEqual(client._remote_max_streams_uni, 129) <26>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection _handle_max_streams_bidi_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_max_streams_uni_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.connection.QuicConnection.__init__ 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.packet QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) encode_uint_var(v) client_receive_context(client) create_transport(client, server) ===========unchanged ref 1=========== at: tests.test_connection.QuicConnectionTest.test_handle_max_streams_bidi_frame client = QuicConnection(is_client=True) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_data_blocked_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives DATA_BLOCKED: 12345 client._handle_data_blocked_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.DATA_BLOCKED, Buffer(data=encode_uint_var(12345)), ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_ack_frame_ecn(self): + client, client_transport = create_standalone_client() + - client = QuicConnection(is_client=True) client._handle_ack_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.ACK_ECN, Buffer(data=b"\x00\x02\x00\x00\x00\x00\x00"), ) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_data_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client._remote_max_data, 1048576) # client receives MAX_DATA raising limit client._handle_max_data_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.MAX_DATA, Buffer(data=encode_uint_var(1048577)), ) self.assertEqual(client._remote_max_data, 1048577) ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_stream_data_frame_receive_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server creates unidirectional stream 3 run(server.create_stream(is_unidirectional=True)) # client receives MAX_STREAM_DATA: 3, 1 with self.assertRaises(QuicConnectionError) as cm: client._handle_max_stream_data_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x03\x01"), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA) self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only")
tests.test_connection/QuicConnectionTest.test_handle_new_connection_id_frame
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<12>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT,
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_new_connection_id_frame(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client receives NEW_CONNECTION_ID <11> client._handle_new_connection_id_frame( <12> tls.Epoch.ONE_RTT, <13> QuicFrameType.NEW_CONNECTION_ID, <14> Buffer( <15> data=binascii.unhexlify( <16> "02117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8" <17> ) <18> ), <19> ) <20>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection _handle_max_streams_uni_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.connection.QuicConnection.__init__ self._remote_max_streams_uni = 0 at: aioquic.connection.QuicConnection._handle_max_streams_uni_frame self._remote_max_streams_uni = max_streams at: aioquic.packet QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) encode_uint_var(v) client_receive_context(client) at: tests.test_connection.QuicConnectionTest.test_handle_max_streams_uni_frame client = QuicConnection(is_client=True) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_data_blocked_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives DATA_BLOCKED: 12345 client._handle_data_blocked_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.DATA_BLOCKED, Buffer(data=encode_uint_var(12345)), ) ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_ack_frame_ecn(self): + client, client_transport = create_standalone_client() + - client = QuicConnection(is_client=True) client._handle_ack_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.ACK_ECN, Buffer(data=b"\x00\x02\x00\x00\x00\x00\x00"), ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_data_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client._remote_max_data, 1048576) # client receives MAX_DATA raising limit client._handle_max_data_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.MAX_DATA, Buffer(data=encode_uint_var(1048577)), ) self.assertEqual(client._remote_max_data, 1048577) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_streams_uni_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client._remote_max_streams_uni, 128) # client receives MAX_STREAMS_UNI raising limit client._handle_max_streams_uni_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAMS_UNI, Buffer(data=encode_uint_var(129)), ) self.assertEqual(client._remote_max_streams_uni, 129) # client receives MAX_STREAMS_UNI raising limit client._handle_max_streams_uni_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAMS_UNI, Buffer(data=encode_uint_var(127)), ) self.assertEqual(client._remote_max_streams_uni, 129) ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_stream_data_frame_receive_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server creates unidirectional stream 3 run(server.create_stream(is_unidirectional=True)) # client receives MAX_STREAM_DATA: 3, 1 with self.assertRaises(QuicConnectionError) as cm: client._handle_max_stream_data_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x03\x01"), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA) self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only")
tests.test_connection/QuicConnectionTest.test_handle_new_token_frame
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<12>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT,
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_new_token_frame(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client receives NEW_TOKEN <11> client._handle_new_token_frame( <12> tls.Epoch.ONE_RTT, <13> QuicFrameType.NEW_TOKEN, <14> Buffer(data=binascii.unhexlify("080102030405060708")), <15> ) <16>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection _handle_new_connection_id_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: binascii unhexlify(hexstr: _Ascii, /) -> bytes at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) client_receive_context(client) at: tests.test_connection.QuicConnectionTest.test_handle_new_connection_id_frame client = QuicConnection(is_client=True) ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_new_connection_id_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives NEW_CONNECTION_ID client._handle_new_connection_id_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.NEW_CONNECTION_ID, Buffer( data=binascii.unhexlify( "02117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8" ) ), ) ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_data_blocked_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives DATA_BLOCKED: 12345 client._handle_data_blocked_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.DATA_BLOCKED, Buffer(data=encode_uint_var(12345)), ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_ack_frame_ecn(self): + client, client_transport = create_standalone_client() + - client = QuicConnection(is_client=True) client._handle_ack_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.ACK_ECN, Buffer(data=b"\x00\x02\x00\x00\x00\x00\x00"), ) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_data_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client._remote_max_data, 1048576) # client receives MAX_DATA raising limit client._handle_max_data_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.MAX_DATA, Buffer(data=encode_uint_var(1048577)), ) self.assertEqual(client._remote_max_data, 1048577) ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_streams_uni_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client._remote_max_streams_uni, 128) # client receives MAX_STREAMS_UNI raising limit client._handle_max_streams_uni_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAMS_UNI, Buffer(data=encode_uint_var(129)), ) self.assertEqual(client._remote_max_streams_uni, 129) # client receives MAX_STREAMS_UNI raising limit client._handle_max_streams_uni_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAMS_UNI, Buffer(data=encode_uint_var(127)), ) self.assertEqual(client._remote_max_streams_uni, 129) ===========changed ref 6=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_stream_data_frame_receive_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server creates unidirectional stream 3 run(server.create_stream(is_unidirectional=True)) # client receives MAX_STREAM_DATA: 3, 1 with self.assertRaises(QuicConnectionError) as cm: client._handle_max_stream_data_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAM_DATA, Buffer(data=b"\x03\x01"), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA) self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only")
tests.test_connection/QuicConnectionTest.test_handle_path_challenge_frame
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<11>:<add> network_path = server._network_paths[0] <add> network_path.is_validated = False <add> server._send_path_challenge(network_path) <del> server._send_path_challenge() <12>:<add> run(asyncio.sleep(0)) <add> self.assertTrue(network_path.is_validated)
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_path_challenge_frame(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # server sends PATH_CHALLENGE <11> server._send_path_challenge() <12>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection.QuicConnection _handle_new_token_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: binascii unhexlify(hexstr: _Ascii, /) -> bytes at: tests.test_connection client_receive_context(client) create_transport(client, server) at: tests.test_connection.QuicConnectionTest.test_handle_new_token_frame client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_new_token_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives NEW_TOKEN client._handle_new_token_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.NEW_TOKEN, Buffer(data=binascii.unhexlify("080102030405060708")), ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_new_connection_id_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives NEW_CONNECTION_ID client._handle_new_connection_id_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.NEW_CONNECTION_ID, Buffer( data=binascii.unhexlify( "02117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8" ) ), ) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_data_blocked_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives DATA_BLOCKED: 12345 client._handle_data_blocked_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.DATA_BLOCKED, Buffer(data=encode_uint_var(12345)), ) ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_ack_frame_ecn(self): + client, client_transport = create_standalone_client() + - client = QuicConnection(is_client=True) client._handle_ack_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.ACK_ECN, Buffer(data=b"\x00\x02\x00\x00\x00\x00\x00"), ) ===========changed ref 6=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_data_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client._remote_max_data, 1048576) # client receives MAX_DATA raising limit client._handle_max_data_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.MAX_DATA, Buffer(data=encode_uint_var(1048577)), ) self.assertEqual(client._remote_max_data, 1048577) ===========changed ref 7=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_max_streams_uni_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) self.assertEqual(client._remote_max_streams_uni, 128) # client receives MAX_STREAMS_UNI raising limit client._handle_max_streams_uni_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAMS_UNI, Buffer(data=encode_uint_var(129)), ) self.assertEqual(client._remote_max_streams_uni, 129) # client receives MAX_STREAMS_UNI raising limit client._handle_max_streams_uni_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.MAX_STREAMS_UNI, Buffer(data=encode_uint_var(127)), ) self.assertEqual(client._remote_max_streams_uni, 129)
tests.test_connection/QuicConnectionTest.test_handle_path_response_frame_bad
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<13>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT,
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_path_response_frame_bad(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # server receives unsollicited PATH_RESPONSE <11> with self.assertRaises(QuicConnectionError) as cm: <12> server._handle_path_response_frame( <13> tls.Epoch.ONE_RTT, <14> QuicFrameType.PATH_RESPONSE, <15> Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"), <16> ) <17> self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION) <18> self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE) <19>
===========unchanged ref 0=========== at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection _send_path_challenge(network_path: QuicNetworkPath) -> None at: aioquic.connection.QuicConnection.__init__ self._network_paths: List[QuicNetworkPath] = [] at: aioquic.connection.QuicConnection.connect self._network_paths = [QuicNetworkPath(addr, is_validated=True)] at: aioquic.connection.QuicConnection.datagram_received self._network_paths = [network_path] at: aioquic.connection.QuicNetworkPath is_validated: bool = False at: asyncio.tasks sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T] at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) create_transport(client, server) at: tests.test_connection.QuicConnectionTest.test_handle_path_challenge_frame client = QuicConnection(is_client=True) at: tests.utils run(coro) at: unittest.case.TestCase assertTrue(expr: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _send_path_challenge(self, network_path: QuicNetworkPath) -> None: - def _send_path_challenge(self) -> None: + if network_path.challenge is None: + network_path.challenge = os.urandom(8) - self.__path_challenge = os.urandom(8) self._pending_flow_control.append( + bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge - bytes([QuicFrameType.PATH_CHALLENGE]) + self.__path_challenge ) self._send_pending() ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_path_challenge_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server sends PATH_CHALLENGE + network_path = server._network_paths[0] + network_path.is_validated = False + server._send_path_challenge(network_path) - server._send_path_challenge() + run(asyncio.sleep(0)) + self.assertTrue(network_path.is_validated) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_new_token_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives NEW_TOKEN client._handle_new_token_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.NEW_TOKEN, Buffer(data=binascii.unhexlify("080102030405060708")), ) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_new_connection_id_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives NEW_CONNECTION_ID client._handle_new_connection_id_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.NEW_CONNECTION_ID, Buffer( data=binascii.unhexlify( "02117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8" ) ), ) ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_data_blocked_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives DATA_BLOCKED: 12345 client._handle_data_blocked_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.DATA_BLOCKED, Buffer(data=encode_uint_var(12345)), ) ===========changed ref 6=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_ack_frame_ecn(self): + client, client_transport = create_standalone_client() + - client = QuicConnection(is_client=True) client._handle_ack_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.ACK_ECN, Buffer(data=b"\x00\x02\x00\x00\x00\x00\x00"), )
tests.test_connection/QuicConnectionTest.test_handle_reset_stream_frame
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<15>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT,
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client creates bidirectional stream 0 <11> run(client.create_stream()) <12> <13> # client receives RESET_STREAM <14> client._handle_reset_stream_frame( <15> tls.Epoch.ONE_RTT, <16> QuicFrameType.RESET_STREAM, <17> Buffer(data=binascii.unhexlify("001122000001")), <18> ) <19>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection _handle_path_response_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicErrorCode(x: Union[str, bytes, bytearray], base: int) QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: tests.test_connection SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) client_receive_context(client) create_transport(client, server) at: tests.test_connection.QuicConnectionTest.test_handle_path_response_frame_bad client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========unchanged ref 1=========== assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E] assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 2=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_path_response_frame( + self, context: QuicReceiveContext, frame_type: int, buf: Buffer - self, epoch: tls.Epoch, frame_type: int, buf: Buffer ) -> None: """ Handle a PATH_RESPONSE frame. """ data = pull_bytes(buf, 8) + if data != context.network_path.challenge: - if data != self.__path_challenge: raise QuicConnectionError( error_code=QuicErrorCode.PROTOCOL_VIOLATION, frame_type=frame_type, reason_phrase="Response does not match challenge", ) + self.__logger.info("Network path %s validated", context.network_path.addr) + context.network_path.is_validated = True ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_path_challenge_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server sends PATH_CHALLENGE + network_path = server._network_paths[0] + network_path.is_validated = False + server._send_path_challenge(network_path) - server._send_path_challenge() + run(asyncio.sleep(0)) + self.assertTrue(network_path.is_validated) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_new_token_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives NEW_TOKEN client._handle_new_token_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.NEW_TOKEN, Buffer(data=binascii.unhexlify("080102030405060708")), ) ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_path_response_frame_bad(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server receives unsollicited PATH_RESPONSE with self.assertRaises(QuicConnectionError) as cm: server._handle_path_response_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.PATH_RESPONSE, Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION) self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE) ===========changed ref 6=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_new_connection_id_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives NEW_CONNECTION_ID client._handle_new_connection_id_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.NEW_CONNECTION_ID, Buffer( data=binascii.unhexlify( "02117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8" ) ), )
tests.test_connection/QuicConnectionTest.test_handle_reset_stream_frame_send_only
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<16>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT,
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame_send_only(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client creates unidirectional stream 2 <11> run(client.create_stream(is_unidirectional=True)) <12> <13> # client receives RESET_STREAM <14> with self.assertRaises(QuicConnectionError) as cm: <15> client._handle_reset_stream_frame( <16> tls.Epoch.ONE_RTT, <17> QuicFrameType.RESET_STREAM, <18> Buffer(data=binascii.unhexlify("021122000001")), <19> ) <20> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) <21> self.assertEqual(cm.exception.frame_type, QuicFrameType.RESET_STREAM) <22> self.assertEqual(cm.exception.reason_phrase, "Stream is send-only") <23>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] _handle_reset_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: binascii unhexlify(hexstr: _Ascii, /) -> bytes at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) client_receive_context(client) create_transport(client, server) at: tests.test_connection.QuicConnectionTest.test_handle_reset_stream_frame client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) at: tests.utils run(coro) ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 run(client.create_stream()) # client receives RESET_STREAM client._handle_reset_stream_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("001122000001")), ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_path_challenge_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server sends PATH_CHALLENGE + network_path = server._network_paths[0] + network_path.is_validated = False + server._send_path_challenge(network_path) - server._send_path_challenge() + run(asyncio.sleep(0)) + self.assertTrue(network_path.is_validated) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_new_token_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives NEW_TOKEN client._handle_new_token_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.NEW_TOKEN, Buffer(data=binascii.unhexlify("080102030405060708")), ) ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_path_response_frame_bad(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server receives unsollicited PATH_RESPONSE with self.assertRaises(QuicConnectionError) as cm: server._handle_path_response_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.PATH_RESPONSE, Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION) self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE) ===========changed ref 6=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_new_connection_id_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives NEW_CONNECTION_ID client._handle_new_connection_id_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.NEW_CONNECTION_ID, Buffer( data=binascii.unhexlify( "02117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8" ) ), )
tests.test_connection/QuicConnectionTest.test_handle_retire_connection_id_frame
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<12>:<add> client_receive_context(client), <add> QuicFrameType.RETIRE_CONNECTION_ID, <add> Buffer(data=b"\x02"), <del> tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b"\x02")
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_retire_connection_id_frame(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client receives RETIRE_CONNECTION_ID <11> client._handle_retire_connection_id_frame( <12> tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b"\x02") <13> ) <14>
===========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 create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] _handle_reset_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicErrorCode(x: Union[str, bytes, bytearray], base: int) QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: binascii unhexlify(hexstr: _Ascii, /) -> bytes at: tests.test_connection client_receive_context(client) create_transport(client, server) at: tests.test_connection.QuicConnectionTest.test_handle_reset_stream_frame_send_only client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) at: tests.utils run(coro) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E] assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 run(client.create_stream()) # client receives RESET_STREAM client._handle_reset_stream_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("001122000001")), ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_path_challenge_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server sends PATH_CHALLENGE + network_path = server._network_paths[0] + network_path.is_validated = False + server._send_path_challenge(network_path) - server._send_path_challenge() + run(asyncio.sleep(0)) + self.assertTrue(network_path.is_validated) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_new_token_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives NEW_TOKEN client._handle_new_token_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.NEW_TOKEN, Buffer(data=binascii.unhexlify("080102030405060708")), ) ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame_send_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates unidirectional stream 2 run(client.create_stream(is_unidirectional=True)) # client receives RESET_STREAM with self.assertRaises(QuicConnectionError) as cm: client._handle_reset_stream_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("021122000001")), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.RESET_STREAM) self.assertEqual(cm.exception.reason_phrase, "Stream is send-only") ===========changed ref 6=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_path_response_frame_bad(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server receives unsollicited PATH_RESPONSE with self.assertRaises(QuicConnectionError) as cm: server._handle_path_response_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.PATH_RESPONSE, Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION) self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)
tests.test_connection/QuicConnectionTest.test_handle_stop_sending_frame
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<15>:<add> client_receive_context(client), <add> QuicFrameType.STOP_SENDING, <add> Buffer(data=b"\x00\x11\x22"), <del> tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b"\x00\x11\x22")
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stop_sending_frame(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client creates bidirectional stream 0 <11> run(client.create_stream()) <12> <13> # client receives STOP_SENDING <14> client._handle_stop_sending_frame( <15> tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b"\x00\x11\x22") <16> ) <17>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection _handle_retire_connection_id_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) client_receive_context(client) create_transport(client, server) ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_retire_connection_id_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives RETIRE_CONNECTION_ID client._handle_retire_connection_id_frame( + client_receive_context(client), + QuicFrameType.RETIRE_CONNECTION_ID, + Buffer(data=b"\x02"), - tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b"\x02") ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 run(client.create_stream()) # client receives RESET_STREAM client._handle_reset_stream_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("001122000001")), ) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_path_challenge_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server sends PATH_CHALLENGE + network_path = server._network_paths[0] + network_path.is_validated = False + server._send_path_challenge(network_path) - server._send_path_challenge() + run(asyncio.sleep(0)) + self.assertTrue(network_path.is_validated) ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_new_token_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives NEW_TOKEN client._handle_new_token_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.NEW_TOKEN, Buffer(data=binascii.unhexlify("080102030405060708")), ) ===========changed ref 6=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame_send_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates unidirectional stream 2 run(client.create_stream(is_unidirectional=True)) # client receives RESET_STREAM with self.assertRaises(QuicConnectionError) as cm: client._handle_reset_stream_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("021122000001")), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.RESET_STREAM) self.assertEqual(cm.exception.reason_phrase, "Stream is send-only") ===========changed ref 7=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_path_response_frame_bad(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server receives unsollicited PATH_RESPONSE with self.assertRaises(QuicConnectionError) as cm: server._handle_path_response_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.PATH_RESPONSE, Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION) self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)
tests.test_connection/QuicConnectionTest.test_handle_stop_sending_frame_receive_only
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<16>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT,
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stop_sending_frame_receive_only(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # server creates unidirectional stream 3 <11> run(server.create_stream(is_unidirectional=True)) <12> <13> # client receives STOP_SENDING <14> with self.assertRaises(QuicConnectionError) as cm: <15> client._handle_stop_sending_frame( <16> tls.Epoch.ONE_RTT, <17> QuicFrameType.STOP_SENDING, <18> Buffer(data=b"\x03\x11\x22"), <19> ) <20> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) <21> self.assertEqual(cm.exception.frame_type, QuicFrameType.STOP_SENDING) <22> self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only") <23>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] _handle_stop_sending_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) client_receive_context(client) create_transport(client, server) at: tests.utils run(coro) ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_retire_connection_id_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives RETIRE_CONNECTION_ID client._handle_retire_connection_id_frame( + client_receive_context(client), + QuicFrameType.RETIRE_CONNECTION_ID, + Buffer(data=b"\x02"), - tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b"\x02") ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stop_sending_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 run(client.create_stream()) # client receives STOP_SENDING client._handle_stop_sending_frame( + client_receive_context(client), + QuicFrameType.STOP_SENDING, + Buffer(data=b"\x00\x11\x22"), - tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b"\x00\x11\x22") ) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 run(client.create_stream()) # client receives RESET_STREAM client._handle_reset_stream_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("001122000001")), ) ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_path_challenge_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server sends PATH_CHALLENGE + network_path = server._network_paths[0] + network_path.is_validated = False + server._send_path_challenge(network_path) - server._send_path_challenge() + run(asyncio.sleep(0)) + self.assertTrue(network_path.is_validated) ===========changed ref 6=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_new_token_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives NEW_TOKEN client._handle_new_token_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.NEW_TOKEN, Buffer(data=binascii.unhexlify("080102030405060708")), ) ===========changed ref 7=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame_send_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates unidirectional stream 2 run(client.create_stream(is_unidirectional=True)) # client receives RESET_STREAM with self.assertRaises(QuicConnectionError) as cm: client._handle_reset_stream_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("021122000001")), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.RESET_STREAM) self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
tests.test_connection/QuicConnectionTest.test_handle_stream_frame_over_max_data
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<18>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT,
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_over_max_data(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # artificially raise received data counter <11> client._local_max_data_used = client._local_max_data <12> <13> # client receives STREAM frame <14> frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF <15> stream_id = 1 <16> with self.assertRaises(QuicConnectionError) as cm: <17> client._handle_stream_frame( <18> tls.Epoch.ONE_RTT, <19> frame_type, <20> Buffer(data=encode_uint_var(stream_id) + encode_uint_var(1)), <21> ) <22> self.assertEqual(cm.exception.error_code, QuicErrorCode.FLOW_CONTROL_ERROR) <23> self.assertEqual(cm.exception.frame_type, frame_type) <24> self.assertEqual(cm.exception.reason_phrase, "Over connection data limit") <25>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] _handle_stop_sending_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicErrorCode(x: Union[str, bytes, bytearray], base: int) QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) client_receive_context(client) create_transport(client, server) at: tests.test_connection.QuicConnectionTest.test_handle_stop_sending_frame_receive_only client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) ===========unchanged ref 1=========== at: tests.utils run(coro) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E] assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_retire_connection_id_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives RETIRE_CONNECTION_ID client._handle_retire_connection_id_frame( + client_receive_context(client), + QuicFrameType.RETIRE_CONNECTION_ID, + Buffer(data=b"\x02"), - tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b"\x02") ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stop_sending_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 run(client.create_stream()) # client receives STOP_SENDING client._handle_stop_sending_frame( + client_receive_context(client), + QuicFrameType.STOP_SENDING, + Buffer(data=b"\x00\x11\x22"), - tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b"\x00\x11\x22") ) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 run(client.create_stream()) # client receives RESET_STREAM client._handle_reset_stream_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("001122000001")), ) ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stop_sending_frame_receive_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # server creates unidirectional stream 3 run(server.create_stream(is_unidirectional=True)) # client receives STOP_SENDING with self.assertRaises(QuicConnectionError) as cm: client._handle_stop_sending_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b"\x03\x11\x22"), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STOP_SENDING) self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only")
tests.test_connection/QuicConnectionTest.test_handle_stream_frame_over_max_stream_data
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<15>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT,
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_over_max_stream_data(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client receives STREAM frame <11> frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF <12> stream_id = 1 <13> with self.assertRaises(QuicConnectionError) as cm: <14> client._handle_stream_frame( <15> tls.Epoch.ONE_RTT, <16> frame_type, <17> Buffer( <18> data=encode_uint_var(stream_id) <19> + encode_uint_var(client._local_max_stream_data_bidi_remote + 1) <20> ), <21> ) <22> self.assertEqual(cm.exception.error_code, QuicErrorCode.FLOW_CONTROL_ERROR) <23> self.assertEqual(cm.exception.frame_type, frame_type) <24> self.assertEqual(cm.exception.reason_phrase, "Over stream data limit") <25>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection _handle_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.connection.QuicConnection.__init__ self._local_max_data = 1048576 self._local_max_data_used = 0 at: aioquic.connection.QuicConnection._handle_stream_frame self._local_max_data_used += newly_received 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) QuicStreamFlag(x: Union[str, bytes, bytearray], base: int) QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) encode_uint_var(v) ===========unchanged ref 1=========== client_receive_context(client) create_transport(client, server) at: tests.test_connection.QuicConnectionTest.test_handle_stream_frame_over_max_data client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E] assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_retire_connection_id_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives RETIRE_CONNECTION_ID client._handle_retire_connection_id_frame( + client_receive_context(client), + QuicFrameType.RETIRE_CONNECTION_ID, + Buffer(data=b"\x02"), - tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b"\x02") ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stop_sending_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 run(client.create_stream()) # client receives STOP_SENDING client._handle_stop_sending_frame( + client_receive_context(client), + QuicFrameType.STOP_SENDING, + Buffer(data=b"\x00\x11\x22"), - tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b"\x00\x11\x22") ) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 run(client.create_stream()) # client receives RESET_STREAM client._handle_reset_stream_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("001122000001")), ) ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_over_max_data(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # artificially raise received data counter client._local_max_data_used = client._local_max_data # client receives STREAM frame frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF stream_id = 1 with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, frame_type, Buffer(data=encode_uint_var(stream_id) + encode_uint_var(1)), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.FLOW_CONTROL_ERROR) self.assertEqual(cm.exception.frame_type, frame_type) self.assertEqual(cm.exception.reason_phrase, "Over connection data limit")
tests.test_connection/QuicConnectionTest.test_handle_stream_frame_over_max_streams
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<13>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT,
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_over_max_streams(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client receives STREAM frame <11> with self.assertRaises(QuicConnectionError) as cm: <12> client._handle_stream_frame( <13> tls.Epoch.ONE_RTT, <14> QuicFrameType.STREAM_BASE, <15> Buffer(data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)), <16> ) <17> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR) <18> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) <19> self.assertEqual(cm.exception.reason_phrase, "Too many streams open") <20>
===========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 _handle_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.connection.QuicConnection.__init__ self._local_max_stream_data_bidi_remote = 1048576 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) QuicStreamFlag(x: Union[str, bytes, bytearray], base: int) QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) at: tests.test_connection encode_uint_var(v) client_receive_context(client) create_transport(client, server) at: tests.test_connection.QuicConnectionTest.test_handle_stream_frame_over_max_stream_data client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========unchanged ref 1=========== assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E] assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_retire_connection_id_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives RETIRE_CONNECTION_ID client._handle_retire_connection_id_frame( + client_receive_context(client), + QuicFrameType.RETIRE_CONNECTION_ID, + Buffer(data=b"\x02"), - tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b"\x02") ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stop_sending_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 run(client.create_stream()) # client receives STOP_SENDING client._handle_stop_sending_frame( + client_receive_context(client), + QuicFrameType.STOP_SENDING, + Buffer(data=b"\x00\x11\x22"), - tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b"\x00\x11\x22") ) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_over_max_stream_data(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives STREAM frame frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF stream_id = 1 with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, frame_type, Buffer( data=encode_uint_var(stream_id) + encode_uint_var(client._local_max_stream_data_bidi_remote + 1) ), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.FLOW_CONTROL_ERROR) self.assertEqual(cm.exception.frame_type, frame_type) self.assertEqual(cm.exception.reason_phrase, "Over stream data limit") ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_reset_stream_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 run(client.create_stream()) # client receives RESET_STREAM client._handle_reset_stream_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.RESET_STREAM, Buffer(data=binascii.unhexlify("001122000001")), )
tests.test_connection/QuicConnectionTest.test_handle_stream_frame_send_only
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<16>:<add> client_receive_context(client), <add> QuicFrameType.STREAM_BASE, <add> Buffer(data=b"\x02"), <del> tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b"\x02")
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_send_only(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client creates unidirectional stream 2 <11> run(client.create_stream(is_unidirectional=True)) <12> <13> # client receives STREAM frame <14> with self.assertRaises(QuicConnectionError) as cm: <15> client._handle_stream_frame( <16> tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b"\x02") <17> ) <18> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) <19> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) <20> self.assertEqual(cm.exception.reason_phrase, "Stream is send-only") <21>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection _handle_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.connection.QuicConnection.__init__ self._local_max_stream_data_uni = 1048576 at: aioquic.packet QuicErrorCode(x: Union[str, bytes, bytearray], base: int) QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) encode_uint_var(v) client_receive_context(client) create_transport(client, server) at: tests.test_connection.QuicConnectionTest.test_handle_stream_frame_over_max_streams client = QuicConnection(is_client=True) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========unchanged ref 1=========== assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E] assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_over_max_streams(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives STREAM frame with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) self.assertEqual(cm.exception.reason_phrase, "Too many streams open") ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_retire_connection_id_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives RETIRE_CONNECTION_ID client._handle_retire_connection_id_frame( + client_receive_context(client), + QuicFrameType.RETIRE_CONNECTION_ID, + Buffer(data=b"\x02"), - tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b"\x02") ) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stop_sending_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 run(client.create_stream()) # client receives STOP_SENDING client._handle_stop_sending_frame( + client_receive_context(client), + QuicFrameType.STOP_SENDING, + Buffer(data=b"\x00\x11\x22"), - tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b"\x00\x11\x22") ) ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_over_max_stream_data(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives STREAM frame frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF stream_id = 1 with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, frame_type, Buffer( data=encode_uint_var(stream_id) + encode_uint_var(client._local_max_stream_data_bidi_remote + 1) ), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.FLOW_CONTROL_ERROR) self.assertEqual(cm.exception.frame_type, frame_type) self.assertEqual(cm.exception.reason_phrase, "Over stream data limit")
tests.test_connection/QuicConnectionTest.test_handle_stream_frame_wrong_initiator
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<13>:<add> client_receive_context(client), <add> QuicFrameType.STREAM_BASE, <add> Buffer(data=b"\x00"), <del> tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b"\x00")
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_wrong_initiator(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client receives STREAM frame <11> with self.assertRaises(QuicConnectionError) as cm: <12> client._handle_stream_frame( <13> tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b"\x00") <14> ) <15> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) <16> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) <17> self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator") <18>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] _handle_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicErrorCode(x: Union[str, bytes, bytearray], base: int) QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) client_receive_context(client) create_transport(client, server) at: tests.test_connection.QuicConnectionTest.test_handle_stream_frame_send_only client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) at: tests.utils run(coro) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========unchanged ref 1=========== assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E] assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_over_max_streams(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives STREAM frame with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) self.assertEqual(cm.exception.reason_phrase, "Too many streams open") ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_send_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates unidirectional stream 2 run(client.create_stream(is_unidirectional=True)) # client receives STREAM frame with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( + client_receive_context(client), + QuicFrameType.STREAM_BASE, + Buffer(data=b"\x02"), - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b"\x02") ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) self.assertEqual(cm.exception.reason_phrase, "Stream is send-only") ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_retire_connection_id_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives RETIRE_CONNECTION_ID client._handle_retire_connection_id_frame( + client_receive_context(client), + QuicFrameType.RETIRE_CONNECTION_ID, + Buffer(data=b"\x02"), - tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b"\x02") ) ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stop_sending_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 run(client.create_stream()) # client receives STOP_SENDING client._handle_stop_sending_frame( + client_receive_context(client), + QuicFrameType.STOP_SENDING, + Buffer(data=b"\x00\x11\x22"), - tls.Epoch.ONE_RTT, QuicFrameType.STOP_SENDING, Buffer(data=b"\x00\x11\x22") )
tests.test_connection/QuicConnectionTest.test_handle_stream_data_blocked_frame
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<15>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT,
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_data_blocked_frame(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client creates bidirectional stream 0 <11> run(client.create_stream()) <12> <13> # client receives STREAM_DATA_BLOCKED <14> client._handle_stream_data_blocked_frame( <15> tls.Epoch.ONE_RTT, <16> QuicFrameType.STREAM_DATA_BLOCKED, <17> Buffer(data=b"\x00\x01"), <18> ) <19>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection _handle_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) client_receive_context(client) create_transport(client, server) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E] assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_wrong_initiator(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives STREAM frame with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( + client_receive_context(client), + QuicFrameType.STREAM_BASE, + Buffer(data=b"\x00"), - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b"\x00") ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator") ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_over_max_streams(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives STREAM frame with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) self.assertEqual(cm.exception.reason_phrase, "Too many streams open") ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_send_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates unidirectional stream 2 run(client.create_stream(is_unidirectional=True)) # client receives STREAM frame with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( + client_receive_context(client), + QuicFrameType.STREAM_BASE, + Buffer(data=b"\x02"), - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b"\x02") ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) self.assertEqual(cm.exception.reason_phrase, "Stream is send-only") ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_retire_connection_id_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives RETIRE_CONNECTION_ID client._handle_retire_connection_id_frame( + client_receive_context(client), + QuicFrameType.RETIRE_CONNECTION_ID, + Buffer(data=b"\x02"), - tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b"\x02") )
tests.test_connection/QuicConnectionTest.test_handle_stream_data_blocked_frame_send_only
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<16>:<add> client_receive_context(client), <del> tls.Epoch.ONE_RTT,
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_data_blocked_frame_send_only(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client creates unidirectional stream 2 <11> run(client.create_stream(is_unidirectional=True)) <12> <13> # client receives STREAM_DATA_BLOCKED <14> with self.assertRaises(QuicConnectionError) as cm: <15> client._handle_stream_data_blocked_frame( <16> tls.Epoch.ONE_RTT, <17> QuicFrameType.STREAM_DATA_BLOCKED, <18> Buffer(data=b"\x02\x01"), <19> ) <20> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) <21> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_DATA_BLOCKED) <22> self.assertEqual(cm.exception.reason_phrase, "Stream is send-only") <23>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] _handle_stream_data_blocked_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.packet QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) client_receive_context(client) create_transport(client, server) at: tests.utils run(coro) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_data_blocked_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 run(client.create_stream()) # client receives STREAM_DATA_BLOCKED client._handle_stream_data_blocked_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_DATA_BLOCKED, Buffer(data=b"\x00\x01"), ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_wrong_initiator(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives STREAM frame with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( + client_receive_context(client), + QuicFrameType.STREAM_BASE, + Buffer(data=b"\x00"), - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b"\x00") ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator") ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_over_max_streams(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives STREAM frame with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) self.assertEqual(cm.exception.reason_phrase, "Too many streams open") ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_send_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates unidirectional stream 2 run(client.create_stream(is_unidirectional=True)) # client receives STREAM frame with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( + client_receive_context(client), + QuicFrameType.STREAM_BASE, + Buffer(data=b"\x02"), - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b"\x02") ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) self.assertEqual(cm.exception.reason_phrase, "Stream is send-only") ===========changed ref 6=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_retire_connection_id_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives RETIRE_CONNECTION_ID client._handle_retire_connection_id_frame( + client_receive_context(client), + QuicFrameType.RETIRE_CONNECTION_ID, + Buffer(data=b"\x02"), - tls.Epoch.ONE_RTT, QuicFrameType.RETIRE_CONNECTION_ID, Buffer(data=b"\x02") )
tests.test_connection/QuicConnectionTest.test_handle_streams_blocked_uni_frame
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<12>:<add> client_receive_context(client), <add> QuicFrameType.STREAMS_BLOCKED_UNI, <add> Buffer(data=b"\x00"), <del> tls.Epoch.ONE_RTT, QuicFrameType.STREAMS_BLOCKED_UNI, Buffer(data=b"\x00")
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_streams_blocked_uni_frame(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client receives STREAMS_BLOCKED_UNI: 0 <11> client._handle_streams_blocked_frame( <12> tls.Epoch.ONE_RTT, QuicFrameType.STREAMS_BLOCKED_UNI, Buffer(data=b"\x00") <13> ) <14>
===========unchanged ref 0=========== at: aioquic.connection QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) create_transport(client, server) at: tests.utils run(coro) at: unittest.case.TestCase assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E] assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None ===========changed ref 0=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 1=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_data_blocked_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 run(client.create_stream()) # client receives STREAM_DATA_BLOCKED client._handle_stream_data_blocked_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_DATA_BLOCKED, Buffer(data=b"\x00\x01"), ) ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_data_blocked_frame_send_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates unidirectional stream 2 run(client.create_stream(is_unidirectional=True)) # client receives STREAM_DATA_BLOCKED with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_data_blocked_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_DATA_BLOCKED, Buffer(data=b"\x02\x01"), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_DATA_BLOCKED) self.assertEqual(cm.exception.reason_phrase, "Stream is send-only") ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_wrong_initiator(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives STREAM frame with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( + client_receive_context(client), + QuicFrameType.STREAM_BASE, + Buffer(data=b"\x00"), - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b"\x00") ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator") ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_over_max_streams(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives STREAM frame with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) self.assertEqual(cm.exception.reason_phrase, "Too many streams open") ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_send_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates unidirectional stream 2 run(client.create_stream(is_unidirectional=True)) # client receives STREAM frame with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( + client_receive_context(client), + QuicFrameType.STREAM_BASE, + Buffer(data=b"\x02"), - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b"\x02") ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
tests.test_connection/QuicConnectionTest.test_handle_unknown_frame
Modified
aiortc~aioquic
132d4d5ecfca530c38a7ab8c42212b6a375c02e1
[connection] pass network path to frame handlers
<13>:<add> client._payload_received(client_receive_context(client), b"\x1e") <del> client._payload_received(tls.Epoch.ONE_RTT, b"\x1e")
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_unknown_frame(self): <0> client = QuicConnection(is_client=True) <1> <2> server = QuicConnection( <3> is_client=False, <4> certificate=SERVER_CERTIFICATE, <5> private_key=SERVER_PRIVATE_KEY, <6> ) <7> <8> # perform handshake <9> client_transport, server_transport = create_transport(client, server) <10> <11> # client receives unknown frame <12> with self.assertRaises(QuicConnectionError) as cm: <13> client._payload_received(tls.Epoch.ONE_RTT, b"\x1e") <14> self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION) <15> self.assertEqual(cm.exception.frame_type, 0x1E) <16> self.assertEqual(cm.exception.reason_phrase, "Unexpected frame type") <17>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.packet QuicErrorCode(x: Union[str, bytes, bytearray], base: int) QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) client_receive_context(client) create_transport(client, server) at: tests.test_connection.QuicConnectionTest.test_handle_stream_data_blocked_frame_send_only client = QuicConnection(is_client=True) at: unittest.case.TestCase assertEqual(first: Any, second: Any, msg: Any=...) -> None ===========changed ref 0=========== # module: tests.test_connection + def client_receive_context(client): + return QuicReceiveContext( + epoch=tls.Epoch.ONE_RTT, network_path=client._network_paths[0] + ) + ===========changed ref 1=========== # module: tests.test_connection def create_transport(client, server): client_transport = FakeTransport(CLIENT_ADDR) client_transport.target = server server_transport = FakeTransport(SERVER_ADDR) server_transport.target = client server.connection_made(server_transport) client.connection_made(client_transport) # like connect() but without waiting + client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)] - client._path = QuicNetworkPath(SERVER_ADDR) client._version = max(client.supported_versions) client._connect() return client_transport, server_transport ===========changed ref 2=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_streams_blocked_uni_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives STREAMS_BLOCKED_UNI: 0 client._handle_streams_blocked_frame( + client_receive_context(client), + QuicFrameType.STREAMS_BLOCKED_UNI, + Buffer(data=b"\x00"), - tls.Epoch.ONE_RTT, QuicFrameType.STREAMS_BLOCKED_UNI, Buffer(data=b"\x00") ) ===========changed ref 3=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_data_blocked_frame(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates bidirectional stream 0 run(client.create_stream()) # client receives STREAM_DATA_BLOCKED client._handle_stream_data_blocked_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_DATA_BLOCKED, Buffer(data=b"\x00\x01"), ) ===========changed ref 4=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_data_blocked_frame_send_only(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client creates unidirectional stream 2 run(client.create_stream(is_unidirectional=True)) # client receives STREAM_DATA_BLOCKED with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_data_blocked_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_DATA_BLOCKED, Buffer(data=b"\x02\x01"), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_DATA_BLOCKED) self.assertEqual(cm.exception.reason_phrase, "Stream is send-only") ===========changed ref 5=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_wrong_initiator(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives STREAM frame with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( + client_receive_context(client), + QuicFrameType.STREAM_BASE, + Buffer(data=b"\x00"), - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=b"\x00") ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator") ===========changed ref 6=========== # module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_stream_frame_over_max_streams(self): client = QuicConnection(is_client=True) server = QuicConnection( is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY, ) # perform handshake client_transport, server_transport = create_transport(client, server) # client receives STREAM frame with self.assertRaises(QuicConnectionError) as cm: client._handle_stream_frame( + client_receive_context(client), - tls.Epoch.ONE_RTT, QuicFrameType.STREAM_BASE, Buffer(data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)), ) self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR) self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE) self.assertEqual(cm.exception.reason_phrase, "Too many streams open")
aioquic.connection/QuicConnection.datagram_received
Modified
aiortc~aioquic
097499d4523f0dba51c93294393db35c66d291a1
[connection] make handshake validate network path
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None: <0> """ <1> Handle an incoming datagram. <2> """ <3> # stop handling packets when closing <4> if self.__state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]: <5> return <6> <7> data = cast(bytes, data) <8> buf = Buffer(data=data) <9> while not buf.eof(): <10> start_off = buf.tell() <11> header = pull_quic_header(buf, host_cid_length=len(self.host_cid)) <12> <13> # check destination CID matches <14> if self.is_client and header.destination_cid != self.host_cid: <15> return <16> <17> # check protocol version <18> if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION: <19> # version negotiation <20> versions = [] <21> while not buf.eof(): <22> versions.append(pull_uint32(buf)) <23> common = set(self.supported_versions).intersection(versions) <24> if not common: <25> self.__logger.error("Could not find a common protocol version") <26> return <27> self._version = QuicProtocolVersion(max(common)) <28> self.__logger.info("Retrying with %s", self._version) <29> self._connect() <30> return <31> elif ( <32> header.version is not None <33> and header.version not in self.supported_versions <34> ): <35> # unsupported version <36> return <37> <38> if self.is_client and header.packet_type == PACKET_TYPE_RETRY: <39> # stateless retry <40> if ( <41> header.destination_cid == self.host_cid <42> and header.original_destination_cid == self.peer_cid <43> ): <44> self.__logger.info("Performing stateless retry") <45> self.peer_cid</s>
===========below chunk 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None: # offset: 1 self.peer_token = header.token self._connect() return network_path = self._find_network_path(addr) # server initialization if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT: assert ( header.packet_type == PACKET_TYPE_INITIAL ), "first packet must be INITIAL" self._network_paths = [network_path] self._version = QuicProtocolVersion(header.version) self._initialize(header.destination_cid) # decrypt packet encrypted_off = buf.tell() - start_off end_off = buf.tell() + header.rest_length pull_bytes(buf, header.rest_length) epoch = get_epoch(header.packet_type) space = self.spaces[epoch] if not space.crypto.recv.is_valid(): return try: plain_header, plain_payload, packet_number = space.crypto.decrypt_packet( data[start_off:end_off], encrypted_off ) except CryptoError as exc: self.__logger.warning(exc) return if not self.peer_cid_set: self.peer_cid = header.source_cid self.peer_cid_set = True # update state if self.__state == QuicConnectionState.FIRSTFLIGHT: self._set_state(QuicConnectionState.CONNECTED) # update spin bit if ( not is_long_header(plain_header[0]) and packet_number > self._spin_highest_pn ): if self.is_client: self._spin_bit = not get_spin_bit(plain_header[0]) else: self._spin_bit = get_spin_bit</s> ===========below chunk 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None: # offset: 2 <s> not get_spin_bit(plain_header[0]) else: self._spin_bit = get_spin_bit(plain_header[0]) self._spin_highest_pn = packet_number # handle payload context = QuicReceiveContext(epoch=epoch, network_path=network_path) try: is_ack_only, is_probing = self._payload_received(context, plain_payload) except QuicConnectionError as exc: self.__logger.warning(exc) self.close( error_code=exc.error_code, frame_type=exc.frame_type, reason_phrase=exc.reason_phrase, ) return # record packet as received network_path.bytes_received += buf.tell() - start_off space.ack_queue.add(packet_number) if not is_ack_only: self.send_ack[epoch] = True self._send_pending() ===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) pull_bytes(buf: Buffer, length: int) -> bytes pull_uint32(buf: Buffer) -> int at: aioquic.buffer.Buffer eof() -> bool tell() -> int at: aioquic.connection NetworkAddress = Any get_epoch(packet_type: int) -> tls.Epoch QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) QuicConnectionState() QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath) at: aioquic.connection.PacketSpace.__init__ self.crypto = CryptoPair() at: aioquic.connection.QuicConnection supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20] close(error_code: int=QuicErrorCode.NO_ERROR, frame_type: Optional[int]=None, reason_phrase: str="") -> None _connect() -> None _find_network_path(addr: NetworkAddress) -> QuicNetworkPath _initialize(peer_cid: bytes) -> None _payload_received(context: QuicReceiveContext, plain: bytes) -> Tuple[bool, bool] _set_state(state: QuicConnectionState) -> None at: aioquic.connection.QuicConnection.__init__ self.is_client = is_client self.host_cid = os.urandom(8) self.peer_cid = os.urandom(8) self.peer_cid_set = False self.peer_token = b"" self.__logger = logger self._network_paths: List[QuicNetworkPath] = [] self._spin_bit = False self._spin_highest_pn = 0 self.__state = QuicConnectionState.FIRSTFLIGHT ===========unchanged ref 1=========== self._version: Optional[int] = None at: aioquic.connection.QuicConnection._initialize self.spaces = { tls.Epoch.INITIAL: PacketSpace(), tls.Epoch.HANDSHAKE: PacketSpace(), tls.Epoch.ONE_RTT: PacketSpace(), } at: aioquic.connection.QuicConnection._set_state self.__state = state at: aioquic.connection.QuicConnection.connect self._network_paths = [QuicNetworkPath(addr, is_validated=True)] self._version = max(self.supported_versions) at: aioquic.connection.QuicConnectionError.__init__ self.error_code = error_code self.frame_type = frame_type self.reason_phrase = reason_phrase at: aioquic.connection.QuicNetworkPath addr: NetworkAddress bytes_received: int = 0 bytes_sent: int = 0 challenge: Optional[bytes] = None is_validated: bool = False at: aioquic.connection.QuicReceiveContext epoch: tls.Epoch network_path: QuicNetworkPath at: aioquic.crypto CryptoError(*args: object) at: aioquic.crypto.CryptoContext is_valid() -> bool at: aioquic.crypto.CryptoPair decrypt_packet(packet: bytes, encrypted_offset: int) -> Tuple[bytes, bytes, int] at: aioquic.crypto.CryptoPair.__init__ self.recv = CryptoContext() at: aioquic.packet PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00 PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30 QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int) QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
aioquic.connection/QuicConnection._handle_path_response_frame
Modified
aiortc~aioquic
097499d4523f0dba51c93294393db35c66d291a1
[connection] make handshake validate network path
<10>:<add> self.__logger.info( <add> "Network path %s validated by challenge", context.network_path.addr <del> self.__logger.info("Network path %s validated", context.network_path.addr) <11>:<add> )
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_path_response_frame( self, context: QuicReceiveContext, frame_type: int, buf: Buffer ) -> None: <0> """ <1> Handle a PATH_RESPONSE frame. <2> """ <3> data = pull_bytes(buf, 8) <4> if data != context.network_path.challenge: <5> raise QuicConnectionError( <6> error_code=QuicErrorCode.PROTOCOL_VIOLATION, <7> frame_type=frame_type, <8> reason_phrase="Response does not match challenge", <9> ) <10> self.__logger.info("Network path %s validated", context.network_path.addr) <11> context.network_path.is_validated = True <12>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) pull_bytes(buf: Buffer, length: int) -> bytes at: aioquic.connection QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath) at: aioquic.connection.QuicConnection.__init__ self._pending_flow_control: List[bytes] = [] at: aioquic.connection.QuicConnection._write_application self._pending_flow_control = [] at: aioquic.packet QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) QuicFrameType(x: Union[str, bytes, bytearray], base: int) ===========changed ref 0=========== # 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 if self.is_client and header.destination_cid != self.host_cid: 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.__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 ): self.__logger.info("Performing stateless retry") self.peer_cid = header.source_cid self.peer_token = header.token self._connect() return network_path = self._find_network_path(addr) </s> ===========changed ref 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None: # offset: 1 <s>token self._connect() return network_path = self._find_network_path(addr) # server initialization if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT: assert ( header.packet_type == PACKET_TYPE_INITIAL ), "first packet must be INITIAL" self._network_paths = [network_path] self._version = QuicProtocolVersion(header.version) self._initialize(header.destination_cid) # decrypt packet encrypted_off = buf.tell() - start_off end_off = buf.tell() + header.rest_length pull_bytes(buf, header.rest_length) epoch = get_epoch(header.packet_type) space = self.spaces[epoch] if not space.crypto.recv.is_valid(): return try: plain_header, plain_payload, packet_number = space.crypto.decrypt_packet( data[start_off:end_off], encrypted_off ) except CryptoError as exc: self.__logger.warning(exc) return if not self.peer_cid_set: self.peer_cid = header.source_cid self.peer_cid_set = True # update state if self.__state == QuicConnectionState.FIRSTFLIGHT: self._set_state(QuicConnectionState.CONNECTED) # update spin bit if ( not is_long_header(plain_header[0]) and packet_number > self._spin_highest_pn ): if self.is_client: self._spin_bit = not get_spin_bit</s> ===========changed ref 2=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None: # offset: 2 <s>_header[0]) else: self._spin_bit = get_spin_bit(plain_header[0]) self._spin_highest_pn = packet_number # handle payload context = QuicReceiveContext(epoch=epoch, network_path=network_path) try: is_ack_only, is_probing = self._payload_received(context, plain_payload) except QuicConnectionError as exc: self.__logger.warning(exc) self.close( error_code=exc.error_code, frame_type=exc.frame_type, reason_phrase=exc.reason_phrase, ) return + # update network path + if not network_path.is_validated and epoch == tls.Epoch.HANDSHAKE: + self.__logger.info( + "Network path %s validated by handshake", network_path.addr + ) + network_path.is_validated = True + network_path.bytes_received += buf.tell() - start_off + if network_path not in self._network_paths: + self._network_paths.append(network_path) + # record packet as received - network_path.bytes_received += buf.tell() - start_off space.ack_queue.add(packet_number) if not is_ack_only: self.send_ack[epoch] = True self._send_pending()
aioquic.stream/QuicStream.get_frame
Modified
aiortc~aioquic
3345b647aa10c8e418b8f2a8d115c22ec9b6e2dd
[stream] fix logic in error in stream flow control
<10>:<add> if size < 0 or (size == 0 and self._send_buffer): <del> if size < 0 or (size == 0 and self._send_buffer and not self._send_eof):
# 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.has_data_to_send(): <5> return None <6> <7> # apply flow control <8> if self.stream_id is not None: <9> size = min(size, self.max_stream_data_remote - self._send_start) <10> if size < 0 or (size == 0 and self._send_buffer and not self._send_eof): <11> return None <12> <13> # create frame <14> size = min(size, len(self._send_buffer)) <15> frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start) <16> self._send_buffer = self._send_buffer[size:] <17> self._send_start += size <18> <19> # if the buffer is empty and EOF was written, set the FIN bit <20> if self._send_eof and not self._send_buffer: <21> frame.fin = True <22> self._send_complete = True <23> <24> return frame <25>
===========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.stream.QuicStream has_data_to_send() -> bool at: aioquic.stream.QuicStream.__init__ self.max_stream_data_remote = max_stream_data_remote self._send_buffer = bytearray() self._send_complete = False self._send_eof = False self._send_start = 0 at: aioquic.stream.QuicStream.write self._send_buffer += data at: aioquic.stream.QuicStream.write_eof self._send_eof = True
aioquic.connection/QuicConnection.__init__
Modified
aiortc~aioquic
14f57afcdddd5d9e6f349050ac972d2c1b7a0bbf
[connection] send PATH_CHALLENGE on new paths
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: <0> if not is_client: <1> assert certificate is not None, "SSL certificate is required" <2> assert private_key is not None, "SSL private key is required" <3> <4> self.alpn_protocols = alpn_protocols <5> self.certificate = certificate <6> self.is_client = is_client <7> self.host_cid = os.urandom(8) <8> self.peer_cid = os.urandom(8) <9> self.peer_cid_set = False <10> self.peer_token = b"" <11> self.private_key = private_key <12> self.secrets_log_file = secrets_log_file <13> self.server_name = server_name <14> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} <15> <16> self.__close: Optional[Dict] = None <17> self.__connected = asyncio.Event() <18> self.__epoch = tls.Epoch.INITIAL <19> self._local_idle_timeout = 60000 # milliseconds <20> self._local_max_data = 1048576 <21> self._local_max_data_used = 0 <22> self._local_max_stream_data_bidi_local = 1048576 <23> self._local_max_stream_data_bidi_remote = 1048576 <24> self._local_max_stream_data_uni = 1048576 <25> self._local_max_streams_bidi = 128 <26> self._local_max_streams_uni = 128 <27> self.__logger = logger <28> self.__path_challenge: Optional[bytes] = None <29> self._network_paths: List</s>
===========below chunk 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: # offset: 1 self._pending_flow_control: List[bytes] = [] 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_bidi = 0 self._remote_max_streams_uni = 0 self._spin_bit = 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 # callbacks self.stream_created_cb: Callable[ [asyncio.StreamReader, asyncio.StreamWriter], None ] = lambda r, w: None # frame handlers self.__frame_handlers = [ self._handle_padding_frame, self._handle_padding_frame, self._handle_ack_frame, self._handle_ack_frame, self._handle_reset_stream_frame, self._handle_stop_sending_frame, self._handle_crypto_frame, self._handle_new_token_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame</s> ===========below chunk 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: # offset: 2 <s>, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_max_data_frame, self._handle_max_stream_data_frame, self._handle_max_streams_bidi_frame, self._handle_max_streams_uni_frame, self._handle_data_blocked_frame, self._handle_stream_data_blocked_frame, self._handle_streams_blocked_frame, self._handle_streams_blocked_frame, self._handle_new_connection_id_frame, self._handle_retire_connection_id_frame, self._handle_path_challenge_frame, self._handle_path_response_frame, self._handle_connection_close_frame, self._handle_connection_close_frame, ] ===========unchanged ref 0=========== at: aioquic.connection logger = logging.getLogger("quic") QuicConnectionState() 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] _handle_ack_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_connection_close_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_crypto_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_data_blocked_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_max_data_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_max_stream_data_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_max_streams_bidi_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_max_streams_uni_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_new_connection_id_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_new_token_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_padding_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None ===========unchanged ref 1=========== _handle_path_challenge_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_path_challenge_frame(self, context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_path_response_frame(self, context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_path_response_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_reset_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_retire_connection_id_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_stop_sending_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_stream_data_blocked_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None _handle_streams_blocked_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None at: aioquic.connection.QuicConnection._handle_crypto_frame self.__epoch = tls.Epoch.ONE_RTT self.__epoch = tls.Epoch.HANDSHAKE at: aioquic.connection.QuicConnection._handle_max_data_frame self._remote_max_data = max_data at: aioquic.connection.QuicConnection._handle_max_streams_bidi_frame self._remote_max_streams_bidi = max_streams at: aioquic.connection.QuicConnection._handle_max_streams_uni_frame self._remote_max_streams_uni = max_streams at: aioquic.connection.QuicConnection._handle_stream_frame self._local_max_data_used += newly_received
aioquic.connection/QuicConnection.datagram_received
Modified
aiortc~aioquic
14f57afcdddd5d9e6f349050ac972d2c1b7a0bbf
[connection] send PATH_CHALLENGE on new paths
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None: <0> """ <1> Handle an incoming datagram. <2> """ <3> # stop handling packets when closing <4> if self.__state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]: <5> return <6> <7> data = cast(bytes, data) <8> buf = Buffer(data=data) <9> while not buf.eof(): <10> start_off = buf.tell() <11> header = pull_quic_header(buf, host_cid_length=len(self.host_cid)) <12> <13> # check destination CID matches <14> if self.is_client and header.destination_cid != self.host_cid: <15> return <16> <17> # check protocol version <18> if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION: <19> # version negotiation <20> versions = [] <21> while not buf.eof(): <22> versions.append(pull_uint32(buf)) <23> common = set(self.supported_versions).intersection(versions) <24> if not common: <25> self.__logger.error("Could not find a common protocol version") <26> return <27> self._version = QuicProtocolVersion(max(common)) <28> self.__logger.info("Retrying with %s", self._version) <29> self._connect() <30> return <31> elif ( <32> header.version is not None <33> and header.version not in self.supported_versions <34> ): <35> # unsupported version <36> return <37> <38> if self.is_client and header.packet_type == PACKET_TYPE_RETRY: <39> # stateless retry <40> if ( <41> header.destination_cid == self.host_cid <42> and header.original_destination_cid == self.peer_cid <43> ): <44> self.__logger.info("Performing stateless retry") <45> self.peer_cid</s>
===========below chunk 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None: # offset: 1 self.peer_token = header.token self._connect() return network_path = self._find_network_path(addr) # server initialization if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT: assert ( header.packet_type == PACKET_TYPE_INITIAL ), "first packet must be INITIAL" self._network_paths = [network_path] self._version = QuicProtocolVersion(header.version) self._initialize(header.destination_cid) # decrypt packet encrypted_off = buf.tell() - start_off end_off = buf.tell() + header.rest_length pull_bytes(buf, header.rest_length) epoch = get_epoch(header.packet_type) space = self.spaces[epoch] if not space.crypto.recv.is_valid(): return try: plain_header, plain_payload, packet_number = space.crypto.decrypt_packet( data[start_off:end_off], encrypted_off ) except CryptoError as exc: self.__logger.warning(exc) return if not self.peer_cid_set: self.peer_cid = header.source_cid self.peer_cid_set = True # update state if self.__state == QuicConnectionState.FIRSTFLIGHT: self._set_state(QuicConnectionState.CONNECTED) # update spin bit if ( not is_long_header(plain_header[0]) and packet_number > self._spin_highest_pn ): if self.is_client: self._spin_bit = not get_spin_bit(plain_header[0]) else: self._spin_bit = get_spin_bit</s> ===========below chunk 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None: # offset: 2 <s> not get_spin_bit(plain_header[0]) else: self._spin_bit = get_spin_bit(plain_header[0]) self._spin_highest_pn = packet_number # handle payload context = QuicReceiveContext(epoch=epoch, network_path=network_path) try: is_ack_only, is_probing = self._payload_received(context, plain_payload) except QuicConnectionError as exc: self.__logger.warning(exc) self.close( error_code=exc.error_code, frame_type=exc.frame_type, reason_phrase=exc.reason_phrase, ) return # update network path if not network_path.is_validated and epoch == tls.Epoch.HANDSHAKE: self.__logger.info( "Network path %s validated by handshake", network_path.addr ) network_path.is_validated = True network_path.bytes_received += buf.tell() - start_off if network_path not in self._network_paths: self._network_paths.append(network_path) # record packet as received space.ack_queue.add(packet_number) if not is_ack_only: self.send_ack[epoch] = True self._send_pending() ===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) pull_bytes(buf: Buffer, length: int) -> bytes pull_uint32(buf: Buffer) -> int at: aioquic.buffer.Buffer eof() -> bool tell() -> int at: aioquic.connection NetworkAddress = Any get_epoch(packet_type: int) -> tls.Epoch QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) QuicConnectionState() QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath) at: aioquic.connection.PacketSpace.__init__ self.crypto = CryptoPair() at: aioquic.connection.QuicConnection supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20] close(error_code: int=QuicErrorCode.NO_ERROR, frame_type: Optional[int]=None, reason_phrase: str="") -> None _connect() -> None _find_network_path(addr: NetworkAddress) -> QuicNetworkPath _initialize(peer_cid: bytes) -> None _payload_received(context: QuicReceiveContext, plain: bytes) -> Tuple[bool, bool] _set_state(state: QuicConnectionState) -> None at: aioquic.connection.QuicConnection.__init__ self.is_client = is_client self.host_cid = os.urandom(8) self.peer_cid = os.urandom(8) self.peer_cid_set = False self.peer_token = b"" self.__logger = logger self._network_paths: List[QuicNetworkPath] = [] self._spin_bit = False self._spin_highest_pn = 0 self.__state = QuicConnectionState.FIRSTFLIGHT ===========unchanged ref 1=========== self._version: Optional[int] = None at: aioquic.connection.QuicConnection._initialize self.spaces = { tls.Epoch.INITIAL: PacketSpace(), tls.Epoch.HANDSHAKE: PacketSpace(), tls.Epoch.ONE_RTT: PacketSpace(), } at: aioquic.connection.QuicConnection._set_state self.__state = state at: aioquic.connection.QuicConnection.connect self._network_paths = [QuicNetworkPath(addr, is_validated=True)] self._version = max(self.supported_versions) at: aioquic.connection.QuicConnectionError.__init__ self.error_code = error_code self.frame_type = frame_type self.reason_phrase = reason_phrase 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.QuicReceiveContext epoch: tls.Epoch network_path: QuicNetworkPath at: aioquic.crypto CryptoError(*args: object) at: aioquic.crypto.CryptoContext is_valid() -> bool at: aioquic.crypto.CryptoPair decrypt_packet(packet: bytes, encrypted_offset: int) -> Tuple[bytes, bytes, int] at: aioquic.crypto.CryptoPair.__init__ self.recv = CryptoContext() at: aioquic.packet PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00 PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30
aioquic.connection/QuicConnection._handle_path_challenge_frame
Modified
aiortc~aioquic
14f57afcdddd5d9e6f349050ac972d2c1b7a0bbf
[connection] send PATH_CHALLENGE on new paths
<4>:<add> context.network_path.remote_challenge = data <del> self._pending_flow_control.append(bytes([QuicFrameType.PATH_RESPONSE]) + data)
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_path_challenge_frame( self, context: QuicReceiveContext, frame_type: int, buf: Buffer ) -> None: <0> """ <1> Handle a PATH_CHALLENGE frame. <2> """ <3> data = pull_bytes(buf, 8) <4> self._pending_flow_control.append(bytes([QuicFrameType.PATH_RESPONSE]) + data) <5>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath) ===========changed ref 0=========== # module: aioquic.connection @dataclass class QuicNetworkPath: addr: NetworkAddress bytes_received: int = 0 bytes_sent: int = 0 - challenge: Optional[bytes] = None is_validated: bool = False + local_challenge: Optional[bytes] = None + remote_challenge: Optional[bytes] = None ===========changed ref 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: if not is_client: assert certificate is not None, "SSL certificate is required" assert private_key is not None, "SSL private key is required" self.alpn_protocols = alpn_protocols self.certificate = certificate self.is_client = is_client self.host_cid = os.urandom(8) self.peer_cid = os.urandom(8) self.peer_cid_set = False self.peer_token = b"" self.private_key = private_key self.secrets_log_file = secrets_log_file self.server_name = server_name self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} self.__close: Optional[Dict] = None self.__connected = asyncio.Event() self.__epoch = tls.Epoch.INITIAL 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 = logger self.__path_challenge: Optional[bytes] = None self._network_paths: List[QuicNetworkPath] = [] - self._pending_flow_control: List[bytes] = [] self._remote</s> ===========changed ref 2=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: # offset: 1 <s>[QuicNetworkPath] = [] - self._pending_flow_control: List[bytes] = [] 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_bidi = 0 self._remote_max_streams_uni = 0 self._spin_bit = 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 # callbacks self.stream_created_cb: Callable[ [asyncio.StreamReader, asyncio.StreamWriter], None ] = lambda r, w: None # frame handlers self.__frame_handlers = [ self._handle_padding_frame, self._handle_padding_frame, self._handle_ack_frame, self._handle_ack_frame, self._handle_reset_stream_frame, self._handle_stop_sending_frame, self._handle_crypto_frame, self._handle_new_</s> ===========changed ref 3=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: # offset: 2 <s>frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_max_data_frame, self._handle_max_stream_data_frame, self._handle_max_streams_bidi_frame, self._handle_max_streams_uni_frame, self._handle_data_blocked_frame, self._handle_stream_data_blocked_frame, self._handle_streams_blocked_frame, self._handle_streams_blocked_frame, self._handle_new_connection_id_frame, self._handle_retire_connection_id_frame, self._handle_path_challenge_frame, self._handle_path_response_frame, self._handle_connection_close_frame, self._handle_connection_close_frame, ]
aioquic.connection/QuicConnection._handle_path_response_frame
Modified
aiortc~aioquic
14f57afcdddd5d9e6f349050ac972d2c1b7a0bbf
[connection] send PATH_CHALLENGE on new paths
<4>:<add> if data != context.network_path.local_challenge: <del> if data != context.network_path.challenge:
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_path_response_frame( self, context: QuicReceiveContext, frame_type: int, buf: Buffer ) -> None: <0> """ <1> Handle a PATH_RESPONSE frame. <2> """ <3> data = pull_bytes(buf, 8) <4> if data != context.network_path.challenge: <5> raise QuicConnectionError( <6> error_code=QuicErrorCode.PROTOCOL_VIOLATION, <7> frame_type=frame_type, <8> reason_phrase="Response does not match challenge", <9> ) <10> self.__logger.info( <11> "Network path %s validated by challenge", context.network_path.addr <12> ) <13> context.network_path.is_validated = True <14>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) pull_bytes(buf: Buffer, length: int) -> bytes at: aioquic.connection QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str) QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath) at: aioquic.connection.QuicNetworkPath local_challenge: Optional[bytes] = None remote_challenge: Optional[bytes] = None at: aioquic.connection.QuicReceiveContext network_path: QuicNetworkPath at: aioquic.packet QuicErrorCode(x: Union[str, bytes, bytearray], base: int) QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) ===========changed ref 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_path_challenge_frame( self, context: QuicReceiveContext, frame_type: int, buf: Buffer ) -> None: """ Handle a PATH_CHALLENGE frame. """ data = pull_bytes(buf, 8) + context.network_path.remote_challenge = data - self._pending_flow_control.append(bytes([QuicFrameType.PATH_RESPONSE]) + data) ===========changed ref 1=========== # module: aioquic.connection @dataclass class QuicNetworkPath: addr: NetworkAddress bytes_received: int = 0 bytes_sent: int = 0 - challenge: Optional[bytes] = None is_validated: bool = False + local_challenge: Optional[bytes] = None + remote_challenge: Optional[bytes] = None ===========changed ref 2=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: if not is_client: assert certificate is not None, "SSL certificate is required" assert private_key is not None, "SSL private key is required" self.alpn_protocols = alpn_protocols self.certificate = certificate self.is_client = is_client self.host_cid = os.urandom(8) self.peer_cid = os.urandom(8) self.peer_cid_set = False self.peer_token = b"" self.private_key = private_key self.secrets_log_file = secrets_log_file self.server_name = server_name self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} self.__close: Optional[Dict] = None self.__connected = asyncio.Event() self.__epoch = tls.Epoch.INITIAL 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 = logger self.__path_challenge: Optional[bytes] = None self._network_paths: List[QuicNetworkPath] = [] - self._pending_flow_control: List[bytes] = [] self._remote</s> ===========changed ref 3=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: # offset: 1 <s>[QuicNetworkPath] = [] - self._pending_flow_control: List[bytes] = [] 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_bidi = 0 self._remote_max_streams_uni = 0 self._spin_bit = 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 # callbacks self.stream_created_cb: Callable[ [asyncio.StreamReader, asyncio.StreamWriter], None ] = lambda r, w: None # frame handlers self.__frame_handlers = [ self._handle_padding_frame, self._handle_padding_frame, self._handle_ack_frame, self._handle_ack_frame, self._handle_reset_stream_frame, self._handle_stop_sending_frame, self._handle_crypto_frame, self._handle_new_</s> ===========changed ref 4=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: # offset: 2 <s>frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_max_data_frame, self._handle_max_stream_data_frame, self._handle_max_streams_bidi_frame, self._handle_max_streams_uni_frame, self._handle_data_blocked_frame, self._handle_stream_data_blocked_frame, self._handle_streams_blocked_frame, self._handle_streams_blocked_frame, self._handle_new_connection_id_frame, self._handle_retire_connection_id_frame, self._handle_path_challenge_frame, self._handle_path_response_frame, self._handle_connection_close_frame, self._handle_connection_close_frame, ]
aioquic.connection/QuicConnection._pending_datagrams
Modified
aiortc~aioquic
14f57afcdddd5d9e6f349050ac972d2c1b7a0bbf
[connection] send PATH_CHALLENGE on new paths
<3>:<add> yield from self._write_application(network_path) <del> yield from self._write_application()
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _pending_datagrams(self, network_path: QuicNetworkPath) -> Iterator[bytes]: - def _pending_datagrams(self) -> Iterator[bytes]: <0> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]: <1> yield from self._write_handshake(epoch) <2> <3> yield from self._write_application() <4>
===========unchanged ref 0=========== at: aioquic.connection.QuicConnection _push_crypto_data() -> None at: aioquic.connection.QuicConnection._payload_received is_ack_only = True is_ack_only = False is_probing = False is_probing = None is_probing = True ===========changed ref 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_path_challenge_frame( self, context: QuicReceiveContext, frame_type: int, buf: Buffer ) -> None: """ Handle a PATH_CHALLENGE frame. """ data = pull_bytes(buf, 8) + context.network_path.remote_challenge = data - self._pending_flow_control.append(bytes([QuicFrameType.PATH_RESPONSE]) + data) ===========changed ref 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_path_response_frame( self, context: QuicReceiveContext, frame_type: int, buf: Buffer ) -> None: """ Handle a PATH_RESPONSE frame. """ data = pull_bytes(buf, 8) + if data != context.network_path.local_challenge: - if data != context.network_path.challenge: raise QuicConnectionError( error_code=QuicErrorCode.PROTOCOL_VIOLATION, frame_type=frame_type, reason_phrase="Response does not match challenge", ) self.__logger.info( "Network path %s validated by challenge", context.network_path.addr ) context.network_path.is_validated = True ===========changed ref 2=========== # module: aioquic.connection @dataclass class QuicNetworkPath: addr: NetworkAddress bytes_received: int = 0 bytes_sent: int = 0 - challenge: Optional[bytes] = None is_validated: bool = False + local_challenge: Optional[bytes] = None + remote_challenge: Optional[bytes] = None ===========changed ref 3=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: if not is_client: assert certificate is not None, "SSL certificate is required" assert private_key is not None, "SSL private key is required" self.alpn_protocols = alpn_protocols self.certificate = certificate self.is_client = is_client self.host_cid = os.urandom(8) self.peer_cid = os.urandom(8) self.peer_cid_set = False self.peer_token = b"" self.private_key = private_key self.secrets_log_file = secrets_log_file self.server_name = server_name self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} self.__close: Optional[Dict] = None self.__connected = asyncio.Event() self.__epoch = tls.Epoch.INITIAL 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 = logger self.__path_challenge: Optional[bytes] = None self._network_paths: List[QuicNetworkPath] = [] - self._pending_flow_control: List[bytes] = [] self._remote</s> ===========changed ref 4=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: # offset: 1 <s>[QuicNetworkPath] = [] - self._pending_flow_control: List[bytes] = [] 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_bidi = 0 self._remote_max_streams_uni = 0 self._spin_bit = 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 # callbacks self.stream_created_cb: Callable[ [asyncio.StreamReader, asyncio.StreamWriter], None ] = lambda r, w: None # frame handlers self.__frame_handlers = [ self._handle_padding_frame, self._handle_padding_frame, self._handle_ack_frame, self._handle_ack_frame, self._handle_reset_stream_frame, self._handle_stop_sending_frame, self._handle_crypto_frame, self._handle_new_</s> ===========changed ref 5=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: # offset: 2 <s>frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_stream_frame, self._handle_max_data_frame, self._handle_max_stream_data_frame, self._handle_max_streams_bidi_frame, self._handle_max_streams_uni_frame, self._handle_data_blocked_frame, self._handle_stream_data_blocked_frame, self._handle_streams_blocked_frame, self._handle_streams_blocked_frame, self._handle_new_connection_id_frame, self._handle_retire_connection_id_frame, self._handle_path_challenge_frame, self._handle_path_response_frame, self._handle_connection_close_frame, self._handle_connection_close_frame, ]
aioquic.connection/QuicConnection._send_pending
Modified
aiortc~aioquic
14f57afcdddd5d9e6f349050ac972d2c1b7a0bbf
[connection] send PATH_CHALLENGE on new paths
<1>:<add> for datagram in self._pending_datagrams(network_path): <del> for datagram in self._pending_datagrams():
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _send_pending(self) -> None: <0> network_path = self._network_paths[0] <1> for datagram in self._pending_datagrams(): <2> self.__transport.sendto(datagram, network_path.addr) <3> network_path.bytes_sent += len(datagram) <4> self.__send_pending_task = None <5>
===========unchanged ref 0=========== at: aioquic.connection.QuicConnection.__init__ self.__send_pending_task: Optional[asyncio.Handle] = None self.__transport: Optional[asyncio.DatagramTransport] = None at: aioquic.connection.QuicConnection._send_pending network_path = self._network_paths[0] at: aioquic.connection.QuicConnection._send_soon self.__send_pending_task = loop.call_soon(self._send_pending) at: aioquic.connection.QuicConnection.connection_made self.__transport = cast(asyncio.DatagramTransport, transport) at: aioquic.connection.QuicNetworkPath addr: NetworkAddress bytes_sent: int = 0 at: asyncio.transports.DatagramTransport __slots__ = () sendto(data: Any, addr: Optional[_Address]=...) -> None ===========changed ref 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _pending_datagrams(self, network_path: QuicNetworkPath) -> Iterator[bytes]: - def _pending_datagrams(self) -> Iterator[bytes]: for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]: yield from self._write_handshake(epoch) + yield from self._write_application(network_path) - yield from self._write_application() ===========changed ref 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): - def _send_path_challenge(self, network_path: QuicNetworkPath) -> None: - if network_path.challenge is None: - network_path.challenge = os.urandom(8) - self._pending_flow_control.append( - bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge - ) - self._send_pending() - ===========changed ref 2=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_path_challenge_frame( self, context: QuicReceiveContext, frame_type: int, buf: Buffer ) -> None: """ Handle a PATH_CHALLENGE frame. """ data = pull_bytes(buf, 8) + context.network_path.remote_challenge = data - self._pending_flow_control.append(bytes([QuicFrameType.PATH_RESPONSE]) + data) ===========changed ref 3=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_path_response_frame( self, context: QuicReceiveContext, frame_type: int, buf: Buffer ) -> None: """ Handle a PATH_RESPONSE frame. """ data = pull_bytes(buf, 8) + if data != context.network_path.local_challenge: - if data != context.network_path.challenge: raise QuicConnectionError( error_code=QuicErrorCode.PROTOCOL_VIOLATION, frame_type=frame_type, reason_phrase="Response does not match challenge", ) self.__logger.info( "Network path %s validated by challenge", context.network_path.addr ) context.network_path.is_validated = True ===========changed ref 4=========== # module: aioquic.connection @dataclass class QuicNetworkPath: addr: NetworkAddress bytes_received: int = 0 bytes_sent: int = 0 - challenge: Optional[bytes] = None is_validated: bool = False + local_challenge: Optional[bytes] = None + remote_challenge: Optional[bytes] = None ===========changed ref 5=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: if not is_client: assert certificate is not None, "SSL certificate is required" assert private_key is not None, "SSL private key is required" self.alpn_protocols = alpn_protocols self.certificate = certificate self.is_client = is_client self.host_cid = os.urandom(8) self.peer_cid = os.urandom(8) self.peer_cid_set = False self.peer_token = b"" self.private_key = private_key self.secrets_log_file = secrets_log_file self.server_name = server_name self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} self.__close: Optional[Dict] = None self.__connected = asyncio.Event() self.__epoch = tls.Epoch.INITIAL 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 = logger self.__path_challenge: Optional[bytes] = None self._network_paths: List[QuicNetworkPath] = [] - self._pending_flow_control: List[bytes] = [] self._remote</s> ===========changed ref 6=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def __init__( self, is_client: bool = True, certificate: Any = None, private_key: Any = None, secrets_log_file: TextIO = None, alpn_protocols: Optional[List[str]] = None, server_name: Optional[str] = None, ) -> None: # offset: 1 <s>[QuicNetworkPath] = [] - self._pending_flow_control: List[bytes] = [] 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_bidi = 0 self._remote_max_streams_uni = 0 self._spin_bit = 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 # callbacks self.stream_created_cb: Callable[ [asyncio.StreamReader, asyncio.StreamWriter], None ] = lambda r, w: None # frame handlers self.__frame_handlers = [ self._handle_padding_frame, self._handle_padding_frame, self._handle_ack_frame, self._handle_ack_frame, self._handle_reset_stream_frame, self._handle_stop_sending_frame, self._handle_crypto_frame, self._handle_new_</s>
aioquic.connection/QuicConnection._write_application
Modified
aiortc~aioquic
14f57afcdddd5d9e6f349050ac972d2c1b7a0bbf
[connection] send PATH_CHALLENGE on new paths
<27>:<add> # PATH CHALLENGE <add> if ( <add> self.__epoch == tls.Epoch.ONE_RTT <add> and not network_path.is_validated <add> and network_path.local_challenge is None <add> ): <add> self.__logger.info( <add> "Network path %s sending challenge", network_path.addr <add> ) <add> network_path.local_challenge = os.urandom(8) <add> push_uint_var(buf, QuicFrameType.PATH_CHALLENGE) <add> push_bytes(buf, network_path.local_challenge) <add> <add> # PATH RESPONSE <add> if network_path.remote_challenge is not None: <add> push_uint_var(buf, QuicFrameType.PATH_RESPONSE) <add> push_bytes(buf, network_path.remote_challenge) <add> network_path.remote_challenge = None <del> # FLOW CONTROL <28>:<del> for control_frame in self._pending_flow_control: <29>:<del> push_bytes(buf, control_frame) <30>:<del> self._pending_flow_control = []
# module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _write_application(self, network_path: QuicNetworkPath) -> Iterator[bytes]: - def _write_application(self) -> Iterator[bytes]: <0> epoch = tls.Epoch.ONE_RTT <1> space = self.spaces[epoch] <2> if not space.crypto.send.is_valid(): <3> return <4> <5> buf = Buffer(capacity=PACKET_MAX_SIZE) <6> capacity = buf.capacity - space.crypto.aead_tag_size <7> <8> while True: <9> # write header <10> push_uint8( <11> buf, <12> PACKET_FIXED_BIT <13> | (self._spin_bit << 5) <14> | (space.crypto.key_phase << 2) <15> | (PACKET_NUMBER_SEND_SIZE - 1), <16> ) <17> push_bytes(buf, self.peer_cid) <18> push_uint16(buf, self.packet_number) <19> header_size = buf.tell() <20> <21> # ACK <22> if self.send_ack[epoch] and space.ack_queue: <23> push_uint_var(buf, QuicFrameType.ACK) <24> packet.push_ack_frame(buf, space.ack_queue, 0) <25> self.send_ack[epoch] = False <26> <27> # FLOW CONTROL <28> for control_frame in self._pending_flow_control: <29> push_bytes(buf, control_frame) <30> self._pending_flow_control = [] <31> <32> # CLOSE <33> if self.__close and self.__epoch == epoch: <34> push_close(buf, **self.__close) <35> self.__close = None <36> <37> # STREAM <38> for stream_id, stream in self.streams.items(): <39> if isinstance(stream_id, int): <40> # the frame data size is constrained by our peer's MAX_DATA and <41> # the space available in the current packet <42> frame_overhead</s>
===========below chunk 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _write_application(self, network_path: QuicNetworkPath) -> Iterator[bytes]: - def _write_application(self) -> Iterator[bytes]: # offset: 1 3 + quic_uint_length(stream_id) + ( quic_uint_length(stream._send_start) if stream._send_start else 0 ) ) frame = stream.get_frame( min( capacity - buf.tell() - 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, 0, frame.offset): push_bytes(buf, frame.data) self._remote_max_data_used += len(frame.data) packet_size = buf.tell() if packet_size > header_size: # encrypt data = buf.data yield space.crypto.encrypt_packet( data[0:header_size], data[header_size:packet_size] ) self.packet_number += 1 buf.seek(0) else: break ===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) push_bytes(buf: Buffer, v: bytes) -> None push_uint8(buf: Buffer, v: int) -> None push_uint16(buf: Buffer, v: int) -> None at: aioquic.buffer.Buffer tell() -> int at: aioquic.connection PACKET_MAX_SIZE = 1280 push_close(buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None at: aioquic.connection.PacketSpace.__init__ self.ack_queue = RangeSet() self.crypto = CryptoPair() at: aioquic.connection.QuicConnection.__init__ self.peer_cid = os.urandom(8) self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {} self.__close: Optional[Dict] = None self.__epoch = tls.Epoch.INITIAL self.__logger = logger self._remote_max_data = 0 self._remote_max_data_used = 0 self._spin_bit = False 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.send_ack = { tls.Epoch.INITIAL: False, tls.Epoch.HANDSHAKE: False, tls.Epoch.ONE_RTT: False, } self.packet_number = 0 at: aioquic.connection.QuicConnection._write_application epoch = tls.Epoch.ONE_RTT space = self.spaces[epoch] ===========unchanged ref 1=========== self.packet_number += 1 at: aioquic.connection.QuicConnection._write_handshake self.__close = None self.packet_number += 1 at: aioquic.connection.QuicConnection.close self.__close = { "error_code": error_code, "frame_type": frame_type, "reason_phrase": reason_phrase, } at: aioquic.connection.QuicConnection.datagram_received self.peer_cid = header.source_cid self._spin_bit = not get_spin_bit(plain_header[0]) self._spin_bit = get_spin_bit(plain_header[0]) at: aioquic.connection.QuicNetworkPath addr: NetworkAddress is_validated: bool = False local_challenge: Optional[bytes] = None remote_challenge: Optional[bytes] = None at: aioquic.crypto.CryptoContext is_valid() -> bool at: aioquic.crypto.CryptoPair.__init__ self.aead_tag_size = 16 self.send = CryptoContext() at: aioquic.packet PACKET_FIXED_BIT = 0x40 PACKET_NUMBER_SEND_SIZE = 2 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) push_ack_frame(buf: Buffer, rangeset: RangeSet, delay: int) -> None QuicStreamFlag(x: Union[str, bytes, bytearray], base: int) QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) push_stream_frame(buf: Buffer, stream_id: int, offset: int) -> Generator ===========unchanged ref 2=========== at: aioquic.packet.QuicStreamFrame data: bytes = b"" fin: bool = False offset: int = 0 at: aioquic.stream.QuicStream get_frame(size: int) -> Optional[QuicStreamFrame] at: aioquic.stream.QuicStream.__init__ self._send_start = 0 at: aioquic.stream.QuicStream.get_frame self._send_start += size at: aioquic.tls Epoch() at: logging.Logger info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None at: os urandom(size: int, /) -> bytes ===========changed ref 0=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _pending_datagrams(self, network_path: QuicNetworkPath) -> Iterator[bytes]: - def _pending_datagrams(self) -> Iterator[bytes]: for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]: yield from self._write_handshake(epoch) + yield from self._write_application(network_path) - yield from self._write_application() ===========changed ref 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): - def _send_path_challenge(self, network_path: QuicNetworkPath) -> None: - if network_path.challenge is None: - network_path.challenge = os.urandom(8) - self._pending_flow_control.append( - bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge - ) - self._send_pending() - ===========changed ref 2=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _send_pending(self) -> None: network_path = self._network_paths[0] + for datagram in self._pending_datagrams(network_path): - for datagram in self._pending_datagrams(): self.__transport.sendto(datagram, network_path.addr) network_path.bytes_sent += len(datagram) self.__send_pending_task = None
tests.test_connection/QuicConnectionTest.test_handle_path_challenge_frame
Modified
aiortc~aioquic
14f57afcdddd5d9e6f349050ac972d2c1b7a0bbf
[connection] send PATH_CHALLENGE on new paths
<10>:<add> # client changes address and sends some data <add> client_transport.local_addr = ("1.2.3.4", 2345) <add> reader, writer = run(client.create_stream()) <add> writer.write(b"01234567") <add> run(asyncio.sleep(0)) <add> <add> # server sends PATH_CHALLENGE and receives PATH_RESPONSE <del> # server sends PATH_CHALLENGE <12>:<del> network_path.is_validated = False <13>:<del> server._send_path_challenge(network_path) <14>:<del> run(asyncio.sleep(0)) <15>:<del> self.assertTrue(network_path.is_validated) <16>:<add> self.assertEqual(len(server._network_paths), 2)
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_path_challenge_frame(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # server sends PATH_CHALLENGE <11> network_path = server._network_paths[0] <12> network_path.is_validated = False <13> server._send_path_challenge(network_path) <14> run(asyncio.sleep(0)) <15> self.assertTrue(network_path.is_validated) <16>
===========unchanged ref 0=========== at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20] create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] at: asyncio.streams.StreamWriter write(data: bytes) -> None at: asyncio.tasks sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T] at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) create_transport(client, server) at: tests.test_connection.FakeTransport.__init__ self.local_addr = local_addr at: tests.utils run(coro) ===========changed ref 0=========== # module: tests.test_connection + CLIENT_ADDR = ("1.2.3.4", 1234) - CLIENT_ADDR = None + SERVER_ADDR = ("2.3.4.5", 4433) - SERVER_ADDR = None SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) ===========changed ref 1=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _pending_datagrams(self, network_path: QuicNetworkPath) -> Iterator[bytes]: - def _pending_datagrams(self) -> Iterator[bytes]: for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]: yield from self._write_handshake(epoch) + yield from self._write_application(network_path) - yield from self._write_application() ===========changed ref 2=========== # module: aioquic.connection @dataclass class QuicNetworkPath: addr: NetworkAddress bytes_received: int = 0 bytes_sent: int = 0 - challenge: Optional[bytes] = None is_validated: bool = False + local_challenge: Optional[bytes] = None + remote_challenge: Optional[bytes] = None ===========changed ref 3=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_path_challenge_frame( self, context: QuicReceiveContext, frame_type: int, buf: Buffer ) -> None: """ Handle a PATH_CHALLENGE frame. """ data = pull_bytes(buf, 8) + context.network_path.remote_challenge = data - self._pending_flow_control.append(bytes([QuicFrameType.PATH_RESPONSE]) + data) ===========changed ref 4=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): - def _send_path_challenge(self, network_path: QuicNetworkPath) -> None: - if network_path.challenge is None: - network_path.challenge = os.urandom(8) - self._pending_flow_control.append( - bytes([QuicFrameType.PATH_CHALLENGE]) + network_path.challenge - ) - self._send_pending() - ===========changed ref 5=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _send_pending(self) -> None: network_path = self._network_paths[0] + for datagram in self._pending_datagrams(network_path): - for datagram in self._pending_datagrams(): self.__transport.sendto(datagram, network_path.addr) network_path.bytes_sent += len(datagram) self.__send_pending_task = None ===========changed ref 6=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): def _handle_path_response_frame( self, context: QuicReceiveContext, frame_type: int, buf: Buffer ) -> None: """ Handle a PATH_RESPONSE frame. """ data = pull_bytes(buf, 8) + if data != context.network_path.local_challenge: - if data != context.network_path.challenge: raise QuicConnectionError( error_code=QuicErrorCode.PROTOCOL_VIOLATION, frame_type=frame_type, reason_phrase="Response does not match challenge", ) self.__logger.info( "Network path %s validated by challenge", context.network_path.addr ) context.network_path.is_validated = True ===========changed ref 7=========== # module: aioquic.connection class QuicConnection(asyncio.DatagramProtocol): + def _write_application(self, network_path: QuicNetworkPath) -> Iterator[bytes]: - def _write_application(self) -> Iterator[bytes]: epoch = tls.Epoch.ONE_RTT space = self.spaces[epoch] if not space.crypto.send.is_valid(): return buf = Buffer(capacity=PACKET_MAX_SIZE) capacity = buf.capacity - space.crypto.aead_tag_size while True: # write header push_uint8( buf, PACKET_FIXED_BIT | (self._spin_bit << 5) | (space.crypto.key_phase << 2) | (PACKET_NUMBER_SEND_SIZE - 1), ) push_bytes(buf, self.peer_cid) push_uint16(buf, self.packet_number) header_size = buf.tell() # ACK if self.send_ack[epoch] and space.ack_queue: push_uint_var(buf, QuicFrameType.ACK) packet.push_ack_frame(buf, space.ack_queue, 0) self.send_ack[epoch] = False + # PATH CHALLENGE + if ( + self.__epoch == tls.Epoch.ONE_RTT + and 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) + push_uint_var(buf, QuicFrameType.PATH_CHALLENGE) + push_bytes(buf, network_path.local_challenge) + + # PATH RESPONSE + if network_path.remote_challenge is not None: + push_uint_var(buf, QuicFrameType.PATH_RESPONSE</s>
examples.server/serve_http_request
Modified
aiortc~aioquic
b449464680b19d13aacef09d10bb2101591a3ee5
[examples] add some more routes to demo server for interop
<5>:<add> if request == b"GET /\r\n" or request == "GET /index.html\r\n": <del> if request == b"GET /\r\n": <7>:<add> elif request == b"GET /5000000\r\n": <add> writer.write(os.urandom(5000000)) <add> elif request == b"GET /10000000\r\n": <add> writer.write(os.urandom(10000000))
# module: examples.server def serve_http_request(reader, writer): <0> """ <1> Serve an HTTP/0.9 request. <2> """ <3> request = await reader.read() <4> <5> if request == b"GET /\r\n": <6> writer.write(TEMPLATE.format(content="It works!").encode("utf8")) <7> else: <8> writer.write( <9> TEMPLATE.format(content="The document could not be found.").encode("utf8") <10> ) <11> <12> writer.write_eof() <13>
===========unchanged ref 0=========== at: examples.server TEMPLATE = """<!DOCTYPE html> <html> <head> <meta charset="utf-8"/> <title>aioquic</title> </head> <body> <h1>Welcome to aioquic</h1> <p>{content}/p> </body> </html> """ at: os urandom(size: int, /) -> bytes
tests.test_connection/QuicConnectionTest.test_handle_path_challenge_frame
Modified
aiortc~aioquic
71bd40578916ed4e36048c2a7da1d9658244d2a2
[tests] fix flake8 error
<17>:<del> network_path = server._network_paths[0]
# module: tests.test_connection class QuicConnectionTest(TestCase): def test_handle_path_challenge_frame(self): <0> client = QuicConnection(is_client=True) <1> server = QuicConnection( <2> is_client=False, <3> certificate=SERVER_CERTIFICATE, <4> private_key=SERVER_PRIVATE_KEY, <5> ) <6> <7> # perform handshake <8> client_transport, server_transport = create_transport(client, server) <9> <10> # client changes address and sends some data <11> client_transport.local_addr = ("1.2.3.4", 2345) <12> reader, writer = run(client.create_stream()) <13> writer.write(b"01234567") <14> run(asyncio.sleep(0)) <15> <16> # server sends PATH_CHALLENGE and receives PATH_RESPONSE <17> network_path = server._network_paths[0] <18> self.assertEqual(len(server._network_paths), 2) <19> <20> # check new path <21> self.assertEqual(server._network_paths[0].addr, ("1.2.3.4", 2345)) <22> self.assertTrue(server._network_paths[0].is_validated) <23> <24> # check old path <25> self.assertEqual(server._network_paths[1].addr, ("1.2.3.4", 1234)) <26> self.assertTrue(server._network_paths[1].is_validated) <27>
===========unchanged ref 0=========== at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20] create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter] at: aioquic.connection.QuicConnection.__init__ self._network_paths: List[QuicNetworkPath] = [] at: aioquic.connection.QuicConnection.connect self._network_paths = [QuicNetworkPath(addr, is_validated=True)] at: aioquic.connection.QuicConnection.datagram_received self._network_paths = [network_path] at: aioquic.connection.QuicNetworkPath addr: NetworkAddress bytes_received: int = 0 bytes_sent: int = 0 is_validated: bool = False local_challenge: Optional[bytes] = None remote_challenge: Optional[bytes] = None at: asyncio.streams.StreamWriter write(data: bytes) -> None at: asyncio.tasks sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T] at: tests.test_connection SERVER_CERTIFICATE = x509.load_pem_x509_certificate( load("ssl_cert.pem"), backend=default_backend() ) SERVER_PRIVATE_KEY = serialization.load_pem_private_key( load("ssl_key.pem"), password=None, backend=default_backend() ) create_transport(client, server) at: tests.test_connection.FakeTransport.__init__ self.local_addr = local_addr ===========unchanged ref 1=========== at: tests.utils run(coro) at: unittest.case.TestCase failureException: Type[BaseException] longMessage: bool maxDiff: Optional[int] _testMethodName: str _testMethodDoc: str assertEqual(first: Any, second: Any, msg: Any=...) -> None assertTrue(expr: Any, msg: Any=...) -> None
examples.server/QuicServerProtocol.__init__
Modified
aiortc~aioquic
04bd90cd0c36e80d68adfc2d0adac3fabd6cbae6
[examples] add optional stateless retry to server
<2>:<add> self._retry_key = None
# module: examples.server class QuicServerProtocol(asyncio.DatagramProtocol): + def __init__(self, retry=False, **kwargs): - def __init__(self, **kwargs): <0> self._connections = {} <1> self._kwargs = kwargs <2> self._transport = None <3>
===========unchanged ref 0=========== at: asyncio.protocols DatagramProtocol()
examples.server/QuicServerProtocol.datagram_received
Modified
aiortc~aioquic
04bd90cd0c36e80d68adfc2d0adac3fabd6cbae6
[examples] add optional stateless retry to server
<20>:<add> # stateless retry <add> if self._retry_key is not None: <add> retry_message = str(addr).encode("ascii") <add> if not header.token: <add> logger.info("Sending retry to %s" % (addr,)) <add> retry_token = self._retry_key.sign( <add> retry_message, <add> padding.PSS( <add> mgf=padding.MGF1(hashes.SHA256()), <add> salt_length=padding.PSS.MAX_LENGTH, <add> ), <add> hashes.SHA256(), <add> ) <add> self._transport.sendto( <add> encode_quic_retry( <add> version=header.version, <add> source_cid=os.urandom(8), <add> destination_cid=header.source_cid, <add> original_destination_cid=header.destination_cid, <add> retry_token=retry_token, <add> ), <add> addr,
# module: examples.server class QuicServerProtocol(asyncio.DatagramProtocol): def datagram_received(self, datagram, addr): <0> buf = Buffer(data=datagram) <1> header = pull_quic_header(buf, host_cid_length=8) <2> <3> # version negotiation <4> if ( <5> header.version is not None <6> and header.version not in QuicConnection.supported_versions <7> ): <8> self._transport.sendto( <9> encode_quic_version_negotiation( <10> source_cid=header.destination_cid, <11> destination_cid=header.source_cid, <12> supported_versions=QuicConnection.supported_versions, <13> ), <14> addr, <15> ) <16> return <17> <18> connection = self._connections.get(header.destination_cid, None) <19> if connection is None and header.packet_type == PACKET_TYPE_INITIAL: <20> # create new connection <21> connection = QuicConnection(is_client=False, **self._kwargs) <22> connection.connection_made(self._transport) <23> connection.stream_created_cb = self.stream_created <24> self._connections[connection.host_cid] = connection <25> logger.info("%s New connection from %s" % (connection_id(connection), addr)) <26> <27> if connection is not None: <28> connection.datagram_received(datagram, addr) <29>
===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.connection QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None) at: aioquic.connection.QuicConnection supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20] at: aioquic.packet PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00 pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader encode_quic_version_negotiation(source_cid: bytes, destination_cid: bytes, supported_versions: List[QuicProtocolVersion]) -> bytes at: aioquic.packet.QuicHeader version: Optional[int] packet_type: int destination_cid: bytes source_cid: bytes original_destination_cid: bytes = b"" token: bytes = b"" rest_length: int = 0 at: asyncio.protocols.BaseProtocol __slots__ = () connection_made(self, transport: transports.BaseTransport) -> None at: asyncio.protocols.DatagramProtocol __slots__ = () datagram_received(self, data: bytes, addr: Tuple[str, int]) -> None at: examples.server.QuicServerProtocol.__init__ self._connections = {} self._transport = None at: typing.Mapping get(key: _KT, default: Union[_VT_co, _T]) -> Union[_VT_co, _T] get(key: _KT) -> Optional[_VT_co] ===========changed ref 0=========== # module: examples.server class QuicServerProtocol(asyncio.DatagramProtocol): + def __init__(self, retry=False, **kwargs): - def __init__(self, **kwargs): self._connections = {} self._kwargs = kwargs + self._retry_key = None self._transport = None
aioquic.tls/decode_public_key
Modified
aiortc~aioquic
fbaa66415943136a608862f4d998c245d216b21e
[tls] add support for X25519
<0>:<add> if key_share[0] == Group.X25519: <add> return x25519.X25519PublicKey.from_public_bytes(key_share[1])
# module: aioquic.tls + def decode_public_key( + key_share: KeyShareEntry + ) -> Union[ec.EllipticCurvePublicKey, x25519.X25519PublicKey]: - def decode_public_key(key_share: KeyShareEntry) -> ec.EllipticCurvePublicKey: <0> return ec.EllipticCurvePublicKey.from_encoded_point( <1> GROUP_TO_CURVE[key_share[0]](), key_share[1] <2> ) <3>
===========unchanged ref 0=========== at: aioquic.tls Group(x: Union[str, bytes, bytearray], base: int) Group(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...) KeyShareEntry = Tuple[Group, bytes]
aioquic.tls/encode_public_key
Modified
aiortc~aioquic
fbaa66415943136a608862f4d998c245d216b21e
[tls] add support for X25519
<0>:<add> if isinstance(public_key, x25519.X25519PublicKey): <add> return (Group.X25519, public_key.public_bytes(Encoding.Raw, PublicFormat.Raw))
# module: aioquic.tls + def encode_public_key( + public_key: Union[ec.EllipticCurvePublicKey, x25519.X25519PublicKey] + ) -> KeyShareEntry: - def encode_public_key(public_key: ec.EllipticCurvePublicKey) -> KeyShareEntry: <0> return ( <1> CURVE_TO_GROUP[public_key.curve.__class__], <2> public_key.public_bytes(Encoding.X962, PublicFormat.UncompressedPoint), <3> ) <4>
===========unchanged ref 0=========== at: aioquic.tls GROUP_TO_CURVE = { Group.SECP256R1: ec.SECP256R1, Group.SECP384R1: ec.SECP384R1, Group.SECP521R1: ec.SECP521R1, } ===========changed ref 0=========== # module: aioquic.tls + def decode_public_key( + key_share: KeyShareEntry + ) -> Union[ec.EllipticCurvePublicKey, x25519.X25519PublicKey]: - def decode_public_key(key_share: KeyShareEntry) -> ec.EllipticCurvePublicKey: + if key_share[0] == Group.X25519: + return x25519.X25519PublicKey.from_public_bytes(key_share[1]) return ec.EllipticCurvePublicKey.from_encoded_point( GROUP_TO_CURVE[key_share[0]](), key_share[1] )
aioquic.tls/Context.__init__
Modified
aiortc~aioquic
fbaa66415943136a608862f4d998c245d216b21e
[tls] add support for X25519
<26>:<add> self._supported_groups = [Group.SECP256R1] <35>:<add> self._ec_private_key: Optional[ec.EllipticCurvePrivateKey] = None <add> self._x25519_private_key: Optional[x25519.X25519PrivateKey] = None <add>
# module: aioquic.tls class Context: def __init__(self, is_client: bool, logger: logging.Logger = None): <0> self.alpn_protocols: Optional[List[str]] = None <1> self.certificate: Optional[x509.Certificate] = None <2> self.certificate_private_key: Optional[ <3> Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey] <4> ] = None <5> self.handshake_extensions: List[Extension] = [] <6> self.is_client = is_client <7> self.key_schedule: Optional[KeySchedule] = None <8> self.received_extensions: List[Extension] = [] <9> self.server_name: Optional[str] = None <10> self.update_traffic_key_cb: Callable[ <11> [Direction, Epoch, bytes], None <12> ] = lambda d, e, s: None <13> <14> self._cipher_suites = [ <15> CipherSuite.AES_256_GCM_SHA384, <16> CipherSuite.AES_128_GCM_SHA256, <17> CipherSuite.CHACHA20_POLY1305_SHA256, <18> ] <19> self._compression_methods = [CompressionMethod.NULL] <20> self._key_exchange_modes = [KeyExchangeMode.PSK_DHE_KE] <21> self._signature_algorithms = [ <22> SignatureAlgorithm.RSA_PSS_RSAE_SHA256, <23> SignatureAlgorithm.RSA_PKCS1_SHA256, <24> SignatureAlgorithm.RSA_PKCS1_SHA1, <25> ] <26> self._supported_versions = [TLS_VERSION_1_3] <27> <28> self._key_schedule_proxy: Optional[KeyScheduleProxy] = None <29> self._peer_certificate: Optional[x509.Certificate] = None <30> self._receive_buffer = b"" <31> self._enc_key: Optional[bytes] = None <32> self._dec_key: Optional[bytes] = None <33> self.__logger = logger <34> <35> if is_client: </s>
===========below chunk 0=========== # module: aioquic.tls class Context: def __init__(self, is_client: bool, logger: logging.Logger = None): # offset: 1 self.session_id = os.urandom(32) self.private_key = ec.generate_private_key( ec.SECP256R1(), default_backend() ) self.state = State.CLIENT_HANDSHAKE_START else: self.client_random = None self.session_id = None self.private_key = None self.state = State.SERVER_EXPECT_CLIENT_HELLO ===========unchanged ref 0=========== at: aioquic.buffer Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None) at: aioquic.buffer.Buffer data_slice(start: int, end: int) -> bytes tell() -> int at: aioquic.tls TLS_VERSION_1_3 = 0x0304 Direction() Epoch() 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] KeySchedule(cipher_suite: CipherSuite) KeyScheduleProxy(cipher_suites: List[CipherSuite]) at: aioquic.tls.Context._client_handle_certificate self._peer_certificate = x509.load_der_x509_certificate( certificate.certificates[0][0], backend=default_backend() ) at: aioquic.tls.Context._client_handle_encrypted_extensions self.received_extensions = encrypted_extensions.other_extensions at: aioquic.tls.Context._client_handle_finished self._enc_key = next_enc_key ===========unchanged ref 1=========== at: aioquic.tls.Context._client_handle_hello self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite) at: aioquic.tls.Context._client_send_hello self._ec_private_key = ec.generate_private_key( GROUP_TO_CURVE[Group.SECP256R1](), default_backend() ) self._x25519_private_key = x25519.X25519PrivateKey.generate() 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.received_extensions = peer_hello.other_extensions self.key_schedule = KeySchedule(cipher_suite) self._x25519_private_key = x25519.X25519PrivateKey.generate() self._ec_private_key = ec.generate_private_key( GROUP_TO_CURVE[key_share[0]](), default_backend() ) 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: aioquic.tls.KeySchedule update_hash(data: bytes) -> None at: aioquic.tls.KeyScheduleProxy update_hash(data: bytes) -> None at: logging Logger(name: str, level: _Level=...) at: typing Callable = _CallableType(collections.abc.Callable, 2) List = _alias(list, 1, inst=False, name='List') Generator = _alias(collections.abc.Generator, 3) ===========changed ref 0=========== # module: aioquic.tls + def decode_public_key( + key_share: KeyShareEntry + ) -> Union[ec.EllipticCurvePublicKey, x25519.X25519PublicKey]: - def decode_public_key(key_share: KeyShareEntry) -> ec.EllipticCurvePublicKey: + if key_share[0] == Group.X25519: + return x25519.X25519PublicKey.from_public_bytes(key_share[1]) return ec.EllipticCurvePublicKey.from_encoded_point( GROUP_TO_CURVE[key_share[0]](), key_share[1] ) ===========changed ref 1=========== # module: aioquic.tls + def encode_public_key( + public_key: Union[ec.EllipticCurvePublicKey, x25519.X25519PublicKey] + ) -> KeyShareEntry: - def encode_public_key(public_key: ec.EllipticCurvePublicKey) -> KeyShareEntry: + if isinstance(public_key, x25519.X25519PublicKey): + return (Group.X25519, public_key.public_bytes(Encoding.Raw, PublicFormat.Raw)) return ( CURVE_TO_GROUP[public_key.curve.__class__], public_key.public_bytes(Encoding.X962, PublicFormat.UncompressedPoint), )