//http請求頭部常用頭部對應的處理函數(shù)
ngx_http_header_t  ngx_http_headers_in[] = 
{
    { ngx_string("Connection"), offsetof(ngx_http_headers_in_t, connection),ngx_http_process_connection },
};

//處理http請求頭部的connection字段
static ngx_int_t ngx_http_process_connection(ngx_http_request_t *r, ngx_table_elt_t *h,
    ngx_uint_t offset)
{
    if (ngx_strcasestrn(h->value.data, "close", 5 - 1))
	{
		//長連接關(guān)閉
        r->headers_in.connection_type = NGX_HTTP_CONNECTION_CLOSE;		

    } 
	else if (ngx_strcasestrn(h->value.data, "keep-alive", 10 - 1)) 
	{
		//保持長連接
        r->headers_in.connection_type = NGX_HTTP_CONNECTION_KEEP_ALIVE;
    }

    return NGX_OK;
}

//調(diào)用各個http模塊協(xié)同處理這個請求
void ngx_http_handler(ngx_http_request_t *r)
{
	//不需要進行內(nèi)部跳轉(zhuǎn)。keepalive機制是在客戶端和nginx服務器之間才需要關(guān)注。對于內(nèi)部跳轉(zhuǎn)則不會用到
	//keepalive機制
    if (!r->internal) 	
	{
        switch (r->headers_in.connection_type) 
		{
	        case 0:
	            r->keepalive = (r->http_version > NGX_HTTP_VERSION_10);//http1.1版本默認開啟keepalive
	            break;
	        case NGX_HTTP_CONNECTION_CLOSE:
	            r->keepalive = 0;					//關(guān)閉長連接
	            break;
	        case NGX_HTTP_CONNECTION_KEEP_ALIVE: 
	            r->keepalive = 1;                   //打開長連接
	            break;
        }
	}
}

//釋放http請求與連接
static void ngx_http_finalize_connection(ngx_http_request_t *r)
{
	//執(zhí)行到這里，引用計數(shù)為1，則要準備結(jié)束請求了
	//keepalive為1表示請求需要釋放，但tcp連接還是用復用的
    if (!ngx_terminate
         && !ngx_exiting
         && r->keepalive
         && clcf->keepalive_timeout > 0)
    {
        ngx_http_set_keepalive(r);
        return;
    }
}

//設(shè)置keepalive過程
static void ngx_http_set_keepalive(ngx_http_request_t *r)
{
	//在接收到來自客戶端的連接請求時，同時也接收到了同一個tcp連接上的第2個http請求頭部。
	//因此在處理完第一個請求時，pos不等于last，說明接收到了第二個http請求頭部，接下來要立馬處理第二個請求
    if (b->pos < b->last) 
	{
		//在接收來自客戶端的請求行、或者請求頭部時。如果連接對象的buffer緩沖區(qū)不能夠存放所有的請求行，請求頭。
		//則http請求對象自己會開辟新的空間。因此在請求結(jié)束時，需要把請求對象開辟的空間加入到空閑表中。
		//這樣在這個連接上有新的http請求到來時，可以復用上一個請求對象開辟的空間
        if (b != c->buffer) 
		{
            if (hc->free == NULL)
			{
                hc->free = ngx_palloc(c->pool, cscf->large_client_header_buffers.num * sizeof(ngx_buf_t *));
            }
			
			//將在用表移動到空閑表
            for (i = 0; i < hc->nbusy - 1; i++)
			{
                f = hc->busy[i];
                hc->free[hc->nfree++] = f;
                f->pos = f->start;
                f->last = f->start;
            }

            hc->busy[0] = b;
            hc->nbusy = 1;
        }
    }
}

static ssize_t ngx_http_read_request_header(ngx_http_request_t *r)
{
	//事件就緒，也就是從epoll_wait中返回后，從內(nèi)核緩沖區(qū)中讀取內(nèi)容到應用層緩沖區(qū)header_in
    if (rev->ready) 
	{
		//ngx_unix_recv
        n = c->recv(c, r->header_in->last, r->header_in->end - r->header_in->last);  
    } 
}

//首次建立tcp連接后，讀事件的回調(diào)，用于創(chuàng)建一個ngx_http_request_t對象
static void ngx_http_init_request(ngx_event_t *rev)
{	
	//剛建立的請求，默認情況下這兩個緩沖區(qū)是相等的
    if (r->header_in == NULL) 
	{
        r->header_in = c->buffer;
    }
}

