//接收到http請求行與請求頭后，http的處理流程,是第一個http處理請求的讀事件回調(diào) 
//這個函數(shù)執(zhí)行后，將把讀寫事件的回調(diào)設(shè)置為ngx_http_request_handler。這樣下次再有事件時 
//將調(diào)用ngx_http_request_handler函數(shù)來處理，而不會再調(diào)用ngx_http_process_request了 
static void ngx_http_process_request(ngx_http_request_t *r) 
{ 
  ngx_connection_t *c; 
  c = r->connection; 
  //因為已經(jīng)接收完http請求行、請求頭部了，準(zhǔn)備調(diào)用各個http模塊處理請求了。 
  //因此需要接收任何來自客戶端的讀事件，也就不存在接收http請求頭部超時問題 
  if (c->read->timer_set)  
  { 
    ngx_del_timer(c->read); 
  } 
  //重新設(shè)置當(dāng)前連接的讀寫事件回調(diào) 
  c->read->handler = ngx_http_request_handler; 
  c->write->handler = ngx_http_request_handler; 
  //設(shè)置http請求對象的讀事件回調(diào)，這個回調(diào)不做任何的事情。 
  //那http請求對象的讀事件回調(diào)，與上面的連接對應(yīng)的讀事件回調(diào)有什么關(guān)系呢? 
  //當(dāng)讀事件發(fā)生后，連接對應(yīng)的讀事件回調(diào)ngx_http_request_handler會被調(diào)用， 
  //在這個回調(diào)內(nèi)會調(diào)用http請求對象的讀事件回調(diào)ngx_http_block_reading，而這個回調(diào)是 
  //不會做任何事件的，因此相當(dāng)于忽略了讀事件。因為已經(jīng)接收完了請求行請求頭，現(xiàn)在要做的是調(diào)用各個http模塊， 
  //對接收到的請求行請求頭進(jìn)行處理 
  r->read_event_handler = ngx_http_block_reading; 
 
  //調(diào)用各個http模塊協(xié)同處理這個請求 
  ngx_http_handler(r); 
  //處理子請求 
  ngx_http_run_posted_requests(c); 
}

//http請求處理讀與寫事件的回調(diào)，在ngx_http_process_request函數(shù)中設(shè)置。 
//這個函數(shù)中將會調(diào)用http請求對象的讀寫事件回調(diào)。將event事件模塊與http框架關(guān)聯(lián)起來 
static void ngx_http_request_handler(ngx_event_t *ev) 
{ 
  //如果同時發(fā)生讀寫事件，則只有寫事件才會觸發(fā)。寫事件優(yōu)先級更高 
  if (ev->write)  
  { 
    r->write_event_handler(r);  //在函數(shù)ngx_http_handler設(shè)置為:ngx_http_core_run_phases 
 
  } 
  else 
  { 
    r->read_event_handler(r);  //在函數(shù)ngx_http_process_request設(shè)置為:ngx_http_block_reading 
  } 
 
  //處理子請求 
  ngx_http_run_posted_requests(c); 
} 

//調(diào)用各個http模塊協(xié)同處理這個請求 
void ngx_http_handler(ngx_http_request_t *r) 
{ 
  //不需要進(jìn)行內(nèi)部跳轉(zhuǎn)。什么是內(nèi)部跳轉(zhuǎn)? 例如有個location結(jié)構(gòu)，里面的 
  // 
  if (!r->internal)   
  { 
    //將數(shù)組序號設(shè)為0,表示從數(shù)組第一個元素開始處理http請求 
    //這個下標(biāo)很重要，決定了當(dāng)前要處理的是11個階段中的哪一個階段， 
    //以及由這個階段的哪個http模塊處理請求 
    r->phase_handler = 0; 
  }  
  else  
  { 
    //需要做內(nèi)部跳轉(zhuǎn) 
    cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module); 
    //將序號設(shè)置為server_rewrite_index 
    r->phase_handler = cmcf->phase_engine.server_rewrite_index; 
  } 
  //設(shè)置請求對象的寫事件回調(diào)，這個回調(diào)將會調(diào)度介入11個http階段的各個http模塊 
  //共同完成對請求的處理 
  r->write_event_handler = ngx_http_core_run_phases; 
  //開始調(diào)度介入11個http階段的各個http模塊 
  ngx_http_core_run_phases(r); 
} 

