ngx_http_lua_server_rewriteby.c

/*
 * Copyright (C) Xiaozhe Wang (chaoslawful)
 * Copyright (C) Yichun Zhang (agentzh)
 */


#ifndefDDEBUG
#defineDDEBUG 0
#endif
#include"ddebug.h"

#include<nginx.h>
#include"ngx_http_lua_server_rewriteby.h"
#include"ngx_http_lua_util.h"
#include"ngx_http_lua_exception.h"
#include"ngx_http_lua_cache.h"

staticngx_int_tngx_http_lua_server_rewrite_by_chunk(lua_State*L,
ngx_http_request_t*r);

ngx_int_t
ngx_http_lua_server_rewrite_handler(ngx_http_request_t*r)
{
ngx_int_trc;
lua_State*L;
ngx_http_lua_srv_conf_t*lscf;
ngx_http_lua_loc_conf_t*llcf;
ngx_http_lua_ctx_t*ctx;

/* XXX we need to take into account ngx_rewrite's location dump */
if (r->uri_changed) {
returnNGX_DECLINED;
 }

ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"lua server rewrite handler, uri:\"%V\" c:%ud", &r->uri,
r->main->count);

lscf=ngx_http_get_module_srv_conf(r, ngx_http_lua_module);
llcf=ngx_http_get_module_loc_conf(r, ngx_http_lua_module);
L=ngx_http_lua_get_lua_vm(r, NULL);

if (lscf->srv.server_rewrite_handler==NULL) {
dd("no rewrite handler found");
returnNGX_DECLINED;
 }

ctx=ngx_http_get_module_ctx(r, ngx_http_lua_module);

dd("ctx = %p", ctx);

if (ctx==NULL) {
ctx=ngx_http_lua_create_ctx(r);
if (ctx==NULL) {
returnNGX_HTTP_INTERNAL_SERVER_ERROR;
 }
 }

dd("entered? %d", (int) ctx->entered_server_rewrite_phase);

if (ctx->entered_server_rewrite_phase) {
dd("rewriteby: calling wev handler");
rc=ctx->resume_handler(r);
dd("rewriteby: wev handler returns %d", (int) rc);

if (rc==NGX_OK) {
rc=NGX_DECLINED;
 }

if (rc==NGX_DECLINED) {
if (r->header_sent
|| (r->headers_out.status!=0&&ctx->out!=NULL))
 {
dd("header already sent");

/* response header was already generated in rewrite_by_lua*,
 * so it is no longer safe to proceed to later phases
 * which may generate responses again */

if (!ctx->eof) {
dd("eof not yet sent");

rc=ngx_http_lua_send_chain_link(r, ctx, NULL
/* indicate last_buf */);
if (rc==NGX_ERROR||rc>NGX_OK) {
returnrc;
 }
 }

returnNGX_HTTP_OK;
 }

r->write_event_handler=ngx_http_core_run_phases;
ctx->entered_server_rewrite_phase=0;

returnNGX_DECLINED;
 }

returnrc;
 }

if (ctx->waiting_more_body) {
returnNGX_DONE;
 }

/* TODO: lscf do not have force_read_body */
if (llcf->force_read_body&& !ctx->read_body_done) {
r->request_body_in_single_buf=1;
r->request_body_in_persistent_file=1;
r->request_body_in_clean_file=1;

rc=ngx_http_read_client_request_body(r,
ngx_http_lua_generic_phase_post_read);

if (rc==NGX_ERROR||rc >= NGX_HTTP_SPECIAL_RESPONSE) {
returnrc;
 }

if (rc==NGX_AGAIN) {
ctx->waiting_more_body=1;
returnNGX_DONE;
 }
 }

dd("calling server rewrite handler");
returnlscf->srv.server_rewrite_handler(r, lscf, L);
}


ngx_int_t
ngx_http_lua_server_rewrite_handler_inline(ngx_http_request_t*r,
ngx_http_lua_srv_conf_t*lscf, lua_State*L)
{
ngx_int_trc;

dd("server_rewrite by lua inline");


/* load Lua inline script (w/ cache) sp = 1 */
rc=ngx_http_lua_cache_loadbuffer(r->connection->log, L,
lscf->srv.server_rewrite_src.value.data,
lscf->srv.server_rewrite_src.value.len,
&lscf->srv.server_rewrite_src_ref,
lscf->srv.server_rewrite_src_key,
 (constchar*)
lscf->srv.server_rewrite_chunkname);
if (rc!=NGX_OK) {
returnNGX_HTTP_INTERNAL_SERVER_ERROR;
 }

returnngx_http_lua_server_rewrite_by_chunk(L, r);
}


