2. 程式人生 > >菜鳥學習nginx之HTTP body接收(2)

菜鳥學習nginx之HTTP body接收(2)

阿新 • • 發佈：2019-01-14

上一篇介紹Nginx是如何丟棄body，雖然是丟棄body但是仍然需要乖乖的從socket緩衝區中讀取報文才行。本篇將介紹實際接收流程。

一、概要

接收流程是比較複雜的，主要涉及到兩個方面考慮：body過長如何儲存以及一次接收不完body應該如何設定下次接收。Nginx採用如下方式解決上述問題：

1、如果一個buffer緩衝區不能夠容納body，則會把body寫入到臨時檔案中。

2、如果一次接收不完則會重新設定epoll可讀事件，並且修改回撥函式。這點在上一篇中也有提到。第一次接收body的回撥函式和第二次接收的回撥函式不一樣。

二、首次接收body函式ngx_http_read_client_request_body

2.1、流程圖

該函式是入口函式且上層應用唯一能夠使用的介面函式，我們先來看一下它的流程圖：

2.2、程式碼

由於函式ngx_http_read_client_request_body邏輯比較複雜，這裡將分段顯示

/**
 * 呼叫接收body
 * @param r 請求
 * @param post_handler body處理的回撥函式
 */
ngx_int_t
ngx_http_read_client_request_body(ngx_http_request_t *r,
    ngx_http_client_body_handler_pt post_handler)
{
    size_t                     preread;
    ssize_t                    size;
    ngx_int_t                  rc;
    ngx_buf_t                 *b;
    ngx_chain_t                out;
    ngx_http_request_body_t   *rb;
    ngx_http_core_loc_conf_t  *clcf;

    r->main->count++;
    
    /**
     * 如果不是原始請求、已經標記是丟棄body、request_body不空則呼叫回撥函式
     * request_body不空說明已經讀取到完整body
     * 為什麼說明這裡request_body不空就能說明已經讀取到完整body呢?
     * 原因: 此函式在業務處理流程只會被呼叫一次 即使一次epoll讀取事件不能把所有
     * body都讀取成功，下一次讀取操作不會由該函式處理而是由
     * ngx_http_read_client_request_body_handler處理
     */
    if (r != r->main || r->request_body || r->discard_body) {
        r->request_body_no_buffering = 0;
        post_handler(r); //回撥函式必須呼叫類似ngx_http_finalize_request將count進行自減
        return NGX_OK;
    }

#if (NGX_HTTP_V2)
    if (r->stream) {
        rc = ngx_http_v2_read_request_body(r, post_handler);
        goto done;
    }
#endif

    if (ngx_http_test_expect(r) != NGX_OK) {
        rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
        goto done;
    }

說明：

1）函式第二引數post_handler是使用者指定的回撥函式。當body接收完畢後會主動呼叫該引數指向的回撥函式。 

2）判斷body是否有效，如果有效則直接呼叫post_handler回撥函式。註釋中已經詳細說明。

    /* 表明開始接收body 分配request_body物件 */
    rb = ngx_pcalloc(r->pool, sizeof(ngx_http_request_body_t));
    if (rb == NULL) {
        rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
        goto done;
    }

    /*
     * set by ngx_pcalloc():
     *
     *     rb->bufs = NULL;
     *     rb->buf = NULL;
     *     rb->free = NULL;
     *     rb->busy = NULL;
     *     rb->chunked = NULL;
     */

    rb->rest = -1; /* 後續流程會賦值 初始值為content-length */
    rb->post_handler = post_handler;

    r->request_body = rb;
    
    /* 表示body小於0且不是chunked模式 則認為沒有接收到body 立即呼叫回撥函式 */
    if (r->headers_in.content_length_n < 0 && !r->headers_in.chunked) {
        r->request_body_no_buffering = 0;
        post_handler(r);
        return NGX_OK;
    }

說明：

1）建立用於儲存body的request_body物件

2）判斷headers_in中content_length是否小於0，如果小於0則說明沒有body，則直接呼叫post_handler回撥函式。

    /* 進入此函式表示 HTTP header內容已經處理完畢 剩餘的內容就是body */
    preread = r->header_in->last - r->header_in->pos;

    if (preread) {

        /**
         * there is the pre-read part of the request body 
         * 表示已經讀取到一部分body
         */

        ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                       "http client request body preread %uz", preread);

        out.buf = r->header_in;
        out.next = NULL;
        /* 過濾出body */
        rc = ngx_http_request_body_filter(r, &out);

        if (rc != NGX_OK) {
            goto done;
        }

        r->request_length += preread - (r->header_in->last - r->header_in->pos);

        /**
         * 進入下面if分支條件:
         * 1、非chunked模式
         * 2、body還沒接收完成，且header_in剩餘空間足夠接收剩下的body
         * 做的主要工作:
         * 重置讀寫事件，進行socket讀取
         */
        if (!r->headers_in.chunked
            && rb->rest > 0
            && rb->rest <= (off_t) (r->header_in->end - r->header_in->last))
        {
            /**
             * the whole request body may be placed in r->header_in
             * 
             */
            b = ngx_calloc_buf(r->pool);
            if (b == NULL) {
                rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
                goto done;
            }

            b->temporary = 1;
            b->start = r->header_in->pos;
            b->pos = r->header_in->pos;
            b->last = r->header_in->last;
            b->end = r->header_in->end;

            rb->buf = b;
            /* 設定讀寫事件回撥函式 */
            r->read_event_handler = ngx_http_read_client_request_body_handler;
            r->write_event_handler = ngx_http_request_empty_handler;

            rc = ngx_http_do_read_client_request_body(r);
            goto done;
        }

    } else {
        /** 表示當前header_in中沒有接收到body 
         * 同時對rb->rest進行賦值
         */
        if (ngx_http_request_body_filter(r, NULL) != NGX_OK) {
            rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
            goto done;
        }
    }

