1
#!/usr/bin/env python3
2
# http11_server.py -- HTTP/1.1 server with keep-alive and chunked encoding
3
import socket
4
import threading
5
import os
6
import time
7
import hashlib
8
from datetime import datetime, timezone
9

10
HOST = '0.0.0.0'
11
PORT = 8080
12
WWW = 'www'
13

14
def parse_request(data):
15
    """解析 HTTP/1.1 请求，返回 (method, path, version, headers, body)"""
16
    try:
17
        if b'\r\n\r\n' in data:
18
            header_part, body = data.split(b'\r\n\r\n', 1)
19
        else:
20
            header_part = data
21
            body = b''
22

23
        lines = header_part.decode('iso-8859-1').split('\r\n')
24
        if not lines:
25
            return None, None, None, {}, b''
26

27
        # 解析请求行
28
        request_line = lines[0]
29
        parts = request_line.split()
30
        if len(parts) < 2:
31
            return None, None, None, {}, b''
32

33
        method = parts[0].upper()
34
        path = parts[1]
35
        version = parts[2] if len(parts) > 2 else 'HTTP/1.0'
36

37
        # 解析请求头
38
        headers = {}
39
        for line in lines[1:]:
40
            if ': ' in line:
41
                key, value = line.split(': ', 1)
42
                headers[key.lower()] = value
43

44
        return method, path, version, headers, body
45
    except Exception as e:
46
        print(f"Error parsing request: {e}")
47
        return None, None, None, {}, b''
48

49
def build_response(status_code, status_text, headers, body, http_version='HTTP/1.1'):
50
    """构建 HTTP 响应"""
51
    response = f"{http_version} {status_code} {status_text}\r\n"
52
    for key, value in headers.items():
53
        response += f"{key}: {value}\r\n"
54
    response += "\r\n"
55
    return response.encode('iso-8859-1') + body
56

57
def build_chunked_response(status_code, status_text, headers, chunks):
58
    """构建分块传输响应"""
59
    response = f"HTTP/1.1 {status_code} {status_text}\r\n"
60
    headers['Transfer-Encoding'] = 'chunked'
61
    for key, value in headers.items():
62
        response += f"{key}: {value}\r\n"
63
    response += "\r\n"
64

65
    result = response.encode('iso-8859-1')
66
    for chunk in chunks:
67
        chunk_data = chunk if isinstance(chunk, bytes) else chunk.encode('utf-8')
68
        result += f"{len(chunk_data):X}\r\n".encode('iso-8859-1')
69
        result += chunk_data
70
        result += b"\r\n"
71
    result += b"0\r\n\r\n"
72
    return result
73

74
def get_mime_type(path):
75
    """根据文件扩展名返回 MIME 类型"""
76
    ext = os.path.splitext(path)[1].lower()
77
    mime_types = {
78
        '.html': 'text/html; charset=utf-8',
79
        '.htm': 'text/html; charset=utf-8',
80
        '.css': 'text/css; charset=utf-8',
81
        '.js': 'application/javascript; charset=utf-8',
82
        '.json': 'application/json; charset=utf-8',
83
        '.png': 'image/png',
84
        '.jpg': 'image/jpeg',
85
        '.jpeg': 'image/jpeg',
86
        '.gif': 'image/gif',
87
        '.ico': 'image/x-icon',
88
        '.txt': 'text/plain; charset=utf-8',
89
    }
90
    return mime_types.get(ext, 'application/octet-stream')
91

92
def compute_etag(content):
93
    """计算 ETag（基于内容哈希）"""
94
    return f'"{hashlib.md5(content).hexdigest()[:16]}"'
95

96
def format_http_date(dt):
97
    """格式化为 HTTP 日期格式"""
98
    return dt.strftime('%a, %d %b %Y %H:%M:%S GMT')
99

100
def handle_conn(conn, addr):
101
    """处理连接（支持持久连接）"""
102
    request_count = 0
103
    connection_timeout = 30  # 持久连接超时时间
104

105
    try:
106
        conn.settimeout(connection_timeout)
107

108
        while True:
109
            request_count += 1
110
            print(f"[{addr}] Waiting for request #{request_count}...")
111

112
            # 读取请求数据
113
            data = b''
114
            while b'\r\n\r\n' not in data:
115
                try:
116
                    chunk = conn.recv(4096)
117
                    if not chunk:
118
                        print(f"[{addr}] Client closed connection")
119
                        return
120
                    data += chunk
121
                except socket.timeout:
122
                    print(f"[{addr}] Connection timeout after {connection_timeout}s")
123
                    return
124

125
            method, path, version, headers, body = parse_request(data)
126

127
            if method is None:
128
                response = build_response(400, "Bad Request",
129
                    {"Content-Type": "text/html", "Connection": "close"},
130
                    b"<html><body><h1>400 Bad Request</h1></body></html>")
131
                conn.sendall(response)
132
                return
133

134
            # 检查是否需要关闭连接
135
            connection = headers.get('connection', '').lower()
136
            should_close = connection == 'close' or version == 'HTTP/1.0'