//調(diào)用各個http模塊協(xié)同處理這個請求, checker函數(shù)內(nèi)部會修改phase_handler 
void ngx_http_core_run_phases(ngx_http_request_t *r) 
{ 
  cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module); 
  ph = cmcf->phase_engine.handlers; 
  //調(diào)用各個http模塊的checker方法，使得各個http模塊可以介入http請求 
  while (ph[r->phase_handler].checker) 
  { 
    rc = ph[r->phase_handler].checker(r, &ph[r->phase_handler]); 
    //從http模塊返回NGX_OK，http框架則會把控制全交還給事件模塊 
    if (rc == NGX_OK)     
    { 
      return; 
    } 
  } 

//開始解析http塊 
static char * ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) 
{ 
  //http配置解析完成后的后續(xù)處理,使得各個http模塊可以介入到11個http階段 
  for (m = 0; ngx_modules[m]; m++)  
  { 
    if (ngx_modules[m]->type != NGX_HTTP_MODULE)  
    { 
      continue; 
    } 
 
    module = ngx_modules[m]->ctx; 
    if (module->postconfiguration)  
    { 
      //每一個http模塊的在這個postconfiguration函數(shù)中，都可以把自己注冊到11個http階段 
      if (module->postconfiguration(cf) != NGX_OK)  
      { 
        return NGX_CONF_ERROR; 
      } 
    } 
  } 
} 

//靜態(tài)模塊將自己注冊到11個http請求階段中的NGX_HTTP_CONTENT_PHASE階段 
static ngx_int_t ngx_http_static_init(ngx_conf_t *cf) 
{ 
  cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module); 
  h = ngx_array_push(&cmcf->phases[NGX_HTTP_CONTENT_PHASE].handlers); 
 
  //靜態(tài)模塊在NGX_HTTP_CONTENT_PHASE階段的處理方法 
  *h = ngx_http_static_handler; 
 
  return NGX_OK; 
} 

//訪問權(quán)限模塊將自己注冊到11個http請求階段中的NGX_HTTP_ACCESS_PHASE階段 
static ngx_int_t ngx_http_access_init(ngx_conf_t *cf) 
{ 
  cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module); 
  h = ngx_array_push(&cmcf->phases[NGX_HTTP_ACCESS_PHASE].handlers); 
   
  //訪問權(quán)限模塊在NGX_HTTP_ACCESS_PHASE階段的處理方法 
  *h = ngx_http_access_handler; 
   
  return NGX_OK; 
} 

//開始解析http塊 
static char * ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) 
{ 
    //初始化請求的各個階段 
  if (ngx_http_init_phase_handlers(cf, cmcf) != NGX_OK)  
  { 
    return NGX_CONF_ERROR; 
  } 
} 