說明：

1、preread大於0，說明header_in緩衝區記憶體在部分body(也可能是完整body)，這個是需要剝離body(也可以理解成解析出body資料)存到request_body物件中。

2、 當執行完剝離body之後，會再次判斷request_body中rest是否為0，如果不為0表示還有body沒有接收完畢。因此需要建立一個buf用接收新的body資料。

3、如果preread為0，表示header_in緩衝區中沒有body，這裡需要設定request_body物件中rest為content_length。

    if (rb->rest == 0) {/* 表示整個body已經讀取完畢 執行回撥函式進行處理 */
        /* the whole request body was pre-read */
        r->request_body_no_buffering = 0;
        post_handler(r);
        return NGX_OK;
    }

    if (rb->rest < 0) {
        ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
                      "negative request body rest");
        rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
        goto done;
    }

    /**
     * 以下流程表示 rest > 0 表示需要再次讀取body 
     * 主要工作是建立buf、設定回撥函式以及讀取socket緩衝區     
     */
    clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

    size = clcf->client_body_buffer_size; //預設1M
    size += size >> 2;// 1M+256K

    /* TODO: honor r->request_body_in_single_buf */

    if (!r->headers_in.chunked && rb->rest < size) {
        size = (ssize_t) rb->rest;

        if (r->request_body_in_single_buf) {
            size += preread;
        }

    } else {
        size = clcf->client_body_buffer_size;
    }
    /* 建立接收緩衝區 */
    rb->buf = ngx_create_temp_buf(r->pool, size);
    if (rb->buf == NULL) {
        rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
        goto done;
    }
    /* 設定讀寫事件回撥函式 */
    r->read_event_handler = ngx_http_read_client_request_body_handler;
    r->write_event_handler = ngx_http_request_empty_handler;
    /* 真正從socket中讀取資料 */
    rc = ngx_http_do_read_client_request_body(r);

 說明：這部分程式碼主要流程，建立一個全新的buffer用於接收body，設定回撥函式，執行函式進行socket recv操作。

