aboutsummaryrefslogtreecommitdiffstats
path: root/netlib/http2
diff options
context:
space:
mode:
Diffstat (limited to 'netlib/http2')
-rw-r--r--netlib/http2/__init__.py1
-rw-r--r--netlib/http2/frame.py79
-rw-r--r--netlib/http2/protocol.py160
3 files changed, 160 insertions, 80 deletions
diff --git a/netlib/http2/__init__.py b/netlib/http2/__init__.py
index 92897b5d..5acf7696 100644
--- a/netlib/http2/__init__.py
+++ b/netlib/http2/__init__.py
@@ -1,3 +1,2 @@
-
from frame import *
from protocol import *
diff --git a/netlib/http2/frame.py b/netlib/http2/frame.py
index 4a305d82..b4783a02 100644
--- a/netlib/http2/frame.py
+++ b/netlib/http2/frame.py
@@ -1,6 +1,5 @@
import sys
import struct
-from functools import reduce
from hpack.hpack import Encoder, Decoder
from .. import utils
@@ -52,7 +51,7 @@ class Frame(object):
self.stream_id = stream_id
@classmethod
- def _check_frame_size(self, length, state):
+ def _check_frame_size(cls, length, state):
if state:
settings = state.http2_settings
else:
@@ -67,7 +66,7 @@ class Frame(object):
length, max_frame_size))
@classmethod
- def from_file(self, fp, state=None):
+ def from_file(cls, fp, state=None):
"""
read a HTTP/2 frame sent by a server or client
fp is a "file like" object that could be backed by a network
@@ -83,7 +82,7 @@ class Frame(object):
if raw_header[:4] == b'HTTP': # pragma no cover
print >> sys.stderr, "WARNING: This looks like an HTTP/1 connection!"
- self._check_frame_size(length, state)
+ cls._check_frame_size(length, state)
payload = fp.safe_read(length)
return FRAMES[fields[2]].from_bytes(
@@ -113,16 +112,13 @@ class Frame(object):
def payload_human_readable(self): # pragma: no cover
raise NotImplementedError()
- def human_readable(self):
+ def human_readable(self, direction="-"):
+ self.length = len(self.payload_bytes())
+
return "\n".join([
- "============================================================",
- "length: %d bytes" % self.length,
- "type: %s (%#x)" % (self.__class__.__name__, self.TYPE),
- "flags: %#x" % self.flags,
- "stream_id: %#x" % self.stream_id,
- "------------------------------------------------------------",
+ "%s: %s | length: %d | flags: %#x | stream_id: %d" % (direction, self.__class__.__name__, self.length, self.flags, self.stream_id),
self.payload_human_readable(),
- "============================================================",
+ "===============================================================",
])
def __eq__(self, other):
@@ -146,10 +142,10 @@ class DataFrame(Frame):
self.pad_length = pad_length
@classmethod
- def from_bytes(self, state, length, flags, stream_id, payload):
- f = self(state=state, length=length, flags=flags, stream_id=stream_id)
+ def from_bytes(cls, state, length, flags, stream_id, payload):
+ f = cls(state=state, length=length, flags=flags, stream_id=stream_id)
- if f.flags & self.FLAG_PADDED:
+ if f.flags & Frame.FLAG_PADDED:
f.pad_length = struct.unpack('!B', payload[0])[0]
f.payload = payload[1:-f.pad_length]
else:
@@ -204,16 +200,16 @@ class HeadersFrame(Frame):
self.weight = weight
@classmethod
- def from_bytes(self, state, length, flags, stream_id, payload):
- f = self(state=state, length=length, flags=flags, stream_id=stream_id)
+ def from_bytes(cls, state, length, flags, stream_id, payload):
+ f = cls(state=state, length=length, flags=flags, stream_id=stream_id)
- if f.flags & self.FLAG_PADDED:
+ if f.flags & Frame.FLAG_PADDED:
f.pad_length = struct.unpack('!B', payload[0])[0]
f.header_block_fragment = payload[1:-f.pad_length]
else:
f.header_block_fragment = payload[0:]
- if f.flags & self.FLAG_PRIORITY:
+ if f.flags & Frame.FLAG_PRIORITY:
f.stream_dependency, f.weight = struct.unpack(
'!LB', f.header_block_fragment[:5])
f.exclusive = bool(f.stream_dependency >> 31)
@@ -279,8 +275,8 @@ class PriorityFrame(Frame):
self.weight = weight
@classmethod
- def from_bytes(self, state, length, flags, stream_id, payload):
- f = self(state=state, length=length, flags=flags, stream_id=stream_id)
+ def from_bytes(cls, state, length, flags, stream_id, payload):
+ f = cls(state=state, length=length, flags=flags, stream_id=stream_id)
f.stream_dependency, f.weight = struct.unpack('!LB', payload)
f.exclusive = bool(f.stream_dependency >> 31)
@@ -325,8 +321,8 @@ class RstStreamFrame(Frame):
self.error_code = error_code
@classmethod
- def from_bytes(self, state, length, flags, stream_id, payload):
- f = self(state=state, length=length, flags=flags, stream_id=stream_id)
+ def from_bytes(cls, state, length, flags, stream_id, payload):
+ f = cls(state=state, length=length, flags=flags, stream_id=stream_id)
f.error_code = struct.unpack('!L', payload)[0]
return f
@@ -369,8 +365,8 @@ class SettingsFrame(Frame):
self.settings = settings
@classmethod
- def from_bytes(self, state, length, flags, stream_id, payload):
- f = self(state=state, length=length, flags=flags, stream_id=stream_id)
+ def from_bytes(cls, state, length, flags, stream_id, payload):
+ f = cls(state=state, length=length, flags=flags, stream_id=stream_id)
for i in xrange(0, len(payload), 6):
identifier, value = struct.unpack("!HL", payload[i:i + 6])
@@ -420,10 +416,10 @@ class PushPromiseFrame(Frame):
self.header_block_fragment = header_block_fragment
@classmethod
- def from_bytes(self, state, length, flags, stream_id, payload):
- f = self(state=state, length=length, flags=flags, stream_id=stream_id)
+ def from_bytes(cls, state, length, flags, stream_id, payload):
+ f = cls(state=state, length=length, flags=flags, stream_id=stream_id)
- if f.flags & self.FLAG_PADDED:
+ if f.flags & Frame.FLAG_PADDED:
f.pad_length, f.promised_stream = struct.unpack('!BL', payload[:5])
f.header_block_fragment = payload[5:-f.pad_length]
else:
@@ -461,7 +457,10 @@ class PushPromiseFrame(Frame):
s.append("padding: %d" % self.pad_length)
s.append("promised stream: %#x" % self.promised_stream)
- s.append("header_block_fragment: %s" % str(self.header_block_fragment))
+ s.append(
+ "header_block_fragment: %s" %
+ self.header_block_fragment.encode('hex'))
+
return "\n".join(s)
@@ -480,8 +479,8 @@ class PingFrame(Frame):
self.payload = payload
@classmethod
- def from_bytes(self, state, length, flags, stream_id, payload):
- f = self(state=state, length=length, flags=flags, stream_id=stream_id)
+ def from_bytes(cls, state, length, flags, stream_id, payload):
+ f = cls(state=state, length=length, flags=flags, stream_id=stream_id)
f.payload = payload
return f
@@ -517,8 +516,8 @@ class GoAwayFrame(Frame):
self.data = data
@classmethod
- def from_bytes(self, state, length, flags, stream_id, payload):
- f = self(state=state, length=length, flags=flags, stream_id=stream_id)
+ def from_bytes(cls, state, length, flags, stream_id, payload):
+ f = cls(state=state, length=length, flags=flags, stream_id=stream_id)
f.last_stream, f.error_code = struct.unpack("!LL", payload[:8])
f.last_stream &= 0x7FFFFFFF
@@ -558,8 +557,8 @@ class WindowUpdateFrame(Frame):
self.window_size_increment = window_size_increment
@classmethod
- def from_bytes(self, state, length, flags, stream_id, payload):
- f = self(state=state, length=length, flags=flags, stream_id=stream_id)
+ def from_bytes(cls, state, length, flags, stream_id, payload):
+ f = cls(state=state, length=length, flags=flags, stream_id=stream_id)
f.window_size_increment = struct.unpack("!L", payload)[0]
f.window_size_increment &= 0x7FFFFFFF
@@ -592,8 +591,8 @@ class ContinuationFrame(Frame):
self.header_block_fragment = header_block_fragment
@classmethod
- def from_bytes(self, state, length, flags, stream_id, payload):
- f = self(state=state, length=length, flags=flags, stream_id=stream_id)
+ def from_bytes(cls, state, length, flags, stream_id, payload):
+ f = cls(state=state, length=length, flags=flags, stream_id=stream_id)
f.header_block_fragment = payload
return f
@@ -605,7 +604,11 @@ class ContinuationFrame(Frame):
return self.header_block_fragment
def payload_human_readable(self):
- return "header_block_fragment: %s" % str(self.header_block_fragment)
+ s = []
+ s.append(
+ "header_block_fragment: %s" %
+ self.header_block_fragment.encode('hex'))
+ return "\n".join(s)
_FRAME_CLASSES = [
DataFrame,
diff --git a/netlib/http2/protocol.py b/netlib/http2/protocol.py
index feac220c..ac89bac4 100644
--- a/netlib/http2/protocol.py
+++ b/netlib/http2/protocol.py
@@ -26,72 +26,106 @@ class HTTP2Protocol(object):
)
# "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
- CLIENT_CONNECTION_PREFACE = '505249202a20485454502f322e300d0a0d0a534d0d0a0d0a'
+ CLIENT_CONNECTION_PREFACE =\
+ '505249202a20485454502f322e300d0a0d0a534d0d0a0d0a'.decode('hex')
ALPN_PROTO_H2 = 'h2'
- def __init__(self, tcp_client):
- self.tcp_client = tcp_client
+ def __init__(self, tcp_handler, is_server=False, dump_frames=False):
+ self.tcp_handler = tcp_handler
+ self.is_server = is_server
self.http2_settings = frame.HTTP2_DEFAULT_SETTINGS.copy()
self.current_stream_id = None
self.encoder = Encoder()
self.decoder = Decoder()
+ self.connection_preface_performed = False
+ self.dump_frames = dump_frames
def check_alpn(self):
- alp = self.tcp_client.get_alpn_proto_negotiated()
+ alp = self.tcp_handler.get_alpn_proto_negotiated()
if alp != self.ALPN_PROTO_H2:
raise NotImplementedError(
"HTTP2Protocol can not handle unknown ALP: %s" % alp)
return True
- def perform_connection_preface(self):
- self.tcp_client.wfile.write(
- bytes(self.CLIENT_CONNECTION_PREFACE.decode('hex')))
- self.send_frame(frame.SettingsFrame(state=self))
+ def _receive_settings(self, hide=False):
+ while True:
+ frm = self.read_frame(hide)
+ if isinstance(frm, frame.SettingsFrame):
+ break
+
+ def _read_settings_ack(self, hide=False): # pragma no cover
+ while True:
+ frm = self.read_frame(hide)
+ if isinstance(frm, frame.SettingsFrame):
+ assert settings_ack_frame.flags & frame.Frame.FLAG_ACK
+ assert len(settings_ack_frame.settings) == 0
+ break
+
+ def perform_server_connection_preface(self, force=False):
+ if force or not self.connection_preface_performed:
+ self.connection_preface_performed = True
- # read server settings frame
- frm = frame.Frame.from_file(self.tcp_client.rfile, self)
- assert isinstance(frm, frame.SettingsFrame)
- self._apply_settings(frm.settings)
+ magic_length = len(self.CLIENT_CONNECTION_PREFACE)
+ magic = self.tcp_handler.rfile.safe_read(magic_length)
+ assert magic == self.CLIENT_CONNECTION_PREFACE
- # read setting ACK frame
- settings_ack_frame = self.read_frame()
- assert isinstance(settings_ack_frame, frame.SettingsFrame)
- assert settings_ack_frame.flags & frame.Frame.FLAG_ACK
- assert len(settings_ack_frame.settings) == 0
+ self.send_frame(frame.SettingsFrame(state=self), hide=True)
+ self._receive_settings(hide=True)
+
+ def perform_client_connection_preface(self, force=False):
+ if force or not self.connection_preface_performed:
+ self.connection_preface_performed = True
+
+ self.tcp_handler.wfile.write(self.CLIENT_CONNECTION_PREFACE)
+
+ self.send_frame(frame.SettingsFrame(state=self), hide=True)
+ self._receive_settings(hide=True)
def next_stream_id(self):
if self.current_stream_id is None:
- self.current_stream_id = 1
+ if self.is_server:
+ # servers must use even stream ids
+ self.current_stream_id = 2
+ else:
+ # clients must use odd stream ids
+ self.current_stream_id = 1
else:
self.current_stream_id += 2
return self.current_stream_id
- def send_frame(self, frame):
- raw_bytes = frame.to_bytes()
- self.tcp_client.wfile.write(raw_bytes)
- self.tcp_client.wfile.flush()
+ def send_frame(self, frm, hide=False):
+ raw_bytes = frm.to_bytes()
+ self.tcp_handler.wfile.write(raw_bytes)
+ self.tcp_handler.wfile.flush()
+ if not hide and self.dump_frames: # pragma no cover
+ print(frm.human_readable(">>"))
- def read_frame(self):
- frm = frame.Frame.from_file(self.tcp_client.rfile, self)
- if isinstance(frm, frame.SettingsFrame):
- self._apply_settings(frm.settings)
+ def read_frame(self, hide=False):
+ frm = frame.Frame.from_file(self.tcp_handler.rfile, self)
+ if not hide and self.dump_frames: # pragma no cover
+ print(frm.human_readable("<<"))
+ if isinstance(frm, frame.SettingsFrame) and not frm.flags & frame.Frame.FLAG_ACK:
+ self._apply_settings(frm.settings, hide)
return frm
- def _apply_settings(self, settings):
+ def _apply_settings(self, settings, hide=False):
for setting, value in settings.items():
old_value = self.http2_settings[setting]
if not old_value:
old_value = '-'
-
self.http2_settings[setting] = value
self.send_frame(
frame.SettingsFrame(
state=self,
- flags=frame.Frame.FLAG_ACK))
+ flags=frame.Frame.FLAG_ACK),
+ hide)
+
+ # be liberal in what we expect from the other end
+ # to be more strict use: self._read_settings_ack(hide)
def _create_headers(self, headers, stream_id, end_stream=True):
# TODO: implement max frame size checks and sending in chunks
@@ -102,12 +136,16 @@ class HTTP2Protocol(object):
header_block_fragment = self.encoder.encode(headers)
- bytes = frame.HeadersFrame(
+ frm = frame.HeadersFrame(
state=self,
flags=flags,
stream_id=stream_id,
- header_block_fragment=header_block_fragment).to_bytes()
- return [bytes]
+ header_block_fragment=header_block_fragment)
+
+ if self.dump_frames: # pragma no cover
+ print(frm.human_readable(">>"))
+
+ return [frm.to_bytes()]
def _create_body(self, body, stream_id):
if body is None or len(body) == 0:
@@ -116,21 +154,32 @@ class HTTP2Protocol(object):
# TODO: implement max frame size checks and sending in chunks
# TODO: implement flow-control window
- bytes = frame.DataFrame(
+ frm = frame.DataFrame(
state=self,
flags=frame.Frame.FLAG_END_STREAM,
stream_id=stream_id,
- payload=body).to_bytes()
- return [bytes]
+ payload=body)
+
+ if self.dump_frames: # pragma no cover
+ print(frm.human_readable(">>"))
+
+ return [frm.to_bytes()]
+
def create_request(self, method, path, headers=None, body=None):
if headers is None:
headers = []
+ authority = self.tcp_handler.sni if self.tcp_handler.sni else self.tcp_handler.address.host
+ if self.tcp_handler.address.port != 443:
+ authority += ":%d" % self.tcp_handler.address.port
+
headers = [
(b':method', bytes(method)),
(b':path', bytes(path)),
- (b':scheme', b'https')] + headers
+ (b':scheme', b'https'),
+ (b':authority', authority),
+ ] + headers
stream_id = self.next_stream_id()
@@ -139,25 +188,54 @@ class HTTP2Protocol(object):
self._create_body(body, stream_id)))
def read_response(self):
+ stream_id, headers, body = self._receive_transmission()
+ return headers[':status'], headers, body
+
+ def read_request(self):
+ return self._receive_transmission()
+
+ def _receive_transmission(self):
+ body_expected = True
+
+ stream_id = 0
header_block_fragment = b''
body = b''
while True:
frm = self.read_frame()
- if isinstance(frm, frame.HeadersFrame):
+ if isinstance(frm, frame.HeadersFrame)\
+ or isinstance(frm, frame.ContinuationFrame):
+ stream_id = frm.stream_id
header_block_fragment += frm.header_block_fragment
- if frm.flags | frame.Frame.FLAG_END_HEADERS:
+ if frm.flags & frame.Frame.FLAG_END_STREAM:
+ body_expected = False
+ if frm.flags & frame.Frame.FLAG_END_HEADERS:
break
- while True:
+ while body_expected:
frm = self.read_frame()
if isinstance(frm, frame.DataFrame):
body += frm.payload
- if frm.flags | frame.Frame.FLAG_END_STREAM:
+ if frm.flags & frame.Frame.FLAG_END_STREAM:
break
+ # TODO: implement window update & flow
headers = {}
for header, value in self.decoder.decode(header_block_fragment):
headers[header] = value
- return headers[':status'], headers, body
+ return stream_id, headers, body
+
+ def create_response(self, code, stream_id=None, headers=None, body=None):
+ if headers is None:
+ headers = []
+
+ headers = [(b':status', bytes(str(code)))] + headers
+
+ if not stream_id:
+ stream_id = self.next_stream_id()
+
+ return list(itertools.chain(
+ self._create_headers(headers, stream_id, end_stream=(body is None)),
+ self._create_body(body, stream_id),
+ ))
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-31 21:19:58 +0000