ngx_http_lua_headers.c

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


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


#include"ngx_http_lua_headers.h"
#include"ngx_http_lua_headers_out.h"
#include"ngx_http_lua_headers_in.h"
#include"ngx_http_lua_util.h"


staticintngx_http_lua_ngx_req_http_version(lua_State*L);
staticintngx_http_lua_ngx_req_raw_header(lua_State*L);
staticintngx_http_lua_ngx_req_header_set_helper(lua_State*L);
staticintngx_http_lua_ngx_resp_get_headers(lua_State*L);
staticintngx_http_lua_ngx_req_header_set(lua_State*L);
#if (nginx_version >= 1011011)
voidngx_http_lua_ngx_raw_header_cleanup(void*data);
#endif


void
ngx_http_lua_inject_resp_header_api(lua_State*L)
{
lua_createtable(L, 0, 1); /* .resp */

lua_pushcfunction(L, ngx_http_lua_ngx_resp_get_headers);
lua_setfield(L, -2, "get_headers");

lua_setfield(L, -2, "resp");
}


void
ngx_http_lua_inject_req_header_api(lua_State*L)
{
lua_pushcfunction(L, ngx_http_lua_ngx_req_http_version);
lua_setfield(L, -2, "http_version");

lua_pushcfunction(L, ngx_http_lua_ngx_req_raw_header);
lua_setfield(L, -2, "raw_header");

lua_pushcfunction(L, ngx_http_lua_ngx_req_header_set);
lua_setfield(L, -2, "set_header");
}


staticint
ngx_http_lua_ngx_req_http_version(lua_State*L)
{
ngx_http_request_t*r;

r=ngx_http_lua_get_req(L);
if (r==NULL) {
returnluaL_error(L, "no request object found");
 }

ngx_http_lua_check_fake_request(L, r);

switch (r->http_version) {
caseNGX_HTTP_VERSION_9:
lua_pushnumber(L, 0.9);
break;

caseNGX_HTTP_VERSION_10:
lua_pushnumber(L, 1.0);
break;

caseNGX_HTTP_VERSION_11:
lua_pushnumber(L, 1.1);
break;

#ifdefNGX_HTTP_VERSION_20
caseNGX_HTTP_VERSION_20:
lua_pushnumber(L, 2.0);
break;
#endif

#ifdefNGX_HTTP_VERSION_30
caseNGX_HTTP_VERSION_30:
lua_pushnumber(L, 3.0);
break;
#endif

default:
lua_pushnil(L);
break;
 }

return1;
}