done:
    
    if (r->request_body_no_buffering
        && (rc == NGX_OK || rc == NGX_AGAIN))
    {
        if (rc == NGX_OK) {
            r->request_body_no_buffering = 0;

        } else {
            /* rc == NGX_AGAIN */
            r->reading_body = 1;
        }

        r->read_event_handler = ngx_http_block_reading;
        post_handler(r);
    }

    if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
        r->main->count--; //如果返回是大於300表示出現錯誤 需要將count自減
    }

    return rc;
}

這部分程式碼，理解不是很清楚，但是大部分流程都進入標籤done中。

2.3、request_body結構

在上面流程中，涉及到一個非常重要的結構--ngx_http_request_body_t，該結構體對於讀取body相關功能，非常重要。其中比較難於理解的就是bufs、buf，在下面的註釋已經寫得很清楚了，具體定義如下：

typedef struct {
    ngx_temp_file_t                  *temp_file; /* 當指標不空說明以檔案方式儲存body */
    /**
     * 儲存body的連結串列 完整body在這裡面 因此我們在編寫業務邏輯需要特別注意 
     * 這裡還需要注意一點 bufs中ngx_buf_t結構既支援記憶體結構又支援檔案結構
     * 當我們處理body時 取出buf後需要判斷in_file變數是否為1
     */
    ngx_chain_t                      *bufs;
    /**
     * 用於接收socket資料 即接收body 在ngx_http_read_client_request_body中賦值
     * buf是用於socket recv函式 所以當body很大的時候 這個buf可能不能滿足body長度
     * 因此會buf指向的記憶體拷貝到bufs中
     */
    ngx_buf_t                        *buf;
    off_t                             rest; /* 該值代表還有多少位元組的body未讀取 */
    off_t                             received; /* 用於http V2版本 */
    ngx_chain_t                      *free; /*  */
    ngx_chain_t                      *busy;
    ngx_http_chunked_t               *chunked; /* chunked資訊 */
    ngx_http_client_body_handler_pt   post_handler; /* 使用者設定的回撥函式 用於處理body */
} ngx_http_request_body_t;

三、非首次接收body函式ngx_http_read_client_request_body_handler

我們在上面，看到兩處重置讀寫事件，其中讀事件設定的函式為ngx_http_read_client_request_body_handler。表明下次接收並且處理body的函式為ngx_http_read_client_request_body_handler，而不在是ngx_http_read_client_request_body。函式實現比較簡單，具體如下所示：

static void
ngx_http_read_client_request_body_handler(ngx_http_request_t *r)
{
    ngx_int_t  rc;

    if (r->connection->read->timedout) {//如果是超時事件 則直接結束http請求
        r->connection->timedout = 1;
        ngx_http_finalize_request(r, NGX_HTTP_REQUEST_TIME_OUT);
        return;
    }

    rc = ngx_http_do_read_client_request_body(r); //真正讀取body函式

    if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
        ngx_http_finalize_request(r, rc); //返回錯直接結束http請求
    }
}

四、真正接收body函式ngx_http_do_read_client_request_body

/**
 * 真正讀取body的函式
 * @param r http請求
 */
