diff --git a/.cocoon-plan.md b/.cocoon-plan.md index d0f9e36..b8b5e59 100644 --- a/.cocoon-plan.md +++ b/.cocoon-plan.md @@ -20,48 +20,59 @@ - [x] 连接超时管理（空闲连接自动清理）✅ 2026-06-03 - [x] 最大并发连接数限制 ✅ 2026-06-03 - [x] 分级日志系统（error / warn / info / debug）✅ 2026-06-03 +- [x] 访问日志（Nginx combined 格式，含 User-Agent / Referer）✅ 2026-06-05 - [x] Gzip 压缩 ✅ 2026-06-03（已接入响应流程） -- [x] 集成测试 suite（37 项 curl/bash 测试全部通过）✅ 2026-06-03 +- [x] Brotli 压缩 ✅ 2026-06-04（优先于 Gzip） +- [x] 集成测试 suite（61 项 curl/bash 测试全部通过）✅ 2026-06-05 - [x] 性能基准（wrk: ~16.2K RPS / ~60μs 延迟）✅ 2026-06-03 - [x] 请求体解析（POST 支持）✅ 2026-06-03 - Content-Length 读取 - JSON / form-urlencoded 回显 - **multipart/form-data 文件上传**（保存到 root_dir/uploads/）✅ 2026-06-04 -- [x] C 语言单元测试框架 ✅ 2026-06-03（Unity 框架，113 个测试全部通过） +- [x] C 语言单元测试框架 ✅ 2026-06-03（Unity 框架，127 个测试全部通过） -### Phase 3 — 扩展 +### Phase 3 — 扩展（已完成） - [x] **配置文件支持** — JSON 配置替代纯命令行 ✅ 2026-06-04 - `config.c` / `config.h`：极简 JSON 解析器（数字、字符串、布尔、注释） - - `cocoon_config_t` 结构体：root_dir / port / threaded / num_workers / max_connections / timeout_ms / log_level / gzip_enabled / brotli_enabled + - `cocoon_config_t` 结构体：root_dir / port / threaded / num_workers / max_connections / timeout_ms / log_level / gzip_enabled / brotli_enabled / access_log - `config_merge()`：命令行参数覆盖配置文件 - `cocoon.json` 示例配置 - `--no-gzip` / `--no-brotli` 命令行选项禁用压缩 - [x] **Brotli 压缩** — 比 gzip 更高压缩率，现代浏览器均支持 ✅ 2026-06-04 +- [x] **HTTPS / TLS** — OpenSSL Memory BIO 集成，支持命令行与配置文件启用 ✅ 2026-06-04 +- [x] **HTTP/2** — nghttp2 完整实现（TLS ALPN 协商 + 静态文件服务 + 缓存 + 目录浏览）✅ 2026-06-04 +- [x] **h2c 升级支持** — 明文 HTTP/2（PRI 魔术字直接连接 + Upgrade: h2c 协商）✅ 2026-06-04 +- [x] **HTTP/2 目录浏览** — 目录无 index.html 时返回目录列表 ✅ 2026-06-04 +- [x] **WebSocket 支持** — RFC 6455 握手 + 帧解析/编码 + echo 服务器 ✅ 2026-06-05 - [x] **Windows 兼容性** — 跨平台抽象层，支持 Linux/macOS/Windows(MinGW/MSVC) ✅ 2026-06-04 -- [ ] HTTPS / TLS -- [ ] HTTP/2 ### Phase 4 — 生态 -- [ ] WebSocket 支持 +- [ ] WebSocket 广播/消息路由 - [ ] 中间件机制 - [ ] 插件系统 ## 当前状态 - 编译通过，零警告（除 coco 子模块的 linker .note.GNU-stack 提示） -- **37 项集成测试全部通过**（GET/HEAD/POST/404/Range/304/gzip/brotli/MIME/目录浏览/路径防护/文件上传） -- **113 个单元测试全部通过**（Unity 框架，覆盖 http.c / static.c / multipart.c / config.c / server.c 核心逻辑） -- 压测数据：wrk -t4 -c100 -d10s → 16,179 RPS，平均延迟 59.86μs +- **61 项集成测试全部通过**（GET/HEAD/POST/404/Range/304/gzip/brotli/MIME/目录浏览/路径防护/文件上传/TLS/HTTP/2/h2c/WebSocket/访问日志） +- **127 个单元测试全部通过**（Unity 框架） +- 压测数据：wrk -t4 -c100 -d10s → 16,179 RPS，平均延迟 59.86μs（单线程） +- 多线程模式（-t -w 4）已修复（主线程 accept + poll，client_handler 1MB 协程栈） - POST 支持：JSON 和 form-urlencoded 回显，multipart 文件上传，Content-Length 解析，8MB 上限 -- **配置文件支持**：JSON 格式，9 个字段，命令行参数可覆盖 +- **配置文件支持**：JSON 格式，9 个字段（含 access_log），命令行参数可覆盖 +- **访问日志**：Nginx combined 格式，支持文件路径或 stdout（`-`），线程安全（pthread_mutex），记录 User-Agent / Referer / 状态码 +- **TLS/HTTPS**：OpenSSL 3.0 Memory BIO + coco 协程集成，自签名证书支持，ALPN 协商 h2/http1.1 +- **HTTP/2**：完整功能（静态文件服务、目录浏览、缓存协商、压缩、HEAD 请求） +- **h2c**：明文 HTTP/2 支持（prior knowledge + Upgrade 协商） +- **WebSocket**：RFC 6455 握手、文本/二进制帧 echo、ping/pong/close - **Windows 兼容性**：跨平台抽象层 platform.h + platform.c，CMakeLists.txt 自动检测平台，Makefile 在 Windows 下自动链接 ws2_32 -- README / Makefile / CMakeLists.txt 已更新 ## 待办池 -1. **[高] HTTPS / TLS** — 生产部署必备 -2. **[高] HTTP/2 多路复用** — 长期演进方向 -3. **[中] 完善 Doxygen 中文注释** — 所有模块的公共 API 需要完整文档 +1. **[高] Phase 4 生态功能** — WebSocket 广播/消息路由、中间件机制、插件系统 +2. **[中] 完善 WebSocket 功能** — 消息路由、广播、连接管理面板 +3. **[低] Doxygen 中文注释** — tls.c, config.c, multipart.c, access_log.c, main.c, websocket.c 等模块待补充 +4. **[低] 性能优化** — 连接池复用、零拷贝优化、压缩预缓存 ## Windows 兼容性实现详情 @@ -92,68 +103,31 @@ - `main.c`：信号处理跨平台化，新增 `cocoon_socket_init()`/`cocoon_socket_cleanup()` - `CMakeLists.txt`：全新跨平台构建配置，自动检测 Windows/POSIX - `Makefile`：添加 `platform.c`，Windows 下自动链接 `ws2_32` - - 单元测试：113 个通过（Linux 验证），集成测试：37 项通过 + - 单元测试：127 个通过（Linux 验证），集成测试：61 项通过 - 推送到 feature/windows-compat-impl -- 2026-06-04: **本轮行动 — Brotli 压缩支持** - - `static.c`：`brotli_compress()` 函数，使用 `libbrotlienc` 高质量压缩（质量 11，窗口 22） - - `static_serve_file()`：优先 Brotli，回退 Gzip，不可压缩/二进制文件跳过 - - `http.c`：解析 `Accept-Encoding: br`，`http_request_t` 新增 `accept_brotli` 字段 - - `cocoon.h`：`cocoon_config_t` 新增 `brotli_enabled` 字段（默认 true） - - `config.c` / `config.h`：解析 `brotli_enabled` JSON 字段，`config_merge()` 新增 `has_brotli_enabled` 参数 - - `main.c`：`--no-brotli` 命令行选项，默认启用 Brotli - - `server.c`：连接结构体新增 `brotli_enabled`，传递至 `static_serve_file()` - - `Makefile`：链接 `-lbrotlienc`，单元测试编译也添加 - - 单元测试：`test_static.c` 新增 4 个 Brotli 测试（可压缩/不可压缩/小数据/溢出） - - 单元测试：`test_config.c` 新增 `brotli_enabled` 解析与 merge 测试，修复所有 `config_merge()` 调用签名 - - 集成测试：`assert_brotli()` / `assert_brotli_preferred()` / `assert_not_brotli()`，新增 5 项 Brotli 测试 - - `cocoon.json` 示例配置添加 `brotli_enabled: true` - - README：更新特性描述、curl 示例、命令行参数、路线图 - - 单元测试：113 个全部通过，集成测试：37 项全部通过 - - 推送到 main -- 2026-06-04: **本轮行动 — 配置文件支持 + README 修正 + bug 修复** - - `config.c` / `config.h`：极简 JSON 配置解析器（支持数字、字符串、布尔 true/false、// 注释） - - `cocoon_config_t` 扩展 `gzip_enabled` 字段（默认 true） - - `main.c`：`-c ` 加载配置文件，`--no-gzip` 禁用压缩，命令行参数覆盖配置文件 - - `config_merge()`：命令行显式指定值覆盖配置文件，新增 `has_gzip_enabled` 参数 - - **修复 `-r` 参数 strdup 崩溃**：`parse_args` 中 `config->root_dir = strdup(argv[i])`，避免 `free()` 野指针 - - **修复 signal handler 双重 free**：`main()` 中 server 指针仅在 `server != NULL` 时调用 `server_destroy()` - - 单元测试：`test_config.c` 17 个测试（配置加载、merge、边界条件、gzip_enabled）全部通过 - - 集成测试：32 项全部通过，配置文件启动验证通过 - - `cocoon.json` 示例配置更新，添加 `gzip_enabled` 字段 - - README 修正： - - "极简配置" → "配置文件"（已支持 JSON 配置） - - 安全设计："仅允许 GET/HEAD" → "支持 GET/HEAD/POST" - - `-v` 参数说明："显示版本号" → "详细日志输出（debug 级别）" - - 路线图：配置文件支持打勾，添加 Brotli 压缩待办 - - 推送到 main -- 2026-06-04: **本轮行动 — multipart 文件上传** - - 实现 `multipart.c` / `multipart.h`：boundary 提取、multipart 解析、part 内存管理 - - `server.c` 集成：POST 请求检测 multipart，保存文件到 `root_dir/uploads/` - - 修复 boundary 解析条件（`>= b_len` 替代 `> b_len`），修复边界扫描越界 - - 创建 `tests/unit/test_multipart.c`（12 个测试）：boundary 提取、解析、边界条件 - - 修复集成测试 CRLF 问题：使用 `printf` 生成真实 CRLF 字节 - - 集成测试 32 项全部通过，单元测试 99 个全部通过 - - 推送到 main -- 2026-06-03: 项目初始化，核心模块全部实现 -- 2026-06-03: 添加缓存协商（ETag + Last-Modified + 304），修复编译警告 -- 2026-06-03: 添加连接空闲超时管理 + 最大并发限制 + 分级日志系统 -- 2026-06-03: 创建集成测试套件 + 性能基准 + 更新文档 -- 2026-06-03: 添加 POST 请求体解析支持，30 项测试全部通过，README 更新 -- 2026-06-03: **本轮行动 — 单元测试框架** - - 引入 Unity 测试框架（ThrowTheSwitch） - - 创建 `tests/unit/test_http.c`（35 个测试）： - - 请求解析：方法、路径、头部、Range、缓存、编码、边界条件 - - 响应格式化：状态行、缓存头、Range、缓冲区溢出 - - MIME 类型：常见类型、大小写、无扩展名、特殊类型 - - 内存管理：请求体释放 - - 创建 `tests/unit/test_static.c`（31 个测试）： - - 压缩判断：文本/二进制/空值 - - 时间处理：格式化、解析、边界 - - ETag：生成、匹配（精确/弱/通配符/空值） - - 路径安全：正常拼接、路径遍历、空值、边界 - - HTML 转义：特殊字符、缓冲区溢出 - - gzip 压缩：可压缩/不可压缩/小数据/溢出 - - socket 层：send_all、错误响应（404/500/未知） - - 更新 Makefile：`make unit-test` 一键编译运行 - - 66 个测试全部通过，集成测试保持 30 项通过 +- 2026-06-05: **本轮行动 — 实现 WebSocket 支持（RFC 6455）** + - 新增 `websocket.h` / `websocket.c`：WebSocket 协议完整实现 + - 帧解析：支持 FIN、opcode、payload length（7/16/64 位）、mask 解掩码 + - 帧编码：服务器端发送（无掩码），支持文本/二进制/close/ping/pong + - 握手：Sec-WebSocket-Key + SHA1 + Base64 计算 Accept + - `server.c`：添加 `is_websocket_upgrade_request()` 检测，握手后进入 `ws_handle_connection()` + - 连接处理：文本/二进制 echo、ping/pong 自动响应、close 帧处理 + - 集成测试：`tests/websocket_test.py`（Python 标准库，零依赖） + - 编译通过，零警告 + - **61 项集成测试全部通过，127 个单元测试全部通过** + - 推送到 main（2775033） +- 2026-06-05: **本轮行动 — 访问日志（Nginx combined 格式）** + - 新增 `access_log.c` / `access_log.h`：Nginx combined 格式访问日志，线程安全（pthread_mutex） + - `cocoon.h`：新增 `access_log_path` 配置字段 + - `config.c` / `config.h`：JSON 配置和命令行参数支持 `access_log` + - `main.c`：新增 `--access-log ` CLI 选项，`-` 表示输出到 stdout + - `server.c`：扩展 `connection_t` 结构体，添加 `client_addr` / `addr_len` / `response_status` + - `server.c`：`handle_request()` 中每个响应路径设置 `response_status`，请求结束时调用 `access_log_write()` + - `server.c`：`accept_loop()` 将客户端地址复制到连接上下文 + - `Makefile`：加入 `access_log.c`，更新单元测试编译规则 + - `cocoon.json`：示例配置添加 `"access_log": "-"` + - `tests/integration_test.sh`：新增 5 项访问日志测试 + - 编译通过，零警告 + - **59 项集成测试全部通过，127 个单元测试全部通过** - 推送到 main +- 2026-06-04: 其他历史记录...（省略） diff --git a/Makefile b/Makefile index 3d1e459..4c9ec39 100644 --- a/Makefile +++ b/Makefile @@ -7,7 +7,7 @@ COCO_LIB ?= $(COCO_DIR)/build CC = gcc CFLAGS = -Wall -Wextra -O2 -std=c11 -D_GNU_SOURCE -I$(COCO_INCLUDE) -LDFLAGS = -L$(COCO_LIB) -lcoco -lpthread -lm -luring -lz -lbrotlienc +LDFLAGS = -L$(COCO_LIB) -lcoco -lpthread -lm -luring -lz -lbrotlienc -lssl -lcrypto -lnghttp2 # 调试模式 DEBUG ?= 0 @@ -20,13 +20,10 @@ PREFIX ?= /usr/local BINDIR = $(PREFIX)/bin # 源文件 -SRCS = main.c server.c http.c static.c log.c config.c multipart.c platform.c +SRCS = main.c server.c http.c static.c log.c config.c multipart.c tls.c http2.c access_log.c websocket.c platform.c OBJS = $(SRCS:.c=.o) TARGET = cocoon -# 链接参数 -LDFLAGS = -L$(COCO_LIB) -lcoco -lpthread -lm -luring -lz -lbrotlienc - # Windows (MinGW) 下链接 Winsock 库 ifeq ($(OS),Windows_NT) LDFLAGS += -lws2_32 @@ -86,8 +83,8 @@ unit-test: $(UNIT_TEST_BINS) fi # 单元测试编译规则 -$(UNIT_TEST_DIR)/test_server: $(UNIT_TEST_DIR)/test_server.c server.c http.c static.c log.c config.c multipart.c platform.c $(UNITY_SRC) - $(CC) $(CFLAGS) -I. -I$(UNIT_TEST_DIR)/../unity -o $@ $(UNIT_TEST_DIR)/test_server.c server.c http.c static.c log.c config.c multipart.c platform.c $(UNITY_SRC) $(LDFLAGS) +$(UNIT_TEST_DIR)/test_server: $(UNIT_TEST_DIR)/test_server.c server.c http.c static.c log.c config.c multipart.c tls.c http2.c access_log.c websocket.c platform.c $(UNITY_SRC) + $(CC) $(CFLAGS) -I. -I$(UNIT_TEST_DIR)/../unity -o $@ $(UNIT_TEST_DIR)/test_server.c server.c http.c static.c log.c config.c multipart.c tls.c http2.c access_log.c websocket.c platform.c $(UNITY_SRC) $(LDFLAGS) $(UNIT_TEST_DIR)/test_multipart: $(UNIT_TEST_DIR)/test_multipart.c multipart.c $(UNITY_SRC) $(CC) $(CFLAGS) -I. -I$(UNIT_TEST_DIR)/../unity -o $@ $(UNIT_TEST_DIR)/test_multipart.c multipart.c $(UNITY_SRC) -lm @@ -95,14 +92,14 @@ $(UNIT_TEST_DIR)/test_multipart: $(UNIT_TEST_DIR)/test_multipart.c multipart.c $ $(UNIT_TEST_DIR)/test_http: $(UNIT_TEST_DIR)/test_http.c http.c log.c $(UNITY_SRC) $(CC) $(CFLAGS) -I. -I$(UNIT_TEST_DIR)/../unity -o $@ $(UNIT_TEST_DIR)/test_http.c http.c log.c $(UNITY_SRC) -lm -$(UNIT_TEST_DIR)/test_static: $(UNIT_TEST_DIR)/test_static.c http.c log.c $(UNITY_SRC) - $(CC) $(CFLAGS) -I. -I$(UNIT_TEST_DIR)/../unity -o $@ $(UNIT_TEST_DIR)/test_static.c http.c log.c $(UNITY_SRC) -lm -lz -lbrotlienc +$(UNIT_TEST_DIR)/test_static: $(UNIT_TEST_DIR)/test_static.c http.c log.c tls.c access_log.c platform.c $(UNITY_SRC) + $(CC) $(CFLAGS) -I. -I$(UNIT_TEST_DIR)/../unity -o $@ $(UNIT_TEST_DIR)/test_static.c http.c log.c tls.c access_log.c platform.c $(UNITY_SRC) $(LDFLAGS) $(UNIT_TEST_DIR)/test_log: $(UNIT_TEST_DIR)/test_log.c log.c $(UNITY_SRC) $(CC) $(CFLAGS) -I. -I$(UNIT_TEST_DIR)/../unity -o $@ $(UNIT_TEST_DIR)/test_log.c log.c $(UNITY_SRC) -lm -$(UNIT_TEST_DIR)/test_config: $(UNIT_TEST_DIR)/test_config.c config.c log.c $(UNITY_SRC) - $(CC) $(CFLAGS) -I. -I$(UNIT_TEST_DIR)/../unity -o $@ $(UNIT_TEST_DIR)/test_config.c config.c log.c $(UNITY_SRC) -lm +$(UNIT_TEST_DIR)/test_config: $(UNIT_TEST_DIR)/test_config.c config.c log.c access_log.c http.c $(UNITY_SRC) + $(CC) $(CFLAGS) -I. -I$(UNIT_TEST_DIR)/../unity -o $@ $(UNIT_TEST_DIR)/test_config.c config.c log.c access_log.c http.c $(UNITY_SRC) -lm # 编译规则 %.o: %.c diff --git a/access_log.c b/access_log.c new file mode 100644 index 0000000..c1f47a4 --- /dev/null +++ b/access_log.c @@ -0,0 +1,193 @@ +/** + * access_log.c - 访问日志模块实现 + * + * 使用简化 Nginx combined 格式： + * %h %l %u %t "%r" %s %b "%{Referer}i" "%{User-Agent}i" + * + * 线程安全：使用 pthread_mutex_t 保护文件写入。 + * + * @author xfy + */ + +#include "access_log.h" +#include "http.h" +#include "log.h" +#include +#include +#include +#include +#include +#include + +/* === 内部状态 === */ +static FILE *g_log_file = NULL; +static pthread_mutex_t g_log_mutex = PTHREAD_MUTEX_INITIALIZER; +static bool g_enabled = false; + +/** + * format_log_time - 格式化当前时间为日志时间格式 + * + * Nginx 格式: [05/Jun/2026:00:00:00 +0800] + * + * @param buf 输出缓冲区 + * @param buf_size 缓冲区大小 + */ +static void format_log_time(char *buf, size_t buf_size) { + time_t now = time(NULL); + struct tm *tm = localtime(&now); + if (!tm) { + buf[0] = '\0'; + return; + } + + /* 计算时区偏移 */ + long tz_offset = 0; +#if defined(__linux__) || defined(__unix__) + tz_offset = tm->tm_gmtoff; +#else + /* 通用回退 */ + struct tm gmt = {0}; + gmtime_r(&now, &gmt); + time_t local = mktime(tm); + time_t gmt_t = mktime(&gmt); + tz_offset = (long)difftime(local, gmt_t); +#endif + + int tz_hours = (int)(tz_offset / 3600); + int tz_mins = (int)((tz_offset % 3600) / 60); + if (tz_mins < 0) tz_mins = -tz_mins; + + const char *months[] = { + "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" + }; + + snprintf(buf, buf_size, "[%02d/%s/%04d:%02d:%02d:%02d %c%02d%02d]", + tm->tm_mday, months[tm->tm_mon], tm->tm_year + 1900, + tm->tm_hour, tm->tm_min, tm->tm_sec, + tz_offset >= 0 ? '+' : '-', tz_hours, tz_mins); +} + +/** + * get_client_ip - 从 sockaddr 提取客户端 IP 字符串 + * + * @param addr sockaddr 结构体 + * @param addr_len 地址长度 + * @param buf 输出缓冲区 + * @param buf_size 缓冲区大小 + */ +static void get_client_ip(const struct sockaddr *addr, socklen_t addr_len, + char *buf, size_t buf_size) { + (void)addr_len; + buf[0] = '\0'; + + if (addr->sa_family == AF_INET) { + const struct sockaddr_in *sin = (const struct sockaddr_in *)addr; + inet_ntop(AF_INET, &sin->sin_addr, buf, (socklen_t)buf_size); + } else if (addr->sa_family == AF_INET6) { + const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)addr; + inet_ntop(AF_INET6, &sin6->sin6_addr, buf, (socklen_t)buf_size); + } else { + snprintf(buf, buf_size, "unknown"); + } +} + +/** + * get_header - 从请求头数组中查找指定头 + * + * @param req HTTP 请求 + * @param name 头名称（小写） + * @return 头值，未找到返回 "-" + */ +static const char *get_header(const http_request_t *req, const char *name) { + for (int i = 0; i < req->num_headers; i++) { + if (strcmp(req->headers[i].name, name) == 0) { + return req->headers[i].value; + } + } + return "-"; +} + +/* === 公共 API === */ + +int access_log_init(const char *path) { + pthread_mutex_lock(&g_log_mutex); + + if (g_log_file && g_log_file != stdout) { + fclose(g_log_file); + } + g_log_file = NULL; + g_enabled = false; + + if (!path || strcmp(path, "-") == 0 || strcmp(path, "stdout") == 0) { + g_log_file = stdout; + g_enabled = true; + log_info("访问日志输出到 stdout"); + } else { + g_log_file = fopen(path, "a"); + if (!g_log_file) { + log_error("无法打开访问日志文件: %s", path); + pthread_mutex_unlock(&g_log_mutex); + return -1; + } + g_enabled = true; + log_info("访问日志: %s", path); + } + + pthread_mutex_unlock(&g_log_mutex); + return 0; +} + +void access_log_close(void) { + pthread_mutex_lock(&g_log_mutex); + if (g_log_file && g_log_file != stdout) { + fclose(g_log_file); + } + g_log_file = NULL; + g_enabled = false; + pthread_mutex_unlock(&g_log_mutex); +} + +bool access_log_is_enabled(void) { + return g_enabled; +} + +void access_log_write(const struct sockaddr *client_addr, socklen_t addr_len, + const http_request_t *req, int status_code, int64_t response_bytes) { + if (!g_enabled || !req) return; + + char ip[64]; + get_client_ip(client_addr, addr_len, ip, sizeof(ip)); + + char time_str[64]; + format_log_time(time_str, sizeof(time_str)); + + const char *method = http_method_str(req->method); + const char *path = req->path; + const char *version = req->version[0] ? req->version : "HTTP/1.1"; + + const char *referer = get_header(req, "referer"); + const char *user_agent = get_header(req, "user-agent"); + + /* 响应字节 */ + char bytes_str[32]; + if (response_bytes < 0) { + snprintf(bytes_str, sizeof(bytes_str), "-"); + } else { + snprintf(bytes_str, sizeof(bytes_str), "%ld", (long)response_bytes); + } + + pthread_mutex_lock(&g_log_mutex); + if (g_log_file) { + fprintf(g_log_file, "%s - - %s \"%s %s %s\" %d %s \"%s\" \"%s\"\n", + ip[0] ? ip : "-", + time_str, + method, path, version, + status_code, + bytes_str, + referer, + user_agent); + fflush(g_log_file); + } + pthread_mutex_unlock(&g_log_mutex); +} diff --git a/access_log.h b/access_log.h new file mode 100644 index 0000000..702c900 --- /dev/null +++ b/access_log.h @@ -0,0 +1,58 @@ +/** + * access_log.h - 访问日志模块接口 + * + * 提供类似 Nginx combined 格式的访问日志记录。 + * 格式: %h %l %u %t "%r" %s %b "%{Referer}i" "%{User-Agent}i" + * + * @author xfy + */ + +#ifndef COCOON_ACCESS_LOG_H +#define COCOON_ACCESS_LOG_H + +#include +#include +#include +#include +#include "http.h" + +/** + * access_log_init - 初始化访问日志 + * + * 打开日志文件（如果 path 为 NULL 或 "-"，则输出到 stdout）。 + * 线程安全：使用内部互斥锁保护。 + * + * @param path 日志文件路径，NULL 或 "-" 表示 stdout + * @return 0 成功，-1 失败 + */ +int access_log_init(const char *path); + +/** + * access_log_close - 关闭访问日志 + * + * 刷新并关闭日志文件。 + */ +void access_log_close(void); + +/** + * access_log_is_enabled - 检查访问日志是否已启用 + * + * @return true 已启用 + */ +bool access_log_is_enabled(void); + +/** + * access_log_write - 写入一条访问日志记录 + * + * 格式: 192.168.1.1 - - [05/Jun/2026:00:00:00 +0800] "GET /index.html HTTP/1.1" 200 1234 "-" "Mozilla/5.0" + * + * @param client_addr 客户端地址（sockaddr 结构体） + * @param addr_len 地址长度 + * @param req HTTP 请求指针（实际类型为 http_request_t *，在 http.h 定义） + * @param status_code HTTP 响应状态码 + * @param response_bytes 响应体字节数（-1 表示未知） + */ +void access_log_write(const struct sockaddr *client_addr, socklen_t addr_len, + const http_request_t *req, int status_code, int64_t response_bytes); + +#endif /* COCOON_ACCESS_LOG_H */ diff --git a/coco b/coco index 62dbb13..b45045e 160000 --- a/coco +++ b/coco @@ -1 +1 @@ -Subproject commit 62dbb13927d5411cb2d35d095e9f887c93c4a13f +Subproject commit b45045ee0671c2a3fabeefbbf43c8b29a4a3ba22 diff --git a/cocoon.h b/cocoon.h index f98ceed..2038525 100644 --- a/cocoon.h +++ b/cocoon.h @@ -19,7 +19,7 @@ #define COCOON_ERROR -1 /**< 通用错误 */ #define COCOON_NOMEM -2 /**< 内存不足 */ #define COCOON_NOTFOUND -3 /**< 文件未找到 */ -#define COCOONForbidden -4 /**< 禁止访问 */ +#define COCOON_FORBIDDEN -4 /**< 禁止访问 */ #define COCOON_BADREQUEST -5 /**< 请求格式错误 */ /* === 服务器配置 === */ @@ -38,6 +38,10 @@ typedef struct cocoon_config { log_level_t log_level; /**< 日志级别 */ bool gzip_enabled; /**< 是否启用 gzip 压缩（默认 true） */ bool brotli_enabled; /**< 是否启用 brotli 压缩（默认 true） */ + bool tls_enabled; /**< 是否启用 TLS（由 cert/key 自动推断） */ + const char *tls_cert; /**< TLS 证书路径 */ + const char *tls_key; /**< TLS 私钥路径 */ + const char *access_log_path; /**< 访问日志文件路径（NULL 或 "-" 表示 stdout） */ } cocoon_config_t; /* === 服务器生命周期 API === */ diff --git a/cocoon.json b/cocoon.json index c57e382..b2fa8c8 100644 --- a/cocoon.json +++ b/cocoon.json @@ -7,5 +7,6 @@ "timeout_ms": 30000, "log_level": "info", "gzip_enabled": true, - "brotli_enabled": true + "brotli_enabled": true, + "access_log": "-" } diff --git a/config.c b/config.c index 238257f..aead4e4 100644 --- a/config.c +++ b/config.c @@ -274,6 +274,27 @@ bool config_load_from_file(const char *path, cocoon_config_t *config) { } else if (strcmp(key_str, "brotli_enabled") == 0) { if (val.type == TOKEN_TRUE) config->brotli_enabled = true; else if (val.type == TOKEN_FALSE) config->brotli_enabled = false; + } else if (strcmp(key_str, "tls_cert") == 0 && val.type == TOKEN_STRING) { + char *v = token_str_dup(&val); + if (v) { + free((void *)config->tls_cert); + config->tls_cert = v; + } + } else if (strcmp(key_str, "tls_key") == 0 && val.type == TOKEN_STRING) { + char *v = token_str_dup(&val); + if (v) { + free((void *)config->tls_key); + config->tls_key = v; + } + } else if (strcmp(key_str, "tls_enabled") == 0) { + if (val.type == TOKEN_TRUE) config->tls_enabled = true; + else if (val.type == TOKEN_FALSE) config->tls_enabled = false; + } else if (strcmp(key_str, "access_log") == 0 && val.type == TOKEN_STRING) { + char *v = token_str_dup(&val); + if (v) { + free((void *)config->access_log_path); + config->access_log_path = v; + } } /* 其他字段：忽略（未来扩展预留） */ @@ -296,7 +317,9 @@ bool config_load_from_file(const char *path, cocoon_config_t *config) { void config_merge(cocoon_config_t *base, const cocoon_config_t *cmdline, bool has_root_dir, bool has_port, bool has_workers, bool has_max_conn, bool has_timeout, bool has_log_level, - bool has_gzip_enabled, bool has_brotli_enabled) { + bool has_gzip_enabled, bool has_brotli_enabled, + bool has_tls_cert, bool has_tls_key, bool has_tls_enabled, + bool has_access_log) { if (!base || !cmdline) return; /* 命令行显式指定的值覆盖配置文件 */ @@ -311,6 +334,19 @@ void config_merge(cocoon_config_t *base, const cocoon_config_t *cmdline, if (has_log_level) base->log_level = cmdline->log_level; if (has_gzip_enabled) base->gzip_enabled = cmdline->gzip_enabled; if (has_brotli_enabled) base->brotli_enabled = cmdline->brotli_enabled; + if (has_tls_cert && cmdline->tls_cert) { + free((void *)base->tls_cert); + base->tls_cert = strdup(cmdline->tls_cert); + } + if (has_tls_key && cmdline->tls_key) { + free((void *)base->tls_key); + base->tls_key = strdup(cmdline->tls_key); + } + if (has_tls_enabled) base->tls_enabled = cmdline->tls_enabled; + if (has_access_log && cmdline->access_log_path) { + free((void *)base->access_log_path); + base->access_log_path = strdup(cmdline->access_log_path); + } /* threaded 是 flag 参数，命令行指定了就用命令行的 */ if (cmdline->threaded) base->threaded = true; } diff --git a/config.h b/config.h index 801f9d3..53975da 100644 --- a/config.h +++ b/config.h @@ -43,6 +43,8 @@ bool config_load_from_file(const char *path, cocoon_config_t *config); void config_merge(cocoon_config_t *base, const cocoon_config_t *cmdline, bool has_root_dir, bool has_port, bool has_workers, bool has_max_conn, bool has_timeout, bool has_log_level, - bool has_gzip_enabled, bool has_brotli_enabled); + bool has_gzip_enabled, bool has_brotli_enabled, + bool has_tls_cert, bool has_tls_key, bool has_tls_enabled, + bool has_access_log); #endif /* COCOON_CONFIG_H */ diff --git a/http2.c b/http2.c new file mode 100644 index 0000000..c280108 --- /dev/null +++ b/http2.c @@ -0,0 +1,1277 @@ +/** + * http2.c - HTTP/2 支持实现 + * + * 使用 nghttp2 库实现 HTTP/2 协议支持。 + * 与 cocoon 的协程 I/O 和 TLS 层集成。 + * + * @author xfy + */ + +#include "http2.h" +#include "static.h" +#include "log.h" +#include "tls.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* 最大 HTTP/2 会话数 */ +#define MAX_HTTP2_SESSIONS 1024 + +/* 压缩辅助函数（与 static.c 独立，保持模块边界） */ +/** + * is_compressible_mime - 判断 MIME 类型是否可压缩 + * + * 检查给定 MIME 类型是否为文本类或可压缩格式。 + * 用于决定是否对响应内容应用 gzip/brotli 压缩。 + * + * @param mime_type MIME 类型字符串 + * @return true 可压缩，false 不可压缩 + */ +static bool is_compressible_mime(const char *mime_type) { + if (!mime_type) return false; + return ( + strstr(mime_type, "text/") != NULL || + strstr(mime_type, "application/javascript") != NULL || + strstr(mime_type, "application/json") != NULL || + strstr(mime_type, "application/xml") != NULL || + strstr(mime_type, "application/manifest") != NULL || + strstr(mime_type, "image/svg") != NULL + ); +} + +/** + * gzip_compress - gzip 压缩数据 + * + * 使用 zlib 对输入数据进行 gzip 压缩。 + * 如果压缩后大小未明显减小（< 95%），返回 0 表示不压缩更优。 + * + * @param src 原始数据 + * @param src_len 原始数据长度 + * @param dst 输出缓冲区 + * @param dst_cap 输出缓冲区容量 + * @return 压缩后长度，0 表示未压缩更优，-1 失败 + */ +static ssize_t gzip_compress(const char *src, size_t src_len, + char *dst, size_t dst_cap) { + z_stream strm = {0}; + if (deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, + 15 + 16, 8, Z_DEFAULT_STRATEGY) != Z_OK) { + return -1; + } + strm.avail_in = (uInt)src_len; + strm.next_in = (Bytef *)src; + strm.avail_out = (uInt)dst_cap; + strm.next_out = (Bytef *)dst; + if (deflate(&strm, Z_FINISH) != Z_STREAM_END) { + deflateEnd(&strm); + return -1; + } + size_t compressed_len = dst_cap - strm.avail_out; + deflateEnd(&strm); + if (compressed_len >= src_len * 0.95) return 0; + return (ssize_t)compressed_len; +} + +/** + * brotli_compress - Brotli 压缩数据 + * + * 使用 Brotli 编码器对输入数据进行压缩。 + * 通常比 gzip 压缩率更高，CPU 消耗也更大。 + * + * @param src 原始数据 + * @param src_len 原始数据长度 + * @param dst 输出缓冲区 + * @param dst_cap 输出缓冲区容量 + * @return 压缩后长度，0 表示未压缩更优，-1 失败 + */ +static ssize_t brotli_compress(const char *src, size_t src_len, + char *dst, size_t dst_cap) { + size_t encoded_size = dst_cap; + BROTLI_BOOL ok = BrotliEncoderCompress( + BROTLI_DEFAULT_QUALITY, + BROTLI_DEFAULT_WINDOW, + BROTLI_MODE_GENERIC, + src_len, + (const uint8_t *)src, + &encoded_size, + (uint8_t *)dst + ); + if (!ok) return -1; + if (encoded_size >= src_len * 0.95) return 0; + return (ssize_t)encoded_size; +} + +static http2_session_t *g_sessions[MAX_HTTP2_SESSIONS]; +static int g_session_count = 0; + +/* 静态文件服务辅助函数 */ +static void format_http_time(time_t t, char *buf, size_t buf_size); +static void generate_etag(const struct stat *st, char *buf, size_t buf_size); +static time_t parse_http_time(const char *str); +static bool match_etag(const char *etag, const char *if_none_match); + +/* 内部函数声明 */ +static ssize_t send_callback(nghttp2_session *session __attribute__((unused)), const uint8_t *data, + size_t length, int flags __attribute__((unused)), void *user_data); +static int on_begin_headers_callback(nghttp2_session *session, + const nghttp2_frame *frame, + void *user_data); +static int on_header_callback(nghttp2_session *session, + const nghttp2_frame *frame, const uint8_t *name, + size_t namelen, const uint8_t *value, + size_t valuelen, uint8_t flags, + void *user_data); +static int on_frame_recv_callback(nghttp2_session *session, + const nghttp2_frame *frame, void *user_data); +static int on_stream_close_callback(nghttp2_session *session, + int32_t stream_id, uint32_t error_code, + void *user_data); +static int on_data_chunk_recv_callback(nghttp2_session *session, + uint8_t flags, int32_t stream_id, + const uint8_t *data, + size_t len, void *user_data); +static ssize_t http2_data_source_read_callback(nghttp2_session *session, int32_t stream_id, + uint8_t *buf, size_t length, uint32_t *data_flags, + nghttp2_data_source *source, void *user_data); +static bool http2_serve_directory(http2_session_t *h2, http2_stream_data_t *stream, + const char *real_path, const char *request_path); +static void http2_serve_static(http2_session_t *h2, http2_stream_data_t *stream); + +/* ===================== 会话管理 ===================== */ + +/** + * http2_init - 初始化 HTTP/2 模块 + * + * 清空会话数组，准备接受新连接。 + * + * @return 0 成功 + */ +int http2_init(void) { + memset(g_sessions, 0, sizeof(g_sessions)); + g_session_count = 0; + return 0; +} + +/** + * http2_cleanup - 清理所有 HTTP/2 会话 + * + * 遍历会话数组，销毁所有存在的会话。 + * 通常在服务器关闭时调用。 + */ +void http2_cleanup(void) { + for (int i = 0; i < MAX_HTTP2_SESSIONS; i++) { + if (g_sessions[i]) { + http2_session_destroy(g_sessions[i]); + g_sessions[i] = NULL; + } + } + g_session_count = 0; +} + +/** + * http2_session_create - 创建 HTTP/2 会话 + * + * 为指定 fd 创建 nghttp2 会话，注册回调函数，发送 SETTINGS 帧。 + * 如果该 fd 已存在会话，先销毁旧会话。 + * + * @param fd 客户端 socket + * @param tls_mode 是否为 TLS 模式 + * @return 新会话指针，NULL 失败 + */ +http2_session_t *http2_session_create(int fd, bool tls_mode) { + if (fd < 0 || fd >= MAX_HTTP2_SESSIONS) { + return NULL; + } + if (g_sessions[fd] != NULL) { + /* 已存在，先销毁 */ + http2_session_destroy(g_sessions[fd]); + } + + http2_session_t *h2 = calloc(1, sizeof(http2_session_t)); + if (!h2) { + return NULL; + } + + h2->fd = fd; + h2->tls_mode = tls_mode; + + /* 创建 nghttp2 会话 */ + nghttp2_session_callbacks *callbacks = NULL; + if (nghttp2_session_callbacks_new(&callbacks) != 0) { + free(h2); + return NULL; + } + + nghttp2_session_callbacks_set_send_callback(callbacks, send_callback); + nghttp2_session_callbacks_set_on_begin_headers_callback( + callbacks, on_begin_headers_callback); + nghttp2_session_callbacks_set_on_header_callback(callbacks, + on_header_callback); + nghttp2_session_callbacks_set_on_frame_recv_callback(callbacks, + on_frame_recv_callback); + nghttp2_session_callbacks_set_on_stream_close_callback( + callbacks, on_stream_close_callback); + nghttp2_session_callbacks_set_on_data_chunk_recv_callback( + callbacks, on_data_chunk_recv_callback); + + if (nghttp2_session_server_new(&h2->session, callbacks, h2) != 0) { + nghttp2_session_callbacks_del(callbacks); + free(h2); + return NULL; + } + + nghttp2_session_callbacks_del(callbacks); + + /* 发送服务器连接前言（SETTINGS 帧） */ + nghttp2_settings_entry iv[] = { + {NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS, 100}, + {NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE, (1 << 16) - 1}}; + if (nghttp2_submit_settings(h2->session, NGHTTP2_FLAG_NONE, iv, + sizeof(iv) / sizeof(iv[0])) != 0) { + nghttp2_session_del(h2->session); + free(h2); + return NULL; + } + + g_sessions[fd] = h2; + g_session_count++; + + return h2; +} + +/** + * http2_session_destroy - 销毁 HTTP/2 会话 + * + * 从全局数组移除，释放 nghttp2 会话，关闭所有关联流。 + * + * @param h2 会话指针 + */ +void http2_session_destroy(http2_session_t *h2) { + if (!h2) return; + + if (h2->fd >= 0 && h2->fd < MAX_HTTP2_SESSIONS) { + g_sessions[h2->fd] = NULL; + } + g_session_count--; + + if (h2->session) { + nghttp2_session_del(h2->session); + } + + /* 清理所有流 */ + http2_stream_data_t *stream = h2->streams; + while (stream) { + http2_stream_data_t *next = stream->next; + if (stream->file_fd >= 0) { + close(stream->file_fd); + } + free(stream->response_body); + http_request_free(&stream->request); + free(stream); + stream = next; + } + + free(h2); +} + +/** + * http2_session_is_http2 - 检查 fd 是否已升级为 HTTP/2 + * + * @param fd 客户端 socket + * @return true 是 HTTP/2 连接 + */ +bool http2_session_is_http2(int fd) { + if (fd < 0 || fd >= MAX_HTTP2_SESSIONS) return false; + return g_sessions[fd] != NULL; +} + +/** + * http2_session_get - 获取 fd 对应的 HTTP/2 会话 + * + * @param fd 客户端 socket + * @return 会话指针，NULL 不存在 + */ +http2_session_t *http2_session_get(int fd) { + if (fd < 0 || fd >= MAX_HTTP2_SESSIONS) return NULL; + return g_sessions[fd]; +} + +/** + * http2_session_set_context - 设置会话的服务上下文 + * + * 传入 root_dir 和压缩配置，供后续静态文件服务使用。 + * + * @param h2 会话指针 + * @param root_dir 静态资源根目录 + * @param gzip_enabled 是否启用 gzip + * @param brotli_enabled 是否启用 brotli + */ +void http2_session_set_context(http2_session_t *h2, const char *root_dir, bool gzip_enabled, bool brotli_enabled) { + if (!h2) return; + h2->root_dir = root_dir; + h2->gzip_enabled = gzip_enabled; + h2->brotli_enabled = brotli_enabled; +} + +/** + * http2_session_upgrade - 将 HTTP/1.1 连接升级为 HTTP/2 + * + * 通过 nghttp2_session_upgrade2 注册 stream 1，处理已解析的 HTTP/1.1 请求。 + * 用于 h2c 升级（Upgrade: h2c）场景。 + * + * @param h2 会话指针 + * @param req HTTP/1.1 请求（已解析） + * @return 0 成功，-1 失败 + */ +int http2_session_upgrade(http2_session_t *h2, const http_request_t *req) { + if (!h2 || !h2->session || !req) return -1; + + /* 创建流数据（stream_id=1） */ + http2_stream_data_t *stream = calloc(1, sizeof(http2_stream_data_t)); + if (!stream) return -1; + + stream->stream_id = 1; + stream->file_fd = -1; + stream->request = *req; + stream->request.body = NULL; /* 升级请求通常无 body，避免双重释放 */ + stream->request_complete = true; + + /* 注册升级流到 nghttp2 */ + int is_head = (req->method == HTTP_HEAD) ? 1 : 0; + if (nghttp2_session_upgrade2(h2->session, NULL, 0, is_head, stream) != 0) { + free(stream); + return -1; + } + + /* 关联到会话 */ + stream->next = h2->streams; + h2->streams = stream; + nghttp2_session_set_stream_user_data(h2->session, 1, stream); + + /* 提交静态文件响应 */ + http2_serve_static(h2, stream); + + return 0; +} + +/* ===================== 数据收发 ===================== */ + +/** + * http2_recv - 接收 HTTP/2 帧数据 + * + * 将数据喂给 nghttp2 解析器，并发送任何挂起的输出帧。 + * + * @param h2 会话指针 + * @param buf 输入数据 + * @param len 数据长度 + * @return 0 成功，-1 失败 + */ +int http2_recv(http2_session_t *h2, const uint8_t *buf, size_t len) { + if (!h2 || !h2->session) return -1; + + ssize_t readlen = nghttp2_session_mem_recv(h2->session, buf, len); + if (readlen < 0) { + log_error("HTTP/2 接收错误: %s", nghttp2_strerror((int)readlen)); + return -1; + } + + /* 发送任何挂起的输出帧 */ + return http2_send_pending(h2); +} + +/** + * http2_send_pending - 发送挂起的 HTTP/2 输出帧 + * + * 调用 nghttp2_session_send 处理所有待发送的帧。 + * + * @param h2 会话指针 + * @return 0 成功，-1 失败 + */ +int http2_send_pending(http2_session_t *h2) { + if (!h2 || !h2->session) return -1; + + int rv = nghttp2_session_send(h2->session); + if (rv != 0) { + log_error("HTTP/2 发送错误: %s", nghttp2_strerror(rv)); + return -1; + } + return 0; +} + +/** + * http2_want_read - 检查会话是否还需要读取数据 + * + * @param h2 会话指针 + * @return true 需要读取 + */ +bool http2_want_read(http2_session_t *h2) { + if (!h2 || !h2->session) return false; + return nghttp2_session_want_read(h2->session) != 0; +} + +/** + * http2_want_write - 检查会话是否还需要写入数据 + * + * @param h2 会话指针 + * @return true 需要写入 + */ +bool http2_want_write(http2_session_t *h2) { + if (!h2 || !h2->session) return false; + return nghttp2_session_want_write(h2->session) != 0; +} + +/* ===================== nghttp2 回调 ===================== */ + +/** + * send_callback - nghttp2 发送回调 + * + * 将 nghttp2 生成的帧数据通过 TLS 或原始 socket 发送。 + * 这是 nghttp2 与 cocoon I/O 层之间的桥接。 + * + * @param session nghttp2 会话（未使用） + * @param data 待发送数据 + * @param length 数据长度 + * @param flags 标志（未使用） + * @param user_data 用户数据（http2_session_t） + * @return 发送字节数，或 NGHTTP2_ERR_CALLBACK_FAILURE + */ +static ssize_t send_callback(nghttp2_session *session __attribute__((unused)), + const uint8_t *data, size_t length, + int flags __attribute__((unused)), + void *user_data) { + http2_session_t *h2 = (http2_session_t *)user_data; + + /* 使用 TLS 或原始 socket 发送 */ + ssize_t sent; + if (h2->tls_mode && tls_has_connection(h2->fd)) { + sent = tls_write(h2->fd, (const char *)data, length); + } else { + if (send_all(h2->fd, (const char *)data, length) != 0) { + return NGHTTP2_ERR_CALLBACK_FAILURE; + } + sent = (ssize_t)length; + } + + if (sent < 0) { + return NGHTTP2_ERR_CALLBACK_FAILURE; + } + return (int)sent; +} + +/** + * on_begin_headers_callback - 新流开始时创建流数据 + * + * 当 nghttp2 开始接收 HEADERS 帧时创建 http2_stream_data_t， + * 插入会话链表并关联到 nghttp2 流。 + * + * @param session nghttp2 会话 + * @param frame 当前帧 + * @param user_data 会话指针 + * @return 0 成功，NGHTTP2_ERR_CALLBACK_FAILURE 失败 + */ +static int on_begin_headers_callback(nghttp2_session *session __attribute__((unused)), + const nghttp2_frame *frame, + void *user_data) { + http2_session_t *h2 = (http2_session_t *)user_data; + + if (frame->hd.type != NGHTTP2_HEADERS || + frame->headers.cat != NGHTTP2_HCAT_REQUEST) { + return 0; + } + + /* 创建新流数据 */ + http2_stream_data_t *stream = calloc(1, sizeof(http2_stream_data_t)); + if (!stream) { + return NGHTTP2_ERR_CALLBACK_FAILURE; + } + + stream->stream_id = frame->hd.stream_id; + stream->file_fd = -1; + + /* 插入链表头部 */ + stream->next = h2->streams; + h2->streams = stream; + + /* 关联到 nghttp2 流 */ + nghttp2_session_set_stream_user_data(session, frame->hd.stream_id, stream); + + return 0; +} + +/** + * on_header_callback - 解析请求头字段 + * + * 处理 HTTP/2 伪头（:path, :method）和普通头字段。 + * 提取缓存相关头（If-None-Match, If-Modified-Since）。 + * + * @param session nghttp2 会话 + * @param frame 当前帧 + * @param name 头名 + * @param namelen 头名长度 + * @param value 头值 + * @param valuelen 头值长度 + * @param flags 标志（未使用） + * @param user_data 未使用 + * @return 0 成功 + */ +static int on_header_callback(nghttp2_session *session, + const nghttp2_frame *frame, const uint8_t *name, + size_t namelen, const uint8_t *value, + size_t valuelen, uint8_t flags __attribute__((unused)), + void *user_data __attribute__((unused))) { + if (frame->hd.type != NGHTTP2_HEADERS || + frame->headers.cat != NGHTTP2_HCAT_REQUEST) { + return 0; + } + + http2_stream_data_t *stream = + nghttp2_session_get_stream_user_data(session, frame->hd.stream_id); + if (!stream) { + return 0; + } + + /* 收集伪头和普通头 */ + if (namelen == 5 && memcmp(":path", name, 5) == 0) { + /* 解析路径（可能包含 query string） */ + size_t path_len = valuelen; + for (size_t i = 0; i < valuelen; i++) { + if (value[i] == '?') { + path_len = i; + break; + } + } + if (path_len > 0) { + size_t copy_len = path_len < sizeof(stream->request.path) - 1 + ? path_len + : sizeof(stream->request.path) - 1; + memcpy(stream->request.path, value, copy_len); + stream->request.path[copy_len] = '\0'; + } else { + stream->request.path[0] = '/'; + stream->request.path[1] = '\0'; + } + } else if (namelen == 7 && memcmp(":method", name, 7) == 0) { + if (valuelen == 3 && memcmp("GET", value, 3) == 0) { + stream->request.method = HTTP_GET; + } else if (valuelen == 4 && memcmp("HEAD", value, 4) == 0) { + stream->request.method = HTTP_HEAD; + } else if (valuelen == 4 && memcmp("POST", value, 4) == 0) { + stream->request.method = HTTP_POST; + } else { + stream->request.method = HTTP_UNKNOWN; + } + } else if (namelen == 7 && memcmp(":scheme", name, 7) == 0) { + /* 忽略 scheme */ + } else if (namelen == 10 && memcmp(":authority", name, 10) == 0) { + /* 忽略 authority，host 可以从 path 推断 */ + } else { + /* 普通头字段 */ + if (stream->request.num_headers < HTTP_MAX_HEADERS) { + int idx = stream->request.num_headers; + memcpy(stream->request.headers[idx].name, name, + namelen < sizeof(stream->request.headers[idx].name) - 1 ? namelen : sizeof(stream->request.headers[idx].name) - 1); + memcpy(stream->request.headers[idx].value, value, + valuelen < sizeof(stream->request.headers[idx].value) - 1 ? valuelen : sizeof(stream->request.headers[idx].value) - 1); + stream->request.num_headers++; + + /* 设置缓存相关标志 */ + if (namelen == 13 && memcmp("if-none-match", name, 13) == 0) { + stream->request.has_if_none_match = true; + size_t copy_len = valuelen < sizeof(stream->request.if_none_match) - 1 + ? valuelen : sizeof(stream->request.if_none_match) - 1; + memcpy(stream->request.if_none_match, value, copy_len); + stream->request.if_none_match[copy_len] = '\0'; + } else if (namelen == 17 && memcmp("if-modified-since", name, 17) == 0) { + stream->request.has_if_modified_since = true; + size_t copy_len = valuelen < sizeof(stream->request.if_modified_since) - 1 + ? valuelen : sizeof(stream->request.if_modified_since) - 1; + memcpy(stream->request.if_modified_since, value, copy_len); + stream->request.if_modified_since[copy_len] = '\0'; + } + } + } + + return 0; +} + +/** + * on_frame_recv_callback - 帧接收完成回调 + * + * 当收到 END_STREAM 标志时，标记请求完整并触发静态文件服务。 + * + * @param session nghttp2 会话 + * @param frame 当前帧 + * @param user_data 会话指针 + * @return 0 成功 + */ +static int on_frame_recv_callback(nghttp2_session *session, + const nghttp2_frame *frame, void *user_data) { + http2_session_t *h2 = (http2_session_t *)user_data; + + switch (frame->hd.type) { + case NGHTTP2_DATA: + case NGHTTP2_HEADERS: + /* 检查请求是否完整（END_STREAM） */ + if (frame->hd.flags & NGHTTP2_FLAG_END_STREAM) { + http2_stream_data_t *stream = + nghttp2_session_get_stream_user_data(session, frame->hd.stream_id); + if (!stream) { + return 0; + } + stream->request_complete = true; + + /* 处理静态文件请求 */ + http2_serve_static(h2, stream); + http2_send_pending(h2); + } + break; + default: + break; + } + + return 0; +} + +/** + * on_stream_close_callback - 流关闭回调 + * + * 从链表移除流，释放资源（关闭文件、释放 body、释放请求）。 + * + * @param session nghttp2 会话（未使用） + * @param stream_id 流 ID + * @param error_code 错误码（未使用） + * @param user_data 会话指针 + * @return 0 成功 + */ +static int on_stream_close_callback(nghttp2_session *session __attribute__((unused)), + int32_t stream_id, uint32_t error_code __attribute__((unused)), + void *user_data) { + http2_session_t *h2 = (http2_session_t *)user_data; + + /* 从链表中移除并释放 */ + http2_stream_data_t **pp = &h2->streams; + while (*pp) { + if ((*pp)->stream_id == stream_id) { + http2_stream_data_t *to_free = *pp; + *pp = to_free->next; + + if (to_free->file_fd >= 0) { + close(to_free->file_fd); + } + free(to_free->response_body); + http_request_free(&to_free->request); + free(to_free); + return 0; + } + pp = &(*pp)->next; + } + + return 0; +} + +/** + * on_data_chunk_recv_callback - DATA 帧数据块接收回调 + * + * 目前为占位实现，TODO：将请求体数据追加到流缓冲区。 + * + * @param session nghttp2 会话（未使用） + * @param flags 标志（未使用） + * @param stream_id 流 ID + * @param data 数据指针 + * @param len 数据长度 + * @param user_data 未使用 + * @return 0 成功 + */ +static int on_data_chunk_recv_callback(nghttp2_session *session __attribute__((unused)), + uint8_t flags __attribute__((unused)), + int32_t stream_id, const uint8_t *data, + size_t len, void *user_data __attribute__((unused))) { + http2_stream_data_t *stream = + nghttp2_session_get_stream_user_data(session, stream_id); + if (!stream) { + return 0; + } + + /* TODO: 将数据追加到请求体缓冲区 */ + (void)data; + (void)len; + + return 0; +} + +/* ===================== HTTP/2 静态文件服务 ===================== */ + +/** + * format_http_time - 格式化 HTTP 时间字符串 + * + * 将 time_t 转换为 "Mon, 01 Jan 2000 00:00:00 GMT" 格式。 + * + * @param t 时间戳 + * @param buf 输出缓冲区 + * @param buf_size 缓冲区大小 + */ +static void format_http_time(time_t t, char *buf, size_t buf_size) { + struct tm *gmt = gmtime(&t); + if (gmt) { + strftime(buf, buf_size, "%a, %d %b %Y %H:%M:%S GMT", gmt); + } else { + buf[0] = '\0'; + } +} + +/** + * generate_etag - 生成 ETag 字符串 + * + * 根据文件大小和修改时间生成强 ETag。 + * + * @param st 文件状态结构 + * @param buf 输出缓冲区 + * @param buf_size 缓冲区大小 + */ +static void generate_etag(const struct stat *st, char *buf, size_t buf_size) { + snprintf(buf, buf_size, "\"%lx-%lx\"", (unsigned long)st->st_size, (unsigned long)st->st_mtime); +} + +/** + * parse_http_time - 解析 HTTP 时间字符串 + * + * 支持三种格式：RFC 1123、RFC 850、ANSI C's asctime()。 + * + * @param str 时间字符串 + * @return 解析后的时间戳，-1 失败 + */ +static time_t parse_http_time(const char *str) { + struct tm tm = {0}; + if (strptime(str, "%a, %d %b %Y %H:%M:%S GMT", &tm) != NULL || + strptime(str, "%A, %d-%b-%y %H:%M:%S GMT", &tm) != NULL || + strptime(str, "%a %b %d %H:%M:%S %Y", &tm) != NULL) { + return timegm(&tm); + } + return -1; +} + +/** + * match_etag - 匹配 ETag + * + * 支持 "*" 通配符和弱验证器（W/ 前缀）。 + * + * @param etag 服务器 ETag + * @param if_none_match 客户端 If-None-Match 头值 + * @return true 匹配 + */ +static bool match_etag(const char *etag, const char *if_none_match) { + if (!etag || !if_none_match) return false; + if (strcmp(if_none_match, "*") == 0) return true; + const char *client = if_none_match; + if (strncmp(client, "W/", 2) == 0) client += 2; + return strcmp(client, etag) == 0; +} + +/** + * http2_data_source_read_callback - nghttp2 数据读取回调 + * + * 从流的 response_body 缓冲区读取数据，供 nghttp2 发送 DATA 帧。 + * 数据发完后设置 EOF 标志。 + * + * @param session nghttp2 会话（未使用） + * @param stream_id 流 ID（未使用） + * @param buf 输出缓冲区 + * @param length 最大读取长度 + * @param data_flags 输出标志（设置 EOF） + * @param source 数据源（含 stream 指针） + * @param user_data 未使用 + * @return 读取字节数 + */ +static ssize_t http2_data_source_read_callback( + nghttp2_session *session __attribute__((unused)), + int32_t stream_id __attribute__((unused)), + uint8_t *buf, size_t length, + uint32_t *data_flags, + nghttp2_data_source *source, + void *user_data __attribute__((unused))) { + + http2_stream_data_t *stream = (http2_stream_data_t *)source->ptr; + if (!stream || !stream->response_body) { + *data_flags |= NGHTTP2_DATA_FLAG_EOF; + return 0; + } + + size_t remaining = stream->response_len - stream->response_sent; + if (remaining == 0) { + *data_flags |= NGHTTP2_DATA_FLAG_EOF; + return 0; + } + + size_t to_send = length < remaining ? length : remaining; + memcpy(buf, stream->response_body + stream->response_sent, to_send); + stream->response_sent += to_send; + + if (stream->response_sent >= stream->response_len) { + *data_flags |= NGHTTP2_DATA_FLAG_EOF; + } + return (ssize_t)to_send; +} + +/** + * http2_serve_directory - 生成 HTTP/2 目录浏览页面 + * + * 读取目录内容，生成 HTML 列表，通过 nghttp2 发送响应。 + * 支持文件大小格式化、修改时间显示、HTML 转义、上级目录链接。 + * + * @param h2 会话指针 + * @param stream 流数据 + * @param real_path 真实目录路径 + * @param request_path 请求路径（用于显示） + * @return true 成功处理，false 不是目录或出错 + */ +static bool http2_serve_directory(http2_session_t *h2, http2_stream_data_t *stream, + const char *real_path, const char *request_path) { + struct stat st; + if (stat(real_path, &st) != 0 || !S_ISDIR(st.st_mode)) { + return false; + } + + DIR *dir = opendir(real_path); + if (!dir) { + nghttp2_nv hdrs[] = { + {(uint8_t *)":status", (uint8_t *)"403", 7, 3, 0}}; + nghttp2_submit_response(h2->session, stream->stream_id, hdrs, 1, NULL); + return true; + } + + /* 收集所有目录项 */ + struct dirent *entry; + char *entries[4096]; + int num_entries = 0; + while ((entry = readdir(dir)) != NULL && num_entries < 4096) { + if (entry->d_name[0] == '.') continue; + entries[num_entries] = strdup(entry->d_name); + num_entries++; + } + closedir(dir); + + /* 构建 HTML */ + char *html = (char *)malloc(65536); + if (!html) { + for (int i = 0; i < num_entries; i++) free(entries[i]); + nghttp2_nv hdrs[] = { + {(uint8_t *)":status", (uint8_t *)"500", 7, 3, 0}}; + nghttp2_submit_response(h2->session, stream->stream_id, hdrs, 1, NULL); + return true; + } + + int n = snprintf(html, 65536, + "\n" + "\n" + "\n" + "Index of %s\n" + "\n" + "\n" + "

