def __init__(self, local_settings=None): super(H2Connection, self).__init__() self.encoder = Encoder() self.decoder = Decoder() self.streams = {} self.local_settings = Settings(local_settings) self.remote_settings = Settings() # 接收数据窗口 self.inbound_flow_control_window = self.local_settings.initial_window_size self.inbound_window_manager = WindowManager(self.local_settings.initial_window_size) # 发送数据窗口(根据对端接受能力,取决于对端设置) self.outbound_flow_control_window = self.remote_settings.initial_window_size self.__set_encoder() self.__set_decoder() # 接收数据缓冲区 self.inbound_buffer = FrameBuffer(self.local_settings.max_frame_size) # 待发送的数据缓冲区 self._data_to_send = b'' self.__dispatch_table = { SettingsFrame: self._receive_settings_frame, HeadersFrame: self._receive_headers_frame, DataFrame: self._receive_data_frame, WindowUpdateFrame: self.receive_window_update_frame, GoAwayFrame: self.receive_goaway_frame, RstStreamFrame: self._receive_rst_stream_frame, PingFrame: self._receive_ping_frame }
def test_ordering_applies_to_encoding(self, special_keys, boring_keys): """ When encoding a dictionary the special keys all appear first. """ def _prepend_colon(k): if isinstance(k, unicode): return u':' + k else: return b':' + k special_keys = set(map(_prepend_colon, special_keys)) input_dict = { k: b'testval' for k in itertools.chain(special_keys, boring_keys) } e = Encoder() d = Decoder() encoded = e.encode(input_dict) decoded = iter(d.decode(encoded, raw=True)) received_special = set() received_boring = set() expected_special = set(map(_to_bytes, special_keys)) expected_boring = set(map(_to_bytes, boring_keys)) for _ in special_keys: k, _ = next(decoded) received_special.add(k) for _ in boring_keys: k, _ = next(decoded) received_boring.add(k) assert expected_special == received_special assert expected_boring == received_boring
def __init__(self, state=None, length=0, flags=FLAG_NO_FLAGS, stream_id=0x0): valid_flags = reduce(lambda x, y: x | y, self.VALID_FLAGS, 0x0) if flags | valid_flags != valid_flags: raise ValueError('invalid flags detected.') if state is None: class State(object): pass state = State() state.http2_settings = HTTP2_DEFAULT_SETTINGS.copy() state.encoder = Encoder() state.decoder = Decoder() self.state = state self.length = length self.type = self.TYPE self.flags = flags self.stream_id = stream_id
def socket_handler(listener): sock = listener.accept()[0] e = Encoder() # We get two messages for the connection open and then a HEADERS # frame. receive_preamble(sock) sock.recv(65535) # Now, send the headers for the response. f = build_headers_frame([(':status', '200'), ('content-length', '14')], e) f.stream_id = 1 sock.send(f.serialize()) # Also send a data frame. f = DataFrame(1) f.data = b'have some data' sock.send(f.serialize()) # Now, send a headers frame again, containing trailing headers. f = build_headers_frame([('trialing', 'no'), ('trailing', 'sure')], e) f.flags.add('END_STREAM') f.stream_id = 1 sock.send(f.serialize()) # Wait for the message from the main thread. recv_event.set() sock.close()
def get_encoder(self): """ Returns a HPACK encoder set up for responses. """ e = Encoder() e.huffman_coder = HuffmanEncoder(REQUEST_CODES, REQUEST_CODES_LENGTH) return e
def test_resizing_header_table(self): # We need to encode a substantial number of headers, to populate the # header table. e = Encoder() header_set = [ (':method', 'GET'), (':scheme', 'https'), (':path', '/some/path'), (':authority', 'www.example.com'), ('custom-key', 'custom-value'), ( "user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:16.0) " "Gecko/20100101 Firefox/16.0", ), ( "accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;" "q=0.8", ), ('X-Lukasa-Test', '88989'), ] e.encode(header_set, huffman=True) # Resize the header table to a size so small that nothing can be in it. e.header_table_size = 40 assert len(e.header_table.dynamic_entries) == 0
def test_evicting_header_table_objects(self): e = Encoder() # Set the header table size large enough to include one header. e.header_table_size = 66 header_set = [('a', 'b'), ('long-custom-header', 'longish value')] e.encode(header_set) assert len(e.header_table.dynamic_entries) == 1
def build_headers_frame(headers, encoder=None): f = HeadersFrame(1) e = encoder if e is None: e = Encoder() e.huffman_coder = HuffmanEncoder(REQUEST_CODES, REQUEST_CODES_LENGTH) f.data = e.encode(headers) f.flags.add('END_HEADERS') return f
def test_resizing_header_table_sends_multiple_updates(self): e = Encoder() e.header_table_size = 40 e.header_table_size = 100 e.header_table_size = 40 header_set = [(':method', 'GET')] out = e.encode(header_set, huffman=True) assert out == b'\x3F\x09\x3F\x45\x3F\x09\x82'
def test_indexed_header_field_from_static_table(self): e = Encoder() e.header_table_size = 0 header_set = {':method': 'GET'} result = b'\x82' # Make sure we don't emit an encoding context update. e.header_table.resized = False assert e.encode(header_set, huffman=False) == result assert list(e.header_table.dynamic_entries) == []
def test_indexed_header_field(self): """ The header field representation uses an indexed header field, from the static table. """ e = Encoder() header_set = {':method': 'GET'} result = b'\x82' assert e.encode(header_set, huffman=False) == result assert list(e.header_table.dynamic_entries) == []
def test_literal_header_field_without_indexing(self): """ The header field representation uses an indexed name and a literal value. """ e = Encoder() header_set = {':path': '/sample/path'} result = b'\x04\x0c/sample/path' assert e.encode(header_set, huffman=False) == result assert list(e.header_table) == []
def test_literal_header_field_with_indexing(self): """ The header field representation uses a literal name and a literal value. """ e = Encoder() header_set = {'custom-key': 'custom-header'} result = b'\x40\x0acustom-key\x0dcustom-header' assert e.encode(header_set, huffman=False) == result assert list(e.header_table) == [(n.encode('utf-8'), v.encode('utf-8')) for n, v in header_set.items()]
def test_resizing_header_table_sends_context_update(self): e = Encoder() # Resize the header table to a size so small that nothing can be in it. e.header_table_size = 40 # Now, encode a header set. Just a small one, with a well-defined # output. header_set = [(':method', 'GET')] out = e.encode(header_set, huffman=True) assert out == b'?\t\x82'
def test_setting_table_size_to_the_same_does_nothing(self): e = Encoder() # Set the header table size to the default. e.header_table_size = 4096 # Now encode a header set. Just a small one, with a well-defined # output. header_set = [(':method', 'GET')] out = e.encode(header_set, huffman=True) assert out == b'\x82'
def test_can_encode_a_story_with_huffman(self, raw_story): d = Decoder() e = Encoder() for case in raw_story['cases']: # The input headers are a list of dicts, which is annoying. input_headers = [(item[0], item[1]) for header in case['headers'] for item in header.items()] encoded = e.encode(input_headers, huffman=True) decoded_headers = d.decode(encoded) assert input_headers == decoded_headers
def __init__(self, client_side=True): self.state_machine = H2ConnectionStateMachine() self.streams = {} self.highest_inbound_stream_id = 0 self.highest_outbound_stream_id = 0 self.encoder = Encoder() self.decoder = Decoder() self.client_side = client_side # Objects that store settings, including defaults. self.local_settings = Settings(client=client_side) self.remote_settings = Settings(client=not client_side) # The curent value of the connection flow control windows on the # connection. self.outbound_flow_control_window = ( self.remote_settings.initial_window_size) self.inbound_flow_control_window = ( self.local_settings.initial_window_size) #: The maximum size of a frame that can be emitted by this peer, in #: bytes. self.max_outbound_frame_size = self.remote_settings.max_frame_size #: The maximum size of a frame that can be received by this peer, in #: bytes. self.max_inbound_frame_size = self.local_settings.max_frame_size # Buffer for incoming data. self.incoming_buffer = FrameBuffer(server=not client_side) # A private variable to store a sequence of received header frames # until completion. self._header_frames = [] # Data that needs to be sent. self._data_to_send = b'' # When in doubt use dict-dispatch. self._frame_dispatch_table = { HeadersFrame: self._receive_headers_frame, PushPromiseFrame: self._receive_push_promise_frame, SettingsFrame: self._receive_settings_frame, DataFrame: self._receive_data_frame, WindowUpdateFrame: self._receive_window_update_frame, PingFrame: self._receive_ping_frame, RstStreamFrame: self._receive_rst_stream_frame, PriorityFrame: self._receive_priority_frame, GoAwayFrame: self._receive_goaway_frame, ContinuationFrame: self._receive_naked_continuation, }
def test_indexed_literal_header_field_with_indexing(self): """ The header field representation uses an indexed name and a literal value and performs incremental indexing. """ e = Encoder() header_set = {':path': '/sample/path'} result = b'\x44\x0c/sample/path' assert e.encode(header_set, huffman=False) == result assert list(e.header_table.dynamic_entries) == [ (n.encode('utf-8'), v.encode('utf-8')) for n, v in header_set.items() ]
def test_sensitive_headers(self): """ Test encoding header values """ e = Encoder() result = (b'\x82\x14\x88\x63\xa1\xa9' + b'\x32\x08\x73\xd0\xc7\x10' + b'\x87\x25\xa8\x49\xe9\xea' + b'\x5f\x5f\x89\x41\x6a\x41' + b'\x92\x6e\xe5\x35\x52\x9f') header_set = [ (':method', 'GET', True), (':path', '/jimiscool/', True), ('customkey', 'sensitiveinfo', True), ] assert e.encode(header_set, huffman=True) == result
def test_sensitive_headers_with_header_tuples(self): """ A header field stored in a NeverIndexedHeaderTuple emits a representation that forbids indexing. """ e = Encoder() result = (b'\x82\x14\x88\x63\xa1\xa9' + b'\x32\x08\x73\xd0\xc7\x10' + b'\x87\x25\xa8\x49\xe9\xea' + b'\x5f\x5f\x89\x41\x6a\x41' + b'\x92\x6e\xe5\x35\x52\x9f') header_set = [ NeverIndexedHeaderTuple(':method', 'GET'), NeverIndexedHeaderTuple(':path', '/jimiscool/'), NeverIndexedHeaderTuple('customkey', 'sensitiveinfo'), ] assert e.encode(header_set, huffman=True) == result
def test_resizing_header_table_to_same_size_ignored(self): e = Encoder() # These size changes should be ignored e.header_table_size = 4096 e.header_table_size = 4096 e.header_table_size = 4096 # These size changes should be encoded e.header_table_size = 40 e.header_table_size = 100 e.header_table_size = 40 header_set = [(':method', 'GET')] out = e.encode(header_set, huffman=True) assert out == b'\x3F\x09\x3F\x45\x3F\x09\x82'
def test_can_encode_a_story_no_huffman(self, raw_story): d = Decoder() e = Encoder() for case in raw_story['cases']: # The input headers are a list of dicts, which is annoying. input_headers = [ (item[0], item[1]) for header in case['headers'] for item in header.items() ] encoded = e.encode(input_headers, huffman=False) decoded_headers = d.decode(encoded) assert input_headers == decoded_headers assert all( isinstance(header, HeaderTuple) for header in decoded_headers )
def __init__( self, tcp_handler=None, rfile=None, wfile=None, is_server=False, dump_frames=False, encoder=None, decoder=None, unhandled_frame_cb=None, ): self.tcp_handler = tcp_handler or TCPHandler(rfile, wfile) self.is_server = is_server self.dump_frames = dump_frames self.encoder = encoder or Encoder() self.decoder = decoder or Decoder() self.unhandled_frame_cb = unhandled_frame_cb self.http2_settings = self.HTTP2_DEFAULT_SETTINGS.copy() self.current_stream_id = None self.connection_preface_performed = False
def test_case19(self): """ http://httpwg.org/specs/rfc7540.html#StreamStates """ print("[ TEST CASE 19 ]----------------------------------") data = self.__read_from_socket() print("< {}".format(self.__parse_client_request(data))) print("> [SETTINGS]") self.send_data([http2.setting()]) data = self.__read_from_socket() print("< {}".format(self.__parse_client_request(data))) print("> [HEADERS]") small_get_index_html_header = { ":method" : "GET", ":scheme" : "http", ":path" : "/index.html", ":authority": "localhost", "host" : "localhost" } header_data = Encoder().encode(small_get_index_html_header, huffman=False) self.send_data([http2.headers(END_HEADERS = True, header_block_fragment = header_data)]) data = self.__read_from_socket() print("< {}".format(self.__parse_client_request(data))) print("> [PUSH_PROMISE]") self.send_data([http2.push_promise(END_HEADERS = False)]) data = self.__read_from_socket() print("< {}".format(self.__parse_client_request(data)))
def test_request_examples_without_huffman(self): """ This section shows several consecutive header sets, corresponding to HTTP requests, on the same connection. """ e = Encoder() first_header_set = [ ( ':method', 'GET', ), ( ':scheme', 'http', ), ( ':path', '/', ), (':authority', 'www.example.com'), ] # We should have :authority in first_header_table since we index it first_header_table = [(':authority', 'www.example.com')] first_result = b'\x82\x86\x84\x41\x0fwww.example.com' assert e.encode(first_header_set, huffman=False) == first_result assert list(e.header_table.dynamic_entries) == [ (n.encode('utf-8'), v.encode('utf-8')) for n, v in first_header_table ] second_header_set = [ ( ':method', 'GET', ), ( ':scheme', 'http', ), ( ':path', '/', ), ( ':authority', 'www.example.com', ), ('cache-control', 'no-cache'), ] second_header_table = [('cache-control', 'no-cache'), (':authority', 'www.example.com')] second_result = b'\x82\x86\x84\xbeX\x08no-cache' assert e.encode(second_header_set, huffman=False) == second_result assert list(e.header_table.dynamic_entries) == [ (n.encode('utf-8'), v.encode('utf-8')) for n, v in second_header_table ] third_header_set = [ ( ':method', 'GET', ), ( ':scheme', 'https', ), ( ':path', '/index.html', ), ( ':authority', 'www.example.com', ), ('custom-key', 'custom-value'), ] third_result = (b'\x82\x87\x85\xbf@\ncustom-key\x0ccustom-value') assert e.encode(third_header_set, huffman=False) == third_result # Don't check the header table here, it's just too complex to be # reliable. Check its length though. assert len(e.header_table.dynamic_entries) == 3
def __init__(self): self.encoder = Encoder()
def refresh_encoder(self): self.encoder = Encoder()
def test_header_table_size_getter(self): e = Encoder() assert e.header_table_size == 4096
def test_request_examples_with_huffman(self): """ This section shows the same examples as the previous section, but using Huffman encoding for the literal values. """ e = Encoder() first_header_set = [ ( ':method', 'GET', ), ( ':scheme', 'http', ), ( ':path', '/', ), (':authority', 'www.example.com'), ] first_header_table = [(':authority', 'www.example.com')] first_result = ( b'\x82\x86\x84\x41\x8c\xf1\xe3\xc2\xe5\xf2:k\xa0\xab\x90\xf4\xff') assert e.encode(first_header_set, huffman=True) == first_result assert list(e.header_table.dynamic_entries) == [ (n.encode('utf-8'), v.encode('utf-8')) for n, v in first_header_table ] second_header_table = [('cache-control', 'no-cache'), (':authority', 'www.example.com')] second_header_set = [ ( ':method', 'GET', ), ( ':scheme', 'http', ), ( ':path', '/', ), ( ':authority', 'www.example.com', ), ('cache-control', 'no-cache'), ] second_result = b'\x82\x86\x84\xbeX\x86\xa8\xeb\x10d\x9c\xbf' assert e.encode(second_header_set, huffman=True) == second_result assert list(e.header_table.dynamic_entries) == [ (n.encode('utf-8'), v.encode('utf-8')) for n, v in second_header_table ] third_header_set = [ ( ':method', 'GET', ), ( ':scheme', 'https', ), ( ':path', '/index.html', ), ( ':authority', 'www.example.com', ), ('custom-key', 'custom-value'), ] third_result = ( b'\x82\x87\x85\xbf' b'@\x88%\xa8I\xe9[\xa9}\x7f\x89%\xa8I\xe9[\xb8\xe8\xb4\xbf') assert e.encode(third_header_set, huffman=True) == third_result assert len(e.header_table.dynamic_entries) == 3