static ngx_int_t
ngx_http_do_read_client_request_body(ngx_http_request_t *r)
{
    off_t                      rest;
    size_t                     size;
    ssize_t                    n;
    ngx_int_t                  rc;
    ngx_chain_t                out;
    ngx_connection_t          *c;
    ngx_http_request_body_t   *rb;
    ngx_http_core_loc_conf_t  *clcf;

    c = r->connection;
    rb = r->request_body;

    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
                   "http read client request body");

    for ( ;; ) {
        for ( ;; ) {
            if (rb->buf->last == rb->buf->end) {//空間已滿

                if (rb->buf->pos != rb->buf->last) {

                    /**
                     * pass buffer to request body filter chain 
                     * 表示當前buf中報文還沒有處理 將當前buf追加到request_body中
                     */

                    out.buf = rb->buf;
                    out.next = NULL;
                    /* 將body儲存在request_body物件中 */
                    rc = ngx_http_request_body_filter(r, &out);

                    if (rc != NGX_OK) {
                        return rc;
                    }

                } else {
                    /* update chains */
                    rc = ngx_http_request_body_filter(r, NULL);

                    if (rc != NGX_OK) {
                        return rc;
                    }
                }
                
                /* 表示緩衝區中還有body沒有被處理 需要再次觸發事件驅動 */
                if (rb->busy != NULL) {
                    if (r->request_body_no_buffering) {//重新註冊讀事件
                        if (c->read->timer_set) {
                            ngx_del_timer(c->read);
                        }

                        if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
                            return NGX_HTTP_INTERNAL_SERVER_ERROR;
                        }

                        return NGX_AGAIN;
                    }

                    return NGX_HTTP_INTERNAL_SERVER_ERROR;
                }
                /** 
                 * 這裡為什麼可以重置標誌位:
                 * Nginx內部實現 當buf緩衝區滿時會把緩衝區記憶體寫到臨時檔案中
                 */
                rb->buf->pos = rb->buf->start;
                rb->buf->last = rb->buf->start;
            }

            size = rb->buf->end - rb->buf->last; //當前buf可用接收資料的空間大小
            rest = rb->rest - (rb->buf->last - rb->buf->pos); //還有多少body沒有接收

            if ((off_t) size > rest) {
                size = (size_t) rest;
            }
            /* 真正從socket中 讀取報文 */
            n = c->recv(c, rb->buf->last, size);

            ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
                           "http client request body recv %z", n);

            if (n == NGX_AGAIN) {
                break;
            }

            if (n == 0) {
                ngx_log_error(NGX_LOG_INFO, c->log, 0,
                              "client prematurely closed connection");
            }

            if (n == 0 || n == NGX_ERROR) {
                c->error = 1;
                return NGX_HTTP_BAD_REQUEST;
            }

            rb->buf->last += n;
            r->request_length += n;

            if (n == rest) {
                /* pass buffer to request body filter chain */

                out.buf = rb->buf;
                out.next = NULL;
                //rb->rest在此函式中會被修改
                rc = ngx_http_request_body_filter(r, &out);

                if (rc != NGX_OK) {
                    return rc;
                }
            }

            if (rb->rest == 0) {//表示body全部內容都已經接收完畢
                break;
            }

            if (rb->buf->last < rb->buf->end) {
                break;
            }
        }//最內層for迴圈結束

        ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
                       "http client request body rest %O", rb->rest);

        if (rb->rest == 0) {//表示body全部內容都已經接收完畢
            break;
        }

        if (!c->read->ready) {//如果是失效事件 需要重新註冊事件

            if (r->request_body_no_buffering
                && rb->buf->pos != rb->buf->last)
            {
                /* pass buffer to request body filter chain */

                out.buf = rb->buf;
                out.next = NULL;

                rc = ngx_http_request_body_filter(r, &out);

                if (rc != NGX_OK) {
                    return rc;
                }
            }
            //重新註冊 讀取事件
            clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
            ngx_add_timer(c->read, clcf->client_body_timeout);

            if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
                return NGX_HTTP_INTERNAL_SERVER_ERROR;
            }

            return NGX_AGAIN;
        }
    }//外層for迴圈
    
    /* 注意: 進入下面程式碼 表示讀取body完成 */
    if (c->read->timer_set) {
        ngx_del_timer(c->read);
    }

    if (!r->request_body_no_buffering) {
        r->read_event_handler = ngx_http_block_reading;
        rb->post_handler(r);//呼叫回撥 處理body
    }

    return NGX_OK;
}

雖然該函式內容比較多，單邏輯不是很複雜，在註釋中我已經做了標記。 

五、總結

至此，本篇將Nginx是如何接收body大體流程已經介紹完畢，但是仍然沒有解決我們心中的疑惑？請看下一篇。

相關推薦

菜鳥學習nginx之HTTP body接收(2)