//初始化請求的各個階段 
static ngx_int_t ngx_http_init_phase_handlers(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf) 
{ 
  //11個http請求階段，每一個階段都可以有多個http模塊介入。 
  //這里統(tǒng)計11個節(jié)點一共有多個少http模塊。以便下面開辟空間 
  for (i = 0; i < NGX_HTTP_LOG_PHASE; i++)  
  { 
    n += cmcf->phases[i].handlers.nelts; 
  } 
  //開辟空間，存放介入11個處理階段的所有http模塊的回調(diào) 
  ph = ngx_pcalloc(cf->pool,n * sizeof(ngx_http_phase_handler_t) + sizeof(void *)); 
  cmcf->phase_engine.handlers = ph; 
  n = 0; 
 
  //對于每一個http處理階段，給該階段中所有介入的http模塊賦值 
  for (i = 0; i < NGX_HTTP_LOG_PHASE; i++) 
  { 
    h = cmcf->phases[i].handlers.elts; 
 
    switch (i)  
    { 
      case NGX_HTTP_SERVER_REWRITE_PHASE://根據(jù)請求的uri查找location之前，修改請求的uri階段 
        if (cmcf->phase_engine.server_rewrite_index == (ngx_uint_t) -1)  
        { 
          cmcf->phase_engine.server_rewrite_index = n; //重定向模塊在數(shù)組中的位置 
        } 
        checker = ngx_http_core_rewrite_phase;   //每一個階段的checker回調(diào) 
        break; 
      case NGX_HTTP_FIND_CONFIG_PHASE://根據(jù)請求的uri查找location階段(只能由http框架實現(xiàn)) 
        find_config_index = n; 
        ph->checker = ngx_http_core_find_config_phase; 
        n++; 
        ph++; 
        continue; 
      case NGX_HTTP_REWRITE_PHASE:  //根據(jù)請求的rui查找location之后，修改請求的uri階段 
        if (cmcf->phase_engine.location_rewrite_index == (ngx_uint_t) -1) 
        { 
          cmcf->phase_engine.location_rewrite_index = n; 
        } 
        checker = ngx_http_core_rewrite_phase; 
        break; 
      case NGX_HTTP_POST_REWRITE_PHASE: //NGX_HTTP_REWRITE_PHASE階段修改rul后，防止遞歸修改uri導(dǎo)致死循環(huán)階段 
        if (use_rewrite)  
        { 
          ph->checker = ngx_http_core_post_rewrite_phase; 
          ph->next = find_config_index;//目的是為了地址重寫后，跳轉(zhuǎn)到NGX_HTTP_FIND_CONFIG_PHASE階段，根據(jù) 
                        //url重寫查找location 
          n++; 
          ph++; 
        } 
        continue; 
      case NGX_HTTP_ACCESS_PHASE:     //是否允許訪問服務(wù)器階段 
        checker = ngx_http_core_access_phase; 
        n++; 
        break; 
      case NGX_HTTP_POST_ACCESS_PHASE:  //根據(jù)NGX_HTTP_ACCESS_PHASE階段的錯誤碼，給客戶端構(gòu)造響應(yīng)階段 
        if (use_access)  
        { 
          ph->checker = ngx_http_core_post_access_phase; 
          ph->next = n; 
          ph++; 
        } 
        continue; 
      case NGX_HTTP_TRY_FILES_PHASE:   //try_file階段 
        if (cmcf->try_files)  
        { 
          ph->checker = ngx_http_core_try_files_phase; 
          n++; 
          ph++; 
        } 
        continue; 
      case NGX_HTTP_CONTENT_PHASE:    //處理http請求內(nèi)容階段，大部分http模塊最愿意介入的階段 
        checker = ngx_http_core_content_phase; 
        break; 
      default: 
        //NGX_HTTP_POST_READ_PHASE,  
        //NGX_HTTP_PREACCESS_PHASE,  
        //NGX_HTTP_LOG_PHASE三個階段的checker方法 
        checker = ngx_http_core_generic_phase; 
    } 
    n += cmcf->phases[i].handlers.nelts; 
    //每一個階段中所介入的所有http模塊，同一個階段中的所有http模塊有唯一的checker回調(diào)， 
    //但handler回調(diào)每一個模塊自己實現(xiàn) 
    for (j = cmcf->phases[i].handlers.nelts - 1; j >=0; j--)  
    { 
      ph->checker = checker;     
      ph->handler = h[j]; 
      ph->next = n; 
      ph++; 
    } 
  } 
  return NGX_OK; 
} 

//NGX_HTTP_POST_READ_PHASE,  
//NGX_HTTP_PREACCESS_PHASE,  
//NGX_HTTP_LOG_PHASE三個階段的checker方法 
//返回值: NGX_OK，http框架會將控制權(quán)交還給epoll模塊 
ngx_int_t ngx_http_core_generic_phase(ngx_http_request_t *r,ngx_http_phase_handler_t *ph) 
{ 
  ngx_int_t rc; 
  //調(diào)用http模塊的處理方法，這樣這個http模塊就介入到了這個請求階段 
  rc = ph->handler(r); 
  //跳轉(zhuǎn)到下一個http階段執(zhí)行 
  if (rc == NGX_OK)         
  { 
    r->phase_handler = ph->next; 
    return NGX_AGAIN; 
  } 
   
  //執(zhí)行本階段的下一個http模塊 
  if (rc == NGX_DECLINED)      
  { 
    r->phase_handler++; 
    return NGX_AGAIN; 
  } 
 
  //表示剛執(zhí)行的handler無法在這一次調(diào)度中處理完這一個階段， 
  //需要多次調(diào)度才能完成 
  if (rc == NGX_AGAIN || rc == NGX_DONE)  
                       
  { 
    return NGX_OK; 
  } 
  //返回出錯 
  /* rc == NGX_ERROR || rc == NGX_HTTP_... */ 
  ngx_http_finalize_request(r, rc); 
 
  return NGX_OK; 
}