staticint
ngx_http_lua_ngx_req_raw_header(lua_State*L)
{
intn, line_break_len;
u_char*data, *p, *last, *pos;
unsignedno_req_line=0, found;
size_tsize;
ngx_buf_t*b, *first=NULL;
ngx_int_ti, j;
#if (nginx_version >= 1011011)
ngx_buf_t**bb;
ngx_chain_t*cl;
ngx_http_lua_main_conf_t*lmcf;
#endif
ngx_connection_t*c;
ngx_http_request_t*r, *mr;
ngx_http_connection_t*hc;

n=lua_gettop(L);
if (n>0) {
no_req_line=lua_toboolean(L, 1);
 }

dd("no req line: %d", (int) no_req_line);

r=ngx_http_lua_get_req(L);
if (r==NULL) {
returnluaL_error(L, "no request object found");
 }

#if (nginx_version >= 1011011)
lmcf=ngx_http_get_module_main_conf(r, ngx_http_lua_module);
#endif

ngx_http_lua_check_fake_request(L, r);

mr=r->main;
hc=mr->http_connection;
c=mr->connection;

#if (NGX_HTTP_V2)
if (mr->stream) {
returnluaL_error(L, "http2 requests not supported yet");
 }
#endif

#if1
dd("hc->nbusy: %d", (int) hc->nbusy);

if (hc->nbusy) {
#if (nginx_version >= 1011011)
dd("hc->busy: %p %p %p %p", hc->busy->buf->start, hc->busy->buf->pos,
hc->busy->buf->last, hc->busy->buf->end);
#else
dd("hc->busy: %p %p %p %p", hc->busy[0]->start, hc->busy[0]->pos,
hc->busy[0]->last, hc->busy[0]->end);
#endif
 }

dd("request line: %p %p", mr->request_line.data,
mr->request_line.data+mr->request_line.len);

dd("header in: %p %p %p %p", mr->header_in->start,
mr->header_in->pos, mr->header_in->last,
mr->header_in->end);

dd("c->buffer: %p %p %p %p", c->buffer->start,
c->buffer->pos, c->buffer->last,
c->buffer->end);
#endif

size=0;
b=c->buffer;

if (mr->request_line.len==0) {
/* return empty string on invalid request */
lua_pushlstring(L, "", 0);
return1;
 }

if (mr->request_line.data[mr->request_line.len] ==CR) {
line_break_len=2;

 } else {
line_break_len=1;
 }

if (mr->request_line.data >= b->start
&&mr->request_line.data+mr->request_line.len
+line_break_len <= b->pos)
 {
first=b;
size+=b->pos-mr->request_line.data;
 }

dd("size: %d", (int) size);

if (hc->nbusy) {
#if (nginx_version >= 1011011)
if (hc->nbusy>lmcf->busy_buf_ptr_count) {
if (lmcf->busy_buf_ptrs) {
ngx_free(lmcf->busy_buf_ptrs);
 }

lmcf->busy_buf_ptrs=ngx_alloc(hc->nbusy*sizeof(ngx_buf_t*),
r->connection->log);

if (lmcf->busy_buf_ptrs==NULL) {
returnluaL_error(L, "no memory");
 }

lmcf->busy_buf_ptr_count=hc->nbusy;
 }

bb=lmcf->busy_buf_ptrs;
for (cl=hc->busy; cl; cl=cl->next) {
*bb++=cl->buf;
 }
#endif
b=NULL;

#if (nginx_version >= 1011011)
bb=lmcf->busy_buf_ptrs;
for (i=hc->nbusy; i>0; i--) {
b=bb[i-1];
#else
for (i=0; i<hc->nbusy; i++) {
b=hc->busy[i];
#endif

dd("busy buf: %d: [%.*s]", (int) i, (int) (b->pos-b->start),
b->start);

if (first==NULL) {
if (mr->request_line.data >= b->pos
||mr->request_line.data
+mr->request_line.len+line_break_len
 <= b->start)
 {
continue;
 }

dd("found first at %d", (int) i);
first=b;
 }

dd("adding size %d", (int) (b->pos-b->start));
size+=b->pos-b->start;
 }
 }

size++; /* plus the null terminator, as required by the later
 ngx_strstr() call */

dd("header size: %d", (int) size);

data=lua_newuserdata(L, size);
last=data;

b=c->buffer;
found=0;

if (first==b) {
found=1;
pos=b->pos;

if (no_req_line) {
last=ngx_copy(data,
mr->request_line.data
+mr->request_line.len+line_break_len,
pos-mr->request_line.data
-mr->request_line.len-line_break_len);

 } else {
last=ngx_copy(data, mr->request_line.data,
pos-mr->request_line.data);
 }

if (b!=mr->header_in) {
/* skip truncated header entries (if any) */
while (last>data&&last[-1] !=LF&&last[-1] !='\0') {
last--;
 }
 }

i=0;
for (p=data; p!=last; p++) {
if (*p=='\0') {
i++;
if (p+1!=last&&*(p+1) ==LF) {
*p=CR;

 } elseif (i % 2==1) {
*p=':';

 } else {
*p=LF;
 }
 }
 }
 }

if (hc->nbusy) {

#if (nginx_version >= 1011011)
bb=lmcf->busy_buf_ptrs;
for (i=hc->nbusy-1; i >= 0; i--) {
b=bb[i];
#else
for (i=0; i<hc->nbusy; i++) {
b=hc->busy[i];
#endif

if (!found) {
if (b!=first) {
continue;
 }

dd("found first");
found=1;
 }

p=last;

pos=b->pos;

if (b==first) {
dd("request line: %.*s", (int) mr->request_line.len,
mr->request_line.data);

if (no_req_line) {
last=ngx_copy(last,
mr->request_line.data
+mr->request_line.len+line_break_len,
pos-mr->request_line.data
-mr->request_line.len-line_break_len);

 } else {
last=ngx_copy(last,
mr->request_line.data,
pos-mr->request_line.data);

 }

 } else {
last=ngx_copy(last, b->start, pos-b->start);
 }

#if1
/* skip truncated header entries (if any) */
while (last>p&&last[-1] !=LF&&last[-1] !='\0') {
last--;
 }
#endif

j=0;
for (; p!=last; p++) {
if (*p=='\0') {
j++;
if (p+1==last) {
*p=LF;

 } elseif (*(p+1) ==LF) {
*p=CR;

 } elseif (j % 2==1) {
*p=':';

 } else {
*p=LF;
 }
 }
 }

if (b==mr->header_in) {
break;
 }
 }
 }

*last++='\0';

if (last-data> (ssize_t) size) {
returnluaL_error(L, "buffer error: %d", (int) (last-data-size));
 }

/* strip the leading part (if any) of the request body in our header.
 * the first part of the request body could slip in because nginx core's
 * ngx_http_request_body_length_filter and etc can move r->header_in->pos
 * in case that some of the body data has been preread into r->header_in.
 */

if ((p= (u_char*) ngx_strstr(data, CRLFCRLF)) !=NULL) {
last=p+sizeof(CRLFCRLF) -1;

 } elseif ((p= (u_char*) ngx_strstr(data, CRLF"\n")) !=NULL) {
last=p+sizeof(CRLF"\n") -1;

 } elseif ((p= (u_char*) ngx_strstr(data, "\n"CRLF)) !=NULL) {
last=p+sizeof("\n"CRLF) -1;

 } else {
for (p=last-1; p-data >= 2; p--) {
if (p[0] ==LF&&p[-1] ==CR) {
p[-1] =LF;
last=p+1;
break;
 }

if (p[0] ==LF&&p[-1] ==LF) {
last=p+1;
break;
 }
 }
 }

lua_pushlstring(L, (char*) data, last-data);
return1;
}


staticint
ngx_http_lua_ngx_resp_get_headers(lua_State*L)
{
ngx_list_part_t*part;
ngx_table_elt_t*header;
ngx_http_request_t*r;
ngx_http_lua_ctx_t*ctx;
u_char*lowcase_key=NULL;
size_tlowcase_key_sz=0;
ngx_uint_ti;
intn;
intmax;
intraw=0;
intcount=0;
inttruncated=0;
intextra=0;
u_char*p=NULL;
size_tlen=0;

n=lua_gettop(L);

if (n >= 1) {
if (lua_isnil(L, 1)) {
max=NGX_HTTP_LUA_MAX_HEADERS;

 } else {
max=luaL_checkinteger(L, 1);
 }

if (n >= 2) {
raw=lua_toboolean(L, 2);
 }

 } else {
max=NGX_HTTP_LUA_MAX_HEADERS;
 }

r=ngx_http_lua_get_req(L);
if (r==NULL) {
returnluaL_error(L, "no request object found");
 }

ctx=ngx_http_get_module_ctx(r, ngx_http_lua_module);
if (ctx==NULL) {
returnluaL_error(L, "no ctx found");
 }

ngx_http_lua_check_fake_request(L, r);

part=&r->headers_out.headers.part;
count=part->nelts;
while (part->next!=NULL) {
part=part->next;
count+=part->nelts;
 }

lua_createtable(L, 0, count+2);

if (!raw) {
lua_pushlightuserdata(L, ngx_http_lua_lightudata_mask(
headers_metatable_key));
lua_rawget(L, LUA_REGISTRYINDEX);
lua_setmetatable(L, -2);
 }

#if1
if (r->headers_out.content_type.len) {
extra++;
lua_pushliteral(L, "content-type");
lua_pushlstring(L, (char*) r->headers_out.content_type.data,
r->headers_out.content_type.len);
lua_rawset(L, -3);
 }

if (r->headers_out.content_length==NULL
&&r->headers_out.content_length_n >= 0)
 {
extra++;
lua_pushliteral(L, "content-length");
if (r->headers_out.content_length_n>NGX_MAX_INT32_VALUE) {
p=ngx_palloc(r->pool, NGX_OFF_T_LEN);
if (p==NULL) {
returnluaL_error(L, "no memory");
 }

len=ngx_snprintf(p, NGX_OFF_T_LEN, "%O",
r->headers_out.content_length_n) -p;

lua_pushlstring(L, (char*) p, len);

 } else {
lua_pushfstring(L, "%d", (int) r->headers_out.content_length_n);
 }

lua_rawset(L, -3);
 }

extra++;
lua_pushliteral(L, "connection");
if (r->headers_out.status==NGX_HTTP_SWITCHING_PROTOCOLS) {
lua_pushliteral(L, "upgrade");

 } elseif (r->keepalive) {
lua_pushliteral(L, "keep-alive");

 } else {
lua_pushliteral(L, "close");
 }

lua_rawset(L, -3);

if (r->chunked) {
extra++;
lua_pushliteral(L, "transfer-encoding");
lua_pushliteral(L, "chunked");
lua_rawset(L, -3);
 }
#endif

if (max>0&&count+extra>max) {
truncated=1;
ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"lua exceeding response header limit %d > %d",
count+extra, max);
count=max-extra;
 }

part=&r->headers_out.headers.part;
header=part->elts;

for (i=0; /* void */; i++) {

dd("stack top: %d", lua_gettop(L));

if (i >= part->nelts) {
if (part->next==NULL) {
break;
 }

part=part->next;
header=part->elts;
i=0;
 }

if (header[i].hash==0) {
continue;
 }

if (raw) {
lua_pushlstring(L, (char*) header[i].key.data, header[i].key.len);

 } else {
/* nginx does not even bother initializing output header entry's
 * "lowcase_key" field. so we cannot count on that at all. */
if (header[i].key.len>lowcase_key_sz) {
lowcase_key_sz=header[i].key.len*2;

/* we allocate via Lua's GC to prevent in-request
 * leaks in the nginx request memory pools */
lowcase_key=lua_newuserdata(L, lowcase_key_sz);
lua_insert(L, 1);
 }

ngx_strlow(lowcase_key, header[i].key.data, header[i].key.len);
lua_pushlstring(L, (char*) lowcase_key, header[i].key.len);
 }

/* stack: [udata] table key */

lua_pushlstring(L, (char*) header[i].value.data,
header[i].value.len); /* stack: [udata] table key
 value */

ngx_http_lua_set_multi_value_table(L, -3);

ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"lua response header: \"%V: %V\"",
&header[i].key, &header[i].value);

if (--count <= 0) {
break;
 }
 } /* for */

if (truncated) {
lua_pushliteral(L, "truncated");
return2;
 }

return1;
}