上一篇介紹Nginx是如何丟棄body，雖然是丟棄body但是仍然需要乖乖的從socket緩衝區中讀取報文才行。本篇將介紹實際接收流程。 一、概要 接收流程是比較複雜的，主要涉及到兩個方面考慮：body過長如何儲存以及一次接收不完body應該如何設定下次接收。Nginx採用如下方式解決上

菜鳥學習nginx之HTTP body接收(3)

上一篇介紹了，Nginx是如何接收body主體流程，但是我們仍然沒有了解到，Nginx是如何儲存body的？也就是第一篇中提到的問題。本篇主要分析ngx_http_request_body_filter函式，該函式會幫助我們解決。 一、ngx_http_request_body_t結構體

菜鳥學習nginx之HTTP body接收(1)

上一篇介紹了Nginx是如何處理HTTP請求的，其實對於一個真正的HTTP請求，往往是有body的，只有處理完body才算真正處理完該請求。 對於HTTP body來說一般處理有兩種方式，要麼是丟棄body，要麼是接收body。對於接收body面臨比較大的挑戰，因為body是不定長，我們無法

菜鳥學習nginx之HTTP請求處理(1)

上一篇主要介紹Nginx是如何處理HTTP Header。由於HTTP請求處理這部分程式碼是Nginx核心內容，打算用兩篇文章深入介紹。本篇先介紹HTTP處理的11個階段。 一、HTTP處理11階段 1.1、為什麼要有11階段？ 這個得從Nginx設計出發。首先Nginx是單執行緒且

菜鳥學習Nginx之HTTP會話

從本篇開始，介紹Nginx中HTTP相關。Nginx做為Web Server那麼HTTP必然是重中之重。本篇不打算介紹太深入，本篇最主要內容是如何與事件驅動關聯起來。 一、監聽埠 Nginx預設監聽埠是80埠，那麼Nginx是如何將80埠的listening事件註冊到事件驅動（epoll

菜鳥學習nginx之接收HTTP Header

