Add URL rewrite support for HTTP static file handler, GH-2732

Author: matyhtf

examples/http/url_rewrite.php

@@ -0,0 +1,39 @@
+<?php
+/**
+ * URL重写功能测试
+ */
+
+$http = new Swoole\Http\Server("0.0.0.0", 9501, SWOOLE_BASE);
+
+$http->set([
+    'enable_static_handler' => true,
+    'document_root' => realpath(__DIR__.'/../www/'),
+    'http_autoindex' => true,
+    // URL重写规则配置
+    'url_rewrite_rules' => [
+        // 普通路径重写: 将 /api 开头的请求重写到 /static/api 目录
+        '/api' => '/static/api',
+        
+        // 正则表达式重写: 将 /user/123 格式的请求重写到 /static/user.html?id=123
+        '~^/user/(\\d+)$~' => '/static/user.html?id=$1',
+        
+        // 正则表达式重写: 将 /article/title-slug 格式的请求重写到 /static/article.html?slug=title-slug
+        '~^/article/([\\w\\-]+)$~' => '/static/article.html?slug=$1'
+    ]
+]);
+
+$http->on('request', function ($request, $response) {
+    $response->header('Content-Type', 'text/plain; charset=utf-8');
+    $response->end("动态处理: " . $request->server['request_uri']);
+});
+
+$http->on('start', function ($server) {
+    echo "HTTP服务器已启动，监听 0.0.0.0:9501\n";
+    echo "URL重写功能已启用\n";
+    echo "测试示例:\n";
+    echo "1. 普通重写: http://localhost:9501/api/test.txt -> /static/api/test.txt\n";
+    echo "2. 正则重写: http://localhost:9501/user/123 -> /static/user.html?id=123\n";
+    echo "3. 正则重写: http://localhost:9501/article/test-title -> /static/article.html?slug=test-title\n";
+});
+
+$http->start();

ext-src/php_swoole_library.h

@@ -568,6 +568,8 @@ static const char* swoole_library_source_core_constant =
     "\n"
     "    public const OPTION_DOCUMENT_ROOT = 'document_root';\n"
     "\n"
+    "    public const OPTION_URL_REWRITE_RULES = 'url_rewrite_rules';\n"
+    "\n"
     "    public const OPTION_HTTP_AUTOINDEX = 'http_autoindex';\n"
     "\n"
     "    public const OPTION_HTTP_INDEX_FILES = 'http_index_files';\n"
@@ -8560,6 +8562,7 @@ static const char* swoole_library_source_core_server_helper =
     "        'upload_max_filesize'         => true,\n"
     "        'enable_static_handler'       => true,\n"
     "        'document_root'               => true,\n"
+    "        'url_rewrite_rules'           => true,\n"
     "        'http_autoindex'              => true,\n"
     "        'http_index_files'            => true,\n"
     "        'http_compression_types'      => true,\n"

ext-src/swoole_http2_server.cc