staticint
ngx_http_lua_ngx_req_header_set(lua_State*L)
{
if (lua_gettop(L) !=2) {
returnluaL_error(L, "expecting two arguments, but seen %d",
lua_gettop(L));
 }

returnngx_http_lua_ngx_req_header_set_helper(L);
}


staticint
ngx_http_lua_ngx_req_header_set_helper(lua_State*L)
{
ngx_http_request_t*r;
u_char*p;
ngx_str_tkey;
ngx_str_tvalue;
ngx_uint_ti;
size_tlen;
ngx_int_trc;
ngx_uint_tn;

r=ngx_http_lua_get_req(L);
if (r==NULL) {
returnluaL_error(L, "no request object found");
 }

ngx_http_lua_check_fake_request(L, r);

if (r->http_version<NGX_HTTP_VERSION_10) {
return0;
 }

p= (u_char*) luaL_checklstring(L, 1, &len);

dd("key: %.*s, len %d", (int) len, p, (int) len);

#if0
/* replace "_" with "-" */
for (i=0; i<len; i++) {
if (p[i] =='_') {
p[i] ='-';
 }
 }
#endif

key.data=ngx_palloc(r->pool, len+1);
if (key.data==NULL) {
returnluaL_error(L, "no memory");
 }

ngx_memcpy(key.data, p, len);

key.data[len] ='\0';

key.len=len;

if (lua_type(L, 2) ==LUA_TNIL) {
ngx_str_null(&value);

 } elseif (lua_type(L, 2) ==LUA_TTABLE) {
n=lua_objlen(L, 2);
if (n==0) {
ngx_str_null(&value);

 } else {
for (i=1; i <= n; i++) {
dd("header value table index %d, top: %d", (int) i,
lua_gettop(L));

lua_rawgeti(L, 2, i);
p= (u_char*) luaL_checklstring(L, -1, &len);

/*
 * we also copy the trailing '\0' char here because nginx
 * header values must be null-terminated
 * */

value.data=ngx_palloc(r->pool, len+1);
if (value.data==NULL) {
returnluaL_error(L, "no memory");
 }

ngx_memcpy(value.data, p, len+1);
value.len=len;

rc=ngx_http_lua_set_input_header(r, key, value,
i==1/* override */);

if (rc==NGX_ERROR) {
returnluaL_error(L,
"failed to set header %s (error: %d)",
key.data, (int) rc);
 }
 }

return0;
 }

 } else {

/*
 * we also copy the trailing '\0' char here because nginx
 * header values must be null-terminated
 * */

p= (u_char*) luaL_checklstring(L, 2, &len);
value.data=ngx_palloc(r->pool, len+1);
if (value.data==NULL) {
returnluaL_error(L, "no memory");
 }

ngx_memcpy(value.data, p, len+1);
value.len=len;
 }

dd("key: %.*s, value: %.*s",
 (int) key.len, key.data, (int) value.len, value.data);

rc=ngx_http_lua_set_input_header(r, key, value, 1/* override */);

if (rc==NGX_ERROR) {
returnluaL_error(L, "failed to set header %s (error: %d)",
key.data, (int) rc);
 }

return0;
}