ngx_int_t
ngx_http_lua_server_rewrite_handler_file(ngx_http_request_t*r,
ngx_http_lua_srv_conf_t*lscf, lua_State*L)
{
ngx_int_trc;
u_char*script_path;
ngx_str_teval_src;


if (ngx_http_complex_value(r, &lscf->srv.server_rewrite_src,
&eval_src) !=NGX_OK)
 {
returnNGX_ERROR;
 }

script_path=ngx_http_lua_rebase_path(r->pool, eval_src.data,
eval_src.len);

if (script_path==NULL) {
returnNGX_ERROR;
 }

/* load Lua script file (w/ cache) sp = 1 */
rc=ngx_http_lua_cache_loadfile(r->connection->log, L, script_path,
&lscf->srv.server_rewrite_src_ref,
lscf->srv.server_rewrite_src_key);
if (rc!=NGX_OK) {
if (rc<NGX_HTTP_SPECIAL_RESPONSE) {
returnNGX_HTTP_INTERNAL_SERVER_ERROR;
 }

returnrc;
 }

returnngx_http_lua_server_rewrite_by_chunk(L, r);
}


staticngx_int_t
ngx_http_lua_server_rewrite_by_chunk(lua_State*L, ngx_http_request_t*r)
{
intco_ref;
lua_State*co;
ngx_int_trc;
ngx_uint_tnreqs;
ngx_event_t*rev;
ngx_connection_t*c;
ngx_http_lua_ctx_t*ctx;
ngx_pool_cleanup_t*cln;

ngx_http_lua_loc_conf_t*llcf;

/* {{{ new coroutine to handle request */
co=ngx_http_lua_new_thread(r, L, &co_ref);

if (co==NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"lua: failed to create new coroutine to handle request");

returnNGX_HTTP_INTERNAL_SERVER_ERROR;
 }

/* move code closure to new coroutine */
lua_xmove(L, co, 1);

#ifndefOPENRESTY_LUAJIT
/* set closure's env table to new coroutine's globals table */
ngx_http_lua_get_globals_table(co);
lua_setfenv(co, -2);
#endif

/* save nginx request in coroutine globals table */
ngx_http_lua_set_req(co, r);

/* {{{ initialize request context */
ctx=ngx_http_get_module_ctx(r, ngx_http_lua_module);

dd("ctx = %p", ctx);

if (ctx==NULL) {
returnNGX_ERROR;
 }

ngx_http_lua_reset_ctx(r, L, ctx);

ctx->entered_server_rewrite_phase=1;

ctx->cur_co_ctx=&ctx->entry_co_ctx;
ctx->cur_co_ctx->co=co;
ctx->cur_co_ctx->co_ref=co_ref;
#ifdefNGX_LUA_USE_ASSERT
ctx->cur_co_ctx->co_top=1;
#endif

ngx_http_lua_attach_co_ctx_to_L(co, ctx->cur_co_ctx);

/* }}} */

/* {{{ register request cleanup hooks */
if (ctx->cleanup==NULL) {
cln=ngx_pool_cleanup_add(r->pool, 0);
if (cln==NULL) {
returnNGX_HTTP_INTERNAL_SERVER_ERROR;
 }

cln->handler=ngx_http_lua_request_cleanup_handler;
cln->data=ctx;
ctx->cleanup=&cln->handler;
 }
/* }}} */

ctx->context=NGX_HTTP_LUA_CONTEXT_SERVER_REWRITE;

llcf=ngx_http_get_module_loc_conf(r, ngx_http_lua_module);

if (llcf->check_client_abort) {
r->read_event_handler=ngx_http_lua_rd_check_broken_connection;

#if (NGX_HTTP_V2)
if (!r->stream) {
#endif

rev=r->connection->read;

if (!rev->active) {
if (ngx_add_event(rev, NGX_READ_EVENT, 0) !=NGX_OK) {
returnNGX_ERROR;
 }
 }

#if (NGX_HTTP_V2)
 }
#endif

 } else {
r->read_event_handler=ngx_http_block_reading;
 }

c=r->connection;
nreqs=c->requests;

rc=ngx_http_lua_run_thread(L, r, ctx, 0);

if (rc==NGX_ERROR||rc>NGX_OK) {
returnrc;
 }

if (rc==NGX_AGAIN) {
rc=ngx_http_lua_run_posted_threads(c, L, r, ctx, nreqs);

 } elseif (rc==NGX_DONE) {
ngx_http_lua_finalize_request(r, NGX_DONE);
rc=ngx_http_lua_run_posted_threads(c, L, r, ctx, nreqs);
 }

if (rc==NGX_OK||rc==NGX_DECLINED) {
if (r->header_sent
|| (r->headers_out.status!=0&&ctx->out!=NULL))
 {
dd("header already sent");

/* response header was already generated in rewrite_by_lua*,
 * so it is no longer safe to proceed to later phases
 * which may generate responses again */

if (!ctx->eof) {
dd("eof not yet sent");

rc=ngx_http_lua_send_chain_link(r, ctx, NULL
/* indicate last_buf */);
if (rc==NGX_ERROR||rc>NGX_OK) {
returnrc;
 }
 }

returnNGX_HTTP_OK;
 }

r->write_event_handler=ngx_http_core_run_phases;
ctx->entered_server_rewrite_phase=0;

returnNGX_DECLINED;
 }

returnrc;
}

/* vi:set ft=c ts=4 sw=4 et fdm=marker: */