@@ -189,7 +189,7 @@ static bool http2_server_is_static_file(Server *serv, HttpContext *ctx) {
     zval *zrequest_uri = zend_hash_str_find(Z_ARR_P(zserver), ZEND_STRL("request_uri"));
     if (zrequest_uri && Z_TYPE_P(zrequest_uri) == IS_STRING) {
         StaticHandler handler(serv, Z_STRVAL_P(zrequest_uri), Z_STRLEN_P(zrequest_uri));
-        if (!handler.hit()) {
+        if (!handler.try_serve()) {
             return false;
         }
 
@@ -204,7 +204,7 @@ static bool http2_server_is_static_file(Server *serv, HttpContext *ctx) {
          * if http_index_files is enabled, need to search the index file first.
          * if the index file is found, set filename to index filename.
          */
-        if (!handler.hit_index_file()) {
+        if (!handler.try_serve_index_file()) {
             return false;
         }
 
@@ -1177,9 +1177,9 @@ int swoole_http2_server_parse(const std::shared_ptr<Http2Session> &client, const
 
             // Exceeded the max_body_size, or if the stream has ended, sends RST_STREAM frame, stops receiving data
             if (buffer->length + length > client->max_body_size || ctx->end_) {
-            	http2_server_send_rst_stream(ctx, 0);
-            	client->remove_stream(stream_id);
-				break;
+                http2_server_send_rst_stream(ctx, 0);
+                client->remove_stream(stream_id);
+                break;
             }
 
             buffer->append(buf, length);

ext-src/swoole_server.cc

@@ -2367,6 +2367,29 @@ static PHP_METHOD(swoole_server, set) {
             RETURN_FALSE;
         }
     }
+    /**
+     * [url_rewrite] rules
+     */
+    if (php_swoole_array_get_value(vht, "url_rewrite_rules", ztmp)) {
+        if (ZVAL_IS_ARRAY(ztmp)) {
+            zval *replacement;
+            zend_string *pattern;
+            ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(ztmp), pattern, replacement) {
+                ZVAL_DEREF(replacement);
+                if (Z_TYPE_P(replacement) == IS_STRING) {
+                    serv->add_rewrite_rule(std::string(ZSTR_VAL(pattern), ZSTR_LEN(pattern)),
+                                           std::string(Z_STRVAL_P(replacement), Z_STRLEN_P(replacement)));
+                } else {
+                    php_swoole_fatal_error(E_ERROR, "The `replacement` must be string");
+                    RETURN_FALSE;
+                }
+            }
+            ZEND_HASH_FOREACH_END();
+        } else {
+            php_swoole_fatal_error(E_ERROR, "The `url_rewrite_rules` must be array");
+            RETURN_FALSE;
+        }
+    }
     /**
      * buffer input size
      */

include/swoole_server.h

@@ -49,7 +49,9 @@ namespace swoole {
 
 namespace http_server {
 struct Request;
-}
+struct RewriteRule;
+class StaticHandler;
+}  // namespace http_server
 
 class Server;
 struct Manager;
@@ -1143,7 +1145,9 @@ class Server {
     void add_static_handler_location(const std::string &);
     void add_static_handler_index_files(const std::string &);
     bool select_static_handler(const http_server::Request *request, const Connection *conn);
+    bool apply_rewrite_rules(http_server::StaticHandler *handler);
     void add_http_compression_type(const std::string &type);
+    void add_rewrite_rule(const std::string &pattern, const std::string &replacement);
 
     int create();
     bool create_worker_pipes();
@@ -1663,6 +1667,8 @@ class Server {
      * http static file directory
      */
     std::string document_root;
+
+    std::shared_ptr<std::vector<http_server::RewriteRule>> rewrite_rules;
     std::mutex lock_;
     uint32_t max_connection = 0;
     TimerNode *enable_accept_timer = nullptr;

include/swoole_static_handler.h

@@ -25,10 +25,18 @@
 
 namespace swoole {
 namespace http_server {
+
+struct RewriteRule {
+    std::string pattern;
+    std::string replacement;
+    bool is_regex;
+};
+
 class StaticHandler {
   private:
     Server *serv;
     std::string request_url;
+    std::string original_url;
     std::string dir_path;
     std::set<std::string> dir_files;
     std::string index_file;
@@ -50,16 +58,17 @@ class StaticHandler {
 
   public:
     int status_code = SW_HTTP_OK;
-    StaticHandler(Server *_server, const char *url, size_t url_length) : request_url(url, url_length) {
+    StaticHandler(Server *_server, const char *url, size_t url_length)
+        : request_url(url, url_length), original_url(url, url_length) {
         serv = _server;
     }
 
     /**
      * @return true: continue to execute backwards
      * @return false: break static handler
      */
-    bool hit();
-    bool hit_index_file();
+    bool try_serve();
+    bool try_serve_index_file();
 
     bool is_modified(const std::string &date_if_modified_since) const;
     bool is_modified_range(const std::string &date_range) const;
@@ -100,6 +109,14 @@ class StaticHandler {
         return filename;
     }
 
+    const std::string &get_request_url() const {
+        return request_url;
+    }
+
+    void set_request_url(const std::string &rewritten_url) {
+        request_url = rewritten_url;
+    }
+
     const std::string &get_boundary() {
         if (boundary.empty()) {
             boundary = std::string(SW_HTTP_SERVER_BOUNDARY_PREKEY);
@@ -127,6 +144,10 @@ class StaticHandler {
 
     bool get_absolute_path();
 
+    const std::string &get_original_url() const {
+        return original_url;
+    }
+
     size_t get_filesize() const {
         return file_stat.st_size;
     }

include/swoole_util.h

@@ -248,6 +248,13 @@ static inline bool starts_with(const char *haystack, size_t l_haystack, const ch
     return memcmp(haystack, needle, l_needle) == 0;
 }
 
+static inline bool starts_with(const std::string &str, const std::string &prefix) {
+    if (prefix.size() > str.size()) {
+        return false;
+    }
+    return std::equal(prefix.begin(), prefix.end(), str.begin());
+}
+
 static inline bool ends_with(const char *haystack, size_t l_haystack, const char *needle, size_t l_needle) {
     if (l_needle > l_haystack) {
         return false;

scripts/format-changed-files.sh

@@ -17,7 +17,7 @@ if [ ! -z "$cpp_files" ]; then
     echo "Formatting C/C++ files..."
     for file in $cpp_files; do
         # 额外检查确保不处理 _arginfo.h 文件
-        if [[ "$file" != *_arginfo.h ]]; then
+        if [[ "$file" != *_arginfo.h && "$file" != "ext-src/php_swoole_library.h" ]]; then
             echo "  - $file"
             clang-format -i "$file"
         fi

src/server/static_handler.cc

@@ -21,6 +21,7 @@
 #include <dirent.h>
 #include <algorithm>
 #include <sstream>
+#include <regex>
 
 namespace swoole {
 namespace http_server {
@@ -101,7 +102,9 @@ bool StaticHandler::get_absolute_path() {
     return true;
 }
 
-bool StaticHandler::hit() {
+bool StaticHandler::try_serve() {
+    serv->apply_rewrite_rules(this);
+
     char *p = filename;
     const char *url = request_url.c_str();
     size_t url_length = request_url.length();
@@ -189,7 +192,7 @@ bool StaticHandler::hit() {
     return true;
 }
 
-bool StaticHandler::hit_index_file() {
+bool StaticHandler::try_serve_index_file() {
     if (serv->http_index_files && !serv->http_index_files->empty() && is_dir()) {
         if (!get_dir_files()) {
             return false;
@@ -441,6 +444,25 @@ void StaticHandler::parse_range(const char *range, const char *if_range) {
     }
 }
 }  // namespace http_server
+
+void Server::add_rewrite_rule(const std::string &pattern, const std::string &replacement) {
+    if (rewrite_rules == nullptr) {
+        rewrite_rules = std::make_shared<std::vector<http_server::RewriteRule>>();
+    }
+
+    http_server::RewriteRule rule;
+    rule.replacement = replacement;
+
+    if (pattern.length() >= 2 && pattern.at(0) == '~' && pattern.at(pattern.length() - 1) == '~') {
+        rule.pattern = pattern.substr(1, pattern.length() - 2);
+        rule.is_regex = true;
+    } else {
+        rule.pattern = pattern;
+        rule.is_regex = false;
+    }
+    rewrite_rules->emplace_back(rule);
+}
+
 void Server::add_static_handler_location(const std::string &location) {
     if (locations == nullptr) {
         locations = std::make_shared<std::unordered_set<std::string>>();
@@ -464,7 +486,7 @@ bool Server::select_static_handler(const http_server::Request *request, const Co
     size_t url_length = request->url_length_;
 
     http_server::StaticHandler handler(this, url, url_length);
-    if (!handler.hit()) {
+    if (!handler.try_serve()) {
         return false;
     }
 
@@ -515,7 +537,7 @@ bool Server::select_static_handler(const http_server::Request *request, const Co
      * if http_index_files is enabled, need to search the index file first.
      * if the index file is found, set filename to index filename.
      */
-    if (!handler.hit_index_file()) {
+    if (!handler.try_serve_index_file()) {
         return false;
     }
 
@@ -638,4 +660,42 @@ bool Server::select_static_handler(const http_server::Request *request, const Co
 
     return true;
 }
+
+bool Server::apply_rewrite_rules(http_server::StaticHandler *handler) {
+    if (!rewrite_rules || rewrite_rules->empty()) {
+        return false;
+    }
+
+    bool rewritten = false;
+    auto current_url = handler->get_request_url();
+
+    for (const auto &rule : *rewrite_rules) {
+        if (rule.is_regex) {
+            try {
+                std::regex pattern(rule.pattern);
+                std::string rewritten_url;
+
+                if (std::regex_search(current_url, pattern)) {
+                    rewritten_url = std::regex_replace(current_url, pattern, rule.replacement);
+                    if (rewritten_url != current_url) {
+                        handler->set_request_url(rewritten_url);
+                        rewritten = true;
+                        break;
+                    }
+                }
+            } catch (const std::regex_error &e) {
+                continue;
+            }
+        } else {
+            if (starts_with(current_url, rule.pattern)) {
+                std::string rewritten_url = rule.replacement + current_url.substr(rule.pattern.length());
+                handler->set_request_url(rewritten_url);
+                rewritten = true;
+                break;
+            }
+        }
+    }
+
+    return rewritten;
+}
 }  // namespace swoole