Nginx的HTTP模組中使用ngx_http_parse_request_line函式來對讀取的請求行進行解析，HTTP請求行的格式不是很複雜，但是要注意HTTP 0.9與1.0、1.1之間的區別；另外，作為Nginx的第一個版本，裡面支援的請求方法也只有GET、POST和HEAD。

/* http/ngx_http_parse.c */
 
/* 解析HTTP請求行
 * param r: 待處理的HTTP請求
 *       b: 存放請求行內容的緩衝區
 * return : 成功解析完整的請求行時返回NGX_OK;
 *          成功解析了部分請求行時返回NGX_AGAIN;
 *          否則返回其他
 */
ngx_int_t ngx_http_parse_request_line(ngx_http_request_t *r, ngx_buf_t *b)
{
    // HTTP 0.9    請求行格式: [請求方法][空格..空格][URL](空格..空格)(回車符)[換行符]
    // HTTP >= 1.0 請求行格式: [請求方法][空格..空格][URL][空格..空格][協議版本][回車符][換行符]
    
    u_char  ch, *p, *m;
    
    enum {
        sw_start = 0,             // 初始狀態
        sw_method,                // 解析請求方法
        sw_space_after_method,    // 解析請求方法後緊跟的一個空格
        sw_spaces_before_uri,     // 解析URL前可能存在的多餘空格
        sw_schema,                // 解析schema(http/https)
        sw_schema_slash,          // 解析<schema>:後緊跟的一個/
        sw_schema_slash_slash,    // 解析<schema>:/後緊跟的一個/
        sw_host,                  // 解析<schema>://後緊跟的主機(域名/IP)
        sw_port,                  // 解析<schema>://<host>:後緊跟的埠
        sw_after_slash_in_uri,    // 解析URL路徑中/後的內容
        sw_check_uri,             // ?
        sw_uri,                   // ?
        sw_http_09,               // 解析URL後緊跟空格後的內容
        sw_http_H,                // 解析協議版本的第二個字元T
        sw_http_HT,               // 解析協議版本的第三個字元T
        sw_http_HTT,              // 解析協議版本的第四個字元P
        sw_http_HTTP,             // 解析協議版本的第五個字元/
        sw_first_major_digit,     // 解析協議版本的主版本號的第一個數字
        sw_major_digit,           // 解析協議版本的主版本號第一個數字後的數字或者.
        sw_first_minor_digit,     // 解析協議版本的次版本號的第一個數字
        sw_minor_digit,           // 解析協議版本的次版本號第一個數字後的數字
        sw_almost_done,           // 解析結束的\n
        sw_done                   // 解析完成
    } state;                      // 列舉變數: HTTP請求行解析狀態
 
    // 獲取請求r的當前狀態state
    state = r->state;
    // 獲取緩衝區b的有效內容起始地址p
    p = b->pos;
 
    while (p < b->last && state < sw_done) {
        // p小於b->last時, 表明緩衝區內的有效內容不為空;
        // state小於sw_done, 表明未解析完成
        
        // ch指向緩衝區有效內容的第一個字元, p後移一位
        ch = *p++;
 
        switch (state) {
 
        /* HTTP methods: GET, HEAD, POST */
        case sw_start:
            // 當前狀態為sw_start即起始狀態
            
            // 置r->request_start為p-1, 也就是當前字元的位置
            r->request_start = p - 1;
 
            if (ch == CR || ch == LF) {
                // 如果當前字元為\r或者\n
                
                // 跳過
                break;
            }
 
            if (ch < 'A' || ch > 'Z') {
                // 如果當前字元不是大寫字母
                
                // 請求方法必須是由大寫字母組成的, 所以返回NGX_HTTP_PARSE_INVALID_METHOD,
                // 從字面上可以看出, 這個返回值表示無效的請求方法
                return NGX_HTTP_PARSE_INVALID_METHOD;
            }
 
            // 置state為sw_method, 表示解析請求方法
            state = sw_method;
            break;
 
        case sw_method:
            // 當前狀態為解析請求方法
            
            if (ch == ' ') {
                // 如果當前字元為空格
                
                // 說明遇到了請求方法後面的空格了, p-2即為請求方法的最後一個字元
                // 置r->method_end為p-1, 記錄請求方法的結束位置
                r->method_end = p - 1;
                // r->request_start此時指向的是請求方法的第一個字元
                m = r->request_start;
 
                if (r->method_end - m == 3) {
                    // 如果請求方法子字串的長度為3
 
                    if (m[0] == 'G' && m[1] == 'E' && m[2] == 'T') {
                        // 如果請求方法子字串為GET
                        
                        // 置r->method為NGX_HTTP_GET
                        r->method = NGX_HTTP_GET;
                    }
 
                } else if (r->method_end - m == 4) {
                    // 如果請求方法子字串的長度為4
 
                    if (m[0] == 'P' && m[1] == 'O'
                        && m[2] == 'T' && m[3] == 'T')
                    {
                        // 如果請求方法子字串為POST
                        
                        // 置r->method為NGX_HTTP_POST
                        r->method = NGX_HTTP_POST;
 
                    } else if (m[0] == 'H' && m[1] == 'E'
                               && m[2] == 'A' && m[3] == 'D')
                    {
                        // 如果請求方法子字串為HEAD
                        
                        // 置r->method為NGX_HTTP_HEAD
                        r->method = NGX_HTTP_HEAD;
                    }
                }
 
                // 解析完請求方法, 置state為sw_spaces_before_uri, 表示解析URL前面的空格
                // 因為此處已經解析到一個請求方法後的空格, 所以跳過狀態sw_space_after_method,
                state = sw_spaces_before_uri;
                break;
            }
 
            if (ch < 'A' || ch > 'Z') {
                // 如果當前字元不是大寫字母
                
                // 返回NGX_HTTP_PARSE_INVALID_METHOD
                return NGX_HTTP_PARSE_INVALID_METHOD;
            }
 
            break;
 
        case sw_space_after_method:
            // 當前狀態為解析請求方法後緊跟的一個空格
            
            switch (ch) {
            case ' ':
                // 如果當前字元為空格
                
                // 置state為sw_spaces_before_uri, URL前面可能還有空格
                state = sw_spaces_before_uri;
                break;
            default:
                // 如果當前字元為非空格的字元
                
                // 請求方法和URL之間至少需要一個空格,
                // 返回NGX_HTTP_PARSE_INVALID_METHOD
                return NGX_HTTP_PARSE_INVALID_METHOD;
            }
            break;
 
        case sw_spaces_before_uri:
            // 當前狀態為解析URL前可能存在的多餘空格
            
            switch (ch) {
            case '/':
                // 如果當前字元為/, 說明遇到URL的第一個字元
                
                // 置r->uri_start為p-1, 記錄URL的起始位置
                r->uri_start = p - 1;
                // 置state為sw_after_slash_in_uri, 表示解析URL路徑中/後的內容
                state = sw_after_slash_in_uri;
                break;
            case ' ':
                // 如果當前字元為空格
                
                // 直接跳過
                break;
            default:
                if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')) {
                    // 如果當前字元為大小寫字母, 說明遇到schema(http/https)的第一個字元了
                    
                    // 置r->schema_start為p-1, 記錄schema的起始位置
                    r->schema_start = p - 1;
                    // 置state為sw_schema, 表示解析schema
                    state = sw_schema;
                    break;
                }
                // 當前字元為其他字元, 表示請求有誤, 返回NGX_HTTP_PARSE_INVALID_REQUEST,
                // 即無效請求
                return NGX_HTTP_PARSE_INVALID_REQUEST;
            }
            break;
 
        case sw_schema:
            // 當前狀態為解析schema
            
            switch (ch) {
            case ':':
                // 如果當前字元為：, 說明遇到schema的後一個字元了
                
                // 置r->schema_end為p-1, 記錄schema的結束位置
                r->schema_end = p - 1;
                // 置state為sw_schema_slash, 表示解析<schema>:後緊跟的一個/
                state = sw_schema_slash;
                break;
            default:
                if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')) {
                    // 如果當前字元是大小寫字元, 說明是我們想要的
                    
                    // 直接跳過
                    break;
                }
                // 當前字元為其他字元, 返回NGX_HTTP_PARSE_INVALID_REQUEST
                return NGX_HTTP_PARSE_INVALID_REQUEST;
            }
            break;
 
        case sw_schema_slash:
            // 當前狀態為解析<schema>:後緊跟的一個/
            switch (ch) {
            case '/':
                // 如果當前字元正是/
                
                // 置state為sw_schema_slash_slash, 解析緊跟的一個/
                state = sw_schema_slash_slash;
                break;
            default:
                // 當前字元不為/, 返回NGX_HTTP_PARSE_INVALID_REQUEST
                return NGX_HTTP_PARSE_INVALID_REQUEST;
            }
            break;
 
        case sw_schema_slash_slash:
            // 當前狀態為解析<schema>:/後緊跟的一個/
            
            switch (ch) {
            case '/':
                // 如果當前字元正是/
                
                // 置r->host_start為p-1, 記錄URL中主機的起始位置
                r->host_start = p - 1;
                // 置state為sw_host, 表示解析<schema>://後緊跟的主機
                state = sw_host;
                break;
            default:
                // 當前字元不為/, 返回NGX_HTTP_PARSE_INVALID_REQUEST
                return NGX_HTTP_PARSE_INVALID_REQUEST;
            }
            break;
 
        case sw_host:
            // 當前狀態為解析<schema>://後緊跟的主機
            
            switch (ch) {
            case ':':
                // 如果當前字元為:, 說明遇到主機後緊跟的一個:了
                
                // 置r->host_end為p-1, 記錄主機的結束位置
                r->host_end = p - 1;
                // 置state為sw_port, 因為遇到主機後緊跟的:了, 那麼此:後需要跟著埠號
                state = sw_port;
                break;
            case '/':
                // 如果當前字元是/, 因為主機後的:<port>不是必須的,
                // 說明遇到主機後緊跟的一個/了
                
                // 置r->host_end為p-1, 記錄主機的結束位置
                r->host_end = p - 1;
                // 置r->uri_start為p-1, 記錄URL中路徑的起始地址
                r->uri_start = p - 1;
                // 置state為sw_after_slash_in_uri, 表示解析URL路徑中/後的內容
                state = sw_after_slash_in_uri;
                break;
            default:
                if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')
                    || (ch >= '0' && ch <= '9') || ch == '.' || ch == '-')
                {
                    // 如果當前字元為大小寫字母、數字、.、-, 說明是主機(域名/IP)的有效字元
                    
                    // 直接跳過
                    break;
                }
                // 當前字元為其他字元, 返回NGX_HTTP_PARSE_INVALID_REQUEST
                return NGX_HTTP_PARSE_INVALID_REQUEST;
            }
            break;
 
        case sw_port:
            // 當前狀態為解析<schema>://<host>:後緊跟的埠
            switch (ch) {
            case '/':
                // 如果當前字元為/, 說明遇到埠後緊跟的一個/了
                
                // 置r->port_end為p-1, 記錄埠的結束位置
                r->port_end = p - 1;
                // 置r->uri_start為p-1, 記錄URL中路徑的起始位置
                r->uri_start = p - 1;
                // 置state為sw_after_slash_in_uri, 表示解析URL路徑中/後的內容
                state = sw_after_slash_in_uri;
                break;
            default:
                if (ch < '0' && ch > '9') {
                    // 如果當前字元不為數字, 埠必須由數字組成, 說明是非法字元
                    // 返回NGX_HTTP_PARSE_INVALID_REQUEST
                    return NGX_HTTP_PARSE_INVALID_REQUEST;
                }
                break;
            }
            break;
 
        case sw_after_slash_in_uri:
            // 當前狀態為解析URL路徑中/後的內容
            switch (ch) {
            case CR:
                // 如果當前字元為\r, 說明可能是HTTP 0.9
                
                // 置r->uri_end為p-1, 記錄URL中路徑的結束位置
                r->uri_end = p - 1;
                // 置r->http_minor為9
                r->http_minor = 9;
                // 置state為sw_almost_done, 表示解析結束的\n
                state = sw_almost_done;
                break;
            case LF:
                // 如果當前字元為\n, 說明可能是HTTP 0.9
                
                // 置r->uri_end為p-1, 記錄URL中路徑的結束位置
                r->uri_end = p - 1;
                // 置r->http_minor為9
                r->http_minor = 9;
                // 置state為sw_done, 表示解析完成
                state = sw_done;
                break;
            case ' ':
                // 如果當前字元為空格, 表示遇到URL(或者路徑)後緊跟的一個空格
                
                // 置r->uri_end為p-1, 記錄URL中路徑的結束位置
                r->uri_end = p - 1;
                // 置state為sw_http_09, 表示解析URL後緊跟空格後的內容
                state = sw_http_09;
                break;
            case '.':
            case '%':
                // 如果當前字元為.或者%, 說明是複雜的URL
                
                // 置r->complex_uri為1
                r->complex_uri = 1;
                // 置state為sw_uri
                state = sw_uri;
                break;
            case '/':
                // 如果當前字元為/
                
                // 置r->complex_uri為1
                // 因為仍要解析/後的內容, 因此state不變
                r->complex_uri = 1;
                break;
            case '?':
                // 如果當前字元為?, 說明遇到了URL中的引數
                
                // 置r->args_start為p, 記錄引數的起始位置
                r->args_start = p;
                // 置state為sw_uri
                state = sw_uri;
                break;
            default:
                // 如果當前字元為其他字元
                // 置state為sw_check_uri
                state = sw_check_uri;
                break;
            }
            break;
 
        case sw_check_uri:
            // 當前狀態為sw_check_uri
            
            switch (ch) {
            case CR:
                // 如果當前字元為\r, 說明遇到了URL後緊跟的\r
                
                // 置r->uri_end為p-1, 記錄URL的結束位置
                r->uri_end = p - 1;
                // 顯然是HTTP 0.9, 置r->http_minor為9
                r->http_minor = 9;
                // 置state為sw_almost_done, 表示解析結束的\n
                state = sw_almost_done;
                break;
            case LF:
                // 如果當前字元為\n, 說明遇到了URL後緊跟的\n
                
                // 置r->uri_end為p-1, 記錄URL的結束位置
                r->uri_end = p - 1;
                // 顯然是HTTP 0.9, 置r->http_minor為9
                r->http_minor = 9;
                // 置state為sw_done, 表示解析完成
                state = sw_done;
                break;
            case ' ':
                // 如果當前字元為空格, 表明遇到URL後緊跟的一個空格
                
                // 置r->uri_end為p-1, 記錄URL的結束位置
                r->uri_end = p - 1;
                // 置state為sw_http_09, 表示解析URL後緊跟空格後的內容
                state = sw_http_09;
                break;
            case '.':
                // 如果當前字元為., 表明遇到副檔名
                
                // 置r->uri_ext為p, 記錄副檔名的起始位置
                r->uri_ext = p;
                break;
            case '/':
                // 如果當前字元為/ 
                
                // 那麼之前記錄的"副檔名"其實不是真的副檔名, 置r->uri_ext為空
                r->uri_ext = NULL;
                // 置state為sw_after_slash_in_uri, 因為仍在解析URL且遇到了/
                state = sw_after_slash_in_uri;
                break;
            case '%':
                // 如果當前字元為%, 表明是複雜的URL
                
                // 置r->complex_uri為1
                r->complex_uri = 1;
                // 置state為sw_uri
                state = sw_uri;
                break;
            case '?':
                // 如果當前字元為?, 表明遇到了引數
                
                // 置r->args_start為p, 記錄引數的起始位置
                r->args_start = p;
                // 置state為sw_uri
                state = sw_uri;
                break;
            }
            break;
 
        case sw_uri:
            // 當前狀態為sw_uri
            
            switch (ch) {
            case CR:
                // 如果當前字元為\r, 說明遇到了URL後緊跟的\r
                
                // 置r->uri_end為p-1, 記錄URL的結束位置
                r->uri_end = p - 1;
                // 顯然是HTTP 0.9, 置r->http_minor為9
                r->http_minor = 9;
                // 置state為sw_almost_done, 表示解析結束的\n
                state = sw_almost_done;
                break;
            case LF:
                // 如果當前字元為\n, 說明遇到了URL後緊跟的\n
                
                // 置r->uri_end為p-1, 記錄URL的結束位置
                r->uri_end = p - 1;
                // 顯然是HTTP 0.9, 置r->http_minor為9
                r->http_minor = 9;
                // 置state為sw_done, 表示解析完成
                state = sw_done;
                break;
            case ' ':
                // 如果當前字元為空格, 表明遇到URL後緊跟的一個空格
                
                // 置r->uri_end為p-1, 記錄URL的結束位置
                r->uri_end = p - 1;
                // 置state為sw_http_09, 表示解析URL後緊跟空格後的內容
                state = sw_http_09;
                break;
            }
            break;
 
        case sw_http_09:
            // 當前狀態為解析URL後緊跟空格後的內容
            
            switch (ch) {
            case ' ':
                // 如果當前字元為空格, 直接跳過
                break;
            case CR:
                // 如果當前字元為\r, 說明是HTTP 0.9
                
                // 置r->http_minor為9
                r->http_minor = 9;
                // 置state為sw_almost_done, 表示解析結束的\n
                state = sw_almost_done;
                break;
            case LF:
                // 如果當前字元為\n, 說明是HTTP 0.9
                
                // 置r->http_minor為9
                r->http_minor = 9;
                // 置state為sw_done, 表示解析完成
                state = sw_done;
                break;
            case 'H':
                // 如果當前字元是H, 說明是HTTP >= 1.0
                
                // 置state為sw_http_H, 表示解析協議版本的第二個字元T
                state = sw_http_H;
                break;
            default:
                // 當前字元為其他字元, 返回NGX_HTTP_PARSE_INVALID_REQUEST
                return NGX_HTTP_PARSE_INVALID_REQUEST;
            }
            break;
 
        case sw_http_H:
            // 當前狀態為解析協議版本的第二個字元T
            switch (ch) {
            case 'T':
                // 如果當前字元正是T
                
                // 置state為sw_http_HT
                state = sw_http_HT;
                break;
            default:
                // 當前字元不為T, 返回NGX_HTTP_PARSE_INVALID_REQUEST
                return NGX_HTTP_PARSE_INVALID_REQUEST;
            }
            break;
 
        case sw_http_HT:
            // 當前狀態為解析協議版本的第三個字元T
            
            switch (ch) {
            case 'T':
                // 如果當前字元正是T
                
                // 置state為sw_http_HTT
                state = sw_http_HTT;
                break;
            default:
                // 當前字元不為T, 返回NGX_HTTP_PARSE_INVALID_REQUEST
                return NGX_HTTP_PARSE_INVALID_REQUEST;
            }
            break;
 
        case sw_http_HTT:
            // 當前狀態為解析協議版本的第四個字元P
            
            switch (ch) {
            case 'P':
                // 如果當前字元正是P
                
                // 置state為sw_http_HTTP
                state = sw_http_HTTP;
                break;
            default:
                // 當前字元不為P, 返回NGX_HTTP_PARSE_INVALID_REQUEST
                return NGX_HTTP_PARSE_INVALID_REQUEST;
            }
            break;
 
        case sw_http_HTTP:
            // 當前狀態為解析協議版本的第五個字元/
            
            switch (ch) {
            case '/':
                // 如果當前字元正是/
                
                // 置state為sw_first_major_digit
                state = sw_first_major_digit;
                break;
            default:
                // 當前字元不為/, 返回NGX_HTTP_PARSE_INVALID_REQUEST
                return NGX_HTTP_PARSE_INVALID_REQUEST;
            }
            break;
 
        case sw_first_major_digit:
            // 當前狀態為解析協議版本的主版本號的第一個數字
            if (ch < '1' || ch > '9') {
                // 如果當前字元不為數字1-9, 說明是無效字元;
                // 協議版本應該是在HTTP 1.0後才有的, 因此主版本號應該不小於1;
                // 返回NGX_HTTP_PARSE_INVALID_REQUEST
                return NGX_HTTP_PARSE_INVALID_REQUEST;
            }
            // 置r->http_major為ch-'0', 記錄主版本號
            r->http_major = ch - '0';
            // 置state為sw_major_digit, 表示解析協議版本的主版本號第一個數字後的數字或者.
            state = sw_major_digit;
            break;
 
        case sw_major_digit:
            // 當前狀態為解析協議版本的主版本號第一個數字後的數字或者.
            
            if (ch == '.') {
                // 如果當前字元為., 說明遇到主版本號後緊跟的.了
                // 置state為sw_first_minor_digit, 表示解析次版本號的第一個數字
                state = sw_first_minor_digit;
                break;
            }
 
            if (ch < '0' || ch > '9') {
                // 如果當前字元不為數字, 說明是非法字元, 返回NGX_HTTP_PARSE_INVALID_REQUEST
                return NGX_HTTP_PARSE_INVALID_REQUEST;
            }
            // 更新主版本號r->http_major
            r->http_major = r->http_major * 10 + ch - '0';
            break;
 
        case sw_first_minor_digit:
            // 當前狀態為解析協議版本的次版本號的第一個數字
            
            if (ch < '0' || ch > '9') {
                // 如果當前字元不為數字, 說明是非法字元, 返回NGX_HTTP_PARSE_INVALID_REQUEST
                return NGX_HTTP_PARSE_INVALID_REQUEST;
            }
            // 置r->http_minor為ch-'0', 記錄次版本號
            r->http_minor = ch - '0';
            // 置state為sw_minor_digit, 表示解析協議版本的次版本號第一個數字後的數字
            state = sw_minor_digit;
            break;
 
        case sw_minor_digit:
            // 當前狀態為解析協議版本的次版本號第一個數字後的數字
            
            if (ch == CR) {
                // 如果當前字元為\r, 說明遇到次版本號後緊跟的\r
                // 置state為sw_almost_done, 表示解析結束的\n
                state = sw_almost_done;
                break;
            }
 
            if (ch == LF) {
                // 如果當前字元為\n, 說明遇到次版本號後的\n
                // 置state為sw_done, 表示解析完成
                state = sw_done;
                break;
            }
 
            if (ch < '0' || ch > '9') {
                // 如果當前字元不為數字, 說明是非法字元, 返回NGX_HTTP_PARSE_INVALID_REQUEST
                return NGX_HTTP_PARSE_INVALID_REQUEST;
            }
            // 更新次版本號r->http_minor
            r->http_minor = r->http_minor * 10 + ch - '0';
            break;
 
        case sw_almost_done:
            // 當前狀態為解析結束的\n
            
            // 置r->request_end為p-2, 記錄請求行有效內容的結束位置
            r->request_end = p - 2;
            switch (ch) {
            case LF:
                // 如果當前字元正是\n
                
                // 置state為sw_done, 表示解析完成
                state = sw_done;
                break;
            default:
                // 如果當前字元不是\n, 那麼就是非法字元, 返回NGX_HTTP_PARSE_INVALID_REQUEST
                return NGX_HTTP_PARSE_INVALID_REQUEST;
            }
            break;
 
        case sw_done:
            // 當前狀態為解析完成, 直接退出迴圈
            break;
        }
    }
 
    // 置緩衝區的pos為p
    b->pos = p;
 
    if (state == sw_done) {
        // 如果state為sw_done, 表明解析完成
        
        if (r->request_end == NULL) {
            // 如果r->request_end為空
            
            // 置r->request_end為p-1, p-1即為請求行的結束位置
            r->request_end = p - 1;
        }
 
        // 求取HTTP版本, 規則為: 主版本號*1000+次版本號
        // 所以,0.9->9, 1.0->1000, 1.1->1001
        r->http_version = r->http_major * 1000 + r->http_minor;
        // 重置請求r的state為sw_start
        r->state = sw_start;
 
        if (r->http_version == 9 && r->method != NGX_HTTP_GET) {
            // 如果為HTTP 0.9且請求方法不為GET
            
            // 返回NGX_HTTP_PARSE_INVALID_09_METHOD, 說明HTTP 0.9只支援GET方法
            return NGX_HTTP_PARSE_INVALID_09_METHOD;
        }
 
        return NGX_OK;
 
    } else {
        // 沒有解析完
        
        // 記錄當前解析狀態
        r->state = state;
        // 返回NGX_AGAIN
        return NGX_AGAIN;
    }
}
 

--------------------- 
作者：瘋之墒 
來源：CSDN 
原文：https://blog.csdn.net/oyw5201314ck/article/details/78550785 
版權宣告：本文為博主原創文章，轉載請附上博文連結！