Index of %s

\n" + "\n" + "\n", + request_path, request_path); + + /* 添加返回上级链接 */ + if (strcmp(request_path, "/") != 0) { + n += snprintf(html + n, 65536 - n, + "\n"); + } + + /* HTML 转义辅助 */ + auto void html_escape(const char *src, char *dst, size_t dst_size) { + size_t j = 0; + for (size_t i = 0; src[i] && j < dst_size - 1; i++) { + switch (src[i]) { + case '&': + if (j + 5 < dst_size) { memcpy(dst + j, "&", 5); j += 5; } + break; + case '<': + if (j + 4 < dst_size) { memcpy(dst + j, "<", 4); j += 4; } + break; + case '>': + if (j + 4 < dst_size) { memcpy(dst + j, ">", 4); j += 4; } + break; + case '"': + if (j + 6 < dst_size) { memcpy(dst + j, """, 6); j += 6; } + break; + default: + dst[j++] = src[i]; + } + } + dst[j] = '\0'; + } + + /* 添加目录项 */ + for (int i = 0; i < num_entries; i++) { + char full_path[4096]; + snprintf(full_path, sizeof(full_path), "%s/%s", real_path, entries[i]); + + struct stat entry_st; + char size_str[32] = "-"; + char mtime_str[32] = "-"; + + if (stat(full_path, &entry_st) == 0) { + if (S_ISDIR(entry_st.st_mode)) { + strncpy(size_str, "-", sizeof(size_str)); + } else if (entry_st.st_size < 1024) { + snprintf(size_str, sizeof(size_str), "%ld B", (long)entry_st.st_size); + } else if (entry_st.st_size < 1024 * 1024) { + snprintf(size_str, sizeof(size_str), "%.1f KB", entry_st.st_size / 1024.0); + } else if (entry_st.st_size < 1024 * 1024 * 1024) { + snprintf(size_str, sizeof(size_str), "%.1f MB", entry_st.st_size / (1024.0 * 1024)); + } else { + snprintf(size_str, sizeof(size_str), "%.1f GB", entry_st.st_size / (1024.0 * 1024 * 1024)); + } + + struct tm *tm_info = localtime(&entry_st.st_mtime); + if (tm_info) { + strftime(mtime_str, sizeof(mtime_str), "%Y-%m-%d %H:%M", tm_info); + } + } + + char escaped_name[512]; + html_escape(entries[i], escaped_name, sizeof(escaped_name)); + + n += snprintf(html + n, 65536 - n, + "\n", + escaped_name, + S_ISDIR(entry_st.st_mode) ? "/" : "", + escaped_name, + S_ISDIR(entry_st.st_mode) ? "/" : "", + size_str, mtime_str); + + free(entries[i]); + } + + n += snprintf(html + n, 65536 - n, + "
NameSizeModified
../--
%s%s%s%s
\n" + "
\n" + "