上一篇介紹了《菜鳥學習nginx之接收HTTP請求行》，本篇介紹Nginx接收HTTP Header處理流程。 一、HTTP Header處理流程 處理Header與上一篇處理HTTP請求行很類似，比較容易理解 1.1、流程圖 1.2、程式碼 /** * 處理HTTP

菜鳥學習nginx之接收HTTP請求行

上一篇介紹了HTTP會話建立流程，本篇介紹接收HTTP Header流程。由於Nginx是完全非同步的，這對編寫HTTP框架提出比較高的要求，因此Nginx在實現HTTP框架時定義出11個階段。後續章節會詳細介紹該11階段。本篇介紹的接收HTTP Header請求在HTTP框架中是邏輯比較簡單。

菜鳥學習Nginx之入門開發留言板

本篇算是學習Nginx開山之作，後面還有會具體解析原始碼。 利用Nginx實現了一個登入、留言板、檔案上傳功能，功能非常簡單。但是對於如何開發一個Nginx模組來說已經足夠，希望能夠起到拋磚引玉的效果。 一、效果 登入介面： http://192.168.1.10/logi

菜鳥學習Nginx之ngx_buf_t

上一篇介紹的是ngx_pool_t記憶體池，對於Nginx來說萬物皆池化，接下來介紹的ngx_buf_t也是從記憶體池中獲取記憶體空間。 一、資料結構定義 1.1、資料結構定義 ngx_buf_t從名字上可知，是緩衝區的意思。與大多數開源軟體定義的緩衝區有點不同，它不僅僅能夠處理記憶

菜鳥學習Nginx之記憶體池

從今天開始深入介紹Nginx框架。 首先來談談我對《深入理解Nginx模組開發與架構解析》看法，這本書應該是到目前為止，市面寫的最詳細，最充實的書籍（沒有之一），值得擁有。然而此書對於一個小白來說，並不太適合，此書適合有相關使用經驗或者開發經驗，適合於進一步深造的同學。如果是小白，建議先瀏覽

菜鳥學習Nginx之啟動流程(3)

由於上一篇《菜鳥學習Nginx之啟動流程(2)》篇幅比較長，因此特地在寫一篇。而本篇將是啟動流程中最後一篇，主要介紹worker程序主函式。 一、ngx_worker_process_cycle worker程序主函式，內容並不是很多，但若是展開說明則將會把整個Nginx框架都牽扯進來。

菜鳥學習Nginx之啟動流程(2)

上一篇介紹了啟動流程中關於初始化ngx_cycle_t。由於ngx_cycle_t是Nginx核心結構，Nginx整個架構均是圍繞它構建起來的。雖然用了一整篇文章介紹ngx_cycle_t，但是感覺還是有些內容沒有介紹清楚。初始化ngx_cycle_t有一部分程式碼沒有介紹，ngx_conf_p

菜鳥學習Nginx之啟動流程(1)

對於C語言編寫的程式來說，main函式就是入口函式，把main函式研究清楚對於理解軟體架構、功能會有事半功倍的效果。好在Nginx的main函式並不是很複雜，這裡會把啟動流程分成兩篇來介紹，希望能夠描述清楚。 我把啟動流程劃分成兩部分：cycle核心結構體初始化、master/worker程

菜鳥學習nginx之事件模組epoll（1）

上一篇介紹核心事件模組，本篇介紹事件模組ngx_epoll_module。Nginx在linux環境下采用epoll網路模型，對於epoll網路型不瞭解的可自行百度查詢，本篇不在闡述。 一、問題 本篇要澄清以下幾個問題： 1、當客戶端發起TCP連線後，事件模組是如何管理新連線？

菜鳥學習nginx之核心模組ngx_events_module

既然Nginx是HTTP服務端軟體，那麼必然離不開網路。今天就介紹Nginx高效能網路是如何實現的。 一、核心模組-ngx_events_module （校長） 上一篇中介紹了Nginx模組抽象，今天深入探討一下ngx_event_module事件模組。 1.1、模組定義 /**

菜鳥學習nginx之模組定義

今天開始介紹Nginx框架相關內容。 Nginx將所有功能進行模組化區分，按照功能統一編排，例如：事件模組，HTTP模組，郵箱模組，配置檔案模組等。對於複雜模組，又支援子模組定義，例如HTTP模組中有ngx_http_header_filter_module等。Nginx為這些模組都進行統一

菜鳥學習Nginx之ngx_array_t

在上一篇介紹了ngx_list_t，本篇介紹一下ngx_array_t，其實有了上一篇的基礎，在介紹ngx_array_t就比較簡單了。 一、資料結構 在資料結構上與ngx_list_t有一點點重複，如下所示： typedef struct { void *el

菜鳥學習Nginx之ngx_list_t

上一篇介紹的是ngx_buf_t，本篇介紹ngx_list_t，幾乎在Nginx中無處不在，出現頻率非常之高。 Nginx中ngx_list_t在名字是連結串列的含義，但是實際可以理解成是陣列形式單鏈表，比一般的連結串列要複雜一些，而ngx_queue_t是我們常說的雙向連結串列。這一點需要

菜鳥學習nginx之驚群處理

“驚群”這個名詞是我閱讀Nginx時第一次接觸到的，也算是學到了一點點知識吧。 一、驚群 1.1、驚群定義 對於驚群的概念簡單描述一下：通常場景一個埠P1只能被一個程序A監聽，所以埠P1發的事件都會被該程序A所處理。但是，如果程序A通過系統呼叫fork()，建立子程序B，那麼程序B也

菜鳥學習nginx之事件模組epoll（2）

上一篇介紹的內容是ngx_epoll_module模組初始化、關閉以及核心內容事件迴圈。但是具體如何將事件註冊到事件驅動中呢？nginx對其進行了封裝，ngx_add_event/ngx_del_event。然而上層應用模組，例如HTTP模組並不直接使用這兩個介面，而是使用再次封裝函式ngx_h