void
ngx_http_lua_create_headers_metatable(ngx_log_t*log, lua_State*L)
{
intrc;
constcharbuf[] =
"local tb, key = ...\n"
"local new_key = string.gsub(string.lower(key), '_', '-')\n"
"if new_key ~= key then return tb[new_key] else return nil end";

lua_pushlightuserdata(L, ngx_http_lua_lightudata_mask(
headers_metatable_key));

/* metatable for ngx.req.get_headers(_, true) and
 * ngx.resp.get_headers(_, true) */
lua_createtable(L, 0, 1);

rc=luaL_loadbuffer(L, buf, sizeof(buf) -1, "=headers metatable");
if (rc!=0) {
ngx_log_error(NGX_LOG_ERR, log, 0,
"failed to load Lua code for the metamethod for "
"headers: %i: %s", rc, lua_tostring(L, -1));

lua_pop(L, 3);
return;
 }

lua_setfield(L, -2, "__index");
lua_rawset(L, LUA_REGISTRYINDEX);
}


int
ngx_http_lua_ffi_req_get_headers_count(ngx_http_request_t*r, intmax,
int*truncated)
{
intcount;
ngx_list_part_t*part;
#if (NGX_HTTP_V3)
inthas_host=0;
ngx_uint_ti;
ngx_table_elt_t*header;
#endif

if (r->connection->fd== (ngx_socket_t) -1) {
returnNGX_HTTP_LUA_FFI_BAD_CONTEXT;
 }

*truncated=0;

if (max<0) {
max=NGX_HTTP_LUA_MAX_HEADERS;
 }

part=&r->headers_in.headers.part;

#if (NGX_HTTP_V3)
count=0;
header=part->elts;

if (r->http_version==NGX_HTTP_VERSION_30
&&r->headers_in.server.data!=NULL)
 {
has_host=1;
count++;
 }

if (has_host==1) {
for (i=0; /* void */; i++) {
if (i >= part->nelts) {
if (part->next==NULL) {
break;
 }

part=part->next;
header=part->elts;
i=0;
 }

if (header[i].key.len==4
&&ngx_strncasecmp(header[i].key.data,
 (u_char*) "host", 4) ==0)
 {
continue;
 }

count++;
 }

 } else {
count=part->nelts;
while (part->next!=NULL) {
part=part->next;
count+=part->nelts;
 }
 }
#else
count=part->nelts;
while (part->next!=NULL) {
part=part->next;
count+=part->nelts;
 }
#endif

if (max>0&&count>max) {
*truncated=1;

ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"lua exceeding request header limit %d > %d", count,
max);
count=max;
 }