Cocoon Server

\n" + "\n"); + + /* 存储响应并发送 */ + stream->response_body = html; + stream->response_len = (size_t)n; + stream->response_sent = 0; + + nghttp2_nv hdrs[8]; + int num_hdrs = 0; + + hdrs[num_hdrs++] = (nghttp2_nv){ + (uint8_t *)":status", (uint8_t *)"200", 7, 3, 0}; + + hdrs[num_hdrs++] = (nghttp2_nv){ + (uint8_t *)"content-type", (uint8_t *)"text/html; charset=utf-8", 12, 24, 0}; + + char content_length_str[32]; + snprintf(content_length_str, sizeof(content_length_str), "%d", n); + hdrs[num_hdrs++] = (nghttp2_nv){ + (uint8_t *)"content-length", (uint8_t *)content_length_str, 14, strlen(content_length_str), 0}; + + hdrs[num_hdrs++] = (nghttp2_nv){ + (uint8_t *)"server", (uint8_t *)"Cocoon/1.0", 6, 10, 0}; + + if (stream->request.method == HTTP_HEAD) { + free(stream->response_body); + stream->response_body = NULL; + stream->response_len = 0; + nghttp2_submit_response(h2->session, stream->stream_id, hdrs, num_hdrs, NULL); + } else { + nghttp2_data_provider provider; + provider.source.ptr = stream; + provider.read_callback = http2_data_source_read_callback; + nghttp2_submit_response(h2->session, stream->stream_id, hdrs, num_hdrs, &provider); + } + + return true; +} + +/** + * http2_serve_static - 处理 HTTP/2 静态文件请求 + * + * 路径安全检查、目录处理（index.html 或目录浏览）、缓存协商（304）、 + * 文件读取、压缩（brotli/gzip）、响应构建。 + * 支持 HEAD 请求（不发送 body）。 + * + * @param h2 会话指针 + * @param stream 流数据（含请求信息） + */ +static void http2_serve_static(http2_session_t *h2, http2_stream_data_t *stream) { + if (!h2->root_dir) { + nghttp2_nv hdrs[] = { + {(uint8_t *)":status", (uint8_t *)"503", 7, 3, 0}}; + nghttp2_submit_response(h2->session, stream->stream_id, hdrs, 1, NULL); + return; + } + + /* 构建真实路径 */ + char real_path[4096]; + char root_normalized[4096]; + + if (!realpath(h2->root_dir, root_normalized)) { + snprintf(root_normalized, sizeof(root_normalized), "%s", h2->root_dir); + } + + int n = snprintf(real_path, sizeof(real_path), "%s%s", root_normalized, stream->request.path); + if (n < 0 || (size_t)n >= sizeof(real_path)) { + nghttp2_nv hdrs[] = { + {(uint8_t *)":status", (uint8_t *)"400", 7, 3, 0}}; + nghttp2_submit_response(h2->session, stream->stream_id, hdrs, 1, NULL); + return; + } + + /* 路径遍历检查 */ + if (strstr(stream->request.path, "..") != NULL) { + char resolved[4096]; + if (!realpath(real_path, resolved) || + strncmp(resolved, root_normalized, strlen(root_normalized)) != 0) { + nghttp2_nv hdrs[] = { + {(uint8_t *)":status", (uint8_t *)"403", 7, 3, 0}}; + nghttp2_submit_response(h2->session, stream->stream_id, hdrs, 1, NULL); + return; + } + snprintf(real_path, sizeof(real_path), "%s", resolved); + } + + struct stat st; + if (stat(real_path, &st) != 0) { + nghttp2_nv hdrs[] = { + {(uint8_t *)":status", (uint8_t *)"404", 7, 3, 0}}; + nghttp2_submit_response(h2->session, stream->stream_id, hdrs, 1, NULL); + return; + } + + /* 目录：尝试 index.html，否则生成目录列表 */ + if (S_ISDIR(st.st_mode)) { + char index_path[4096]; + size_t real_len = strlen(real_path); + if (real_len + 12 < sizeof(index_path)) { + snprintf(index_path, sizeof(index_path), "%s/index.html", real_path); + struct stat index_st; + if (stat(index_path, &index_st) == 0 && S_ISREG(index_st.st_mode)) { + snprintf(real_path, sizeof(real_path), "%s", index_path); + stat(real_path, &st); + } else { + /* 生成目录浏览页面 */ + if (http2_serve_directory(h2, stream, real_path, stream->request.path)) { + return; + } + } + } else { + if (http2_serve_directory(h2, stream, real_path, stream->request.path)) { + return; + } + } + } + + if (!S_ISREG(st.st_mode)) { + nghttp2_nv hdrs[] = { + {(uint8_t *)":status", (uint8_t *)"403", 7, 3, 0}}; + nghttp2_submit_response(h2->session, stream->stream_id, hdrs, 1, NULL); + return; + } + + /* 生成 ETag 和 Last-Modified */ + char etag[64]; + char last_modified[64]; + generate_etag(&st, etag, sizeof(etag)); + format_http_time(st.st_mtime, last_modified, sizeof(last_modified)); + + /* 检查 If-None-Match */ + if (stream->request.has_if_none_match && match_etag(etag, stream->request.if_none_match)) { + nghttp2_nv hdrs[] = { + {(uint8_t *)":status", (uint8_t *)"304", 7, 3, 0}, + {(uint8_t *)"etag", (uint8_t *)etag, 4, strlen(etag), 0}, + {(uint8_t *)"last-modified", (uint8_t *)last_modified, 13, strlen(last_modified), 0}, + }; + nghttp2_submit_response(h2->session, stream->stream_id, hdrs, 3, NULL); + return; + } + + /* 检查 If-Modified-Since */ + if (stream->request.has_if_modified_since) { + time_t client_time = parse_http_time(stream->request.if_modified_since); + if (client_time >= 0 && st.st_mtime <= client_time) { + nghttp2_nv hdrs[] = { + {(uint8_t *)":status", (uint8_t *)"304", 7, 3, 0}, + {(uint8_t *)"etag", (uint8_t *)etag, 4, strlen(etag), 0}, + {(uint8_t *)"last-modified", (uint8_t *)last_modified, 13, strlen(last_modified), 0}, + }; + nghttp2_submit_response(h2->session, stream->stream_id, hdrs, 3, NULL); + return; + } + } + + /* 打开文件 */ + int file_fd = open(real_path, O_RDONLY); + if (file_fd < 0) { + nghttp2_nv hdrs[] = { + {(uint8_t *)":status", (uint8_t *)"403", 7, 3, 0}}; + nghttp2_submit_response(h2->session, stream->stream_id, hdrs, 1, NULL); + return; + } + + /* 读取文件内容到内存 */ + int64_t file_size = st.st_size; + char *file_buf = (char *)malloc((size_t)file_size); + if (!file_buf) { + close(file_fd); + nghttp2_nv hdrs[] = { + {(uint8_t *)":status", (uint8_t *)"500", 7, 3, 0}}; + nghttp2_submit_response(h2->session, stream->stream_id, hdrs, 1, NULL); + return; + } + + ssize_t read_total = 0; + while (read_total < file_size) { + ssize_t n = read(file_fd, file_buf + read_total, (size_t)(file_size - read_total)); + if (n <= 0) break; + read_total += n; + } + close(file_fd); + + if (read_total != file_size) { + free(file_buf); + nghttp2_nv hdrs[] = { + {(uint8_t *)":status", (uint8_t *)"500", 7, 3, 0}}; + nghttp2_submit_response(h2->session, stream->stream_id, hdrs, 1, NULL); + return; + } + + /* 判断是否需要压缩 */ + bool use_gzip = false; + bool use_brotli = false; + const char *mime = http_mime_type(real_path); + + if (stream->request.method != HTTP_HEAD && is_compressible_mime(mime) && file_size > 256) { + char *compress_buf = (char *)malloc((size_t)file_size); + if (compress_buf) { + if (h2->brotli_enabled) { + ssize_t cl = brotli_compress(file_buf, (size_t)file_size, compress_buf, (size_t)file_size); + if (cl > 0) { + free(file_buf); + file_buf = compress_buf; + file_size = cl; + use_brotli = true; + } else { + free(compress_buf); + } + } else if (h2->gzip_enabled) { + ssize_t cl = gzip_compress(file_buf, (size_t)file_size, compress_buf, (size_t)file_size); + if (cl > 0) { + free(file_buf); + file_buf = compress_buf; + file_size = cl; + use_gzip = true; + } else { + free(compress_buf); + } + } else { + free(compress_buf); + } + } + } + + /* 存储到流 */ + stream->response_body = file_buf; + stream->response_len = (size_t)file_size; + stream->response_sent = 0; + + /* 构建响应头 */ + nghttp2_nv hdrs[16]; + int num_hdrs = 0; + + hdrs[num_hdrs++] = (nghttp2_nv){ + (uint8_t *)":status", (uint8_t *)"200", 7, 3, 0}; + + hdrs[num_hdrs++] = (nghttp2_nv){ + (uint8_t *)"content-type", (uint8_t *)mime, 12, strlen(mime), 0}; + + char content_length_str[32]; + snprintf(content_length_str, sizeof(content_length_str), "%ld", (long)file_size); + hdrs[num_hdrs++] = (nghttp2_nv){ + (uint8_t *)"content-length", (uint8_t *)content_length_str, 14, strlen(content_length_str), 0}; + + if (use_brotli) { + hdrs[num_hdrs++] = (nghttp2_nv){ + (uint8_t *)"content-encoding", (uint8_t *)"br", 16, 2, 0}; + } else if (use_gzip) { + hdrs[num_hdrs++] = (nghttp2_nv){ + (uint8_t *)"content-encoding", (uint8_t *)"gzip", 16, 4, 0}; + } + + hdrs[num_hdrs++] = (nghttp2_nv){ + (uint8_t *)"etag", (uint8_t *)etag, 4, strlen(etag), 0}; + + hdrs[num_hdrs++] = (nghttp2_nv){ + (uint8_t *)"last-modified", (uint8_t *)last_modified, 13, strlen(last_modified), 0}; + + hdrs[num_hdrs++] = (nghttp2_nv){ + (uint8_t *)"server", (uint8_t *)"Cocoon/1.0", 6, 10, 0}; + + /* HEAD 请求：不发送 body */ + if (stream->request.method == HTTP_HEAD) { + free(stream->response_body); + stream->response_body = NULL; + stream->response_len = 0; + nghttp2_submit_response(h2->session, stream->stream_id, hdrs, num_hdrs, NULL); + } else { + nghttp2_data_provider provider; + provider.source.ptr = stream; + provider.read_callback = http2_data_source_read_callback; + nghttp2_submit_response(h2->session, stream->stream_id, hdrs, num_hdrs, &provider); + } +} + +/* ===================== 连接处理 ===================== */ + +/** + * http2_on_connection_accepted - 新连接接入时初始化 HTTP/2 + * + * TLS 模式：直接创建 HTTP/2 会话并发送前言。 + * 明文模式：返回 0，由 server.c 在读取前几个字节后检测 PRI 魔术字。 + * + * @param fd 客户端 socket + * @param tls_mode 是否为 TLS 模式 + * @return 0 成功，-1 失败 + */ +int http2_on_connection_accepted(int fd, bool tls_mode) { + /* 检查是否应启用 HTTP/2 */ + if (!tls_mode) { + /* 明文模式：需要读取客户端魔术字 "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n" */ + /* 这由 server.c 在读取前几个字节时检测 */ + return 0; + } + + /* TLS 模式：ALPN 已协商为 h2 */ + http2_session_t *h2 = http2_session_create(fd, true); + if (!h2) { + return -1; + } + + /* 发送服务器连接前言 */ + if (http2_send_pending(h2) != 0) { + http2_session_destroy(h2); + return -1; + } + + return 0; +} diff --git a/http2.h b/http2.h new file mode 100644 index 0000000..4a950b5 --- /dev/null +++ b/http2.h @@ -0,0 +1,175 @@ +/** + * http2.h - HTTP/2 支持头文件 + * + * 使用 nghttp2 库实现 HTTP/2 协议支持。 + * 支持 TLS ALPN 协商和明文 h2c 升级。 + * + * @author xfy + */ + +#ifndef COCOON_HTTP2_H +#define COCOON_HTTP2_H + +#include "cocoon.h" +#include "http.h" +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * http2_session_t - HTTP/2 会话状态 + * + * 每个启用了 HTTP/2 的连接拥有一个此结构体。 + */ +typedef struct { + nghttp2_session *session; /**< nghttp2 会话对象 */ + int fd; /**< 底层 socket fd */ + bool tls_mode; /**< 是否通过 TLS ALPN 协商 */ + struct http2_stream_data *streams; /**< 活跃的流列表（头节点） */ + const char *root_dir; /**< 静态资源根目录 */ + bool gzip_enabled; /**< 是否启用 gzip 压缩 */ + bool brotli_enabled; /**< 是否启用 brotli 压缩 */ +} http2_session_t; + +/** + * http2_stream_data - HTTP/2 流级数据 + * + * 每个请求流对应一个此结构体。 + */ +typedef struct http2_stream_data { + struct http2_stream_data *next; + int32_t stream_id; /**< HTTP/2 流 ID */ + http_request_t request; /**< 解析后的 HTTP 请求 */ + bool request_complete; /**< 请求是否接收完整 */ + int file_fd; /**< 响应文件 fd（-1 表示无） */ + char *response_body; /**< 响应体（用于动态内容） */ + size_t response_len; /**< 响应体长度 */ + size_t response_sent; /**< 已发送的响应体字节数 */ +} http2_stream_data_t; + +/** + * http2_init - 初始化 HTTP/2 全局状态 + * + * 应在服务器启动前调用一次。 + * + * @return 0 成功，-1 失败 + */ +int http2_init(void); + +/** + * http2_cleanup - 清理 HTTP/2 全局状态 + */ +void http2_cleanup(void); + +/** + * http2_session_create - 为连接创建 HTTP/2 会话 + * + * @param fd socket 文件描述符 + * @param tls_mode 是否通过 TLS ALPN 协商（true=TLS，false=h2c） + * @return 新会话对象，失败返回 NULL + */ +http2_session_t *http2_session_create(int fd, bool tls_mode); + +/** + * http2_session_destroy - 销毁 HTTP/2 会话 + * + * @param h2 会话对象 + */ +void http2_session_destroy(http2_session_t *h2); + +/** + * http2_session_is_http2 - 判断连接是否已升级为 HTTP/2 + * + * @param fd socket 文件描述符 + * @return true 是 HTTP/2 连接 + */ +bool http2_session_is_http2(int fd); + +/** + * http2_session_get - 获取 fd 对应的 HTTP/2 会话 + * + * @param fd socket 文件描述符 + * @return 会话对象，NULL 表示非 HTTP/2 连接 + */ +http2_session_t *http2_session_get(int fd); + +/** + * http2_recv - 接收并处理客户端数据 + * + * 将读取的数据喂给 nghttp2 库，触发回调处理请求。 + * + * @param h2 会话对象 + * @param buf 接收缓冲区 + * @param len 数据长度 + * @return 0 成功，-1 错误（应关闭连接） + */ +int http2_recv(http2_session_t *h2, const uint8_t *buf, size_t len); + +/** + * http2_send_pending - 发送挂起的 HTTP/2 帧 + * + * 应在 socket 可写时调用。 + * + * @param h2 会话对象 + * @return 0 成功，-1 错误 + */ +int http2_send_pending(http2_session_t *h2); + +/** + * http2_want_read - 检查 nghttp2 是否还需要读取数据 + * + * @param h2 会话对象 + * @return true 需要继续读取 + */ +bool http2_want_read(http2_session_t *h2); + +/** + * http2_want_write - 检查 nghttp2 是否还需要写入数据 + * + * @param h2 会话对象 + * @return true 需要继续写入 + */ +bool http2_want_write(http2_session_t *h2); + +/** + * http2_on_connection_accepted - 新连接接受后的处理 + * + * 对于 TLS 连接，在 TLS 握手完成后调用； + * 对于明文连接，在读取到客户端魔术字后调用。 + * + * @param fd socket 文件描述符 + * @param tls_mode 是否通过 TLS ALPN 协商 + * @return 0 成功，-1 失败（应关闭连接） + */ +int http2_on_connection_accepted(int fd, bool tls_mode); + +/** + * http2_session_upgrade - 处理 h2c 升级请求 + * + * 注册升级流（stream_id=1）并提交静态文件响应。 + * 调用前应先创建会话并发送服务器 SETTINGS 前言。 + * + * @param h2 HTTP/2 会话 + * @param req HTTP/1.1 升级请求（会被复制） + * @return 0 成功，-1 失败 + */ +int http2_session_upgrade(http2_session_t *h2, const http_request_t *req); + +/** + * + * @param h2 会话对象 + * @param root_dir 静态资源根目录 + * @param gzip_enabled 是否启用 gzip + * @param brotli_enabled 是否启用 brotli + */ +void http2_session_set_context(http2_session_t *h2, const char *root_dir, bool gzip_enabled, bool brotli_enabled); + +#ifdef __cplusplus +} +#endif + +#endif /* COCOON_HTTP2_H */ diff --git a/main.c b/main.c index 8b75d57..3e4a08a 100644 --- a/main.c +++ b/main.c @@ -10,6 +10,7 @@ #include "server.h" #include "config.h" #include "platform.h" +#include "access_log.h" #include #include #include @@ -51,8 +52,11 @@ static void print_usage(const char *prog) { printf(" -o 连接空闲超时毫秒（默认 30000）\n"); printf(" -l 日志级别: error, warn, info, debug（默认 info）\n"); printf(" -v 详细日志输出（等同于 -l debug）\n"); + printf(" --cert TLS 证书路径（启用 HTTPS）\n"); + printf(" --key TLS 私钥路径\n"); + printf(" --tls 显式启用 TLS（需同时指定 --cert 和 --key）\n"); printf(" --no-gzip 禁用 gzip 压缩\n"); - printf(" --no-brotli 禁用 brotli 压缩\n"); + printf(" --access-log 访问日志文件路径（- 表示 stdout）\n"); printf(" -h 显示此帮助\n"); printf("\nExample:\n"); printf(" %s -c cocoon.json\n", prog); @@ -82,6 +86,10 @@ static bool parse_args(int argc, char *argv[], cocoon_config_t *config) { config->gzip_enabled = true; config->brotli_enabled = true; + config->tls_cert = NULL; + config->tls_key = NULL; + config->tls_enabled = false; + bool has_root_dir = false; bool has_port = false; bool has_workers = false; @@ -90,6 +98,10 @@ static bool parse_args(int argc, char *argv[], cocoon_config_t *config) { bool has_log_level = false; bool has_gzip_enabled = false; bool has_brotli_enabled = false; + bool has_tls_cert = false; + bool has_tls_key = false; + bool has_tls_enabled = false; + bool has_access_log = false; const char *config_file = NULL; for (int i = 1; i < argc; i++) { @@ -139,6 +151,21 @@ static bool parse_args(int argc, char *argv[], cocoon_config_t *config) { } else if (strcmp(argv[i], "--no-brotli") == 0) { config->brotli_enabled = false; has_brotli_enabled = true; + } else if (strcmp(argv[i], "--cert") == 0) { + if (++i >= argc) return false; + config->tls_cert = strdup(argv[i]); + has_tls_cert = true; + } else if (strcmp(argv[i], "--key") == 0) { + if (++i >= argc) return false; + config->tls_key = strdup(argv[i]); + has_tls_key = true; + } else if (strcmp(argv[i], "--tls") == 0) { + config->tls_enabled = true; + has_tls_enabled = true; + } else if (strcmp(argv[i], "--access-log") == 0) { + if (++i >= argc) return false; + config->access_log_path = strdup(argv[i]); + has_access_log = true; } else if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) { print_usage(argv[0]); exit(0); @@ -156,7 +183,10 @@ static bool parse_args(int argc, char *argv[], cocoon_config_t *config) { } /* 用命令行参数覆盖配置文件 */ config_merge(config, config, has_root_dir, has_port, has_workers, - has_max_conn, has_timeout, has_log_level, has_gzip_enabled, has_brotli_enabled); + has_max_conn, has_timeout, has_log_level, + has_gzip_enabled, has_brotli_enabled, + has_tls_cert, has_tls_key, has_tls_enabled, + has_access_log); } if (!config->root_dir) { @@ -196,6 +226,11 @@ int main(int argc, char *argv[]) { /* 设置日志级别 */ log_set_level(config.log_level); + /* 初始化访问日志 */ + if (config.access_log_path) { + access_log_init(config.access_log_path); + } + /* 创建服务器 */ g_ctx = server_create(&config); if (!g_ctx) { @@ -213,11 +248,14 @@ int main(int argc, char *argv[]) { /* 释放 socket 子系统（Windows 下 WSACleanup） */ cocoon_socket_cleanup(); - /* 释放配置文件分配的 root_dir */ - if (config.root_dir) { - free((void *)config.root_dir); - config.root_dir = NULL; - } + /* 关闭访问日志 */ + access_log_close(); + + /* 释放配置文件分配的内存 */ + if (config.root_dir) free((void *)config.root_dir); + if (config.tls_cert) free((void *)config.tls_cert); + if (config.tls_key) free((void *)config.tls_key); + if (config.access_log_path) free((void *)config.access_log_path); return ret == COCOON_OK ? 0 : 1; } diff --git a/platform.c b/platform.c index ec91516..d686e9c 100644 --- a/platform.c +++ b/platform.c @@ -14,10 +14,20 @@ #include #include #include +#include +#include /* ========== POSIX 实现 ========== */ #ifdef COCOON_PLATFORM_POSIX +#include /* O_NONBLOCK */ +#include /* close, read, write, lseek, dup2 */ +#include /* opendir, readdir, closedir */ +#include /* errno, EAGAIN, EINTR */ +#include /* sendfile */ +#include /* sigaction */ +#include /* send */ + /** * POSIX socket 子系统无需显式初始化。 */ diff --git a/server.c b/server.c index 87471af..7a59537 100644 --- a/server.c +++ b/server.c @@ -21,11 +21,16 @@ #include "cocoon.h" #include "log.h" #include "multipart.h" +#include "tls.h" +#include "http2.h" +#include "access_log.h" +#include "websocket.h" #include "platform.h" #include #include #include #include +#include #include "coco.h" @@ -37,7 +42,7 @@ /** * connection_t - 单个客户端连接上下文 * - * 包含 socket fd、接收缓冲区、解析状态、超时管理。 + * 包含 socket fd、接收缓冲区、解析状态、超时管理、客户端地址、响应状态。 */ typedef struct { cocoon_socket_t fd; /**< 客户端 socket */ @@ -51,6 +56,9 @@ typedef struct { coco_coro_t *coro; /**< 当前处理协程 */ bool gzip_enabled; /**< 是否启用 gzip 压缩 */ bool brotli_enabled; /**< 是否启用 brotli 压缩 */ + struct sockaddr_storage client_addr; /**< 客户端地址 */ + socklen_t addr_len; /**< 地址长度 */ + int response_status; /**< 最后响应的 HTTP 状态码 */ } connection_t; struct server_context { cocoon_socket_t listen_fd; /**< 监听 socket */ @@ -80,6 +88,7 @@ static void set_nonblocking(cocoon_socket_t fd) { */ static void close_connection(connection_t *conn) { if (conn && conn->fd != COCOON_INVALID_SOCKET) { + tls_close(conn->fd); cocoon_socket_close(conn->fd); conn->fd = COCOON_INVALID_SOCKET; conn->closed = true; @@ -104,8 +113,9 @@ static ssize_t conn_read(connection_t *conn) { ssize_t n; - /* 尝试使用 coco 的异步 I/O */ - if (coco_sched_get_current() != NULL) { + if (tls_has_connection(conn->fd)) { + n = tls_read(conn->fd, conn->buf + conn->buf_len, space); + } else if (coco_sched_get_current() != NULL) { n = coco_read(conn->fd, conn->buf + conn->buf_len, space); } else { /* 无调度器时直接 read */ @@ -156,7 +166,9 @@ static int conn_read_body(connection_t *conn, http_request_t *req, size_t need) /* 从 socket 读取剩余数据 */ while (got < need) { ssize_t n; - if (coco_sched_get_current() != NULL) { + if (tls_has_connection(conn->fd)) { + n = tls_read(conn->fd, req->body + got, need - got); + } else if (coco_sched_get_current() != NULL) { n = coco_read(conn->fd, req->body + got, need - got); } else { n = cocoon_socket_recv(conn->fd, req->body + got, need - got); @@ -322,6 +334,7 @@ static bool handle_post_request(int fd, const http_request_t *req, const char *r * * 从缓冲区解析请求，判断是文件还是目录，调用对应的服务函数。 * 新增：支持 POST 请求体读取和简单回显。 + * 新增：记录响应状态码到访问日志。 * * @param conn 连接上下文 * @param root_dir 静态资源根目录 @@ -337,7 +350,10 @@ static bool handle_request(connection_t *conn, const char *root_dir) { return true; } /* 格式错误 */ + conn->response_status = 400; static_send_error(conn->fd, 400, false); + access_log_write((struct sockaddr *)&conn->client_addr, conn->addr_len, + &req, conn->response_status, -1); return false; } @@ -351,7 +367,11 @@ static bool handle_request(connection_t *conn, const char *root_dir) { if (req.content_length > 0) { size_t need = (size_t)req.content_length; if (conn_read_body(conn, &req, need) != 0) { + conn->response_status = 413; static_send_error(conn->fd, 413, req.keep_alive); /* Payload Too Large */ + access_log_write((struct sockaddr *)&conn->client_addr, conn->addr_len, + &req, conn->response_status, -1); + http_request_free(&req); return req.keep_alive; } } @@ -359,13 +379,19 @@ static bool handle_request(connection_t *conn, const char *root_dir) { /* 处理 POST */ if (req.method == HTTP_POST) { bool keep = handle_post_request(conn->fd, &req, conn->root_dir); + conn->response_status = 200; /* POST 目前总是返回 200 */ + access_log_write((struct sockaddr *)&conn->client_addr, conn->addr_len, + &req, conn->response_status, -1); http_request_free(&req); return keep; } /* 只支持 GET 和 HEAD */ if (req.method != HTTP_GET && req.method != HTTP_HEAD) { + conn->response_status = 405; static_send_error(conn->fd, 405, req.keep_alive); + access_log_write((struct sockaddr *)&conn->client_addr, conn->addr_len, + &req, conn->response_status, -1); http_request_free(&req); return req.keep_alive; } @@ -380,7 +406,10 @@ static bool handle_request(connection_t *conn, const char *root_dir) { int n = snprintf(real_path, sizeof(real_path), "%s%s", root_normalized, req.path); if (n < 0 || (size_t)n >= sizeof(real_path)) { + conn->response_status = 400; static_send_error(conn->fd, 400, req.keep_alive); + access_log_write((struct sockaddr *)&conn->client_addr, conn->addr_len, + &req, conn->response_status, -1); http_request_free(&req); return req.keep_alive; } @@ -390,7 +419,10 @@ static bool handle_request(connection_t *conn, const char *root_dir) { char resolved[4096]; if (!cocoon_realpath(real_path, resolved, sizeof(resolved)) || strncmp(resolved, root_normalized, strlen(root_normalized)) != 0) { + conn->response_status = 403; static_send_error(conn->fd, 403, req.keep_alive); + access_log_write((struct sockaddr *)&conn->client_addr, conn->addr_len, + &req, conn->response_status, -1); http_request_free(&req); return req.keep_alive; } @@ -400,7 +432,10 @@ static bool handle_request(connection_t *conn, const char *root_dir) { /* 判断文件类型 */ cocoon_stat_t st; if (cocoon_file_stat(real_path, &st) != 0) { + conn->response_status = 404; static_send_error(conn->fd, 404, req.keep_alive); + access_log_write((struct sockaddr *)&conn->client_addr, conn->addr_len, + &req, conn->response_status, -1); http_request_free(&req); return req.keep_alive; } @@ -409,7 +444,10 @@ static bool handle_request(connection_t *conn, const char *root_dir) { /* 目录：尝试 index.html */ char index_path[4096]; if (snprintf(index_path, sizeof(index_path), "%s/index.html", real_path) >= (int)sizeof(index_path)) { + conn->response_status = 400; static_send_error(conn->fd, 400, req.keep_alive); + access_log_write((struct sockaddr *)&conn->client_addr, conn->addr_len, + &req, conn->response_status, -1); http_request_free(&req); return req.keep_alive; } @@ -418,22 +456,31 @@ static bool handle_request(connection_t *conn, const char *root_dir) { /* 有 index.html，作为文件服务 */ http_request_t index_req = req; if (snprintf(index_req.path, sizeof(index_req.path), "%s/index.html", req.path) >= (int)sizeof(index_req.path)) { + conn->response_status = 400; static_send_error(conn->fd, 400, req.keep_alive); + access_log_write((struct sockaddr *)&conn->client_addr, conn->addr_len, + &req, conn->response_status, -1); http_request_free(&req); return req.keep_alive; } + conn->response_status = 200; static_serve_file(conn->fd, &index_req, root_dir, conn->gzip_enabled, conn->brotli_enabled); } else { /* 无 index.html，生成目录列表 */ + conn->response_status = 200; static_serve_directory(conn->fd, &req, root_dir, real_path); } } else if (cocoon_stat_isreg(&st)) { /* 普通文件 */ + conn->response_status = 200; static_serve_file(conn->fd, &req, root_dir, conn->gzip_enabled, conn->brotli_enabled); } else { + conn->response_status = 403; static_send_error(conn->fd, 403, req.keep_alive); } + access_log_write((struct sockaddr *)&conn->client_addr, conn->addr_len, + &req, conn->response_status, -1); http_request_free(&req); return req.keep_alive; } @@ -498,36 +545,267 @@ static void conn_cancel_timer(connection_t *conn) { * * @param arg 连接上下文指针（connection_t*） */ +/** + * handle_http2 - 处理 HTTP/2 连接 + * + * 使用 nghttp2 库处理 HTTP/2 帧，服务静态资源。 + * + * @param conn 连接上下文 + */ +static void handle_http2(connection_t *conn) { + http2_session_t *h2 = http2_session_get(conn->fd); + if (!h2) return; + http2_session_set_context(h2, conn->root_dir, conn->gzip_enabled, conn->brotli_enabled); + + uint32_t timeout_ms = conn->timeout_ms > 0 ? conn->timeout_ms : CONN_TIMEOUT_MS; + + while (!conn->closed && http2_want_read(h2)) { + /* 读取数据 */ + char buf[8192]; + ssize_t n; + if (tls_has_connection(conn->fd)) { + n = tls_read(conn->fd, buf, sizeof(buf)); + } else if (coco_sched_get_current() != NULL) { + n = coco_read(conn->fd, buf, sizeof(buf)); + } else { + n = read(conn->fd, buf, sizeof(buf)); + } + + if (n > 0) { + conn_reset_timer(conn, timeout_ms); + if (http2_recv(h2, (const uint8_t *)buf, (size_t)n) != 0) { + log_debug("HTTP/2 接收错误 fd=%d", conn->fd); + break; + } + } else if (n == 0) { + break; /* 对端关闭 */ + } else { + if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) { + continue; + } + break; + } + + /* 发送挂起的帧 */ + if (http2_want_write(h2)) { + if (http2_send_pending(h2) != 0) { + break; + } + } + } + + http2_session_destroy(h2); +} + +/* HTTP/2 h2c 连接前言（24字节） */ +static const char H2C_PREFACE[] = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"; +#define H2C_PREFACE_LEN 24 + +/** + * is_h2c_upgrade_request - 检查是否是 HTTP/1.1 Upgrade: h2c 请求 + * + * @param req HTTP 请求 + * @return true 是 h2c 升级请求 + */ +static bool is_h2c_upgrade_request(const http_request_t *req) { + if (strcmp(req->version, "HTTP/1.1") != 0) return false; + + bool has_upgrade = false; + bool has_connection_upgrade = false; + + for (int i = 0; i < req->num_headers; i++) { + if (strcasecmp(req->headers[i].name, "upgrade") == 0) { + if (strcasestr(req->headers[i].value, "h2c") != NULL) { + has_upgrade = true; + } + } else if (strcasecmp(req->headers[i].name, "connection") == 0) { + if (strcasestr(req->headers[i].value, "upgrade") != NULL) { + has_connection_upgrade = true; + } + } + } + return has_upgrade && has_connection_upgrade; +} + +/** + * is_websocket_upgrade_request - 检查是否是 WebSocket Upgrade 请求 + * + * 检查请求头是否包含 Upgrade: websocket、Connection: Upgrade 和 Sec-WebSocket-Key。 + * + * @param req HTTP 请求 + * @return true 是 WebSocket 升级请求 + */ +static bool is_websocket_upgrade_request(const http_request_t *req) { + if (strcmp(req->version, "HTTP/1.1") != 0) return false; + if (req->method != HTTP_GET) return false; + + bool has_upgrade = false; + bool has_connection_upgrade = false; + const char *key = NULL; + + for (int i = 0; i < req->num_headers; i++) { + if (strcasecmp(req->headers[i].name, "upgrade") == 0) { + if (strcasestr(req->headers[i].value, "websocket") != NULL) { + has_upgrade = true; + } + } else if (strcasecmp(req->headers[i].name, "connection") == 0) { + if (strcasestr(req->headers[i].value, "upgrade") != NULL) { + has_connection_upgrade = true; + } + } else if (strcasecmp(req->headers[i].name, "sec-websocket-key") == 0) { + key = req->headers[i].value; + } + } + return has_upgrade && has_connection_upgrade && key != NULL; +} + +/** + * send_h2c_upgrade_response - 发送 101 Switching Protocols + * + * @param conn 连接上下文 + * @return true 发送成功 + */ +static bool send_h2c_upgrade_response(connection_t *conn) { + const char *resp = + "HTTP/1.1 101 Switching Protocols\r\n" + "Connection: Upgrade\r\n" + "Upgrade: h2c\r\n" + "\r\n"; + return send_all(conn->fd, resp, strlen(resp)) == 0; +} + static void client_handler(void *arg) { connection_t *conn = (connection_t *)arg; if (!conn) return; conn->coro = coco_self(); + log_debug("client_handler 启动 fd=%d", conn->fd); + + log_debug("fd=%d 检查 HTTP/2...", conn->fd); + /* 检查是否是 HTTP/2 连接（TLS ALPN 协商） */ + if (http2_session_is_http2(conn->fd)) { + log_debug("fd=%d 是 HTTP/2 连接", conn->fd); + handle_http2(conn); + conn_cancel_timer(conn); + close_connection(conn); + free(conn); + return; + } + log_debug("fd=%d 不是 HTTP/2", conn->fd); /* 启动空闲定时器 */ + log_debug("fd=%d 创建定时器...", conn->fd); uint32_t timeout_ms = conn->timeout_ms > 0 ? conn->timeout_ms : CONN_TIMEOUT_MS; conn->timer = coco_timer(timeout_ms, conn_timeout_handler, conn); + log_debug("fd=%d 定时器已创建 timer=%p", conn->fd, (void*)conn->timer); while (!conn->closed) { /* 读取数据 */ ssize_t n = conn_read(conn); + log_debug("fd=%d conn_read 返回 %zd", conn->fd, n); if (n < 0) { if (errno == EAGAIN || errno == EWOULDBLOCK) { - /* 数据不足，继续等待 */ + log_debug("fd=%d EAGAIN，继续等待", conn->fd); continue; } /* coco_read 返回负值错误码（如 COCO_ERROR_CANCELLED）或系统错误 */ + log_debug("fd=%d conn_read 错误: %d %s", conn->fd, (int)n, strerror(errno)); break; } if (n == 0) { + log_debug("fd=%d 对端关闭", conn->fd); break; /* 对端关闭 */ } /* 有数据读取，重置定时器 */ conn_reset_timer(conn, timeout_ms); + /* 检查 h2c 直接连接前言 */ + if (conn->buf_len >= H2C_PREFACE_LEN && + memcmp(conn->buf, H2C_PREFACE, H2C_PREFACE_LEN) == 0) { + log_debug("fd=%d 检测到 h2c 直接连接前言", conn->fd); + http2_session_t *h2 = http2_session_create(conn->fd, false); + if (h2) { + http2_session_set_context(h2, conn->root_dir, + conn->gzip_enabled, + conn->brotli_enabled); + if (http2_send_pending(h2) == 0) { + if (http2_recv(h2, (const uint8_t *)conn->buf, conn->buf_len) == 0) { + conn->buf_len = 0; + handle_http2(conn); + break; /* handle_http2 内部已销毁会话 */ + } + } + http2_session_destroy(h2); + } + break; + } + + /* 检查 HTTP/1.1 Upgrade: h2c 请求 */ + http_request_t req; + int parsed = http_parse_request(conn->buf, conn->buf_len, &req); + if (parsed > 0 && is_h2c_upgrade_request(&req)) { + /* 消费已解析的 HTTP/1.1 请求数据 */ + if ((size_t)parsed < conn->buf_len) { + memmove(conn->buf, conn->buf + parsed, conn->buf_len - (size_t)parsed); + } + conn->buf_len -= (size_t)parsed; + + if (send_h2c_upgrade_response(conn)) { + http2_session_t *h2 = http2_session_create(conn->fd, false); + if (h2) { + http2_session_set_context(h2, conn->root_dir, + conn->gzip_enabled, + conn->brotli_enabled); + if (http2_send_pending(h2) == 0) { + if (http2_session_upgrade(h2, &req) == 0) { + if (http2_send_pending(h2) == 0) { + /* 消费缓冲区中的剩余数据 */ + if (conn->buf_len > 0) { + http2_recv(h2, (const uint8_t *)conn->buf, conn->buf_len); + conn->buf_len = 0; + } + handle_http2(conn); + break; /* handle_http2 内部已销毁会话 */ + } + } + http2_session_destroy(h2); + } + } + } + http_request_free(&req); + break; + } + + /* 检查 WebSocket Upgrade 请求 */ + if (parsed > 0 && is_websocket_upgrade_request(&req)) { + const char *key = NULL; + for (int i = 0; i < req.num_headers; i++) { + if (strcasecmp(req.headers[i].name, "sec-websocket-key") == 0) { + key = req.headers[i].value; + break; + } + } + if (key) { + conn_cancel_timer(conn); + if (ws_handshake(conn->fd, key) == 0) { + http_request_free(&req); + /* 消费已解析的请求数据 */ + if ((size_t)parsed < conn->buf_len) { + memmove(conn->buf, conn->buf + parsed, conn->buf_len - (size_t)parsed); + } + conn->buf_len -= (size_t)parsed; + ws_handle_connection(conn->fd, conn->timeout_ms); + break; + } + } + } + + http_request_free(&req); + /* 尝试处理请求 */ bool keep = handle_request(conn, conn->root_dir); + log_debug("fd=%d handle_request 返回 %d", conn->fd, keep); if (!keep) { break; } @@ -535,6 +813,7 @@ static void client_handler(void *arg) { conn_cancel_timer(conn); close_connection(conn); + log_debug("client_handler 结束 fd=%d", conn->fd); free(conn); } @@ -547,6 +826,7 @@ static void client_handler(void *arg) { * @param arg 服务器上下文指针 */ static void accept_loop(void *arg) { + log_debug("=== accept_loop 启动 ==="); server_context_t *ctx = (server_context_t *)arg; if (!ctx) return; @@ -570,14 +850,14 @@ static void accept_loop(void *arg) { log_info("连接空闲超时: %u ms", ctx->config.timeout_ms > 0 ? ctx->config.timeout_ms : CONN_TIMEOUT_MS); while (ctx->running) { - struct sockaddr_in client_addr; + if (ctx->listen_fd < 0) break; + struct sockaddr_storage client_addr; socklen_t addr_len = sizeof(client_addr); - cocoon_socket_t client_fd = accept(ctx->listen_fd, (struct sockaddr *)&client_addr, &addr_len); if (client_fd == COCOON_INVALID_SOCKET) { int err = cocoon_get_last_error(); - if (err == EAGAIN || err == EWOULDBLOCK || err == EINTR) { + if (err == EAGAIN || err == EINTR) { continue; } log_error("accept 失败: %s", cocoon_strerror(err)); @@ -594,8 +874,16 @@ static void accept_loop(void *arg) { const char *resp = "HTTP/1.1 503 Service Unavailable\r\n" "Content-Length: 0\r\n" "Connection: close\r\n\r\n"; - cocoon_socket_send(client_fd, resp, strlen(resp)); - cocoon_socket_close(client_fd); + if (tls_has_context()) { + if (tls_accept(client_fd) == 0) { + tls_write(client_fd, resp, strlen(resp)); + tls_close(client_fd); + } + cocoon_socket_close(client_fd); + } else { + cocoon_socket_send(client_fd, resp, strlen(resp)); + cocoon_socket_close(client_fd); + } continue; } } @@ -604,10 +892,41 @@ static void accept_loop(void *arg) { int opt = 1; setsockopt(client_fd, IPPROTO_TCP, TCP_NODELAY, (const char *)&opt, sizeof(opt)); + /* 多线程模式下设置 client_fd 非阻塞（用于 coco_read/coco_write） */ + if (ctx->config.threaded) { + set_nonblocking(client_fd); + } + + /* TLS 握手（如果启用） */ + if (tls_has_context()) { + if (tls_accept(client_fd) != 0) { + log_warn("TLS 握手失败 fd=%d，关闭连接", client_fd); + cocoon_socket_close(client_fd); + continue; + } + /* 检查 ALPN 协商结果，创建 HTTP/2 会话 */ + if (tls_negotiated_http2(client_fd)) { + log_debug("fd=%d ALPN 协商为 HTTP/2", client_fd); + if (http2_on_connection_accepted(client_fd, true) != 0) { + log_warn("HTTP/2 会话创建失败 fd=%d", client_fd); + cocoon_socket_close(client_fd); + continue; + } + http2_session_t *h2 = http2_session_get(client_fd); + if (h2) { + http2_session_set_context(h2, ctx->config.root_dir, + ctx->config.gzip_enabled, + ctx->config.brotli_enabled); + } + } + } + /* 创建连接上下文 */ connection_t *conn = (connection_t *)calloc(1, sizeof(connection_t)); if (!conn) { - close(client_fd); + http2_session_t *h2 = http2_session_get(client_fd); + if (h2) http2_session_destroy(h2); + cocoon_socket_close(client_fd); continue; } conn->fd = client_fd; @@ -617,21 +936,33 @@ static void accept_loop(void *arg) { conn->timeout_ms = ctx->config.timeout_ms > 0 ? ctx->config.timeout_ms : CONN_TIMEOUT_MS; conn->gzip_enabled = ctx->config.gzip_enabled; conn->brotli_enabled = ctx->config.brotli_enabled; + memcpy(&conn->client_addr, &client_addr, sizeof(client_addr)); + conn->addr_len = addr_len; + conn->response_status = 0; atomic_fetch_add(&g_active_connections, 1); log_debug("新连接 fd=%d，当前活跃连接: %d", client_fd, atomic_load(&g_active_connections)); - if (ctx->config.threaded && coco_sched_get_current()) { - /* 多线程协程模式：创建协程处理连接 */ - coco_coro_t *coro = coco_create(coco_sched_get_current(), - client_handler, conn, 0); + if (ctx->config.threaded) { + /* 多线程模式：使用 coco_go_with_opts 创建工作协程，128KB 栈 */ + coco_go_opts_t opts = { + .stack_size = 1024 * 1024, + .context = NULL, + .priority = -1, + .p_id = -1 + }; + coco_coro_t *coro = coco_go_with_opts(client_handler, conn, &opts); if (!coro) { - log_error("创建协程失败，关闭连接 fd=%d", client_fd); - atomic_fetch_sub(&g_active_connections, 1); - close_connection(conn); + log_error("coco_go_with_opts(client_handler) 返回 NULL，无法创建协程 fd=%d", client_fd); + http2_session_t *h2 = http2_session_get(client_fd); + if (h2) http2_session_destroy(h2); + cocoon_socket_close(client_fd); free(conn); + atomic_fetch_sub(&g_active_connections, 1); + continue; } + log_debug("client_handler 协程已创建 coro=%p fd=%d", (void*)coro, client_fd); } else { /* 单线程模式：直接调用处理函数（阻塞） */ client_handler(conn); @@ -689,8 +1020,15 @@ server_context_t *server_create(const cocoon_config_t *config) { return NULL; } - /* 非阻塞模式 */ - set_nonblocking(ctx->listen_fd); + /* 初始化 TLS 上下文（如果配置了证书） */ + if (ctx->config.tls_cert && ctx->config.tls_key) { + if (tls_create_context(ctx->config.tls_cert, ctx->config.tls_key) != 0) { + log_error("TLS 上下文初始化失败"); + close(ctx->listen_fd); + free(ctx); + return NULL; + } + } return ctx; } @@ -721,14 +1059,17 @@ int server_start(server_context_t *ctx) { return COCOON_ERROR; } - /* 在调度器上运行 accept 循环 */ - /* 注意：当前实现使用主线程直接 accept，多线程仅用于工作协程 */ + /* 多线程模式下 listen_fd 需要非阻塞（用于 accept + poll 等待） */ + set_nonblocking(ctx->listen_fd); + + /* 在主线程中运行 accept_loop */ accept_loop(ctx); + /* 等待所有协程完成 */ coco_global_sched_wait(); coco_global_sched_stop(); } else { - /* 单线程模式 */ + /* 单线程模式：listen_fd 保持阻塞 */ accept_loop(ctx); } @@ -745,6 +1086,10 @@ int server_start(server_context_t *ctx) { void server_stop(server_context_t *ctx) { if (ctx) { ctx->running = 0; + if (ctx->listen_fd >= 0) { + close(ctx->listen_fd); + ctx->listen_fd = -1; + } } } @@ -758,6 +1103,8 @@ void server_stop(server_context_t *ctx) { void server_destroy(server_context_t *ctx) { if (!ctx) return; + tls_destroy_context(); + if (ctx->listen_fd != COCOON_INVALID_SOCKET) { cocoon_socket_close(ctx->listen_fd); ctx->listen_fd = COCOON_INVALID_SOCKET; diff --git a/static.c b/static.c index 922f4ab..38f8343 100644 --- a/static.c +++ b/static.c @@ -11,6 +11,8 @@ #include "static.h" #include "cocoon.h" #include "platform.h" +#include "../coco/include/coco.h" +#include "tls.h" #include #include #include @@ -235,9 +237,27 @@ static bool safe_path_join(char *dst, size_t dst_size, * @return 0 鎴愬姛锛?1 澶辫触 */ int send_all(int fd, const char *buf, size_t len) { + if (tls_has_connection(fd)) { + return tls_write(fd, buf, len) == (ssize_t)len ? 0 : -1; + } + size_t sent = 0; while (sent < len) { - ssize_t n = cocoon_socket_send(fd, buf + sent, len - sent); + ssize_t n; + if (tls_has_connection(fd)) { + n = tls_write(fd, buf + sent, len - sent); + } else if (coco_sched_get_current() != NULL) { + int ret = coco_write(fd, buf + sent, len - sent); + if (ret < 0) { + if (ret == COCO_ERROR_WOULD_BLOCK) { + continue; + } + return -1; + } + n = ret; + } else { + n = cocoon_socket_send(fd, buf + sent, len - sent); + } if (n < 0) { int err = cocoon_get_last_error(); if (err == EAGAIN || err == EINTR) continue; @@ -467,10 +487,25 @@ int static_serve_file(int fd, const http_request_t *req, const char *root_dir, b return COCOON_OK; } - if (use_gzip || use_brotli) { - /* 鍙戦€佸帇缂╁悗鐨勬暟鎹?*/ - send_all(fd, compress_buf, (size_t)compress_len); - free(compress_buf); + if (use_gzip || use_brotli || tls_has_connection(fd)) { + /* 发送压缩后的数据，或 TLS 模式下的文件内容 */ + if (use_gzip || use_brotli) { + send_all(fd, compress_buf, (size_t)compress_len); + free(compress_buf); + } else { + /* 定位到起始位置（文件可能已被压缩读取提前读至末尾） */ + cocoon_file_seek(file_fd, send_start, SEEK_SET); + /* TLS 模式：不能使用 sendfile，需读取文件后发送 */ + char file_buf[65536]; + ssize_t remaining = send_length; + while (remaining > 0) { + size_t to_read = (size_t)remaining < sizeof(file_buf) ? (size_t)remaining : sizeof(file_buf); + ssize_t n = cocoon_file_read(file_fd, file_buf, to_read); + if (n <= 0) break; + if (send_all(fd, file_buf, (size_t)n) != 0) break; + remaining -= n; + } + } cocoon_file_close(file_fd); } else { /* 浣跨敤璺ㄥ钩鍙版枃浠跺彂閫侊紙Linux sendfile / Windows read+send锛?*/ diff --git a/tests/integration_test.sh b/tests/integration_test.sh index 681ade2..3663cf9 100755 --- a/tests/integration_test.sh +++ b/tests/integration_test.sh @@ -18,7 +18,9 @@ TMPDIR=$(mktemp -d) trap 'rm -rf "$TMPDIR"; kill_server' EXIT kill_server() { - pkill -f "$SERVER.*$HOST" 2>/dev/null || true + pkill -f "cocoon.*-p 9999" 2>/dev/null || true + pkill -f "cocoon.*--cert" 2>/dev/null || true + sleep 0.5 } # 启动服务器 @@ -145,7 +147,7 @@ assert_body_contains() { local expect="$2" local desc="${3:-$url}" local body - body=$(curl -s "$url") + body=$(curl -s -k --compressed "$url") if echo "$body" | grep -q "$expect"; then echo " ✓ $desc — 响应体包含 '$expect'" pass @@ -314,6 +316,48 @@ assert_post_form() { fi } +assert_http2_brotli() { + local url="$1" + local desc="${2:-$url}" + local encoding + encoding=$(curl --http2 -k -s -D - -o /dev/null "$url" | grep -i "Content-Encoding:" | tr -d '\r' || true) + if echo "$encoding" | grep -qi "br"; then + echo " ✓ $desc — HTTP/2 返回 brotli 压缩" + pass + else + echo " ✗ $desc — HTTP/2 期望 brotli 压缩, 实际: $encoding" + fail + fi +} + +assert_http2_gzip() { + local url="$1" + local desc="${2:-$url}" + local encoding + encoding=$(curl --http2 -k -s -D - -o /dev/null "$url" | grep -i "Content-Encoding:" | tr -d '\r' || true) + if echo "$encoding" | grep -qi "gzip"; then + echo " ✓ $desc — HTTP/2 返回 gzip 压缩" + pass + else + echo " ✗ $desc — HTTP/2 期望 gzip 压缩, 实际: $encoding" + fail + fi +} + +assert_http2_not_compressed() { + local url="$1" + local desc="${2:-$url}" + local encoding + encoding=$(curl --http2 -k -s -D - -o /dev/null "$url" | grep -i "Content-Encoding:" | tr -d '\r' || true) + if [[ -z "$encoding" ]]; then + echo " ✓ $desc — HTTP/2 无压缩" + pass + else + echo " ✗ $desc — HTTP/2 期望无压缩, 实际: $encoding" + fail + fi +} + assert_status_405() { local url="$1" local desc="${2:-$url}" @@ -328,6 +372,25 @@ assert_status_405() { fi } +assert_access_log() { + local log_file="$1" + local desc="${2:-访问日志}" + if [ -f "$log_file" ] && [ -s "$log_file" ]; then + local count + count=$(grep -c '"GET /' "$log_file" || true) + if [ "$count" -ge 1 ]; then + echo " ✓ $desc — 日志文件包含请求记录" + pass + else + echo " ✗ $desc — 日志文件无请求记录" + fail + fi + else + echo " ✗ $desc — 日志文件不存在或为空" + fail + fi +} + # ===== 测试开始 ===== start_server @@ -411,6 +474,267 @@ echo "" echo "=== 文件上传测试 ===" assert_post_multipart "$BASE/upload" "multipart 文件上传" +echo "" +echo "=== 访问日志测试 ===" +# 带访问日志启动服务器 +kill_server +sleep 1 +LOG_FILE="$TMPDIR/access.log" +$SERVER -r "$ROOT" -p 9999 --access-log "$LOG_FILE" > "$TMPDIR/server_access.log" 2>&1 & +pid_access=$! +for i in {1..30}; do + if curl -s -o /dev/null "$BASE/" 2>/dev/null; then + break + fi + sleep 0.1 +done +# 发送请求并验证日志记录 +curl -s -o /dev/null "$BASE/index.html" -H "User-Agent: CocoonTest/1.0" +curl -s -o /dev/null "$BASE/nonexist.html" -H "Referer: http://example.com" +sleep 0.5 +assert_access_log "$LOG_FILE" "访问日志文件生成" +# 检查日志格式是否包含关键字段 +if grep -q '"GET /index.html HTTP/1.1"' "$LOG_FILE"; then + echo " ✓ 日志包含 GET /index.html" + pass +else + echo " ✗ 日志缺少 GET /index.html" + fail +fi +if grep -q 'CocoonTest/1.0' "$LOG_FILE"; then + echo " ✓ 日志包含 User-Agent" + pass +else + echo " ✗ 日志缺少 User-Agent" + fail +fi +if grep -q 'example.com' "$LOG_FILE"; then + echo " ✓ 日志包含 Referer" + pass +else + echo " ✗ 日志缺少 Referer" + fail +fi +if grep -q '404' "$LOG_FILE"; then + echo " ✓ 日志包含 404 状态码" + pass +else + echo " ✗ 日志缺少 404 状态码" + fail +fi + +# 恢复普通服务器 +kill_server +sleep 1 +start_server + +echo "" +echo "=== TLS/HTTPS 测试 ===" +# 启动 HTTPS 服务器（使用测试证书） +kill_server +sleep 1 +$SERVER -r "$ROOT" -p 9999 --cert tests/server.crt --key tests/server.key > "$TMPDIR/server_tls.log" 2>&1 & +pid_tls=$! + +# 等待服务器就绪（curl -k 忽略证书验证） +for i in {1..50}; do + if curl -s -o /dev/null -k --max-time 2 "https://$HOST/" 2>/dev/null; then + break + fi + sleep 0.2 +done + +# 使用 openssl s_client 验证 TLS 握手 +if command -v openssl >/dev/null 2>&1; then + tls_resp=$(echo -e "GET / HTTP/1.1\r\nHost: $HOST\r\nConnection: close\r\n\r\n" | \ + timeout 5 openssl s_client -connect "$HOST" -quiet 2>/dev/null | head -20) + if echo "$tls_resp" | grep -q "HTTP/1.1"; then + echo " ✓ TLS 握手 + HTTP GET — 通过 HTTPS 获取响应" + pass + else + echo " ✗ TLS 握手 + HTTP GET — 未能通过 HTTPS 获取响应" + fail + fi +else + echo " ⚠ openssl 未安装，跳过 TLS 握手验证" +fi + +# 使用 curl -k 验证 HTTPS 响应体 +assert_body_contains "https://$HOST/" "Cocoon" "HTTPS 首页响应" + +echo "" +echo "=== HTTP/2 测试 ===" +# 使用已启动的 TLS 服务器测试 HTTP/2（ALPN 协商） +kill_server +sleep 1 +$SERVER -r "$ROOT" -p 9999 --cert tests/server.crt --key tests/server.key > "$TMPDIR/server_h2.log" 2>&1 & +pid_h2=$! + +# 等待服务器就绪 +for i in {1..50}; do + if curl -s -o /dev/null -k --max-time 2 "https://$HOST/" 2>/dev/null; then + break + fi + sleep 0.2 +done + +# 验证 HTTP/2 协议版本 +h2_version=$(curl --http2 -k -s -o /dev/null -w "%{http_version}" "https://$HOST/") +if [[ "$h2_version" == "2" ]]; then + echo " ✓ HTTP/2 ALPN 协商 — 协议版本 HTTP/2" + pass +else + echo " ✗ HTTP/2 ALPN 协商 — 期望 HTTP/2, 实际 HTTP/$h2_version" + fail +fi + +# HTTP/2 GET 首页 +h2_status=$(curl --http2 -k -s -o /dev/null -w "%{http_code}" "https://$HOST/") +if [[ "$h2_status" == "200" ]]; then + echo " ✓ HTTP/2 GET 首页 — HTTP 200" + pass +else + echo " ✗ HTTP/2 GET 首页 — 期望 200, 实际 $h2_status" + fail +fi + +# HTTP/2 响应体 +h2_body=$(curl --http2 -k -s --compressed "https://$HOST/") +if echo "$h2_body" | grep -q "Cocoon"; then + echo " ✓ HTTP/2 响应体 — 包含 'Cocoon'" + pass +else + echo " ✗ HTTP/2 响应体 — 未包含 'Cocoon'" + fail +fi + +# HTTP/2 HEAD 请求 +h2_head_status=$(curl --http2 -k -s -o /dev/null -w "%{http_code}" -I "https://$HOST/index.html") +if [[ "$h2_head_status" == "200" ]]; then + echo " ✓ HTTP/2 HEAD 请求 — HTTP 200" + pass +else + echo " ✗ HTTP/2 HEAD 请求 — 期望 200, 实际 $h2_head_status" + fail +fi + +# HTTP/2 404 +h2_404=$(curl --http2 -k -s -o /dev/null -w "%{http_code}" "https://$HOST/nonexist.html") +if [[ "$h2_404" == "404" ]]; then + echo " ✓ HTTP/2 404 请求 — HTTP 404" + pass +else + echo " ✗ HTTP/2 404 请求 — 期望 404, 实际 $h2_404" + fail +fi + +# HTTP/2 缓存协商（ETag 304） +H2_ETAG=$(curl --http2 -k -sI "https://$HOST/index.html" | grep -i "ETag:" | awk '{print $2}' | tr -d '\r') +if [[ -n "$H2_ETAG" ]]; then + h2_304=$(curl --http2 -k -s -o /dev/null -w "%{http_code}" -H "If-None-Match: $H2_ETAG" "https://$HOST/index.html") + if [[ "$h2_304" == "304" ]]; then + echo " ✓ HTTP/2 If-None-Match 304 — 缓存命中" + pass + else + echo " ✗ HTTP/2 If-None-Match 304 — 期望 304, 实际 $h2_304" + fail + fi +fi + +# HTTP/2 压缩测试 +assert_http2_brotli "https://$HOST/index.html" "HTTP/2 HTML brotli" +assert_http2_brotli "https://$HOST/style.css" "HTTP/2 CSS brotli" +assert_http2_brotli "https://$HOST/app.js" "HTTP/2 JS brotli" + +# HTTP/2 目录浏览测试 +h2_dir_status=$(curl --http2 -k -s -o /dev/null -w "%{http_code}" "https://$HOST/subdir/") +h2_dir_body=$(curl --http2 -k -s "https://$HOST/subdir/") +if [[ "$h2_dir_status" == "200" ]] && echo "$h2_dir_body" | grep -q "page.html"; then + echo " ✓ HTTP/2 目录浏览 — HTTP 200，包含 page.html" + pass +else + echo " ✗ HTTP/2 目录浏览 — 期望 200+page.html, 实际 $h2_dir_status" + fail +fi + +# 停止 HTTP/2 服务器，恢复 HTTP 服务器 +kill_server +sleep 1 +start_server + +# h2c 测试（明文 HTTP/2） +echo "" +echo "=== h2c 测试 ===" + +# h2c prior knowledge 直接连接 +h2c_pk_status=$(curl --http2-prior-knowledge -s -o /dev/null -w "%{http_code}" "http://$HOST/") +h2c_pk_version=$(curl --http2-prior-knowledge -s -o /dev/null -w "%{http_version}" "http://$HOST/") +if [[ "$h2c_pk_status" == "200" && "$h2c_pk_version" == "2" ]]; then + echo " ✓ h2c prior knowledge — HTTP 200, 协议 HTTP/2" + pass +else + echo " ✗ h2c prior knowledge — 期望 200+HTTP/2, 实际 $h2c_pk_status+HTTP/$h2c_pk_version" + fail +fi + +# h2c prior knowledge 404 +h2c_pk_404=$(curl --http2-prior-knowledge -s -o /dev/null -w "%{http_code}" "http://$HOST/nonexist.html") +if [[ "$h2c_pk_404" == "404" ]]; then + echo " ✓ h2c prior knowledge 404 — HTTP 404" + pass +else + echo " ✗ h2c prior knowledge 404 — 期望 404, 实际 $h2c_pk_404" + fail +fi + +# h2c Upgrade 协商 +h2c_up_status=$(curl --http2 -s -o /dev/null -w "%{http_code}" "http://$HOST/") +h2c_up_version=$(curl --http2 -s -o /dev/null -w "%{http_version}" "http://$HOST/") +if [[ "$h2c_up_status" == "200" && "$h2c_up_version" == "2" ]]; then + echo " ✓ h2c Upgrade 协商 — HTTP 200, 协议 HTTP/2" + pass +else + echo " ✗ h2c Upgrade 协商 — 期望 200+HTTP/2, 实际 $h2c_up_status+HTTP/$h2c_up_version" + fail +fi + +# h2c Upgrade 404 +h2c_up_404=$(curl --http2 -s -o /dev/null -w "%{http_code}" "http://$HOST/nonexist.html") +if [[ "$h2c_up_404" == "404" ]]; then + echo " ✓ h2c Upgrade 404 — HTTP 404" + pass +else + echo " ✗ h2c Upgrade 404 — 期望 404, 实际 $h2c_up_404" + fail +fi + +# HTTP/2 目录浏览测试 +# subdir 目录没有 index.html，应返回 200 目录列表 +h2c_dir_status=$(curl --http2-prior-knowledge -s -o /dev/null -w "%{http_code}" "http://$HOST/subdir/") +h2c_dir_body=$(curl --http2-prior-knowledge -s "http://$HOST/subdir/") +if [[ "$h2c_dir_status" == "200" ]] && echo "$h2c_dir_body" | grep -q "page.html"; then + echo " ✓ h2c 目录浏览 — HTTP 200，包含 page.html" + pass +else + echo " ✗ h2c 目录浏览 — 期望 200+page.html, 实际 $h2c_dir_status" + fail +fi + +# WebSocket 测试 +echo "" +echo "=== WebSocket 测试 ===" + +if python3 "$ROOT/../websocket_test.py" > "$TMPDIR/ws_test.log" 2>&1; then + echo " ✓ WebSocket 握手 + echo — 通过" + pass + pass +else + echo " ✗ WebSocket 测试失败" + cat "$TMPDIR/ws_test.log" + fail + fail +fi + echo "" echo "=== 结果汇总 ===" echo "通过: $PASS" diff --git a/tests/server.crt b/tests/server.crt new file mode 100644 index 0000000..6c520ec --- /dev/null +++ b/tests/server.crt @@ -0,0 +1,19 @@ +-----BEGIN CERTIFICATE----- +MIIDCTCCAfGgAwIBAgIUPVEDY05Y47B5Xs305idz++X3wrgwDQYJKoZIhvcNAQEL +BQAwFDESMBAGA1UEAwwJbG9jYWxob3N0MB4XDTI2MDYwNDA0MTkzM1oXDTI2MDYw +NTA0MTkzM1owFDESMBAGA1UEAwwJbG9jYWxob3N0MIIBIjANBgkqhkiG9w0BAQEF +AAOCAQ8AMIIBCgKCAQEArRpnw9qH9mw3Px8FvRhgyVqMA1B0sJTlareiHNnIh9kP +W2q2M0alzPiOllysEcEQn//FPPh/cH6gXhsQziNTRK7VPrkCV8+4jV/FbdG74WJx +GMliemPwUvOKf+oLU/OFuyLvbze3VG+Wcwg/tdUxRUwHwu9nDj1F0nCbtGQBV+m3 +GS0diluKyYWE2rn54H6F1tnJcNNnfPGXptvFGKgI/6HVret28VYX9iMILy4UnA4H +j7p8+MMyhDXqOi9y+nSPTXM2HaRUSgA0tWxlHsR9gE75+3bNRVU+3GzJaM6lDxzf +jAHQgGWHwibCPJFX4eAgJseromlQKKAtLdToa4ngjwIDAQABo1MwUTAdBgNVHQ4E +FgQUTPTOzkZPBbV1xHfZmPCxv4CQ7LUwHwYDVR0jBBgwFoAUTPTOzkZPBbV1xHfZ +mPCxv4CQ7LUwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEADBVC +KECbcbb8rBPmZkh2sJDtuXnW403+1Tg/YsUoSpLxa8Jq35JWfMR5fnmCAsaOxuNQ +rFXNotVxLhaMK7IwIsyazdRkRAT4SLLLx5bt3p6BY4L9C/SUVlSK0SC1E39AGPB/ +vwce9xB4wmUj3o+zcn09r9ARhnr4ccMaOaHiX/opd6T+62XKoer/tSTvx31t44gW +o5IPz7dk20g379jb1PTnq5lJWD1E1ttlRbETlivuMOwg3GjVWRc7smk7AlBnsems +LzyrpySsvAsY/mLbwSJfNlSd00T/VV8WFUCkr/pm0l7WWPx2nHrUu9t4YjJ0UHY/ +UQNisxe3vGPxoTpD+A== +-----END CERTIFICATE----- diff --git a/tests/server.key b/tests/server.key new file mode 100644 index 0000000..c1209a1 --- /dev/null +++ b/tests/server.key @@ -0,0 +1,28 @@ +-----BEGIN PRIVATE KEY----- +MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCtGmfD2of2bDc/ +HwW9GGDJWowDUHSwlOVqt6Ic2ciH2Q9barYzRqXM+I6WXKwRwRCf/8U8+H9wfqBe +GxDOI1NErtU+uQJXz7iNX8Vt0bvhYnEYyWJ6Y/BS84p/6gtT84W7Iu9vN7dUb5Zz +CD+11TFFTAfC72cOPUXScJu0ZAFX6bcZLR2KW4rJhYTaufngfoXW2clw02d88Zem +28UYqAj/odWt63bxVhf2IwgvLhScDgePunz4wzKENeo6L3L6dI9NczYdpFRKADS1 +bGUexH2ATvn7ds1FVT7cbMlozqUPHN+MAdCAZYfCJsI8kVfh4CAmx6uiaVAooC0t +1OhrieCPAgMBAAECggEAAOeW7DybokuNfFx2pLbYZqT8/1Vvzq5whn7AL6Npu2AE +hwdHPXxciHYyFJIWah9WrWdiSf/IdreKsgM1MsaXfE/nmGTSINBamA6MkxbaAwMH +MUh4JciY7G4OZr274mvu4nv7wVqKsDvHDwHXh2U+VSzhC4FByh7C2ycwgSBWq3Vw +hm6D/8QOU7ZkIkaMWGc82KgjAXm8jrG2K5k0WWw5IDItQmX7M/ZYN5FS7ArXtbqw +prlr1QdIWQvi/UtG0MQ2ys5ZRqbDTTfwAw06oIhq7e6zqMEjCD9G/WLGwqkRhe86 +hVcZ2DM01ge7Pva9XKNxIuh7DMrFnacAE3nnb1w0iQKBgQDZrfpllwKDIGNSauVD +rejbstJDocMlWhuQsj2r+29nnFCqS8OEmG8E9r0uDZpCTUWzY2EgYb8cvTaFI7vs +3owH1pF9nZRr1NZFeli4EuNEJFF10Qf8wp3mwTXweBckDW6ZwWfkgOKWJhAB9Eg7 +7GFlpAzgiJmeTa5ztCQpLqwcBwKBgQDLk4ea9quNoF/54U50dWs/Vb9F0X+aYupP +OdmPHYpwfaAO7KCVVSE9qufqTRrrqssIvstODWZ3clxszQC1iiJpjTMhhCTfIOW+ +p6ZqU/mLUQ3kPsQuxoCagcn8HhCvuD4wcBG/rIHLr9iBuYjFuFnl+XxpuqUowXG9 +mpfGJBiFOQKBgCzFKpXQXDTp6WOfFq43y4e8HKDKWV+KS9cTwbloij4uGS0dTgYs +b9D+imQ5afuu9uHxU52cXPklNVxmwBT0pKpMCDpkuY0ABl3dzvd08wclzRdFObZT +tLQsEtL1cBT7Kj83Vw3ZMEEfbPVp751bfaCw//ECR04WvgWQDEvoDH/rAoGBAJEe +g+ZlvPliv8gjYogGRAOMHqOoqivmI12CwaIRzuRNyVGaQQby/pU1RclyWaRxxfZf +/BGR3996OISexsiixdE0hKR5zMb6bowweqMFZbh4eUyhqbwmaPq7Vr9Qt1hsIHjr +Ctv2HziSC+a92dAIkJ0t8hB0qtOYwnoEv/jRNmGRAoGBAMUo7zXuvPi11es6L/1S +kzh00RV7JdSOZ7cyEdzaGBMeMRpAFrjoy5kiXUj2mPuESqd3FiTR9dgYHrZBirfI +mmCQxp8PZ5f+G2M5JbRslZfinPL7ePX/fijJ1kWMUGVuk3502tf5HjgE9k1/i0He +TIi3EoBZvP9v9Y1ZUom5IFct +-----END PRIVATE KEY----- diff --git a/tests/unit/test_config.c b/tests/unit/test_config.c index 693ec07..d50c02b 100644 --- a/tests/unit/test_config.c +++ b/tests/unit/test_config.c @@ -126,7 +126,7 @@ void test_merge_override_all(void) { .brotli_enabled = false }; config_merge(&base, &cmdline, - true, true, true, true, true, true, true, true); + true, true, true, true, true, true, true, true, true, true, true, true); TEST_ASSERT_EQUAL_STRING("/new", base.root_dir); TEST_ASSERT_EQUAL(9090, base.port); TEST_ASSERT_TRUE(base.threaded); @@ -155,7 +155,7 @@ void test_merge_no_override(void) { .log_level = LOG_LEVEL_DEBUG }; config_merge(&base, &cmdline, - false, false, false, false, false, false, false, false); + false, false, false, false, false, false, false, false, false, false, false, false); TEST_ASSERT_EQUAL_STRING("/old", base.root_dir); TEST_ASSERT_EQUAL(8080, base.port); TEST_ASSERT_FALSE(base.threaded); @@ -178,7 +178,7 @@ void test_merge_partial_override(void) { .log_level = LOG_LEVEL_DEBUG }; config_merge(&base, &cmdline, - true, false, false, true, false, false, false, false); + true, false, false, true, false, false, false, false, false, false, false, false); TEST_ASSERT_EQUAL_STRING("/new", base.root_dir); /* overridden */ TEST_ASSERT_EQUAL(8080, base.port); /* not overridden */ TEST_ASSERT_EQUAL(2, base.num_workers); /* not overridden */ @@ -243,7 +243,7 @@ void test_merge_cmdline_null_root_dir(void) { /* cmdline root_dir 为 NULL，不应覆盖 base */ cocoon_config_t base = {.root_dir = strdup("/old"), .port = 8080}; cocoon_config_t cmdline = {.root_dir = NULL, .port = 9090}; - config_merge(&base, &cmdline, true, true, false, false, false, false, false, false); + config_merge(&base, &cmdline, true, true, false, false, false, false, false, false, false, false, false, false); TEST_ASSERT_EQUAL_STRING("/old", base.root_dir); /* NULL 不覆盖 */ TEST_ASSERT_EQUAL(9090, base.port); /* port 覆盖 */ free((void *)base.root_dir); @@ -251,7 +251,7 @@ void test_merge_cmdline_null_root_dir(void) { void test_merge_null_safety(void) { /* 不应 crash */ - config_merge(NULL, NULL, true, true, true, true, true, true, true, true); + config_merge(NULL, NULL, true, true, true, true, true, true, true, true, true, true, true, true); TEST_ASSERT_TRUE(1); } diff --git a/tests/unit/test_server.c b/tests/unit/test_server.c index ef20161..e58053a 100644 --- a/tests/unit/test_server.c +++ b/tests/unit/test_server.c @@ -2,6 +2,7 @@ #include "server.h" #include "config.h" #include +#include /* ===== server_create 参数校验 ===== */ @@ -15,6 +16,132 @@ void test_create_null_root_dir(void) { TEST_ASSERT_NULL(server_create(&cfg)); } +void test_create_empty_root_dir(void) { + cocoon_config_t cfg = {.root_dir = "", .port = 30001}; + /* 空字符串 root_dir 应该也失败（或成功取决于实现） */ + server_context_t *ctx = server_create(&cfg); + if (ctx) { + server_destroy(ctx); + } + /* 空字符串可能成功也可能失败，不强制断言 */ + TEST_ASSERT_TRUE(1); +} + +/* ===== server_create 配置边界测试 ===== */ + +void test_create_port_zero(void) { + /* port=0 让系统分配随机端口，应该能成功 */ + cocoon_config_t cfg = { + .root_dir = "/tmp", + .port = 0, + .threaded = false + }; + server_context_t *ctx = server_create(&cfg); + if (ctx) { + server_destroy(ctx); + TEST_ASSERT_TRUE(1); + } else { + TEST_IGNORE_MESSAGE("port 0 create failed, system may restrict"); + } +} + +void test_create_high_port(void) { + cocoon_config_t cfg = { + .root_dir = "/tmp", + .port = 65535, + .threaded = false + }; + server_context_t *ctx = server_create(&cfg); + if (ctx) { + server_destroy(ctx); + TEST_ASSERT_TRUE(1); + } else { + TEST_IGNORE_MESSAGE("port 65535 create failed, possibly in use"); + } +} + +void test_create_multithread_config(void) { + cocoon_config_t cfg = { + .root_dir = "/tmp", + .port = 30002, + .threaded = true, + .num_workers = 2 + }; + server_context_t *ctx = server_create(&cfg); + if (ctx) { + server_destroy(ctx); + TEST_ASSERT_TRUE(1); + } else { + TEST_IGNORE_MESSAGE("multithread create failed, possibly port in use"); + } +} + +void test_create_zero_workers(void) { + /* workers=0 应该自动检测 CPU 核心数 */ + cocoon_config_t cfg = { + .root_dir = "/tmp", + .port = 30003, + .threaded = true, + .num_workers = 0 + }; + server_context_t *ctx = server_create(&cfg); + if (ctx) { + server_destroy(ctx); + TEST_ASSERT_TRUE(1); + } else { + TEST_IGNORE_MESSAGE("zero workers create failed, possibly port in use"); + } +} + +void test_create_with_timeout(void) { + cocoon_config_t cfg = { + .root_dir = "/tmp", + .port = 30004, + .threaded = false, + .timeout_ms = 5000 + }; + server_context_t *ctx = server_create(&cfg); + if (ctx) { + server_destroy(ctx); + TEST_ASSERT_TRUE(1); + } else { + TEST_IGNORE_MESSAGE("create with timeout failed, possibly port in use"); + } +} + +void test_create_with_max_connections(void) { + cocoon_config_t cfg = { + .root_dir = "/tmp", + .port = 30005, + .threaded = false, + .max_connections = 100 + }; + server_context_t *ctx = server_create(&cfg); + if (ctx) { + server_destroy(ctx); + TEST_ASSERT_TRUE(1); + } else { + TEST_IGNORE_MESSAGE("create with max_connections failed, possibly port in use"); + } +} + +void test_create_with_compression_flags(void) { + cocoon_config_t cfg = { + .root_dir = "/tmp", + .port = 30006, + .threaded = false, + .gzip_enabled = false, + .brotli_enabled = false + }; + server_context_t *ctx = server_create(&cfg); + if (ctx) { + server_destroy(ctx); + TEST_ASSERT_TRUE(1); + } else { + TEST_IGNORE_MESSAGE("create with compression flags failed, possibly port in use"); + } +} + /* ===== server_stop / server_destroy 安全路径 ===== */ void test_stop_null(void) { @@ -29,6 +156,29 @@ void test_destroy_null(void) { TEST_ASSERT_TRUE(1); } +void test_stop_then_destroy(void) { + cocoon_config_t cfg = { + .root_dir = "/tmp", + .port = 30007, + .threaded = false + }; + server_context_t *ctx = server_create(&cfg); + if (!ctx) { + TEST_IGNORE_MESSAGE("server_create failed, possibly port in use"); + return; + } + server_stop(ctx); + server_destroy(ctx); + TEST_ASSERT_TRUE(1); +} + +void test_double_destroy(void) { + /* 测试二次 destroy 的安全性（虽然用户不应这样做，但不应 crash） */ + /* 注意：第一次 destroy 后指针已释放，第二次是悬空指针，这个测试有风险 */ + /* 暂时跳过，因为 C 中无法安全地 double-free */ + TEST_IGNORE_MESSAGE("double destroy test skipped (unsafe in C)"); +} + /* ===== server_create 成功后销毁 ===== */ void test_create_and_destroy(void) { @@ -49,6 +199,40 @@ void test_create_and_destroy(void) { } } +void test_create_multiple_instances(void) { + /* 创建两个不同端口的服务器 */ + cocoon_config_t cfg1 = { + .root_dir = "/tmp", + .port = 30008, + .threaded = false + }; + cocoon_config_t cfg2 = { + .root_dir = "/tmp", + .port = 30009, + .threaded = false + }; + server_context_t *ctx1 = server_create(&cfg1); + server_context_t *ctx2 = server_create(&cfg2); + + if (ctx1 && ctx2) { + server_destroy(ctx2); + server_destroy(ctx1); + TEST_ASSERT_TRUE(1); + } else { + if (ctx1) server_destroy(ctx1); + if (ctx2) server_destroy(ctx2); + TEST_IGNORE_MESSAGE("multiple instances create failed, possibly port in use"); + } +} + +/* ===== server_start 参数校验 ===== */ + +void test_start_null(void) { + /* server_start 传入 NULL 应该返回错误 */ + int ret = server_start(NULL); + TEST_ASSERT_EQUAL_INT(COCOON_ERROR, ret); +} + void setUp(void) {} void tearDown(void) {} @@ -57,9 +241,21 @@ int main(void) { RUN_TEST(test_create_null_config); RUN_TEST(test_create_null_root_dir); + RUN_TEST(test_create_empty_root_dir); + RUN_TEST(test_create_port_zero); + RUN_TEST(test_create_high_port); + RUN_TEST(test_create_multithread_config); + RUN_TEST(test_create_zero_workers); + RUN_TEST(test_create_with_timeout); + RUN_TEST(test_create_with_max_connections); + RUN_TEST(test_create_with_compression_flags); RUN_TEST(test_stop_null); RUN_TEST(test_destroy_null); + RUN_TEST(test_stop_then_destroy); + RUN_TEST(test_double_destroy); RUN_TEST(test_create_and_destroy); + RUN_TEST(test_create_multiple_instances); + RUN_TEST(test_start_null); return UNITY_END(); } diff --git a/tests/websocket_test.py b/tests/websocket_test.py new file mode 100644 index 0000000..623c702 --- /dev/null +++ b/tests/websocket_test.py @@ -0,0 +1,245 @@ +#!/usr/bin/env python3 +""" +WebSocket 集成测试 — 使用 Python 标准库实现 + +测试内容： +1. HTTP 升级握手（101 Switching Protocols） +2. 发送文本帧，接收 echo 回显 +3. 发送关闭帧，接收关闭响应 +""" + +import socket +import base64 +import hashlib +import struct +import sys + +HOST = "localhost" +PORT = 9999 +GUID = b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11" + + +def build_handshake(): + """构建 WebSocket 握手请求""" + key = base64.b64encode(b"\x00" * 16).decode() + req = ( + f"GET /ws HTTP/1.1\r\n" + f"Host: {HOST}:{PORT}\r\n" + f"Upgrade: websocket\r\n" + f"Connection: Upgrade\r\n" + f"Sec-WebSocket-Key: {key}\r\n" + f"Sec-WebSocket-Version: 13\r\n" + f"\r\n" + ) + return req, key + + +def parse_response(data): + """解析 HTTP 101 响应""" + lines = data.split(b"\r\n") + status = lines[0].decode() + headers = {} + for line in lines[1:]: + if line == b"": + break + if b":" in line: + k, v = line.split(b":", 1) + headers[k.decode().strip().lower()] = v.decode().strip() + return status, headers + + +def compute_accept(key): + """计算 Sec-WebSocket-Accept""" + concat = key.encode() + GUID + digest = hashlib.sha1(concat).digest() + return base64.b64encode(digest).decode() + + +def build_frame(opcode, payload, masked=True): + """构建 WebSocket 帧（客户端发送，带掩码）""" + length = len(payload) + header = bytearray() + header.append(0x80 | opcode) # FIN=1, opcode + + if length <= 125: + header.append((0x80 if masked else 0x00) | length) + elif length <= 65535: + header.append((0x80 if masked else 0x00) | 126) + header.extend(struct.pack(">H", length)) + else: + header.append((0x80 if masked else 0x00) | 127) + header.extend(struct.pack(">Q", length)) + + if masked: + mask = b"\x12\x34\x56\x78" + masked_payload = bytearray() + for i, b in enumerate(payload): + masked_payload.append(b ^ mask[i % 4]) + return bytes(header) + mask + bytes(masked_payload) + + return bytes(header) + payload + + +def parse_frame(data): + """解析服务器发来的 WebSocket 帧（无掩码）""" + if len(data) < 2: + return None, 0 + + b0 = data[0] + b1 = data[1] + fin = (b0 >> 7) & 1 + opcode = b0 & 0x0F + payload_len = b1 & 0x7F + offset = 2 + + if payload_len == 126: + if len(data) < 4: + return None, 0 + payload_len = struct.unpack(">H", data[2:4])[0] + offset = 4 + elif payload_len == 127: + if len(data) < 10: + return None, 0 + payload_len = struct.unpack(">Q", data[2:10])[0] + offset = 10 + + # 服务器不掩码 + if len(data) < offset + payload_len: + return None, 0 + + payload = data[offset:offset + payload_len] + return {"opcode": opcode, "fin": fin, "payload": payload}, offset + payload_len + + +def recv_all(sock, n): + """接收至少 n 字节数据""" + data = b"" + while len(data) < n: + chunk = sock.recv(n - len(data)) + if not chunk: + break + data += chunk + return data + + +def recv_frame(sock): + """接收一个完整帧（自动读取足够的数据）""" + data = b"" + while True: + frame, consumed = parse_frame(data) + if frame is not None: + return frame, consumed + chunk = sock.recv(1024) + if not chunk: + return None, 0 + data += chunk + + +def test_handshake(): + """测试 WebSocket 握手""" + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.connect((HOST, PORT)) + + req, key = build_handshake() + sock.send(req.encode()) + + data = b"" + while b"\r\n\r\n" not in data: + chunk = sock.recv(1024) + if not chunk: + break + data += chunk + + status, headers = parse_response(data) + if "101" not in status: + print(f"FAIL: 期望 101，实际: {status}") + sock.close() + return False + + accept = compute_accept(key) + if headers.get("sec-websocket-accept") != accept: + print(f"FAIL: Sec-WebSocket-Accept 不匹配") + print(f" 期望: {accept}") + print(f" 实际: {headers.get('sec-websocket-accept')}") + sock.close() + return False + + print("PASS: WebSocket 握手 101 + Sec-WebSocket-Accept 正确") + sock.close() + return True + + +def test_echo(): + """测试文本帧 echo""" + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.settimeout(5.0) + sock.connect((HOST, PORT)) + + req, key = build_handshake() + sock.send(req.encode()) + + data = b"" + while b"\r\n\r\n" not in data: + chunk = sock.recv(1024) + if not chunk: + break + data += chunk + + # 发送文本帧 + msg = b"Hello, Cocoon!" + frame = build_frame(0x01, msg) + sock.send(frame) + + # 接收 echo 回显 + frame, _ = recv_frame(sock) + if frame is None: + print("FAIL: 未收到响应帧") + sock.close() + return False + + if frame["opcode"] != 0x01: + print(f"FAIL: 期望文本帧(1)，实际操作码: {frame['opcode']}") + sock.close() + return False + + if frame["payload"] != msg: + print(f"FAIL: 回显内容不匹配") + print(f" 期望: {msg}") + print(f" 实际: {frame['payload']}") + sock.close() + return False + + print("PASS: 文本帧 echo 正确") + + # 发送关闭帧 + close_frame = build_frame(0x08, b"\x03\xe8") # 1000 + sock.send(close_frame) + + # 接收关闭响应 + frame, _ = recv_frame(sock) + if frame is None or frame["opcode"] != 0x08: + print("FAIL: 未收到关闭帧响应") + sock.close() + return False + + print("PASS: 关闭帧响应正确") + sock.close() + return True + + +if __name__ == "__main__": + passed = 0 + failed = 0 + + if test_handshake(): + passed += 1 + else: + failed += 1 + + if test_echo(): + passed += 1 + else: + failed += 1 + + print(f"\n通过: {passed}, 失败: {failed}") + sys.exit(0 if failed == 0 else 1) diff --git a/tls.c b/tls.c new file mode 100644 index 0000000..def1637 --- /dev/null +++ b/tls.c @@ -0,0 +1,381 @@ +/** + * tls.c - TLS/SSL 模块实现 + * + * 使用 OpenSSL Memory BIO 与 coco 协程 I/O 集成： + * - SSL_read 从 read BIO 消费解密数据 + * - SSL_write 向 write BIO 产出加密数据 + * - 网络 I/O 由 coco_read/coco_write 或 read/write 完成 + * + * @author xfy + */ + +#include "tls.h" +#include "log.h" +#include +#include +#include +#include +#include +#include +#include + +#include "../coco/include/coco.h" + +/* 内部：TLS 连接条目 */ +typedef struct { + SSL *ssl; + BIO *rbio; /* 从 socket 读取的加密数据写入此处 */ + BIO *wbio; /* SSL_write 产出的加密数据从此读取 */ +} tls_conn_t; + +/* fd → TLS 连接映射（动态数组，O(1) 索引） */ +static tls_conn_t **g_map = NULL; +static int g_map_cap = 0; +static SSL_CTX *g_ctx = NULL; + +/* 内部：O(1) fd 查表 */ +static tls_conn_t* tls_lookup(int fd) { + if (fd >= 0 && fd < g_map_cap) return g_map[fd]; + return NULL; +} + +static void tls_map_set(int fd, tls_conn_t *t) { + if (fd >= g_map_cap) { + int old_cap = g_map_cap; + g_map_cap = fd + 1; + g_map = (tls_conn_t **)realloc(g_map, g_map_cap * sizeof(tls_conn_t *)); + for (int i = old_cap; i < g_map_cap; i++) g_map[i] = NULL; + } + g_map[fd] = t; +} + +static void tls_map_clear(int fd) { + if (fd >= 0 && fd < g_map_cap) g_map[fd] = NULL; +} + +/* 内部：从 socket 读取原始数据（协程感知） */ +static ssize_t socket_read(int fd, void *buf, size_t len) { + if (coco_sched_get_current() != NULL) { + return coco_read(fd, buf, len); + } + return read(fd, buf, len); +} + +/* 内部：向 socket 写入原始数据 */ +static ssize_t socket_write_all(int fd, const void *buf, size_t len) { + if (coco_sched_get_current() != NULL) { + size_t sent = 0; + while (sent < len) { + ssize_t n = coco_write(fd, (const char *)buf + sent, len - sent); + if (n > 0) { + sent += (size_t)n; + } else if (n < 0) { + if (n == -EAGAIN || n == -EINTR || n == COCO_ERROR_WOULD_BLOCK) continue; + return -1; + } else { + return -1; + } + } + return (ssize_t)sent; + } else { + size_t sent = 0; + while (sent < len) { + ssize_t n = write(fd, (const char *)buf + sent, len - sent); + if (n > 0) { + sent += (size_t)n; + } else if (n < 0) { + if (errno == EAGAIN || errno == EINTR) continue; + return -1; + } else { + return -1; + } + } + return (ssize_t)sent; + } +} + +/* 内部：将 write BIO 中的加密数据刷到 socket */ +static int flush_wbio(int fd, BIO *wbio) { + char buf[16384]; + int pending = BIO_read(wbio, buf, sizeof(buf)); + while (pending > 0) { + if (socket_write_all(fd, buf, (size_t)pending) < 0) return -1; + pending = BIO_read(wbio, buf, sizeof(buf)); + } + return 0; +} + +/* 内部：ALPN 选择回调，优先选择 h2，否则 http/1.1 */ +static int tls_alpn_select_cb(SSL *ssl __attribute__((unused)), const unsigned char **out, + unsigned char *outlen, const unsigned char *in, + unsigned int inlen, void *arg __attribute__((unused))) { + const unsigned char *h2 = (const unsigned char *)"h2"; + const unsigned char *http11 = (const unsigned char *)"http/1.1"; + unsigned int h2_len = 2; + unsigned int http11_len = 8; + + /* 客户端发送的 ALPN 列表格式：长度前缀字符串序列 */ + const unsigned char *p = in; + unsigned int remaining = inlen; + + while (remaining > 0) { + unsigned char len = *p; + p++; + remaining--; + if (len > remaining) break; + + /* 优先匹配 h2 */ + if (len == h2_len && memcmp(p, h2, h2_len) == 0) { + *out = p; + *outlen = h2_len; + return SSL_TLSEXT_ERR_OK; + } + /* 次选 http/1.1 */ + if (len == http11_len && memcmp(p, http11, http11_len) == 0) { + *out = p; + *outlen = http11_len; + return SSL_TLSEXT_ERR_OK; + } + + p += len; + remaining -= len; + } + + return SSL_TLSEXT_ERR_NOACK; +} + +/* ===== 公共 API ===== */ + +int tls_create_context(const char *cert_path, const char *key_path) { + if (!cert_path || !key_path) return -1; + + SSL_library_init(); + OpenSSL_add_all_algorithms(); + SSL_load_error_strings(); + + const SSL_METHOD *method = TLS_server_method(); + if (!method) return -1; + + g_ctx = SSL_CTX_new(method); + if (!g_ctx) return -1; + + /* 最低 TLS 1.2 */ + SSL_CTX_set_min_proto_version(g_ctx, TLS1_2_VERSION); + + /* 加载证书 */ + if (SSL_CTX_use_certificate_file(g_ctx, cert_path, SSL_FILETYPE_PEM) <= 0) { + log_error("加载 TLS 证书失败: %s", cert_path); + SSL_CTX_free(g_ctx); + g_ctx = NULL; + return -1; + } + + /* 加载私钥 */ + if (SSL_CTX_use_PrivateKey_file(g_ctx, key_path, SSL_FILETYPE_PEM) <= 0) { + log_error("加载 TLS 私钥失败: %s", key_path); + SSL_CTX_free(g_ctx); + g_ctx = NULL; + return -1; + } + + /* 验证私钥与证书匹配 */ + if (!SSL_CTX_check_private_key(g_ctx)) { + log_error("TLS 私钥与证书不匹配"); + SSL_CTX_free(g_ctx); + g_ctx = NULL; + return -1; + } + + /* 注册 ALPN 回调，支持 HTTP/2 和 HTTP/1.1 协商 */ + SSL_CTX_set_alpn_select_cb(g_ctx, tls_alpn_select_cb, NULL); + + log_info("TLS 上下文已初始化: cert=%s", cert_path); + return 0; +} + +void tls_destroy_context(void) { + if (g_ctx) { + SSL_CTX_free(g_ctx); + g_ctx = NULL; + } + if (g_map) { + for (int i = 0; i < g_map_cap; i++) { + if (g_map[i]) { + if (g_map[i]->ssl) SSL_free(g_map[i]->ssl); + if (g_map[i]->rbio) BIO_free(g_map[i]->rbio); + if (g_map[i]->wbio) BIO_free(g_map[i]->wbio); + free(g_map[i]); + } + } + free(g_map); + g_map = NULL; + g_map_cap = 0; + } +} + +bool tls_has_context(void) { + return g_ctx != NULL; +} + +int tls_accept(int fd) { + if (!g_ctx) return -1; + + tls_conn_t *t = (tls_conn_t *)calloc(1, sizeof(tls_conn_t)); + if (!t) return -1; + + t->ssl = SSL_new(g_ctx); + if (!t->ssl) { + free(t); + return -1; + } + + /* 创建 Memory BIO 对 */ + t->rbio = BIO_new(BIO_s_mem()); + t->wbio = BIO_new(BIO_s_mem()); + if (!t->rbio || !t->wbio) { + SSL_free(t->ssl); + free(t); + return -1; + } + + BIO_set_mem_eof_return(t->rbio, -1); + BIO_set_mem_eof_return(t->wbio, -1); + SSL_set_bio(t->ssl, t->rbio, t->wbio); + SSL_set_accept_state(t->ssl); + + tls_map_set(fd, t); + + /* 执行握手循环 */ + while (1) { + int ret = SSL_do_handshake(t->ssl); + if (ret == 1) { + log_debug("TLS 握手完成 fd=%d", fd); + return 0; /* 成功 */ + } + + int err = SSL_get_error(t->ssl, ret); + if (err == SSL_ERROR_WANT_READ) { + /* 尝试先刷出 write BIO 中的数据 */ + if (flush_wbio(fd, t->wbio) < 0) goto fail; + + /* 从 socket 读取加密数据 */ + char buf[8192]; + ssize_t n = socket_read(fd, buf, sizeof(buf)); + if (n > 0) { + BIO_write(t->rbio, buf, (int)n); + } else if (n < 0) { + if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) { + /* 非阻塞模式下暂时无数据，继续尝试 */ + continue; + } + goto fail; + } else { + goto fail; + } + } else if (err == SSL_ERROR_WANT_WRITE) { + if (flush_wbio(fd, t->wbio) < 0) goto fail; + } else { + log_error("TLS 握手失败 fd=%d, err=%d", fd, err); + goto fail; + } + } + +fail: + tls_map_clear(fd); + SSL_free(t->ssl); + free(t); + return -1; +} + +ssize_t tls_read(int fd, void *buf, size_t len) { + tls_conn_t *t = tls_lookup(fd); + if (!t || !t->ssl) return -1; + + while (1) { + int ret = SSL_read(t->ssl, buf, (int)len); + if (ret > 0) return (ssize_t)ret; + + int err = SSL_get_error(t->ssl, ret); + if (err == SSL_ERROR_WANT_READ) { + /* 从 socket 读取加密数据 */ + char tmp[8192]; + ssize_t n = socket_read(fd, tmp, sizeof(tmp)); + if (n > 0) { + BIO_write(t->rbio, tmp, (int)n); + } else { + return n; /* 0 或 -1 */ + } + } else if (err == SSL_ERROR_WANT_WRITE) { + if (flush_wbio(fd, t->wbio) < 0) return -1; + } else if (err == SSL_ERROR_ZERO_RETURN) { + return 0; /* 对端关闭 */ + } else { + return -1; + } + } +} + +ssize_t tls_write(int fd, const void *buf, size_t len) { + tls_conn_t *t = tls_lookup(fd); + if (!t || !t->ssl) return -1; + + size_t total = 0; + while (total < len) { + int ret = SSL_write(t->ssl, (const char *)buf + total, (int)(len - total)); + if (ret > 0) { + total += (size_t)ret; + /* 刷出 write BIO */ + if (flush_wbio(fd, t->wbio) < 0) return -1; + } else { + int err = SSL_get_error(t->ssl, ret); + if (err == SSL_ERROR_WANT_READ) { + char tmp[8192]; + ssize_t n = socket_read(fd, tmp, sizeof(tmp)); + if (n > 0) { + BIO_write(t->rbio, tmp, (int)n); + } else { + return -1; + } + } else if (err == SSL_ERROR_WANT_WRITE) { + if (flush_wbio(fd, t->wbio) < 0) return -1; + } else { + return -1; + } + } + } + return (ssize_t)total; +} + +void tls_close(int fd) { + tls_conn_t *t = tls_lookup(fd); + if (!t) return; + + if (t->ssl) { + SSL_shutdown(t->ssl); + /* 刷出最后的 close_notify */ + flush_wbio(fd, t->wbio); + SSL_free(t->ssl); + } + /* rbio/wbio 已被 SSL_free 释放（SSL_set_bio 转移所有权） */ + + tls_map_clear(fd); + free(t); +} + +bool tls_has_connection(int fd) { + return tls_lookup(fd) != NULL; +} + +bool tls_negotiated_http2(int fd) { + tls_conn_t *t = tls_lookup(fd); + if (!t || !t->ssl) return false; + + const unsigned char *alpn = NULL; + unsigned int alpn_len = 0; + SSL_get0_alpn_selected(t->ssl, &alpn, &alpn_len); + + if (alpn_len == 2 && memcmp(alpn, "h2", 2) == 0) { + return true; + } + return false; +} diff --git a/tls.h b/tls.h new file mode 100644 index 0000000..17cfdc9 --- /dev/null +++ b/tls.h @@ -0,0 +1,102 @@ +/** + * tls.h - TLS/SSL 模块接口 + * + * 基于 OpenSSL 实现 HTTPS 支持，使用 Memory BIO 与 coco 协程 I/O 集成。 + * + * 设计: + * - 全局 SSL_CTX 管理证书和私钥 + * - 每个连接独立的 SSL* + Memory BIO 对 + * - fd→SSL 映射表，使 send_all 等现有代码透明支持 TLS + * - SSL_read/write 的 WANT_READ/WANT_WRITE 通过 coco_read/write 协程化 + * + * @author xfy + */ + +#ifndef COCOON_TLS_H +#define COCOON_TLS_H + +#include +#include +#include + +/** + * tls_create_context - 创建全局 TLS 上下文 + * + * 加载证书和私钥，初始化 OpenSSL。 + * + * @param cert_path PEM 格式证书路径 + * @param key_path PEM 格式私钥路径 + * @return 0 成功，-1 失败 + */ +int tls_create_context(const char *cert_path, const char *key_path); + +/** + * tls_destroy_context - 销毁全局 TLS 上下文 + */ +void tls_destroy_context(void); + +/** + * tls_has_context - 检查 TLS 上下文是否已创建 + */ +bool tls_has_context(void); + +/** + * tls_accept - 为指定 fd 创建 SSL 连接并完成握手 + * + * 在协程上下文中调用，WANT_READ/WANT_WRITE 时自动 yield。 + * + * @param fd 已连接的客户端 socket + * @return 0 成功，-1 失败 + */ +int tls_accept(int fd); + +/** + * tls_read - 从 TLS 连接读取解密后的数据 + * + * 在协程上下文中调用，数据不足时自动 yield。 + * + * @param fd 客户端 socket + * @param buf 输出缓冲区 + * @param len 最大读取字节数 + * @return 读取字节数，0 对端关闭，-1 错误 + */ +ssize_t tls_read(int fd, void *buf, size_t len); + +/** + * tls_write - 向 TLS 连接写入明文数据（自动加密后发送） + * + * @param fd 客户端 socket + * @param buf 待发送数据 + * @param len 数据长度 + * @return 写入字节数（明文），-1 错误 + */ +ssize_t tls_write(int fd, const void *buf, size_t len); + +/** + * tls_close - 关闭 TLS 连接并释放资源 + * + * 执行 SSL_shutdown，清理 fd 映射。 + * + * @param fd 客户端 socket + */ +void tls_close(int fd); + +/** + * tls_has_connection - 检查 fd 是否关联了 TLS 连接 + * + * @param fd 客户端 socket + * @return true 是 TLS 连接 + */ +bool tls_has_connection(int fd); + +/** + * tls_negotiated_http2 - 检查 ALPN 是否协商为 HTTP/2 + * + * 在 TLS 握手成功后调用。 + * + * @param fd 客户端 socket + * @return true 协商为 h2 + */ +bool tls_negotiated_http2(int fd); + +#endif /* COCOON_TLS_H */ diff --git a/websocket.c b/websocket.c new file mode 100644 index 0000000..a9ad845 --- /dev/null +++ b/websocket.c @@ -0,0 +1,338 @@ +/** + * @file websocket.c + * @brief WebSocket 协议实现（RFC 6455） + * + * 支持握手、帧解析、帧编码、连接管理。 + * 当前为简单 echo 服务器，可扩展为消息路由或广播。 + */ + +#include "websocket.h" +#include "log.h" +#include +#include +#include +#include +#include +#include +#include + +/* WebSocket 魔数字符串（GUID） */ +static const char WS_GUID[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; + +/* 基础 64 编码表 */ +static const char BASE64_TABLE[] = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + +/** + * @brief 简单 Base64 编码（内部使用） + * + * @param in 输入数据 + * @param in_len 输入长度 + * @param out 输出缓冲区（至少 4/3 * in_len + 4 字节） + * @return 输出字符串长度 + */ +static size_t base64_encode(const uint8_t *in, size_t in_len, char *out) { + size_t i, j; + for (i = 0, j = 0; i + 2 < in_len; i += 3, j += 4) { + uint32_t v = ((uint32_t)in[i] << 16) | ((uint32_t)in[i + 1] << 8) | in[i + 2]; + out[j] = BASE64_TABLE[(v >> 18) & 0x3F]; + out[j + 1] = BASE64_TABLE[(v >> 12) & 0x3F]; + out[j + 2] = BASE64_TABLE[(v >> 6) & 0x3F]; + out[j + 3] = BASE64_TABLE[v & 0x3F]; + } + if (i < in_len) { + uint32_t v = (uint32_t)in[i] << 16; + if (i + 1 < in_len) v |= (uint32_t)in[i + 1] << 8; + out[j] = BASE64_TABLE[(v >> 18) & 0x3F]; + out[j + 1] = BASE64_TABLE[(v >> 12) & 0x3F]; + out[j + 2] = (i + 1 < in_len) ? BASE64_TABLE[(v >> 6) & 0x3F] : '='; + out[j + 3] = '='; + j += 4; + } + out[j] = '\0'; + return j; +} + +/** + * @brief 生成 WebSocket 握手响应的 Sec-WebSocket-Accept + * + * 对 key + GUID 计算 SHA1，然后 Base64 编码。 + * + * @param key 客户端 Sec-WebSocket-Key + * @param accept 输出缓冲区（至少 32 字节） + * @return 0 成功 + */ +static int ws_compute_accept(const char *key, char *accept) { + char concat[128]; + size_t key_len = strlen(key); + if (key_len + sizeof(WS_GUID) >= sizeof(concat)) return -1; + + memcpy(concat, key, key_len); + memcpy(concat + key_len, WS_GUID, sizeof(WS_GUID) - 1); + concat[key_len + sizeof(WS_GUID) - 1] = '\0'; + + unsigned char digest[SHA_DIGEST_LENGTH]; + SHA1((unsigned char *)concat, key_len + sizeof(WS_GUID) - 1, digest); + + base64_encode(digest, SHA_DIGEST_LENGTH, accept); + return 0; +} + +/** + * @brief 发送完整的 HTTP 响应 + * + * @param fd 客户端 socket + * @param buf 数据 + * @param len 长度 + * @return 0 成功，-1 失败 + */ +static int ws_send_all(int fd, const char *buf, size_t len) { + size_t sent = 0; + while (sent < len) { + ssize_t n = send(fd, buf + sent, len - sent, MSG_NOSIGNAL); + if (n > 0) { + sent += (size_t)n; + } else if (n < 0 && (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)) { + continue; + } else { + return -1; + } + } + return 0; +} + +int ws_handshake(int fd, const char *key) { + char accept[32]; + if (ws_compute_accept(key, accept) != 0) return -1; + + char response[512]; + int n = snprintf(response, sizeof(response), + "HTTP/1.1 101 Switching Protocols\r\n" + "Upgrade: websocket\r\n" + "Connection: Upgrade\r\n" + "Sec-WebSocket-Accept: %s\r\n" + "Server: Cocoon/1.0\r\n" + "\r\n", + accept); + + if (n < 0 || (size_t)n >= sizeof(response)) return -1; + return ws_send_all(fd, response, (size_t)n); +} + +int ws_parse_frame(const uint8_t *data, size_t len, ws_frame_t *frame, size_t *consumed) { + if (len < 2) return -1; /* 至少需要 2 字节 */ + + uint8_t b0 = data[0]; + uint8_t b1 = data[1]; + + frame->fin = (b0 >> 7) & 1; + frame->opcode = b0 & 0x0F; + frame->masked = (b1 >> 7) & 1; + uint64_t payload_len = b1 & 0x7F; + + size_t header_len = 2; + + if (payload_len == 126) { + if (len < 4) return -1; + payload_len = ((uint64_t)data[2] << 8) | data[3]; + header_len = 4; + } else if (payload_len == 127) { + if (len < 10) return -1; + payload_len = 0; + for (int i = 0; i < 8; i++) { + payload_len = (payload_len << 8) | data[2 + i]; + } + header_len = 10; + } + + if (frame->masked) { + if (len < header_len + 4) return -1; + memcpy(frame->mask_key, data + header_len, 4); + header_len += 4; + } + + if (len < header_len + payload_len) return -1; + + frame->payload_len = payload_len; + if (payload_len > 0) { + frame->payload = (uint8_t *)malloc(payload_len + 1); + if (!frame->payload) return -2; + memcpy(frame->payload, data + header_len, payload_len); + if (frame->masked) { + for (uint64_t i = 0; i < payload_len; i++) { + frame->payload[i] ^= frame->mask_key[i % 4]; + } + } + frame->payload[payload_len] = '\0'; + } else { + frame->payload = NULL; + } + + *consumed = header_len + payload_len; + return 0; +} + +void ws_frame_free(ws_frame_t *frame) { + if (frame && frame->payload) { + free(frame->payload); + frame->payload = NULL; + } +} + +int ws_send_frame(int fd, uint8_t opcode, const uint8_t *payload, size_t len) { + uint8_t header[14]; + size_t header_len = 0; + + header[0] = 0x80 | (opcode & 0x0F); /* FIN=1, opcode */ + + if (len <= 125) { + header[1] = (uint8_t)len; + header_len = 2; + } else if (len <= 65535) { + header[1] = 126; + header[2] = (uint8_t)(len >> 8); + header[3] = (uint8_t)(len & 0xFF); + header_len = 4; + } else { + header[1] = 127; + for (int i = 0; i < 8; i++) { + header[2 + i] = (uint8_t)(len >> (56 - i * 8)); + } + header_len = 10; + } + + /* 服务器发送不掩码 */ + if (ws_send_all(fd, (char *)header, header_len) != 0) return -1; + if (len > 0 && ws_send_all(fd, (char *)payload, len) != 0) return -1; + return 0; +} + +int ws_send_text(int fd, const char *text) { + return ws_send_frame(fd, WS_OP_TEXT, (const uint8_t *)text, strlen(text)); +} + +int ws_send_close(int fd, uint16_t code, const char *reason) { + uint8_t payload[128]; + size_t len = 0; + if (code != 0) { + payload[0] = (uint8_t)(code >> 8); + payload[1] = (uint8_t)(code & 0xFF); + len = 2; + if (reason) { + size_t rlen = strlen(reason); + if (rlen > sizeof(payload) - 3) rlen = sizeof(payload) - 3; + memcpy(payload + 2, reason, rlen); + len += rlen; + } + } + return ws_send_frame(fd, WS_OP_CLOSE, payload, len); +} + +int ws_send_ping(int fd) { + return ws_send_frame(fd, WS_OP_PING, NULL, 0); +} + +int ws_send_pong(int fd, const uint8_t *payload, size_t len) { + return ws_send_frame(fd, WS_OP_PONG, payload, len); +} + +/** + * @brief 从连接读取数据（简单阻塞读取） + */ +static ssize_t ws_read_data(int fd, uint8_t *buf, size_t max_len) { + ssize_t n = recv(fd, buf, max_len, 0); + return n; +} + +void ws_handle_connection(int fd, uint32_t timeout_ms) { + (void)timeout_ms; /* TODO: 超时处理 */ + + uint8_t buf[8192]; + size_t buf_len = 0; + bool closed = false; + + log_info("WebSocket 连接建立 fd=%d", fd); + + while (!closed) { + ssize_t n = ws_read_data(fd, buf + buf_len, sizeof(buf) - buf_len); + if (n <= 0) { + if (n < 0 && (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)) { + continue; + } + log_debug("WebSocket fd=%d 读取结束或错误", fd); + break; + } + buf_len += (size_t)n; + + /* 解析帧 */ + size_t parsed = 0; + while (parsed < buf_len) { + ws_frame_t frame = {0}; + size_t consumed = 0; + int ret = ws_parse_frame(buf + parsed, buf_len - parsed, &frame, &consumed); + if (ret == -1) { + break; /* 数据不完整，等待更多 */ + } + if (ret == -2) { + log_warn("WebSocket fd=%d 收到畸形帧", fd); + ws_send_close(fd, 1002, "Protocol error"); + closed = true; + break; + } + + parsed += consumed; + + switch (frame.opcode) { + case WS_OP_TEXT: + log_debug("WebSocket fd=%d 收到文本: %s", fd, + frame.payload ? (char *)frame.payload : "(empty)"); + if (frame.fin) { + ws_send_text(fd, frame.payload ? (char *)frame.payload : ""); + } + break; + + case WS_OP_BINARY: + log_debug("WebSocket fd=%d 收到二进制 %llu 字节", fd, + (unsigned long long)frame.payload_len); + /* 简单 echo 回二进制 */ + ws_send_frame(fd, WS_OP_BINARY, frame.payload, frame.payload_len); + break; + + case WS_OP_CLOSE: + log_info("WebSocket fd=%d 收到关闭帧", fd); + ws_send_close(fd, 1000, NULL); + closed = true; + break; + + case WS_OP_PING: + log_debug("WebSocket fd=%d 收到 Ping", fd); + ws_send_pong(fd, frame.payload, frame.payload_len); + break; + + case WS_OP_PONG: + log_debug("WebSocket fd=%d 收到 Pong", fd); + break; + + case WS_OP_CONT: + log_debug("WebSocket fd=%d 收到继续帧", fd); + break; + + default: + log_warn("WebSocket fd=%d 未知操作码 %d", fd, frame.opcode); + break; + } + + ws_frame_free(&frame); + } + + /* 移动剩余数据到缓冲区开头 */ + if (parsed > 0 && parsed < buf_len) { + memmove(buf, buf + parsed, buf_len - parsed); + buf_len -= parsed; + } else if (parsed == buf_len) { + buf_len = 0; + } + } + + log_info("WebSocket 连接关闭 fd=%d", fd); +} diff --git a/websocket.h b/websocket.h new file mode 100644 index 0000000..4601f86 --- /dev/null +++ b/websocket.h @@ -0,0 +1,130 @@ +#ifndef WEBSOCKET_H +#define WEBSOCKET_H + +#include +#include +#include + +/** + * @file websocket.h + * @brief WebSocket 协议实现 + * + * 支持 RFC 6455 WebSocket 握手、帧解析与编码。 + * 服务器端实现：不发送掩码（mask=0），接收客户端掩码帧。 + */ + +/** + * @brief WebSocket 操作码 + */ +typedef enum { + WS_OP_CONT = 0x0, /**< 继续帧 */ + WS_OP_TEXT = 0x1, /**< 文本帧 */ + WS_OP_BINARY = 0x2, /**< 二进制帧 */ + WS_OP_CLOSE = 0x8, /**< 关闭帧 */ + WS_OP_PING = 0x9, /**< Ping 帧 */ + WS_OP_PONG = 0xA /**< Pong 帧 */ +} ws_opcode_t; + +/** + * @brief WebSocket 帧结构 + */ +typedef struct { + uint8_t opcode; /**< 操作码 */ + bool fin; /**< 是否为最后一帧 */ + bool masked; /**< 是否掩码 */ + uint64_t payload_len;/**< 负载长度 */ + uint8_t mask_key[4]; /**< 掩码密钥（仅客户端发送时有效） */ + uint8_t *payload; /**< 负载数据（已解掩码） */ +} ws_frame_t; + +/** + * @brief 执行 WebSocket 握手响应 + * + * 根据 RFC 6455，对 Sec-WebSocket-Key 计算 SHA1 + Base64 响应。 + * + * @param fd 客户端 socket + * @param key 客户端发来的 Sec-WebSocket-Key + * @return 0 成功，-1 失败 + */ +int ws_handshake(int fd, const char *key); + +/** + * @brief 解析单个 WebSocket 帧 + * + * 从数据流中解析一个完整帧。如果数据不完整，返回 -1 且不修改 frame。 + * + * @param data 输入数据 + * @param len 数据长度 + * @param frame 输出帧结构（调用者需初始化） + * @param consumed 输出：消耗的字节数 + * @return 0 成功，-1 数据不完整，-2 格式错误 + */ +int ws_parse_frame(const uint8_t *data, size_t len, ws_frame_t *frame, size_t *consumed); + +/** + * @brief 释放帧占用的负载内存 + * + * @param frame 帧指针 + */ +void ws_frame_free(ws_frame_t *frame); + +/** + * @brief 发送 WebSocket 帧 + * + * @param fd 客户端 socket + * @param opcode 操作码 + * @param payload 负载数据 + * @param len 负载长度 + * @return 0 成功，-1 失败 + */ +int ws_send_frame(int fd, uint8_t opcode, const uint8_t *payload, size_t len); + +/** + * @brief 发送文本帧 + * + * @param fd 客户端 socket + * @param text 文本内容（UTF-8） + * @return 0 成功，-1 失败 + */ +int ws_send_text(int fd, const char *text); + +/** + * @brief 发送关闭帧 + * + * @param fd 客户端 socket + * @param code 关闭码（如 1000） + * @param reason 关闭原因（可为 NULL） + * @return 0 成功，-1 失败 + */ +int ws_send_close(int fd, uint16_t code, const char *reason); + +/** + * @brief 发送 Ping 帧 + * + * @param fd 客户端 socket + * @return 0 成功，-1 失败 + */ +int ws_send_ping(int fd); + +/** + * @brief 发送 Pong 帧 + * + * @param fd 客户端 socket + * @param payload Ping 的负载（可为 NULL） + * @param len 负载长度 + * @return 0 成功，-1 失败 + */ +int ws_send_pong(int fd, const uint8_t *payload, size_t len); + +/** + * @brief 处理 WebSocket 连接（主循环） + * + * 进入 WebSocket 帧循环，处理文本/二进制/ping/pong/close。 + * 当前实现为简单 echo 服务器。 + * + * @param fd 客户端 socket + * @param timeout_ms 超时毫秒（0 表示默认） + */ +void ws_handle_connection(int fd, uint32_t timeout_ms); + +#endif /* WEBSOCKET_H */ diff --git a/www/index.html b/www/index.html new file mode 100644 index 0000000..b7cc039 --- /dev/null +++ b/www/index.html @@ -0,0 +1 @@ +Hello Cocoon