Add basic HTTP parsing tools.

They provide adequate parsing of HTTP headers with the standard library.

Author: aaugustin

websockets/http.py

@@ -0,0 +1,81 @@
+"""
+HTTP parsing utilities, adequate for the WebSocket handshake.
+"""
+
+import email.parser
+import io
+
+import tulip
+
+
+MAX_HEADERS = 256
+MAX_LINE = 4096
+
+
+@tulip.coroutine
+def read_request(stream):
+    """
+    Read an HTTP/1.1 request that doesn't have a body from `stream`.
+
+    Return `(uri, headers)` where `uri` is a `str` and `headers` an
+    `email.message.Message`.
+
+    `uri` is transmitted as-is; it isn't URL-decoded.
+    """
+    request_line, headers = yield from read_message(stream)
+    method, uri, version = request_line[:-2].decode().split(None, 2)
+    if method != 'GET':
+        raise ValueError("Unsupported method")
+    if version != 'HTTP/1.1':
+        raise ValueError("Unsupported HTTP version")
+    return uri, headers
+
+
+@tulip.coroutine
+def read_response(stream):
+    """
+    Read an HTTP/1.1 response that doesn't have a body from `stream`.
+
+    Return `(status, headers)` where `status` is an `int` and `headers` an
+    `email.message.Message`.
+    """
+    status_line, headers = yield from read_message(stream)
+    version, status, reason = status_line[:-2].decode().split(None, 2)
+    if version != 'HTTP/1.1':
+        raise ValueError("Unsupported HTTP version")
+    return int(status), headers
+
+
+@tulip.coroutine
+def read_message(stream):
+    """
+    Read an HTTP message that doesn't have a body from `stream`.
+
+    Return `(start line, headers)` where `start_line` is `bytes` and `headers`
+    an `email.message.Message`.
+    """
+    start_line = yield from read_line(stream)
+    header_lines = io.BytesIO()
+    for num in range(MAX_HEADERS):
+        header_line = yield from read_line(stream)
+        header_lines.write(header_line)
+        if header_line == b'\r\n':
+            break
+    else:
+        raise ValueError("Too many headers")
+    header_lines.seek(0)
+    headers = email.parser.BytesHeaderParser().parse(header_lines)
+    return start_line, headers
+
+
+@tulip.coroutine
+def read_line(stream):
+    """
+    Read a single line from `stream`.
+    """
+    line = yield from stream.readline()
+    if len(line) > MAX_LINE:
+        raise ValueError("Line too long")
+    if not line.endswith(b'\r\n'):
+        raise ValueError("Line without CRLF")
+    return line

websockets/test_http.py

@@ -0,0 +1,83 @@
+import unittest
+
+import tulip
+import tulip.test_utils
+
+from .http import *
+
+
+class HTTPTests(tulip.test_utils.LogTrackingTestCase, unittest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.loop = tulip.new_event_loop()
+        tulip.set_event_loop(self.loop)
+        self.stream = tulip.StreamReader()
+
+    def tearDown(self):
+        self.loop.close()
+        super().tearDown()
+
+    def test_read_request(self):
+        # Example from the protocol overview in RFC 6455
+        self.stream.feed_data(
+            b'GET /chat HTTP/1.1\r\n'
+            b'Host: server.example.com\r\n'
+            b'Upgrade: websocket\r\n'
+            b'Connection: Upgrade\r\n'
+            b'Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n'
+            b'Origin: http://example.com\r\n'
+            b'Sec-WebSocket-Protocol: chat, superchat\r\n'
+            b'Sec-WebSocket-Version: 13\r\n'
+            b'\r\n'
+        )
+        uri, hdrs = self.loop.run_until_complete(read_request(self.stream))
+        self.assertEqual(uri, '/chat')
+        self.assertEqual(hdrs['Upgrade'], 'websocket')
+
+    def test_read_response(self):
+        # Example from the protocol overview in RFC 6455
+        self.stream.feed_data(
+            b'HTTP/1.1 101 Switching Protocols\r\n'
+            b'Upgrade: websocket\r\n'
+            b'Connection: Upgrade\r\n'
+            b'Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n'
+            b'Sec-WebSocket-Protocol: chat\r\n'
+            b'\r\n'
+        )
+        status, hdrs = self.loop.run_until_complete(read_response(self.stream))
+        self.assertEqual(status, 101)
+        self.assertEqual(hdrs['Upgrade'], 'websocket')
+
+    def test_method(self):
+        self.suppress_log_errors()
+        self.stream.feed_data(b'OPTIONS * HTTP/1.1\r\n\r\n')
+        with self.assertRaises(ValueError):
+            self.loop.run_until_complete(read_request(self.stream))
+
+    def test_version(self):
+        self.suppress_log_errors()
+        self.stream.feed_data(b'GET /chat HTTP/1.0\r\n\r\n')
+        with self.assertRaises(ValueError):
+            self.loop.run_until_complete(read_request(self.stream))
+        self.stream.feed_data(b'HTTP/1.0 400 Bad Request\r\n\r\n')
+        with self.assertRaises(ValueError):
+            self.loop.run_until_complete(read_response(self.stream))
+
+    def test_headers_limit(self):
+        self.suppress_log_errors()
+        self.stream.feed_data(b'foo: bar\r\n' * 500 + b'\r\n')
+        with self.assertRaises(ValueError):
+            self.loop.run_until_complete(read_message(self.stream))
+
+    def test_line_limit(self):
+        self.suppress_log_errors()
+        self.stream.feed_data(b'a' * 5000 + b'\r\n\r\n')
+        with self.assertRaises(ValueError):
+            self.loop.run_until_complete(read_message(self.stream))
+
+    def test_line_ending(self):
+        self.suppress_log_errors()
+        self.stream.feed_data(b'GET / HTTP/1.1\n\n')
+        with self.assertRaises(ValueError):
+            self.loop.run_until_complete(read_message(self.stream))