returncount;
}


int
ngx_http_lua_ffi_req_get_headers(ngx_http_request_t*r,
ngx_http_lua_ffi_table_elt_t*out, intcount, intraw)
{
intn;
ngx_uint_ti;
ngx_list_part_t*part;
ngx_table_elt_t*header;
#if (NGX_HTTP_V3)
inthas_host=0;
#endif

if (count <= 0) {
returnNGX_OK;
 }

n=0;

#if (NGX_HTTP_V3)
if (r->http_version==NGX_HTTP_VERSION_30
&&r->headers_in.server.data!=NULL)
 {
out[n].key.data= (u_char*) "host";
out[n].key.len=sizeof("host") -1;
out[n].value.len=r->headers_in.server.len;
out[n].value.data=r->headers_in.server.data;
has_host=1;
++n;
 }
#endif

part=&r->headers_in.headers.part;
header=part->elts;

for (i=0; /* void */; i++) {

if (i >= part->nelts) {
if (part->next==NULL) {
break;
 }

part=part->next;
header=part->elts;
i=0;
 }

#if (NGX_HTTP_V3)
if (has_host==1&&header[i].key.len==4
&&ngx_strncasecmp(header[i].key.data, (u_char*) "host", 4) ==0)
 {
continue;
 }
#endif

if (raw) {
out[n].key.data=header[i].key.data;
out[n].key.len= (int) header[i].key.len;

 } else {
out[n].key.data=header[i].lowcase_key;
out[n].key.len= (int) header[i].key.len;
 }

out[n].value.data=header[i].value.data;
out[n].value.len= (int) header[i].value.len;

if (++n==count) {
returnNGX_OK;
 }
 }

returnNGX_OK;
}