137

138
            print(f"[{addr}] {method} {path} {version} (keep-alive: {not should_close})")
139

140
            # 处理 Host 头（HTTP/1.1 必需）
141
            if version == 'HTTP/1.1' and 'host' not in headers:
142
                response = build_response(400, "Bad Request",
143
                    {"Content-Type": "text/html", "Connection": "close"},
144
                    b"<html><body><h1>400 Bad Request</h1><p>Host header required.</p></body></html>")
145
                conn.sendall(response)
146
                return
147

148
            response_headers = {
149
                "Server": "HTTP11-Demo/1.0",
150
                "Date": format_http_date(datetime.now(timezone.utc)),
151
            }
152

153
            if should_close:
154
                response_headers["Connection"] = "close"
155
            else:
156
                response_headers["Connection"] = "keep-alive"
157
                response_headers["Keep-Alive"] = f"timeout={connection_timeout}"
158

159
            # 处理路径
160
            if path == '/':
161
                path = '/index.html'
162

163
            # 演示分块传输的端点
164
            if path == '/chunked':
165
                chunks = [
166
                    "<html><head><title>Chunked Demo</title></head><body>\n",
167
                    f"<h1>Chunked Transfer Encoding Demo</h1>\n",
168
                    f"<p>Generated at: {datetime.now().isoformat()}</p>\n",
169
                    "<ul>\n"
170
                ]
171
                for i in range(1, 6):
172
                    chunks.append(f"<li>Item {i}</li>\n")
173
                    time.sleep(0.1)  # 模拟生成延迟
174
                chunks.append("</ul>\n</body></html>")
175

176
                response = build_chunked_response(200, "OK",
177
                    {"Content-Type": "text/html; charset=utf-8"},
178
                    chunks)
179
                conn.sendall(response)
180
                if should_close:
181
                    return
182
                continue
183

184
            # 演示流式日志端点
185
            if path == '/stream':
186
                chunks = []
187
                for i in range(5):
188
                    chunks.append(f"[{datetime.now().isoformat()}] Log entry {i+1}\n")
189
                    time.sleep(0.2)
190

191
                response = build_chunked_response(200, "OK",
192
                    {"Content-Type": "text/plain; charset=utf-8"},
193
                    chunks)
194
                conn.sendall(response)
195
                if should_close:
196
                    return
197
                continue
198

199
            # 安全处理：防止路径遍历攻击
200
            safe_path = os.path.normpath(path).lstrip(os.sep)
201
            full_path = os.path.join(WWW, safe_path)
202

203
            # 处理 HEAD 请求
204
            if method == 'HEAD':
205
                if os.path.isfile(full_path):
206
                    with open(full_path, 'rb') as f:
207
                        content = f.read()
208
                    mime = get_mime_type(full_path)
209
                    etag = compute_etag(content)
210
                    mtime = os.path.getmtime(full_path)
211
                    last_modified = format_http_date(datetime.fromtimestamp(mtime, timezone.utc))
212

213
                    response_headers["Content-Type"] = mime
214
                    response_headers["Content-Length"] = str(len(content))
215
                    response_headers["ETag"] = etag
216
                    response_headers["Last-Modified"] = last_modified
217
                    response_headers["Cache-Control"] = "max-age=3600"
218

219
                    response = build_response(200, "OK", response_headers, b'')
220
                else:
221
                    body = b'<html><body><h1>404 Not Found</h1></body></html>'
222
                    response_headers["Content-Type"] = "text/html"
223
                    response_headers["Content-Length"] = str(len(body))
224
                    response = build_response(404, "Not Found", response_headers, b'')
225
                conn.sendall(response)
226
                if should_close:
227
                    return
228
                continue
229

230
            # 处理 GET 请求（支持条件请求）
231
            if method == 'GET':
232
                if os.path.isfile(full_path):
233
                    with open(full_path, 'rb') as f:
234
                        content = f.read()
235
                    mime = get_mime_type(full_path)
236
                    etag = compute_etag(content)
237
                    mtime = os.path.getmtime(full_path)
238
                    last_modified = format_http_date(datetime.fromtimestamp(mtime, timezone.utc))
239

240
                    # 检查 If-None-Match（ETag 验证）
241
                    if_none_match = headers.get('if-none-match')
242
                    if if_none_match and if_none_match == etag:
243
                        response_headers["ETag"] = etag
244
                        response_headers["Cache-Control"] = "max-age=3600"
245
                        response = build_response(304, "Not Modified", response_headers, b'')
246
                        conn.sendall(response)
247
                        print(f"[{addr}] 304 Not Modified (ETag match)")
248
                        if should_close:
249
                            return
250
                        continue
251

252
                    # 检查 If-Modified-Since
253
                    if_modified_since = headers.get('if-modified-since')
254
                    if if_modified_since:
255
                        try:
256
                            client_time = datetime.strptime(if_modified_since, '%a, %d %b %Y %H:%M:%S GMT')
257
                            file_time = datetime.fromtimestamp(mtime, timezone.utc)