//開辟一個大的緩沖區(qū)，并把舊緩沖區(qū)的數(shù)據(jù)拷貝到新緩沖區(qū)中
//解析請求行時，request_line = 1, 解析請求頭時，request_line = 0
static ngx_int_t ngx_http_alloc_large_header_buffer(ngx_http_request_t *r, ngx_uint_t request_line)
{
	/* 檢查給該請求分配的請求頭緩沖區(qū)個數(shù)是否已經(jīng)超過限制，默認最大個數(shù)為4個 */ 
	if (hc->busy == NULL) 
	{
		hc->busy = ngx_palloc(r->connection->pool, cscf->large_client_header_buffers.num * sizeof(ngx_buf_t *));
	}

	/* 如果還沒有達到最大分配數(shù)量，則分配一個新的大緩沖區(qū) */  
	b = ngx_create_temp_buf(r->connection->pool, cscf->large_client_header_buffers.size);

	/* 將從空閑隊列取得的或者新分配的緩沖區(qū)加入已使用隊列 */  
    hc->busy[hc->nbusy++] = b;
	
	//header_in指向這個新的緩沖區(qū), 連接對象的緩沖區(qū)仍然為舊的緩沖區(qū)，大小沒有改變
    r->header_in = b;
}

//設(shè)置keepalive過程
static void ngx_http_set_keepalive(ngx_http_request_t *r)
{
	//釋放請求的內(nèi)容空間
    ngx_http_free_request(r, 0);
	//將讀事件注冊到紅黑樹實現(xiàn)的定時器中，超時時間由keepalive_timeout命令設(shè)置，默認為75秒。
	//如果超時時間到后都還沒有再收到來自客戶端的http請求，則會關(guān)閉連接。
    ngx_add_timer(rev, clcf->keepalive_timeout);
    ngx_handle_read_event(rev, 0);
	//接收來自客戶端請求時，還不需要向客戶端寫入數(shù)據(jù)，因此把寫回調(diào)設(shè)置為不做任何事情
    wev = c->write;
    wev->handler = ngx_http_empty_handler;
}

static void ngx_http_set_keepalive(ngx_http_request_t *r)
{
	//該請求結(jié)束了，設(shè)置接收回調(diào)為ngx_http_init_request。在這個tcp連接上的下一個請求到來時，
	//重新開始對一個新請求進行處理
    if (b->pos < b->last) 
	{
		//設(shè)置為串行請求
        hc->pipeline = 1;
		//設(shè)置讀事件的回調(diào)，并加入到post事件隊列
        rev->handler = ngx_http_init_request;
        ngx_post_event(rev, &ngx_posted_events);
        return;
    }
}

static void ngx_http_init_request(ngx_event_t *rev)
{
    r = hc->request;
    if (r) 
	{
        ngx_memzero(r, sizeof(ngx_http_request_t));
		//串行請求時值為1，表示舊請求結(jié)束后，內(nèi)部資源已經(jīng)釋放了，但請求本身沒有釋放。
		//這樣的話，在這個tcp連接上的新請求可以使用舊請求的對象。
		//配和ngx_http_set_keepalive函數(shù)就理解這部分的實現(xiàn)了
        r->pipeline = hc->pipeline;

		//串行請求時，在用緩沖區(qū)加入到了空閑緩沖區(qū)數(shù)組中。配和ngx_http_set_keepalive函數(shù)幫助理解
        if (hc->nbusy) 
		{
            r->header_in = hc->busy[0];
        }
    } 
}

static void ngx_http_set_keepalive(ngx_http_request_t *r)
{
	//釋放資源
	if (hc->busy) 
	{
        for (i = 0; i < hc->nbusy; i++) 
		{
            ngx_pfree(c->pool, hc->busy[i]->start);
            hc->busy[i] = NULL;
        }
    }
	
	//設(shè)置讀事件回調(diào)，用于處理來自客戶端的新的http請求
    rev->handler = ngx_http_keepalive_handler;
}

//http請求關(guān)閉后，tcp連接并沒有關(guān)閉。這個函數(shù)用于在這個tcp連接上接收新的http請求
static void ngx_http_keepalive_handler(ngx_event_t *rev)
{
	//開辟接收請求行、請求頭緩沖區(qū)。因為非pipeline情況下，釋放之前的一個請求時，
	//也把連接對象的buffer緩沖區(qū)也給釋放了。因此新的請求到來時，需要重新開辟空間
	b->pos = ngx_palloc(c->pool, size);

	//調(diào)用這個函數(shù)，重新開始一個新的http請求處理
    ngx_http_init_request(rev);
}