int
ngx_http_lua_ffi_set_resp_header(ngx_http_request_t*r, constu_char*key_data,
size_tkey_len, intis_nil, constu_char*sval, size_tsval_len,
ngx_http_lua_ffi_str_t*mvals, size_tmvals_len, intoverride,
char**errmsg)
{
u_char*p;
ngx_str_tvalue, key;
ngx_uint_ti;
size_tlen;
ngx_http_lua_ctx_t*ctx;
ngx_int_trc;
ngx_http_lua_loc_conf_t*llcf;

ctx=ngx_http_get_module_ctx(r, ngx_http_lua_module);
if (ctx==NULL) {
returnNGX_HTTP_LUA_FFI_NO_REQ_CTX;
 }

if (r->connection->fd== (ngx_socket_t) -1) {
returnNGX_HTTP_LUA_FFI_BAD_CONTEXT;
 }

if (r->header_sent||ctx->header_sent) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "attempt to "
"set ngx.header.HEADER after sending out "
"response headers");
returnNGX_DECLINED;
 }

key.data=ngx_palloc(r->pool, key_len+1);
if (key.data==NULL) {
 goto nomem;
 }

ngx_memcpy(key.data, key_data, key_len);
key.data[key_len] ='\0';
key.len=key_len;

llcf=ngx_http_get_module_loc_conf(r, ngx_http_lua_module);

if (llcf->transform_underscores_in_resp_headers) {
/* replace "_" with "-" */
p=key.data;
for (i=0; i<key_len; i++) {
if (p[i] =='_') {
p[i] ='-';
 }
 }
 }

ctx->headers_set=1;

if (is_nil) {
value.data=NULL;
value.len=0;

 } elseif (mvals) {

if (mvals_len==0) {
value.data=NULL;
value.len=0;