258
                            if file_time <= client_time.replace(tzinfo=timezone.utc):
259
                                response_headers["ETag"] = etag
260
                                response_headers["Last-Modified"] = last_modified
261
                                response_headers["Cache-Control"] = "max-age=3600"
262
                                response = build_response(304, "Not Modified", response_headers, b'')
263
                                conn.sendall(response)
264
                                print(f"[{addr}] 304 Not Modified (Last-Modified)")
265
                                if should_close:
266
                                    return
267
                                continue
268
                        except:
269
                            pass
270

271
                    response_headers["Content-Type"] = mime
272
                    response_headers["Content-Length"] = str(len(content))
273
                    response_headers["ETag"] = etag
274
                    response_headers["Last-Modified"] = last_modified
275
                    response_headers["Cache-Control"] = "max-age=3600"
276

277
                    response = build_response(200, "OK", response_headers, content)
278
                    conn.sendall(response)
279
                else:
280
                    body = b'<html><body><h1>404 Not Found</h1><p>The requested resource was not found.</p></body></html>'
281
                    response_headers["Content-Type"] = "text/html"
282
                    response_headers["Content-Length"] = str(len(body))
283
                    response = build_response(404, "Not Found", response_headers, body)
284
                    conn.sendall(response)
285

286
                if should_close:
287
                    return
288
                continue
289

290
            # 处理 OPTIONS 请求
291
            if method == 'OPTIONS':
292
                response_headers["Allow"] = "GET, HEAD, POST, OPTIONS"
293
                response_headers["Access-Control-Allow-Origin"] = "*"
294
                response_headers["Access-Control-Allow-Methods"] = "GET, HEAD, POST, OPTIONS"
295
                response = build_response(200, "OK", response_headers, b'')
296
                conn.sendall(response)
297
                if should_close:
298
                    return
299
                continue
300

301
            # 不支持的方法
302
            body = b'<html><body><h1>501 Not Implemented</h1></body></html>'
303
            response_headers["Content-Type"] = "text/html"
304
            response_headers["Content-Length"] = str(len(body))
305
            response = build_response(501, "Not Implemented", response_headers, body)
306
            conn.sendall(response)
307
            if should_close:
308
                return
309

310
    except Exception as e:
311
        print(f"Error handling connection: {e}")
312
        import traceback
313
        traceback.print_exc()
314
    finally:
315
        conn.close()
316
        print(f"[{addr}] Connection closed (handled {request_count} requests)")
317

318
def main():
319
    os.makedirs(WWW, exist_ok=True)
320

321
    # 创建测试文件
322
    idx = os.path.join(WWW, 'index.html')
323
    if not os.path.exists(idx):
324
        with open(idx, 'w', encoding='utf-8') as f:
325
            f.write('''<!DOCTYPE html>
326
<html>
327
<head><title>HTTP/1.1 Demo</title></head>
328
<body>
329
<h1>HTTP/1.1 Demo Server</h1>
330
<p>This server demonstrates HTTP/1.1 features:</p>
331
<ul>
332
<li><a href="/page1.html">Page 1</a> - Normal page</li>
333
<li><a href="/chunked">Chunked Demo</a> - Chunked transfer encoding</li>
334
<li><a href="/stream">Stream Demo</a> - Server-sent log stream</li>
335
<li><a href="/data.json">JSON Data</a> - JSON with caching headers</li>
336
</ul>
337
<h2>Test Keep-Alive</h2>
338
<p>Use nc or curl with --http1.1 to test persistent connections.</p>
339
<p>Run: <code>curl -v --http1.1 http://localhost:8080/</code></p>
340
</body>
341
</html>''')
342

343
    page1 = os.path.join(WWW, 'page1.html')
344
    if not os.path.exists(page1):
345
        with open(page1, 'w', encoding='utf-8') as f:
346
            f.write('''<!DOCTYPE html>
347
<html>
348
<head><title>Page 1</title></head>
349
<body>
350
<h1>Page 1</h1>
351
<p><a href="/">Back to index</a></p>
352
</body>
353
</html>''')
354

355
    json_file = os.path.join(WWW, 'data.json')
356
    if not os.path.exists(json_file):
357
        with open(json_file, 'w', encoding='utf-8') as f:
358
            f.write('{"name": "HTTP/1.1 Demo", "version": "1.1", "features": ["keep-alive", "chunked", "etag", "cache-control"]}')
359

360
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
361
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
362
    s.bind((HOST, PORT))
363
    s.listen(5)
364
    print(f"HTTP/1.1 server listening on {HOST}:{PORT}")
365
    print(f"Serving files from: {os.path.abspath(WWW)}")
366
    print(f"Features: keep-alive, chunked encoding, ETag, conditional requests")
367

368
    try:
369
        while True:
370
            conn, addr = s.accept()
371
            threading.Thread(target=handle_conn, args=(conn, addr), daemon=True).start()
372
    except KeyboardInterrupt:
373
        print("\nShutting down.")
374
    finally:
375
        s.close()
376

377
if __name__ == '__main__':
378
    main()