static ngx_int_t ngx_http_mycookie_handler(ngx_http_request_t *r)
{
ngx_int_t rc;
ngx_buf_t *b;
ngx_chain_t out;
ngx_http_mycookie_loc_conf_t *my_cf;
u_char ngx_my_string[1024] = {0};
ngx_uint_t content_length = 0;
ngx_log_error(NGX_LOG_EMERG, r->connection->log, 0, "ngx_http_mycookie_handler is called!");
my_cf = ngx_http_get_module_loc_conf(r,ngx_http_mycookie_module);
if (my_cf->cookieflag == NGX_CONF_UNSET )
{
ngx_log_error(NGX_LOG_EMERG, r->connection->log, 0, "cookieflag is UNSET!");
return NGX_DECLINED;
}
//从请求头读取cookies，使用的时候可以使用cookies[0]->value.data,cookies[0]->value.len
ngx_table_elt_t ** cookies = NULL;
cookies = r->headers_in.cookies.elts;
ngx_table_elt_t * client_ip = NULL;
client_ip = r->headers_in.user_agent;
/*
* supported formats:
* %[0][width][x][X]O off_t
* %[0][width]T time_t
* %[0][width][u][x|X]z ssize_t/size_t
* %[0][width][u][x|X]d int/u_int
* %[0][width][u][x|X]l long
* %[0][width|m][u][x|X]i ngx_int_t/ngx_uint_t
* %[0][width][u][x|X]D int32_t/uint32_t
* %[0][width][u][x|X]L int64_t/uint64_t
* %[0][width|m][u][x|X]A ngx_atomic_int_t/ngx_atomic_uint_t
* %[0][width][.width]f double, max valid number fits to %18.15f
* %P ngx_pid_t
* %M ngx_msec_t
* %r rlim_t
* %p void *
* %V ngx_str_t *
* %v ngx_variable_value_t *
* %s null-terminated string
* %*s length and string
* %Z '\0'
* %N '\n'
* %c char
* %% %
*
* reserved:
* %t ptrdiff_t
* %S null-terminated wchar string
* %C wchar
*/
//u_char ipchar[client_ip->value.len+1]={0};
//u_char cookiechar[cookies[0]->value.len+1]={0};
//ngx_sprintf(ipchar, "%V\0",&client_ip->value);
//ngx_sprintf(cookiechar, "%V\0",&cookies[0]->value);
if ( cookies != NULL) //未定义cookie？
{
ngx_sprintf(ngx_my_string, "user_agent is %V, you have cookie",
&client_ip->value);
}
else
{
ngx_sprintf(ngx_my_string, "user_agent is %V, you do not have cookie or cookie not match",
&client_ip->value);
//没有cookie，则给他cookie
ngx_table_elt_t *set_cookie = ngx_list_push(&r->headers_out.headers);
if (set_cookie == NULL) {
return NGX_ERROR;
}
set_cookie->hash = 1;
set_cookie->key.len = sizeof("Set-Cookie") - 1;
set_cookie->key.data = (u_char *) "Set-Cookie";
set_cookie->value = client_ip->value;
}
content_length = ngx_strlen(ngx_my_string);
/* we response to 'GET' and 'HEAD' requests only */
if (!(r->method & (NGX_HTTP_GET|NGX_HTTP_HEAD))) {
return NGX_HTTP_NOT_ALLOWED;
}
/* discard request body, since we don't need it here */
rc = ngx_http_discard_request_body(r);
if (rc != NGX_OK) {
return rc;
}
/* set the 'Content-type' header */
/*
*r->headers_out.content_type.len = sizeof("text/html") - 1;
*r->headers_out.content_type.data = (u_char *)"text/html";
*/
ngx_str_set(&r->headers_out.content_type, "text/html");
r->headers_out.status = NGX_HTTP_OK;
r->headers_out.content_length_n = content_length;
/* send the header only, if the request type is http 'HEAD' */
if (r->method == NGX_HTTP_HEAD) {
return ngx_http_send_header(r);
}
/* allocate a buffer for your response body */
b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
if (b == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
/*另一种方式
对于创建temporary字段为1的buf（就是其内容可以被后续的filter模块进行修改），可以直接使用函数ngx_create_temp_buf进行创建。
ngx_buf_t *ngx_create_temp_buf(ngx_pool_t *pool, size_t size);
该函数创建一个ngx_but_t类型的对象，并返回指向这个对象的指针，创建失败返回NULL。
对于创建的这个对象，它的start和end指向新分配内存开始和结束的地方。pos和last都指向这块新分配内存的开始处，这样，后续的操作可以在这块新分配的内存上存入数据。*/
/* adjust the pointers of the buffer */
b->pos = ngx_my_string;
b->last = ngx_my_string + content_length;
b->memory = 1; /* this buffer is in memory */
b->last_buf = 1; /* this is the last buffer in the buffer chain */
/* attach this buffer to the buffer chain */
out.buf = b;
out.next = NULL;
/* send the headers of your response */
rc = ngx_http_send_header(r);
if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
return rc;
}
/* send the buffer chain of your response */
return ngx_http_output_filter(r, &out);
}
static ngx_int_t
ngx_http_set_header_helper(ngx_http_request_t *r,
ngx_http_headers_more_header_val_t *hv, ngx_str_t *value,
ngx_table_elt_t **output_header)
{
ngx_table_elt_t *h;
ngx_list_part_t *part;
ngx_uint_t i;
ngx_uint_t rc;
dd_enter();
retry:
part = &r->headers_in.headers.part;
h = part->elts;
for (i = 0; /* void */; i++) {
dd("i: %d, part: %p", (int) i, part);
if (i >= part->nelts) {
if (part->next == NULL) {
break;
}
part = part->next;
h = part->elts;
i = 0;
}
if (h[i].key.len == hv->key.len
&& ngx_strncasecmp(h[i].key.data, hv->key.data,
h[i].key.len) == 0)
{
if (value->len == 0) {
h[i].hash = 0;
rc = ngx_http_headers_more_rm_header_helper(
&r->headers_in.headers, part, i);
if (rc == NGX_OK) {
if (output_header) {
*output_header = NULL;
}
goto retry;
}
}
h[i].value = *value;
if (output_header) {
*output_header = &h[i];
dd("setting existing builtin input header");
}
return NGX_OK;
}
}
if (value->len == 0 || hv->replace) {
return NGX_OK;
}
h = ngx_list_push(&r->headers_in.headers);
if (h == NULL) {
return NGX_ERROR;
}
dd("created new header for %.*s", (int) hv->key.len, hv->key.data);
if (value->len == 0) {
h->hash = 0;
} else {
h->hash = hv->hash;
}
h->key = hv->key;
h->value = *value;
h->lowcase_key = ngx_pnalloc(r->pool, h->key.len);
if (h->lowcase_key == NULL) {
return NGX_ERROR;
}
ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
if (output_header) {
*output_header = h;
while (r != r->main) {
r->parent->headers_in = r->headers_in;
r = r->parent;
}
}
return NGX_OK;
}
static ngx_int_t
ngx_http_set_header_helper(ngx_http_request_t *r, ngx_http_lua_header_val_t *hv,
ngx_str_t *value, ngx_table_elt_t **output_header)
{
ngx_table_elt_t *h, *matched;
ngx_list_part_t *part;
ngx_uint_t i;
ngx_uint_t rc;
if (hv->no_override) {
goto new_header;
}
matched = NULL;
retry:
part = &r->headers_in.headers.part;
h = part->elts;
for (i = 0; /* void */; i++) {
if (i >= part->nelts) {
if (part->next == NULL) {
break;
}
part = part->next;
h = part->elts;
i = 0;
}
dd("i: %d, part: %p", (int) i, part);
if (h[i].key.len == hv->key.len
&& ngx_strncasecmp(h[i].key.data, hv->key.data, h[i].key.len)
== 0)
{
if (value->len == 0 || (matched && matched != &h[i])) {
h[i].hash = 0;
dd("rm header %.*s: %.*s", (int) h[i].key.len, h[i].key.data,
(int) h[i].value.len, h[i].value.data);
rc = ngx_http_lua_rm_header_helper(&r->headers_in.headers,
part, i);
ngx_http_lua_assert(!(r->headers_in.headers.part.next == NULL
&& r->headers_in.headers.last
!= &r->headers_in.headers.part));
dd("rm header: rc=%d", (int) rc);
if (rc == NGX_OK) {
if (output_header) {
*output_header = NULL;
}
goto retry;
}
return NGX_ERROR;
}
h[i].value = *value;
if (output_header) {
*output_header = &h[i];
dd("setting existing builtin input header");
}
if (matched == NULL) {
matched = &h[i];
}
}
}
if (matched){
return NGX_OK;
}
if (value->len == 0) {
return NGX_OK;
}
new_header:
h = ngx_list_push(&r->headers_in.headers);
if (h == NULL) {
return NGX_ERROR;
}
dd("created new header for %.*s", (int) hv->key.len, hv->key.data);
if (value->len == 0) {
h->hash = 0;
} else {
h->hash = hv->hash;
}
h->key = hv->key;
h->value = *value;
h->lowcase_key = ngx_pnalloc(r->pool, h->key.len);
if (h->lowcase_key == NULL) {
return NGX_ERROR;
}
ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
if (output_header) {
*output_header = h;
}
return NGX_OK;
}
static ngx_int_t
ngx_http_gzip_static_handler(ngx_http_request_t *r)
{
u_char *p;
size_t root;
ngx_str_t path;
ngx_int_t rc;
ngx_uint_t level;
ngx_log_t *log;
ngx_buf_t *b;
ngx_chain_t out;
ngx_table_elt_t *h;
ngx_open_file_info_t of;
ngx_http_core_loc_conf_t *clcf;
ngx_http_gzip_static_conf_t *gzcf;
if (!(r->method & (NGX_HTTP_GET|NGX_HTTP_HEAD))) {
return NGX_DECLINED;
}
if (r->uri.data[r->uri.len - 1] == '/') {
return NGX_DECLINED;
}
gzcf = ngx_http_get_module_loc_conf(r, ngx_http_gzip_static_module);
if (gzcf->enable == NGX_HTTP_GZIP_STATIC_OFF) {
return NGX_DECLINED;
}
if (gzcf->enable == NGX_HTTP_GZIP_STATIC_ON) {
rc = ngx_http_gzip_ok(r);
} else {
/* always */
rc = NGX_OK;
}
clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
if (!clcf->gzip_vary && rc != NGX_OK) {
return NGX_DECLINED;
}
log = r->connection->log;
p = ngx_http_map_uri_to_path(r, &path, &root, sizeof(".gz") - 1);
if (p == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
*p++ = '.';
*p++ = 'g';
*p++ = 'z';
*p = '\0';
path.len = p - path.data;
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, log, 0,
"http filename: \"%s\"", path.data);
ngx_memzero(&of, sizeof(ngx_open_file_info_t));
of.read_ahead = clcf->read_ahead;
of.directio = clcf->directio;
of.valid = clcf->open_file_cache_valid;
of.min_uses = clcf->open_file_cache_min_uses;
of.errors = clcf->open_file_cache_errors;
of.events = clcf->open_file_cache_events;
if (ngx_http_set_disable_symlinks(r, clcf, &path, &of) != NGX_OK) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
if (ngx_open_cached_file(clcf->open_file_cache, &path, &of, r->pool)
!= NGX_OK)
{
switch (of.err) {
case 0:
return NGX_HTTP_INTERNAL_SERVER_ERROR;
case NGX_ENOENT:
case NGX_ENOTDIR:
case NGX_ENAMETOOLONG:
return NGX_DECLINED;
case NGX_EACCES:
#if (NGX_HAVE_OPENAT)
case NGX_EMLINK:
case NGX_ELOOP:
#endif
level = NGX_LOG_ERR;
break;
default:
level = NGX_LOG_CRIT;
break;
}
ngx_log_error(level, log, of.err,
"%s \"%s\" failed", of.failed, path.data);
return NGX_DECLINED;
}
if (gzcf->enable == NGX_HTTP_GZIP_STATIC_ON) {
r->gzip_vary = 1;
if (rc != NGX_OK) {
return NGX_DECLINED;
}
}
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, log, 0, "http static fd: %d", of.fd);
if (of.is_dir) {
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, log, 0, "http dir");
return NGX_DECLINED;
}
#if !(NGX_WIN32) /* the not regular files are probably Unix specific */
if (!of.is_file) {
ngx_log_error(NGX_LOG_CRIT, log, 0,
"\"%s\" is not a regular file", path.data);
return NGX_HTTP_NOT_FOUND;
}
#endif
r->root_tested = !r->error_page;
rc = ngx_http_discard_request_body(r);
if (rc != NGX_OK) {
return rc;
}
log->action = "sending response to client";
r->headers_out.status = NGX_HTTP_OK;
r->headers_out.content_length_n = of.size;
r->headers_out.last_modified_time = of.mtime;
if (ngx_http_set_etag(r) != NGX_OK) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
if (ngx_http_set_content_type(r) != NGX_OK) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
h = ngx_list_push(&r->headers_out.headers);
if (h == NULL) {
return NGX_ERROR;
}
h->hash = 1;
ngx_str_set(&h->key, "Content-Encoding");
ngx_str_set(&h->value, "gzip");
r->headers_out.content_encoding = h;
r->ignore_content_encoding = 1;
/* we need to allocate all before the header would be sent */
b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
if (b == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
b->file = ngx_pcalloc(r->pool, sizeof(ngx_file_t));
if (b->file == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
rc = ngx_http_send_header(r);
if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
return rc;
}
b->file_pos = 0;
b->file_last = of.size;
b->in_file = b->file_last ? 1 : 0;
b->last_buf = (r == r->main) ? 1 : 0;
b->last_in_chain = 1;
b->file->fd = of.fd;
b->file->name = path;
b->file->log = log;
b->file->directio = of.is_directio;
out.buf = b;
out.next = NULL;
return ngx_http_output_filter(r, &out);
}
ngx_open_file_t *
ngx_conf_open_file(ngx_cycle_t *cycle, ngx_str_t *name)
{
ngx_str_t full;
ngx_uint_t i;
ngx_list_part_t *part;
ngx_open_file_t *file;
#if (NGX_SUPPRESS_WARN)
ngx_str_null(&full);
#endif
if (name->len) {
full = *name;
if (ngx_conf_full_name(cycle, &full, 0) != NGX_OK) {
return NULL;
}
part = &cycle->open_files.part;
file = part->elts;
for (i = 0; /* void */ ; i++) {
if (i >= part->nelts) {
if (part->next == NULL) {
break;
}
part = part->next;
file = part->elts;
i = 0;
}
if (full.len != file[i].name.len) {
continue;
}
if (ngx_strcmp(full.data, file[i].name.data) == 0) {
return &file[i];
}
}
}
file = ngx_list_push(&cycle->open_files);
if (file == NULL) {
return NULL;
}
if (name->len) {
file->fd = NGX_INVALID_FILE;
file->name = full;
} else {
file->fd = ngx_stderr;
file->name = *name;
}
file->buffer = NULL;
return file;
}
static ngx_int_t
ngx_http_memcached_hash_process_header(ngx_http_request_t *r)
{
u_char *p, *start;
ngx_str_t line;
ngx_uint_t flags;
ngx_table_elt_t *h;
ngx_http_upstream_t *u;
ngx_http_memcached_hash_ctx_t *ctx;
ngx_http_memcached_hash_loc_conf_t *mlcf;
u = r->upstream;
for (p = u->buffer.pos; p < u->buffer.last; p++) {
if (*p == LF) {
goto found;
}
}
return NGX_AGAIN;
found:
*p = '\0';
line.len = p - u->buffer.pos - 1;
line.data = u->buffer.pos;
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"memcached hash: \"%V\"", &line);
p = u->buffer.pos;
ctx = ngx_http_get_module_ctx(r, ngx_http_memcached_hash_module);
mlcf = ngx_http_get_module_loc_conf(r, ngx_http_memcached_hash_module);
if (ngx_strncmp(p, "VALUE ", sizeof("VALUE ") - 1) == 0) {
p += sizeof("VALUE ") - 1;
if (ngx_strncmp(p, ctx->key.data, ctx->key.len) != 0) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"memcached sent invalid key in response \"%V\" "
"for key \"%V\"",
&line, &ctx->key);
return NGX_HTTP_UPSTREAM_INVALID_HEADER;
}
p += ctx->key.len;
if (*p++ != ' ') {
goto no_valid;
}
/* flags */
start = p;
while (*p) {
if (*p++ == ' ') {
if (mlcf->gzip_flag) {
goto flags;
} else {
goto length;
}
}
}
goto no_valid;
flags:
flags = ngx_atoi(start, p - start - 1);
if (flags == (ngx_uint_t) NGX_ERROR) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"memcached sent invalid flags in response \"%V\" "
"for key \"%V\"",
&line, &ctx->key);
return NGX_HTTP_UPSTREAM_INVALID_HEADER;
}
if (flags & mlcf->gzip_flag) {
h = ngx_list_push(&r->headers_out.headers);
if (h == NULL) {
return NGX_ERROR;
}
h->hash = 1;
h->key.len = sizeof("Content-Encoding") - 1;
h->key.data = (u_char *) "Content-Encoding";
h->value.len = sizeof("gzip") - 1;
h->value.data = (u_char *) "gzip";
r->headers_out.content_encoding = h;
}
length:
start = p;
while (*p && *p++ != CR) { /* void */ }
r->headers_out.content_length_n = ngx_atoof(start, p - start - 1);
if (r->headers_out.content_length_n == -1) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"memcached sent invalid length in response \"%V\" "
"for key \"%V\"",
&line, &ctx->key);
return NGX_HTTP_UPSTREAM_INVALID_HEADER;
}
u->headers_in.status_n = 200;
u->state->status = 200;
u->buffer.pos = p + 1;
return NGX_OK;
}
if (ngx_strcmp(p, "END\x0d") == 0) {
ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
"key: \"%V\" was not found by memcached", &ctx->key);
u->headers_in.status_n = 404;
u->state->status = 404;
return NGX_OK;
}
no_valid:
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"memcached sent invalid response: \"%V\"", &line);
return NGX_HTTP_UPSTREAM_INVALID_HEADER;
}
static ngx_int_t
ngx_http_auth_radius_handler( ngx_http_request_t *r )
{
ngx_http_auth_radius_ctx_t* ctx;
ctx = ngx_http_get_module_ctx( r, ngx_http_auth_radius_module );
ngx_http_auth_radius_main_conf_t* conf = ngx_http_get_module_loc_conf( r, ngx_http_auth_radius_module );
if ( conf->realm.data == NULL || conf->realm.len == 0 )
return NGX_OK;
ngx_int_t rc = ngx_http_auth_basic_user( r );
if ( rc == NGX_ERROR )
return NGX_HTTP_INTERNAL_SERVER_ERROR;
if ( rc == NGX_DECLINED || ( ctx && ctx->done && ctx->accepted == 0 ) ) {
r->headers_out.www_authenticate = ngx_list_push( &r->headers_out.headers );
if ( r->headers_out.www_authenticate == NULL ) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
r->headers_out.www_authenticate->hash = 1;
r->headers_out.www_authenticate->key.len = sizeof( "WWW-Authenticate" ) - 1;
r->headers_out.www_authenticate->key.data = (u_char *) "WWW-Authenticate";
ngx_int_t realm_len = sizeof( "Basic realm=\"\"" ) + conf->realm.len;
ngx_buf_t* b = ngx_create_temp_buf( r->pool, realm_len );
ngx_snprintf( b->pos, realm_len, "Basic realm=\"%V\"", &conf->realm );
r->headers_out.www_authenticate->value.data = b->pos;
r->headers_out.www_authenticate->value.len = realm_len - 1;
return NGX_HTTP_UNAUTHORIZED;
}
if ( ctx == NULL ) {
ctx = ngx_pcalloc( r->pool, sizeof( *ctx ) );
if ( ctx == NULL ) {
// TODO log
return NGX_ERROR;
}
ctx->attempts = conf->radius_attempts;
ctx->done = 0;
ctx->accepted = 0;
ngx_http_set_ctx( r, ctx, ngx_http_auth_radius_module );
r->read_event_handler = http_req_read_handler;
ngx_str_t args;
ngx_str_t key;
calc_req_digest( r, &conf->secret, ctx->digest );
key.data = ctx->digest;
key.len = sizeof( ctx->digest );
args.len = sizeof( "o=get&k=" ) - 1 + key.len; // TODO
args.data = ngx_palloc( r->pool, args.len );
u_char* e = ngx_snprintf( args.data, args.len, "o=get&k=%V", &key );
args.len = e - args.data;
rc = ngx_http_auth_radius_init_subrequest( r, &conf->radius_cache, &args, ngx_http_auth_radius_subrequest_mcget_done );
return NGX_AGAIN;
}
if ( ctx->done == 0 ) {
return NGX_AGAIN;
}
ngx_log_error( NGX_LOG_ERR, r->connection->log, 0, "GRANTED 0x%xl", r );
return NGX_OK;
}
static ngx_int_t
ngx_http_trailers_filter(ngx_http_request_t *r, ngx_chain_t *in)
{
ngx_str_t value;
ngx_uint_t i, safe_status;
ngx_chain_t *cl;
ngx_table_elt_t *t;
ngx_http_header_val_t *h;
ngx_http_headers_conf_t *conf;
conf = ngx_http_get_module_loc_conf(r, ngx_http_headers_filter_module);
if (in == NULL
|| conf->trailers == NULL
|| !r->expect_trailers
|| r->header_only)
{
return ngx_http_next_body_filter(r, in);
}
for (cl = in; cl; cl = cl->next) {
if (cl->buf->last_buf) {
break;
}
}
if (cl == NULL) {
return ngx_http_next_body_filter(r, in);
}
switch (r->headers_out.status) {
case NGX_HTTP_OK:
case NGX_HTTP_CREATED:
case NGX_HTTP_NO_CONTENT:
case NGX_HTTP_PARTIAL_CONTENT:
case NGX_HTTP_MOVED_PERMANENTLY:
case NGX_HTTP_MOVED_TEMPORARILY:
case NGX_HTTP_SEE_OTHER:
case NGX_HTTP_NOT_MODIFIED:
case NGX_HTTP_TEMPORARY_REDIRECT:
case NGX_HTTP_PERMANENT_REDIRECT:
safe_status = 1;
break;
default:
safe_status = 0;
break;
}
h = conf->trailers->elts;
for (i = 0; i < conf->trailers->nelts; i++) {
if (!safe_status && !h[i].always) {
continue;
}
if (ngx_http_complex_value(r, &h[i].value, &value) != NGX_OK) {
return NGX_ERROR;
}
if (value.len) {
t = ngx_list_push(&r->headers_out.trailers);
if (t == NULL) {
return NGX_ERROR;
}
t->key = h[i].key;
t->value = value;
t->hash = 1;
}
}
return ngx_http_next_body_filter(r, in);
}
static ngx_int_t mytest_upstream_process_header(ngx_http_request_t *r) {
ngx_int_t rc;
ngx_table_elt_t *h;
ngx_http_upstream_header_t *hh;
ngx_http_upstream_main_conf_t *umcf;
umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);
for (;;) {
rc = ngx_http_parse_header_line(r, &r->upstream->buffer, 1); //解析HTTP头部
if (rc == NGX_OK) {
h = ngx_list_push(&r->upstream->headers_in.headers);
if (h == NULL)
return NGX_ERROR;
h->hash = r->header_hash;
h->key.len = r->header_name_end - r->header_name_start;
h->value.len = r->header_end - r->header_start;
h->key.data = ngx_pnalloc(r->pool,
h->key.len + 1 + h->value.len + 1 + h->key.len);
if (h->key.data == NULL)
return NGX_ERROR;
h->value.data = h->key.data + h->key.len + 1;
h->lowcase_key = h->key.data + h->key.len + 1 + h->value.len + 1;
ngx_memcpy(h->key.data, r->header_name_start, h->key.len);
h->key.data[h->key.len] = '\0';
ngx_memcpy(h->value.data, r->header_start, h->value.len);
h->value.data[h->value.len] = '\0';
if (h->key.len == r->lowcase_index) {
ngx_memcpy(h->lowcase_key, r->lowcase_header, h->key.len);
} else {
ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
}
hh = ngx_hash_find(&umcf->headers_in_hash, h->hash, h->lowcase_key,
h->key.len);
if (hh && hh->handler(r, h, hh->offset) != NGX_OK)
return NGX_ERROR;
continue;
}
}
if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
if (r->upstream->headers_in.server == NULL) {
h = ngx_list_push(&r->upstream->headers_in.headers);
if (h == NULL)
return NGX_ERROR;
h->hash = ngx_hash(
ngx_hash(ngx_hash(ngx_hash(ngx_hash('s', 'e'), 'r'), 'v'),
'e'), 'r');
ngx_str_set(&h->key, "Server");
ngx_str_null(&h->value);
h->lowcase_key = (u_char*) "server";
}
if (r->upstream->headers_in.date == NULL) {
h = ngx_list_push(&r->upstream->headers_in.headers);
if (h == NULL)
return NGX_ERROR;
h->hash = ngx_hash(ngx_hash(ngx_hash('d', 'a'), 't'), 'e');
ngx_str_set(&h->key, "Data");
ngx_str_null(&h->value);
h->lowcase_key = (u_char*) "data";
}
return NGX_OK;
}
if (rc == NGX_AGAIN)
return NGX_AGAIN;
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"[jseanj] upstream sent invalid header");
return NGX_HTTP_UPSTREAM_INVALID_HEADER;
}
//-----------------------------------------------------------------------------
static void
ngx_c2h5oh_post_response(ngx_http_request_t * r, ngx_c2h5oh_ctx_t * ctx)
{
ngx_buf_t *b;
ngx_chain_t out;
ngx_int_t rc;
if (r->method & NGX_HTTP_POST) {
r->main->count--;
}
const char * result_src = c2h5oh_result(ctx->conn);
int result_len = c2h5oh_result_len(ctx->conn);
if (result_len <= 0 || result_src == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"[c2h5oh] empty response: %d", result_len);
c2h5oh_free(ctx->conn); ctx->conn = NULL;
return ngx_http_finalize_request(r, NGX_HTTP_NO_CONTENT);
}
if (c2h5oh_is_error(ctx->conn)) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"[c2h5oh] query error %s", result_src);
c2h5oh_free(ctx->conn); ctx->conn = NULL;
if (result_len > 6 && ngx_memcmp(result_src, "42883_", sizeof("42883_") - 1) == 0) {
return ngx_http_finalize_request(r, NGX_HTTP_NOT_FOUND);
} else {
return ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
}
}
b = ngx_create_temp_buf(r->pool, result_len + ctx->callback.len + sizeof("();"));
if (b == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"[c2h5oh] allocation error");
return ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
}
b->pos = b->start + ctx->callback.len + 1;
memcpy(b->pos, result_src, result_len);
b->last = b->pos + result_len;
jsmn_init(&ngx_c2h5oh_jsmn_parser);
int i, j;
int js = JSMN_ERROR_NOMEM;
u_char * content = NULL;
int content_length = 0;
while(js == JSMN_ERROR_NOMEM) {
js = jsmn_parse(&ngx_c2h5oh_jsmn_parser, (char *)b->pos, result_len,
ngx_c2h5oh_js_tokens, ngx_c2h5oh_js_tokens_count);
if (js < -1) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"[c2h5oh] json parse error: invalid json string");
return ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
} else if (js == JSMN_ERROR_NOMEM) {
ngx_c2h5oh_js_tokens_count *= 3; ngx_c2h5oh_js_tokens_count /= 2;
void * p = realloc(ngx_c2h5oh_js_tokens,
sizeof(jsmntok_t) * ngx_c2h5oh_js_tokens_count);
if (p == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"[c2h5oh] error allocating ngx_c2h5oh_js_tokens");
return ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
} else {
ngx_c2h5oh_js_tokens = p;
}
} else if (js == 0) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"[c2h5oh] json parse error: empty json");
return ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
}
}
jsmntok_t * t = ngx_c2h5oh_js_tokens;
if (t->type != JSMN_OBJECT) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"[c2h5oh] json parse error: root has to be an object");
return ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
}
int size = t->size;
for(i = 0; i < size; i++) {
t++;
if (ngx_memcmp(b->pos + t->start, "headers", sizeof("headers") - 1) == 0) {
t++;
if (t->type == JSMN_ARRAY || t->type == JSMN_STRING) {
if (t->type == JSMN_STRING) {
t--;
}
int headers_size = t->size;
for(j = 0; j < headers_size; j++) {
t++;
if (t->type != JSMN_STRING) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"[c2h5oh] json parse error: header has to be a string");
return ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
}
if (ngx_memcmp(b->pos + t->start, "Content-Type: ", sizeof("Content-Type:")) == 0) {
r->headers_out.content_type.len = t->end - t->start - sizeof("Content-Type:");
r->headers_out.content_type.data = b->pos + t->start + sizeof("Content-Type:");
} else {
ngx_table_elt_t * set_header = ngx_list_push(&r->headers_out.headers);
if (set_header == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"[c2h5oh] error allocating header");
return ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
}
set_header->hash = 1;
set_header->key.data = b->pos + t->start;
set_header->value.len = t->end - t->start - 2;
set_header->value.data = b->pos + t->start + 1;
set_header->key.len = 0;
for(set_header->key.len = 0; set_header->value.len > 0; set_header->value.len--, set_header->key.len++) {
set_header->value.data++;
if (*(set_header->key.data + set_header->key.len) == ':') {
break;
}
}
}
}
} else {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"[c2h5oh] json error: headers has to be array or string");
return ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
}
} else if (ngx_memcmp(b->pos + t->start, "content", sizeof("content") - 1) == 0) {
t++;
content = b->pos + t->start;
content_length = t->end - t->start;
// skip tokens
int content_size = t->size;
while(content_size > 0) {
t++;
content_size += t->size - 1;
}
} else if (ngx_memcmp(b->pos + t->start, "status", sizeof("status") - 1) == 0) {
t++;
r->headers_out.status = ngx_atoi(b->pos + t->start, t->end - t->start);
if (r->headers_out.status <= 0) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"[c2h5oh] wrong status: [%.*s]", t->end - t->start, b->pos + t->start);
return ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
}
} else {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"[c2h5oh] unexpected token in json: [%*.s]", t->end - t->start, b->pos + t->start);
return ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
}
}
if (content_length == 0) {
if (r->headers_out.status == 404) {
return ngx_http_finalize_request(r, NGX_HTTP_NOT_FOUND);
} else if (r->headers_out.status == 403) {
return ngx_http_finalize_request(r, NGX_HTTP_FORBIDDEN);
} else {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"[c2h5oh] empty content");
return ngx_http_finalize_request(r, NGX_HTTP_NO_CONTENT);
}
}
b->last_buf = 1;
b->pos = content;
b->last = content + content_length;
if (ctx->callback.len) {
b->pos -= ctx->callback.len + 1;
ngx_memcpy(b->pos, ctx->callback.data, ctx->callback.len);
*(b->pos + ctx->callback.len) = '(';
*b->last++ = ')';
*b->last++ = ';';
}
out.buf = b;
out.next = NULL;
c2h5oh_free(ctx->conn); ctx->conn = NULL;
if (r->headers_out.content_type.len == 0) {
r->headers_out.content_type.len = sizeof(ngx_c2h5oh_content_type) - 1;
r->headers_out.content_type.data = (u_char *)ngx_c2h5oh_content_type;
}
if (ctx->callback.len) {
content_length += ctx->callback.len + sizeof("();") - 1;
}
r->headers_out.content_length_n = content_length;
r->headers_out.last_modified_time = -1;
if (r->headers_out.status == 0) {
r->headers_out.status = 200;
}
rc = ngx_http_send_header(r);
if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
return ngx_http_finalize_request(r, rc);
}
rc = ngx_http_output_filter(r, &out);
ngx_http_finalize_request(r, NGX_HTTP_OK);
}
ngx_int_t
ngx_http_psgi_process_headers(pTHX_ ngx_http_request_t *r, SV *headers, SV *status)
{
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"Process PSGI headers");
if (r->headers_out.status == 0) {
r->headers_out.status = SvIV(status);
}
if (!SvROK(headers) || SvTYPE(SvRV(headers)) != SVt_PVAV) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"PSGI app returned wrong headers: %s", SvPV_nolen(headers));
return NGX_ERROR;
}
AV *h = (AV *)SvRV(headers);
int len = av_len(h);
int i;
if (!(len % 2)) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"Even number of header-value elements: %i. Possible error.", len);
}
for (i = 0; i <= len; i+=2) {
if (i + 1 > len)
break;
SV **header = av_fetch(h, i, 0);
u_char *key, *value;
STRLEN klen, vlen;
key = (u_char *) SvPV(header[0], klen);
value = (u_char *) SvPV(header[1], vlen);
if (ngx_strncasecmp(key, (u_char *)"CONTENT-TYPE", klen) == 0) {
r->headers_out.content_type.data = ngx_pnalloc(r->pool, vlen);
if (r->headers_out.content_type.data == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"In PSGI response: header 'Content-Type' not defined");
return NGX_ERROR;
}
r->headers_out.content_type.len = vlen;
ngx_memcpy(r->headers_out.content_type.data, value, vlen);
} else {
ngx_table_elt_t *header_ent;
header_ent = ngx_list_push(&r->headers_out.headers);
header_ent->hash = 1;
if (header_ent == NULL) {
return NGX_ERROR;
}
if (ngx_sv2str(r, &header_ent->key, key, klen) != NGX_OK) {
return NGX_ERROR;
}
if (ngx_sv2str(r, &header_ent->value, value, vlen) != NGX_OK) {
return NGX_ERROR;
}
}
}
ngx_http_send_header(r);
return NGX_OK;
}
//PCRE使用参考http://blog.chinaunix.net/uid-26575352-id-3517146.html http://blog.csdn.net/kofiory/article/details/5829697
ngx_int_t
ngx_regex_compile(ngx_regex_compile_t *rc)
{
int n, erroff;
char *p;
pcre *re;
const char *errstr;
ngx_regex_elt_t *elt;
ngx_regex_malloc_init(rc->pool);
//正则表达式在使用之前要经过编译。编译的目的是将正则表达式的pattern转换成PCRE引擎能够识别的结构（struct real_pcre）。
re = pcre_compile((const char *) rc->pattern.data, (int) rc->options,
&errstr, &erroff, NULL);
/* ensure that there is no current pool */
ngx_regex_malloc_done();
if (re == NULL) {
if ((size_t) erroff == rc->pattern.len) {
rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
"pcre_compile() failed: %s in \"%V\"",
errstr, &rc->pattern)
- rc->err.data;
} else {
rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
"pcre_compile() failed: %s in \"%V\" at \"%s\"",
errstr, &rc->pattern, rc->pattern.data + erroff)
- rc->err.data;
}
return NGX_ERROR;
}
rc->regex = ngx_pcalloc(rc->pool, sizeof(ngx_regex_t));
if (rc->regex == NULL) {
goto nomem;
}
rc->regex->code = re;
/* do not study at runtime */
if (ngx_pcre_studies != NULL) {
elt = ngx_list_push(ngx_pcre_studies);
if (elt == NULL) {
goto nomem;
}
elt->regex = rc->regex;
elt->name = rc->pattern.data;
}
//PCRE_INFO_CAPTURECOUNT: 得到的是所有子模式的个数,包含命名子模式和非命名子模式
n = pcre_fullinfo(re, NULL, PCRE_INFO_CAPTURECOUNT, &rc->captures);
if (n < 0) {
p = "pcre_fullinfo(\"%V\", PCRE_INFO_CAPTURECOUNT) failed: %d";
goto failed;
}
if (rc->captures == 0) {
return NGX_OK;
}
/* See if there are any named substrings, and if so, show them by name. First
we have to extract the count of named parentheses from the pattern. */
n = pcre_fullinfo(re, NULL, PCRE_INFO_NAMECOUNT, &rc->named_captures);
if (n < 0) {
p = "pcre_fullinfo(\"%V\", PCRE_INFO_NAMECOUNT) failed: %d";
goto failed;
}
if (rc->named_captures == 0) {
return NGX_OK;
}
/* Before we can access the substrings, we must extract the table for
translating names to numbers, and the size of each entry in the table. */
n = pcre_fullinfo(re, NULL, PCRE_INFO_NAMEENTRYSIZE, &rc->name_size); /* where to put the answer */
if (n < 0) {
p = "pcre_fullinfo(\"%V\", PCRE_INFO_NAMEENTRYSIZE) failed: %d";
goto failed;
}
n = pcre_fullinfo(re, NULL, PCRE_INFO_NAMETABLE, &rc->names); /* where to put the answer */
if (n < 0) {
p = "pcre_fullinfo(\"%V\", PCRE_INFO_NAMETABLE) failed: %d";
goto failed;
}
return NGX_OK;
failed:
rc->err.len = ngx_snprintf(rc->err.data, rc->err.len, p, &rc->pattern, n)
- rc->err.data;
return NGX_ERROR;
nomem:
rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
"regex \"%V\" compilation failed: no memory",
&rc->pattern)
- rc->err.data;
return NGX_ERROR;
}
static ngx_int_t
ngx_http_google_request_parser(ngx_http_request_t * r,
ngx_http_google_ctx_t * ctx)
{
// parse arg
u_char * last = r->unparsed_uri.data + r->unparsed_uri.len;
ctx->arg->data = ngx_strlchr(ctx->uri->data, last, '?');
// parse uri
if (ctx->arg->data) {
ctx->arg->len = last - ++ctx->arg->data;
ctx->uri->len -= ctx->arg->len + 1;
}
// parse args
if (ctx->arg->len) {
ctx->args = ngx_http_google_explode_kv(r, ctx->arg, "&");
} else {
ctx->args = ngx_array_create(r->pool, 4, sizeof(ngx_keyval_t));
}
if (!ctx->args) return NGX_ERROR;
// parse cookies
if (r->headers_in.cookies.nelts) {
ngx_table_elt_t ** ck = r->headers_in.cookies.elts;
ctx->cookies = ngx_http_google_explode_kv(r, &(*ck)->value, ";");
} else {
ctx->cookies = ngx_array_create(r->pool, 4, sizeof(ngx_keyval_t));
}
if (!ctx->cookies) return NGX_ERROR;
// parse host
if (ngx_http_google_request_parse_host(r, ctx)) return NGX_ERROR;
// traverse headers
ngx_uint_t i, acl = 0;
ngx_list_part_t * pt = &r->headers_in.headers.part;
ngx_table_elt_t * hd = pt->elts, * tb;
for (i = 0; /* void */; i++)
{
if (i >= pt->nelts) {
if (pt->next == NULL) break;
pt = pt->next;
hd = pt->elts;
i = 0;
}
tb = hd + i;
if (!ngx_strncasecmp(tb->key.data, (u_char *)"Accept-Language", 15)) {
acl = 1; tb->value = *ctx->lang;
}
}
if (!acl) {
tb = ngx_list_push(&r->headers_in.headers);
if (!tb) return NGX_ERROR;
ngx_str_set(&tb->key, "Accept-Language");
tb->value = *ctx->lang;
tb->hash = ngx_hash_key_lc(tb->key.data, tb->key.len);
}
return NGX_OK;
}
static ngx_int_t ngx_http_mp4frag_handler(ngx_http_request_t *r)
{
ngx_int_t rc;
ngx_chain_t out;
u_char *resp_body;
ngx_buf_t *resp;
char *lastslash;
char *mediafilename;
u_char *last;
size_t root;
ngx_str_t path;
ngx_str_t index_map = ngx_null_string;
const u_char *indexptr;
ngx_str_t mediafile_map = ngx_null_string;
unsigned medianum, fragnum;
uint16_t nmedia;
ngx_str_t videocodecdata, audiocodecdata;
uint32_t mediaoffset, fragments_offset;
uint16_t mediafilenamelen;
uint16_t nsamples, nfragments;
uint32_t totalsize;
unsigned int iii;
ngx_table_elt_t *self;
if (!(r->method & (NGX_HTTP_GET|NGX_HTTP_HEAD))) {
return NGX_HTTP_NOT_ALLOWED;
}
if ( (rc = ngx_http_discard_request_body(r)) != NGX_OK ) {
return rc;
}
if ( (self = ngx_list_push(&r->headers_out.headers)) == NULL ) {
ngx_log_error(NGX_LOG_DEBUG, r->connection->log, 0, "Insufficient memory for ngx_list_push");
return NGX_ERROR;
}
self->hash = 1;
ngx_str_set(&self->key, "X-Mp4frag-Version");
ngx_str_set(&self->value, VERSION);
last = ngx_http_map_uri_to_path(r, &path, &root, 0);
ngx_log_error(NGX_LOG_DEBUG, r->connection->log, 0, "path=%s", path.data);
lastslash = strrchr((char*)path.data, '/');
if ( lastslash ) {
path.len = lastslash - (char*)path.data;
}
/* определить путь к файлу индекса и номер фрагмента: */
*lastslash++ = 0;
// uri - dirname, lastslash - basename
if ( memcmp(lastslash, "Seg1-Frag", 9) != 0 ) {
return NGX_HTTP_NOT_FOUND;
}
fragnum = atoi(lastslash + 9);
lastslash = strrchr((char*)path.data, '/');
if ( !lastslash ) {
return NGX_HTTP_NOT_FOUND;
}
medianum = atoi(lastslash + 1);
memcpy(lastslash + 1, "index", 6);
ngx_log_error(NGX_LOG_DEBUG, r->connection->log, 0, "index_path=%s", path.data);
if ( (rc = make_mapping((const char *)path.data, &index_map, r)) != NGX_OK ) {
return rc;
}
indexptr = index_map.data;
#define CHECKMAP(nbytes) do { if (indexptr + nbytes >= index_map.data + index_map.len) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "index underrun, offset 0x%0x", nbytes); goto GENERAL_ERROR;} } while(0)
CHECKMAP(10); /* 8 for signature and 2 for media count */
if ( memcmp(index_map.data, "mp4frag", 7) != 0 || index_map.data[7] /* version */ > 2 ) {
free_mapping(&index_map);
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "Bad index format in %s", path.data);
goto GENERAL_ERROR;
}
indexptr += 8;
nmedia = get16(indexptr);
if ( medianum >= nmedia ) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "No media #%d in %s, total %d media", medianum, path.data, nmedia);
goto GENERAL_ERROR;
}
indexptr += 2;
CHECKMAP(nmedia * 4);
mediaoffset = get32(indexptr + medianum * 4);
if ( mediaoffset >= index_map.len ) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "short index in %s", path.data);
goto GENERAL_ERROR;
}
indexptr = index_map.data;
CHECKMAP(mediaoffset);
indexptr = index_map.data + mediaoffset;
CHECKMAP(2);
mediafilenamelen = get16(indexptr);
indexptr += 2;
CHECKMAP(mediafilenamelen);
if ( index_map.data[7] == 1 ) {
if ( (mediafilename = ngx_pcalloc(r->pool, mediafilenamelen + 1)) == NULL ) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "Insufficient memory");
goto GENERAL_ERROR;
}
memcpy(mediafilename, (const char *)indexptr, mediafilenamelen);
mediafilename[mediafilenamelen] = 0;
}
else /* index_map.data[7] == 2 */ {
mediafilename = (char *)indexptr;
}
indexptr += mediafilenamelen;
CHECKMAP(2);
videocodecdata.len = get16(indexptr);
indexptr += 2;
CHECKMAP(videocodecdata.len);
videocodecdata.data = (u_char*)indexptr;
indexptr += videocodecdata.len;
CHECKMAP(2);
audiocodecdata.len = get16(indexptr);
indexptr += 2;
CHECKMAP(audiocodecdata.len);
audiocodecdata.data = (u_char*)indexptr;
indexptr += audiocodecdata.len;
/* number of fragments in the media */
CHECKMAP(2);
nfragments = get16(indexptr);
if ( fragnum > nfragments || fragnum < 1 ) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "No fragment #%d in media #%d in file %s", fragnum, medianum, path.data);
goto NOT_FOUND;
}
indexptr += 2;
CHECKMAP(nfragments * 4);
fragments_offset = get32(indexptr + (fragnum - 1) * 4);
indexptr = index_map.data;
CHECKMAP(fragments_offset);
indexptr += fragments_offset;
CHECKMAP(6); /* first entry should present anyway */
nsamples = get16(indexptr);
if ( nsamples < 1 ) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "Number of samples is 0 for media #%d, fragment #%d, index %s",
medianum, fragnum, path.data);
goto GENERAL_ERROR;
}
/* total fragment size in bytes: */
totalsize = get32(indexptr + 2);
ngx_log_error(NGX_LOG_DEBUG, r->connection->log, 0, "nsamples=%d, totalsize=%d", nsamples, totalsize);
indexptr += 6;
/* allocate memory for response */
if ( (resp_body = ngx_pcalloc(r->pool, totalsize)) == NULL ) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "Insufficient memory");
goto GENERAL_ERROR;
}
if ( (resp = ngx_pcalloc(r->pool, sizeof(ngx_buf_t))) == NULL ) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "Insufficient memory");
goto GENERAL_ERROR;
}
out.buf = resp;
out.next = NULL;
resp->pos = resp_body;
resp->last = resp_body + totalsize;
resp->memory = 1;
resp->last_buf = 1;
if ( make_mapping(mediafilename, &mediafile_map, r) != NGX_OK ) goto GENERAL_ERROR;
/* generate the fragment */
write32(resp_body, totalsize);
memcpy(resp_body + 4, "mdat", 4);
CHECKMAP(16 * nsamples - 1); /* check if the last byte still inside the index */
/* fragment timestamp is equal to first sample timestamp */
resp_body = write_fragment_prefix(resp_body + 8, &videocodecdata, &audiocodecdata, get32(indexptr + 8));
for ( iii = 0; iii < nsamples; ++iii ) {
uint32_t offset = get32(indexptr);
uint32_t size = get32(indexptr + 4);
uint32_t timestamp = get32(indexptr + 8);
uint32_t composition_offset = get24(indexptr + 12);
uint8_t flags = indexptr[15];
indexptr += 16;
if ( flags ) {
resp_body = write_video_packet(resp_body, flags & 2, 0, composition_offset, timestamp,
mediafile_map.data + offset, size);
}
else {
resp_body = write_audio_packet(resp_body, 0, timestamp, mediafile_map.data + offset, size);
}
}
free_mapping(&index_map);
free_mapping(&mediafile_map);
if ( resp_body != resp->last ) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "response buffer overrun");
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
r->headers_out.status = NGX_HTTP_OK;
r->headers_out.content_length_n = totalsize;
rc = ngx_http_send_header(r);
if (rc == NGX_ERROR || rc > NGX_OK || r->header_only || r->method == NGX_HTTP_HEAD) {
return rc;
}
/* send the buffer chain of your response */
return ngx_http_output_filter(r, &out);
GENERAL_ERROR:
free_mapping(&index_map);
free_mapping(&mediafile_map);
return NGX_HTTP_INTERNAL_SERVER_ERROR;
NOT_FOUND:
free_mapping(&index_map);
free_mapping(&mediafile_map);
return NGX_HTTP_NOT_FOUND;
}
static ngx_int_t
ngx_http_srcache_set_content_length_header(ngx_http_request_t *r, off_t len)
{
ngx_table_elt_t *h, *header;
u_char *p;
ngx_list_part_t *part;
ngx_http_request_t *pr;
ngx_uint_t i;
r->headers_in.content_length_n = len;
if (ngx_list_init(&r->headers_in.headers, r->pool, 20,
sizeof(ngx_table_elt_t))
!= NGX_OK)
{
return NGX_ERROR;
}
h = ngx_list_push(&r->headers_in.headers);
if (h == NULL) {
return NGX_ERROR;
}
h->key = ngx_http_srcache_content_length_header_key;
h->lowcase_key = ngx_pnalloc(r->pool, h->key.len);
if (h->lowcase_key == NULL) {
return NGX_ERROR;
}
ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
r->headers_in.content_length = h;
p = ngx_palloc(r->pool, NGX_OFF_T_LEN);
if (p == NULL) {
return NGX_ERROR;
}
h->value.data = p;
h->value.len = ngx_sprintf(h->value.data, "%O", len) - h->value.data;
h->hash = ngx_hash(ngx_hash(ngx_hash(ngx_hash(ngx_hash(ngx_hash(ngx_hash(
ngx_hash(ngx_hash(ngx_hash(ngx_hash(ngx_hash(
ngx_hash('c', 'o'), 'n'), 't'), 'e'), 'n'), 't'), '-'), 'l'), 'e'),
'n'), 'g'), 't'), 'h');
dd("r content length: %.*s",
(int)r->headers_in.content_length->value.len,
r->headers_in.content_length->value.data);
pr = r->parent;
if (pr == NULL) {
return NGX_OK;
}
/* forward the parent request's all other request headers */
part = &pr->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 (header[i].key.len == sizeof("Content-Length") - 1
&& ngx_strncasecmp(header[i].key.data,
(u_char *) "Content-Length",
sizeof("Content-Length") - 1) == 0)
{
continue;
}
h = ngx_list_push(&r->headers_in.headers);
if (h == NULL) {
return NGX_ERROR;
}
*h = header[i];
}
/* XXX maybe we should set those built-in header slot in
* ngx_http_headers_in_t too? */
return NGX_OK;
}
static ngx_int_t ngx_http_dynamic_etags_body_filter(ngx_http_request_t *r, ngx_chain_t *in) {
ngx_chain_t *chain_link;
ngx_http_dynamic_etags_module_ctx_t *ctx;
ngx_int_t rc;
ngx_md5_t md5;
unsigned char digest[16];
ngx_uint_t i;
ctx = ngx_http_get_module_ctx(r, ngx_http_dynamic_etags_module);
if (ctx == NULL) {
return ngx_http_next_body_filter(r, in);
}
ngx_http_dynamic_etags_loc_conf_t *loc_conf;
loc_conf = ngx_http_get_module_loc_conf(r, ngx_http_dynamic_etags_module);
if (1 == loc_conf->enable) {
ngx_md5_init(&md5);
for (chain_link = in; chain_link; chain_link = chain_link->next) {
ngx_md5_update(&md5, chain_link->buf->pos,
chain_link->buf->last - chain_link->buf->pos);
}
ngx_md5_final(digest, &md5);
unsigned char* etag = ngx_pcalloc(r->pool, 34);
etag[0] = etag[33] = '"';
for ( i = 0 ; i < 16; i++ ) {
etag[2*i+1] = hex[digest[i] >> 4];
etag[2*i+2] = hex[digest[i] & 0xf];
}
if(!r->headers_out.etag) {
r->headers_out.etag = ngx_list_push(&r->headers_out.headers);
}
r->headers_out.etag->hash = 1;
r->headers_out.etag->key.len = sizeof("ETag") - 1;
r->headers_out.etag->key.data = (u_char *) "ETag";
r->headers_out.etag->value.len = 34;
r->headers_out.etag->value.data = etag;
/* look for If-None-Match in request headers */
ngx_uint_t found=0;
ngx_list_part_t *part = NULL;
ngx_table_elt_t *header = NULL;
ngx_table_elt_t if_none_match;
part = &r->headers_in.headers.part;
header = part->elts;
for ( i = 0 ; ; i++ ) {
if ( i >= part->nelts) {
if ( part->next == NULL ) {
break;
}
part = part->next;
header = part->elts;
i = 0;
}
if ( ngx_strcmp(header[i].key.data, "If-None-Match") == 0 ) {
if_none_match = header[i];
found = 1;
break;
}
}
if ( found ) {
if ( ngx_strncmp(r->headers_out.etag->value.data, if_none_match.value.data, r->headers_out.etag->value.len) == 0 ) {
r->headers_out.status = NGX_HTTP_NOT_MODIFIED;
r->headers_out.status_line.len = 0;
r->headers_out.content_type.len = 0;
ngx_http_clear_content_length(r);
ngx_http_clear_accept_ranges(r);
}
}
}
static ngx_int_t
ngx_http_send_error_page(ngx_http_request_t *r, ngx_http_err_page_t *err_page)
{
ngx_int_t overwrite;
ngx_str_t uri, args;
ngx_table_elt_t *location;
ngx_http_core_loc_conf_t *clcf;
overwrite = err_page->overwrite;
if (overwrite && overwrite != NGX_HTTP_OK) {
r->expect_tested = 1;
}
if (overwrite >= 0) {
r->err_status = overwrite;
}
if (ngx_http_complex_value(r, &err_page->value, &uri) != NGX_OK) {
return NGX_ERROR;
}
if (uri.len && uri.data[0] == '/') {
if (err_page->value.lengths) {
ngx_http_split_args(r, &uri, &args);
} else {
args = err_page->args;
}
if (r->method != NGX_HTTP_HEAD) {
r->method = NGX_HTTP_GET;
r->method_name = ngx_http_get_name;
}
return ngx_http_internal_redirect(r, &uri, &args);
}
if (uri.len && uri.data[0] == '@') {
return ngx_http_named_location(r, &uri);
}
location = ngx_list_push(&r->headers_out.headers);
if (location == NULL) {
return NGX_ERROR;
}
if (overwrite != NGX_HTTP_MOVED_PERMANENTLY
&& overwrite != NGX_HTTP_MOVED_TEMPORARILY
&& overwrite != NGX_HTTP_SEE_OTHER
&& overwrite != NGX_HTTP_TEMPORARY_REDIRECT)
{
r->err_status = NGX_HTTP_MOVED_TEMPORARILY;
}
location->hash = 1;
ngx_str_set(&location->key, "Location");
location->value = uri;
ngx_http_clear_location(r);
r->headers_out.location = location;
clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
if (clcf->msie_refresh && r->headers_in.msie) {
return ngx_http_send_refresh(r);
}
return ngx_http_send_special_response(r, clcf, r->err_status
- NGX_HTTP_MOVED_PERMANENTLY
+ NGX_HTTP_OFF_3XX);
}
static ngx_int_t ngx_http_gridfs_handler(ngx_http_request_t* request) {
ngx_http_gridfs_loc_conf_t* gridfs_conf;
ngx_http_core_loc_conf_t* core_conf;
ngx_buf_t* buffer;
ngx_chain_t out;
ngx_str_t location_name;
ngx_str_t full_uri;
// --------------- xulin add start -------------------
char* ml_args;
char* arg;
unsigned int add_arg;
unsigned int add_len;
// --------------- xulin add end -------------------
char* value;
ngx_http_mongo_connection_t *mongo_conn;
gridfs gfs;
gridfile gfile;
gridfs_offset length;
ngx_uint_t numchunks;
char* contenttype;
char* md5;
bson_date_t last_modified;
volatile ngx_uint_t i;
ngx_int_t rc = NGX_OK;
bson query;
bson_oid_t oid;
mongo_cursor ** cursors;
gridfs_offset chunk_len;
const char * chunk_data;
bson_iterator it;
bson chunk;
ngx_pool_cleanup_t* gridfs_cln;
ngx_http_gridfs_cleanup_t* gridfs_clndata;
int status;
volatile ngx_uint_t e = FALSE;
volatile ngx_uint_t ecounter = 0;
gridfs_conf = ngx_http_get_module_loc_conf(request, ngx_http_gridfs_module);
core_conf = ngx_http_get_module_loc_conf(request, ngx_http_core_module);
// ---------- ENSURE MONGO CONNECTION ---------- //
mongo_conn = ngx_http_get_mongo_connection( gridfs_conf->mongo );
if (mongo_conn == NULL) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Mongo Connection not found: \"%V\"", &gridfs_conf->mongo);
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
if ( !(&mongo_conn->conn.connected)
&& (ngx_http_mongo_reconnect(request->connection->log, mongo_conn) == NGX_ERROR
|| ngx_http_mongo_reauth(request->connection->log, mongo_conn) == NGX_ERROR)) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Could not connect to mongo: \"%V\"", &gridfs_conf->mongo);
if(&mongo_conn->conn.connected) { mongo_disconnect(&mongo_conn->conn); }
return NGX_HTTP_SERVICE_UNAVAILABLE;
}
// ---------- RETRIEVE KEY ---------- //
location_name = core_conf->name;
full_uri = request->uri;
if (full_uri.len < location_name.len) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Invalid location name or uri.");
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
value = (char*)malloc(sizeof(char) * (full_uri.len - location_name.len + 1 + request->args.len + 1));
if (value == NULL) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Failed to allocate memory for value buffer.");
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
memcpy(value, full_uri.data + location_name.len, full_uri.len - location_name.len);
// ------------------------------------ xulin add start --------------------------------------
if (request->args.len > 0)
{
ml_args = (char*)malloc(sizeof(char) * (request->args.len + 1));
memcpy(ml_args, request->args.data, request->args.len);
ml_args[request->args.len] = '\0';
add_len = full_uri.len - location_name.len;
memcpy(value + add_len, "?", 1);
add_len += 1;
arg = strtok(ml_args, "&");
while (arg != NULL)
{
add_arg = 1;
if (strstr(arg, "xc_md5") != NULL)
{
add_arg = 0;
}
else if (strstr(arg, "_xingcloud_t") != NULL)
{
add_arg = 0;
}
if (add_arg == 1)
{
memcpy(value + add_len, arg, strlen(arg));
add_len += strlen(arg);
memcpy(value + add_len, "&", 1);
add_len += 1;
}
arg = strtok(NULL, "&");
}
free(ml_args);
if (value[add_len - 1] == '?' || value[add_len - 1] == '&')
{
value[add_len - 1] = '\0';
}
else
{
value[add_len] = '\0';
}
}
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0, "ml_url = [%s]", value);
// ------------------------------------ xulin add end --------------------------------------
if (!url_decode(value)) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Malformed request.");
free(value);
return NGX_HTTP_BAD_REQUEST;
}
// ---------- RETRIEVE GRIDFILE ---------- //
do {
e = FALSE;
if (gridfs_init(&mongo_conn->conn,
(const char*)gridfs_conf->db.data,
(const char*)gridfs_conf->root_collection.data,
&gfs) != MONGO_OK) {
e = TRUE; ecounter++;
if (ecounter > MONGO_MAX_RETRIES_PER_REQUEST
|| ngx_http_mongo_reconnect(request->connection->log, mongo_conn) == NGX_ERROR
|| ngx_http_mongo_reauth(request->connection->log, mongo_conn) == NGX_ERROR) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Mongo connection dropped, could not reconnect");
if(&mongo_conn->conn.connected) { mongo_disconnect(&mongo_conn->conn); }
free(value);
return NGX_HTTP_SERVICE_UNAVAILABLE;
}
}
} while (e);
bson_init(&query);
switch (gridfs_conf->type) {
case BSON_OID:
bson_oid_from_string(&oid, value);
bson_append_oid(&query, (char*)gridfs_conf->field.data, &oid);
break;
case BSON_INT:
bson_append_int(&query, (char*)gridfs_conf->field.data, ngx_atoi((u_char*)value, strlen(value)));
break;
case BSON_STRING:
bson_append_string(&query, (char*)gridfs_conf->field.data, value);
break;
}
bson_finish(&query);
status = gridfs_find_query(&gfs, &query, &gfile);
bson_destroy(&query);
free(value);
if(status == MONGO_ERROR) {
gridfs_destroy(&gfs);
return NGX_HTTP_NOT_FOUND;
}
/* Get information about the file */
length = gridfile_get_contentlength(&gfile);
numchunks = gridfile_get_numchunks(&gfile);
contenttype = (char*)gridfile_get_contenttype(&gfile);
md5 = (char*)gridfile_get_md5(&gfile);
last_modified = gridfile_get_uploaddate(&gfile);
// ---------- SEND THE HEADERS ---------- //
request->headers_out.status = NGX_HTTP_OK;
request->headers_out.content_length_n = length;
if (contenttype != NULL) {
request->headers_out.content_type.len = strlen(contenttype);
request->headers_out.content_type.data = (u_char*)contenttype;
}
else ngx_http_set_content_type(request);
// use md5 field as ETag if possible
if (md5 != NULL) {
request->headers_out.etag = ngx_list_push(&request->headers_out.headers);
request->headers_out.etag->hash = 1;
request->headers_out.etag->key.len = sizeof("ETag") - 1;
request->headers_out.etag->key.data = (u_char*)"ETag";
ngx_buf_t *b;
b = ngx_create_temp_buf(request->pool, strlen(md5) + 2);
b->last = ngx_sprintf(b->last, "\"%s\"", md5);
request->headers_out.etag->value.len = strlen(md5) + 2;
request->headers_out.etag->value.data = b->start;
}
// use uploadDate field as last_modified if possible
if (last_modified) {
request->headers_out.last_modified_time = (time_t)(last_modified/1000);
}
/* Determine if content is gzipped, set headers accordingly */
if ( gridfile_get_boolean(&gfile,"gzipped") ) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0, gridfile_get_field(&gfile,"gzipped") );
request->headers_out.content_encoding = ngx_list_push(&request->headers_out.headers);
if (request->headers_out.content_encoding == NULL) {
gridfile_destroy(&gfile);
gridfs_destroy(&gfs);
return NGX_ERROR;
}
request->headers_out.content_encoding->hash = 1;
request->headers_out.content_encoding->key.len = sizeof("Content-Encoding") - 1;
request->headers_out.content_encoding->key.data = (u_char *) "Content-Encoding";
request->headers_out.content_encoding->value.len = sizeof("gzip") - 1;
request->headers_out.content_encoding->value.data = (u_char *) "gzip";
}
ngx_http_send_header(request);
// ---------- SEND THE BODY ---------- //
/* Empty file */
if (numchunks == 0) {
/* Allocate space for the response buffer */
buffer = ngx_pcalloc(request->pool, sizeof(ngx_buf_t));
if (buffer == NULL) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Failed to allocate response buffer");
gridfile_destroy(&gfile);
gridfs_destroy(&gfs);
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
buffer->pos = NULL;
buffer->last = NULL;
buffer->memory = 1;
buffer->last_buf = 1;
out.buf = buffer;
out.next = NULL;
gridfile_destroy(&gfile);
gridfs_destroy(&gfs);
return ngx_http_output_filter(request, &out);
}
cursors = (mongo_cursor **)ngx_pcalloc(request->pool, sizeof(mongo_cursor *) * numchunks);
if (cursors == NULL) {
gridfile_destroy(&gfile);
gridfs_destroy(&gfs);
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
ngx_memzero( cursors, sizeof(mongo_cursor *) * numchunks);
/* Hook in the cleanup function */
gridfs_cln = ngx_pool_cleanup_add(request->pool, sizeof(ngx_http_gridfs_cleanup_t));
if (gridfs_cln == NULL) {
gridfile_destroy(&gfile);
gridfs_destroy(&gfs);
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
gridfs_cln->handler = ngx_http_gridfs_cleanup;
gridfs_clndata = gridfs_cln->data;
gridfs_clndata->cursors = cursors;
gridfs_clndata->numchunks = numchunks;
/* Read and serve chunk by chunk */
for (i = 0; i < numchunks; i++) {
/* Allocate space for the response buffer */
buffer = ngx_pcalloc(request->pool, sizeof(ngx_buf_t));
if (buffer == NULL) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Failed to allocate response buffer");
gridfile_destroy(&gfile);
gridfs_destroy(&gfs);
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
/* Fetch the chunk from mongo */
do {
e = FALSE;
cursors[i] = gridfile_get_chunks(&gfile, i, 1);
if (!(cursors[i] && mongo_cursor_next(cursors[i]) == MONGO_OK)) {
e = TRUE; ecounter++;
if (ecounter > MONGO_MAX_RETRIES_PER_REQUEST
|| ngx_http_mongo_reconnect(request->connection->log, mongo_conn) == NGX_ERROR
|| ngx_http_mongo_reauth(request->connection->log, mongo_conn) == NGX_ERROR) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Mongo connection dropped, could not reconnect");
if(&mongo_conn->conn.connected) { mongo_disconnect(&mongo_conn->conn); }
gridfile_destroy(&gfile);
gridfs_destroy(&gfs);
return NGX_HTTP_SERVICE_UNAVAILABLE;
}
}
} while (e);
chunk = cursors[i]->current;
bson_find(&it, &chunk, "data");
chunk_len = bson_iterator_bin_len( &it );
chunk_data = bson_iterator_bin_data( &it );
/* Set up the buffer chain */
buffer->pos = (u_char*)chunk_data;
buffer->last = (u_char*)chunk_data + chunk_len;
buffer->memory = 1;
buffer->last_buf = (i == numchunks-1);
out.buf = buffer;
out.next = NULL;
/* Serve the Chunk */
rc = ngx_http_output_filter(request, &out);
/* TODO: More Codes to Catch? */
if (rc == NGX_ERROR) {
gridfile_destroy(&gfile);
gridfs_destroy(&gfs);
return NGX_ERROR;
}
}
gridfile_destroy(&gfile);
gridfs_destroy(&gfs);
return rc;
}
static ngx_int_t
ngx_http_range_header_filter(ngx_http_request_t *r)
{
time_t if_range_time;
ngx_str_t *if_range, *etag;
ngx_uint_t ranges;
ngx_http_core_loc_conf_t *clcf;
ngx_http_range_filter_ctx_t *ctx;
if (r->http_version < NGX_HTTP_VERSION_10
|| r->headers_out.status != NGX_HTTP_OK
|| r != r->main
|| r->headers_out.content_length_n == -1
|| !r->allow_ranges)
{
return ngx_http_next_header_filter(r);
}
clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
if (clcf->max_ranges == 0) {
return ngx_http_next_header_filter(r);
}
if (r->headers_in.range == NULL
|| r->headers_in.range->value.len < 7
|| ngx_strncasecmp(r->headers_in.range->value.data,
(u_char *) "bytes=", 6)
!= 0)
{
goto next_filter;
}
if (r->headers_in.if_range) {
if_range = &r->headers_in.if_range->value;
if (if_range->len >= 2 && if_range->data[if_range->len - 1] == '"') {
if (r->headers_out.etag == NULL) {
goto next_filter;
}
etag = &r->headers_out.etag->value;
ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"http ir:%V etag:%V", if_range, etag);
if (if_range->len != etag->len
|| ngx_strncmp(if_range->data, etag->data, etag->len) != 0)
{
goto next_filter;
}
goto parse;
}
if (r->headers_out.last_modified_time == (time_t) -1) {
goto next_filter;
}
if_range_time = ngx_parse_http_time(if_range->data, if_range->len);
ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"http ir:%d lm:%d",
if_range_time, r->headers_out.last_modified_time);
if (if_range_time != r->headers_out.last_modified_time) {
goto next_filter;
}
}
parse:
ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_range_filter_ctx_t));
if (ctx == NULL) {
return NGX_ERROR;
}
if (ngx_array_init(&ctx->ranges, r->pool, 1, sizeof(ngx_http_range_t))
!= NGX_OK)
{
return NGX_ERROR;
}
ranges = r->single_range ? 1 : clcf->max_ranges;
switch (ngx_http_range_parse(r, ctx, ranges)) {
case NGX_OK:
ngx_http_set_ctx(r, ctx, ngx_http_range_body_filter_module);
r->headers_out.status = NGX_HTTP_PARTIAL_CONTENT;
r->headers_out.status_line.len = 0;
if (ctx->ranges.nelts == 1) {
return ngx_http_range_singlepart_header(r, ctx);
}
return ngx_http_range_multipart_header(r, ctx);
case NGX_HTTP_RANGE_NOT_SATISFIABLE:
return ngx_http_range_not_satisfiable(r);
case NGX_ERROR:
return NGX_ERROR;
default: /* NGX_DECLINED */
break;
}
next_filter:
r->headers_out.accept_ranges = ngx_list_push(&r->headers_out.headers);
if (r->headers_out.accept_ranges == NULL) {
return NGX_ERROR;
}
r->headers_out.accept_ranges->hash = 1;
ngx_str_set(&r->headers_out.accept_ranges->key, "Accept-Ranges");
ngx_str_set(&r->headers_out.accept_ranges->value, "bytes");
return ngx_http_next_header_filter(r);
}
static ngx_int_t
ngx_http_set_header_helper(ngx_http_request_t *r, ngx_http_lua_header_val_t *hv,
ngx_str_t *value, ngx_table_elt_t **output_header,
unsigned no_create)
{
ngx_table_elt_t *h;
ngx_list_part_t *part;
ngx_uint_t i;
unsigned matched = 0;
if (hv->no_override) {
goto new_header;
}
#if 1
if (r->headers_out.location
&& r->headers_out.location->value.len
&& r->headers_out.location->value.data[0] == '/')
{
/* XXX ngx_http_core_find_config_phase, for example,
* may not initialize the "key" and "hash" fields
* for a nasty optimization purpose, and
* we have to work-around it here */
r->headers_out.location->hash = ngx_http_lua_location_hash;
ngx_str_set(&r->headers_out.location->key, "Location");
}
#endif
part = &r->headers_out.headers.part;
h = part->elts;
for (i = 0; /* void */; i++) {
if (i >= part->nelts) {
if (part->next == NULL) {
break;
}
part = part->next;
h = part->elts;
i = 0;
}
if (h[i].hash != 0
&& h[i].key.len == hv->key.len
&& ngx_strncasecmp(hv->key.data, h[i].key.data, h[i].key.len) == 0)
{
dd("found out header %.*s", (int) h[i].key.len, h[i].key.data);
if (value->len == 0 || matched) {
dd("clearing normal header for %.*s", (int) hv->key.len,
hv->key.data);
h[i].value.len = 0;
h[i].hash = 0;
} else {
dd("setting header to value %.*s", (int) value->len,
value->data);
h[i].value = *value;
h[i].hash = hv->hash;
}
if (output_header) {
*output_header = &h[i];
}
/* return NGX_OK; */
matched = 1;
}
}
if (matched){
return NGX_OK;
}
if (no_create && value->len == 0) {
return NGX_OK;
}
new_header:
/* XXX we still need to create header slot even if the value
* is empty because some builtin headers like Last-Modified
* relies on this to get cleared */
h = ngx_list_push(&r->headers_out.headers);
if (h == NULL) {
return NGX_ERROR;
}
if (value->len == 0) {
h->hash = 0;
} else {
h->hash = hv->hash;
}
h->key = hv->key;
h->value = *value;
h->lowcase_key = ngx_pnalloc(r->pool, h->key.len);
if (h->lowcase_key == NULL) {
return NGX_ERROR;
}
ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
if (output_header) {
*output_header = h;
}
return NGX_OK;
}
static void ngx_http_mapcache_write_response(mapcache_context *ctx, ngx_http_request_t *r,
mapcache_http_response *response) {
if(response->mtime) {
time_t if_modified_since;
if(r->headers_in.if_modified_since) {
if_modified_since = ngx_http_parse_time(r->headers_in.if_modified_since->value.data,
r->headers_in.if_modified_since->value.len);
if (if_modified_since != NGX_ERROR) {
apr_time_t apr_if_m_s;
apr_time_ansi_put ( &apr_if_m_s, if_modified_since);
if(apr_if_m_s<response->mtime) {
r->headers_out.status = NGX_HTTP_NOT_MODIFIED;
ngx_http_send_header(r);
return;
}
}
}
char *datestr;
datestr = apr_palloc(ctx->pool, APR_RFC822_DATE_LEN);
apr_rfc822_date(datestr, response->mtime);
apr_table_setn(response->headers,"Last-Modified",datestr);
}
if(response->headers && !apr_is_empty_table(response->headers)) {
const apr_array_header_t *elts = apr_table_elts(response->headers);
int i;
for(i=0;i<elts->nelts;i++) {
apr_table_entry_t entry = APR_ARRAY_IDX(elts,i,apr_table_entry_t);
if(!strcasecmp(entry.key,"Content-Type")) {
r->headers_out.content_type.len = strlen(entry.val);
r->headers_out.content_type.data = (u_char*)entry.val;
} else {
ngx_table_elt_t *h;
h = ngx_list_push(&r->headers_out.headers);
if (h == NULL) {
return;
}
h->key.len = strlen(entry.key) ;
h->key.data = (u_char*)entry.key ;
h->value.len = strlen(entry.val) ;
h->value.data = (u_char*)entry.val ;
h->hash = 1;
}
}
}
if(response->data) {
r->headers_out.content_length_n = response->data->size;
}
int rc;
r->headers_out.status = response->code;
rc = ngx_http_send_header(r);
if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
return;
}
if(response->data) {
ngx_buf_t *b;
ngx_chain_t out;
b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
if (b == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"Failed to allocate response buffer.");
return;
}
b->pos = ngx_pcalloc(r->pool,response->data->size);
memcpy(b->pos,response->data->buf,response->data->size);
b->last = b->pos + response->data->size;
b->memory = 1;
b->last_buf = 1;
b->flush = 1;
out.buf = b;
out.next = NULL;
ngx_http_output_filter(r, &out);
}
}
static ngx_int_t
ngx_http_set_builtin_multi_header(ngx_http_request_t *r,
ngx_http_lua_header_val_t *hv, ngx_str_t *value)
{
ngx_array_t *pa;
ngx_table_elt_t *ho, **ph;
ngx_uint_t i;
pa = (ngx_array_t *) ((char *) &r->headers_out + hv->offset);
if (pa->elts == NULL) {
if (ngx_array_init(pa, r->pool, 2, sizeof(ngx_table_elt_t *))
!= NGX_OK)
{
return NGX_ERROR;
}
}
if (hv->no_override) {
ph = pa->elts;
for (i = 0; i < pa->nelts; i++) {
if (!ph[i]->hash) {
ph[i]->value = *value;
ph[i]->hash = hv->hash;
return NGX_OK;
}
}
goto create;
}
/* override old values (if any) */
if (pa->nelts > 0) {
ph = pa->elts;
for (i = 1; i < pa->nelts; i++) {
ph[i]->hash = 0;
ph[i]->value.len = 0;
}
ph[0]->value = *value;
if (value->len == 0) {
ph[0]->hash = 0;
} else {
ph[0]->hash = hv->hash;
}
return NGX_OK;
}
create:
ph = ngx_array_push(pa);
if (ph == NULL) {
return NGX_ERROR;
}
ho = ngx_list_push(&r->headers_out.headers);
if (ho == NULL) {
return NGX_ERROR;
}
ho->value = *value;
if (value->len == 0) {
ho->hash = 0;
} else {
ho->hash = hv->hash;
}
ho->key = hv->key;
*ph = ho;
return NGX_OK;
}
static ngx_int_t
process_header(ngx_http_request_t *r)
{
ngx_str_t *status_line;
ngx_int_t rc, status;
ngx_table_elt_t *h;
ngx_http_upstream_t *u;
ngx_http_upstream_header_t *hh;
ngx_http_upstream_main_conf_t *umcf;
ngx_http_core_loc_conf_t *clcf;
umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);
clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
for ( ;; ) {
rc = ngx_http_parse_header_line(r, &r->upstream->buffer, 1);
if (rc == NGX_OK) {
/* a header line has been parsed successfully */
h = ngx_list_push(&r->upstream->headers_in.headers);
if (h == NULL) {
return NGX_ERROR;
}
h->hash = r->header_hash;
h->key.len = r->header_name_end - r->header_name_start;
h->value.len = r->header_end - r->header_start;
h->key.data = ngx_pnalloc(r->pool,
h->key.len + 1 + h->value.len + 1
+ h->key.len);
if (h->key.data == NULL) {
return NGX_ERROR;
}
h->value.data = h->key.data + h->key.len + 1;
h->lowcase_key = h->key.data + h->key.len + 1 + h->value.len + 1;
ngx_memcpy(h->key.data, r->header_name_start, h->key.len);
h->key.data[h->key.len] = '\0';
ngx_memcpy(h->value.data, r->header_start, h->value.len);
h->value.data[h->value.len] = '\0';
if (h->key.len == r->lowcase_index) {
ngx_memcpy(h->lowcase_key, r->lowcase_header, h->key.len);
} else {
ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
}
hh = ngx_hash_find(&umcf->headers_in_hash, h->hash,
h->lowcase_key, h->key.len);
if (hh && hh->handler(r, h, hh->offset) != NGX_OK) {
return NGX_ERROR;
}
ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"http scgi header: \"%V: %V\"", &h->key, &h->value);
continue;
}
if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
/* a whole header has been parsed successfully */
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"http scgi header done");
/*
* if no "Server" and "Date" in header line,
* then add the default headers
*/
if (r->upstream->headers_in.server == NULL) {
h = ngx_list_push(&r->upstream->headers_in.headers);
if (h == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
h->hash = ngx_hash(ngx_hash(ngx_hash(ngx_hash(
ngx_hash('s', 'e'), 'r'), 'v'), 'e'), 'r');
h->key.len = sizeof("Server") - 1;
h->key.data = (u_char *) "Server";
if (!passenger_main_conf.show_version_in_header) {
if (clcf->server_tokens) {
h->value.data = (u_char *) (NGINX_VER " + " PROGRAM_NAME);
} else {
h->value.data = (u_char *) ("nginx + " PROGRAM_NAME);
}
} else {
if (clcf->server_tokens) {
h->value.data = (u_char *) (NGINX_VER " + " PROGRAM_NAME " " PASSENGER_VERSION);
} else {
h->value.data = (u_char *) ("nginx + " PROGRAM_NAME " " PASSENGER_VERSION);
}
}
h->value.len = ngx_strlen(h->value.data);
h->lowcase_key = (u_char *) "server";
}
if (r->upstream->headers_in.date == NULL) {
h = ngx_list_push(&r->upstream->headers_in.headers);
if (h == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
h->hash = ngx_hash(ngx_hash(ngx_hash('d', 'a'), 't'), 'e');
h->key.len = sizeof("Date") - 1;
h->key.data = (u_char *) "Date";
h->value.len = 0;
h->value.data = NULL;
h->lowcase_key = (u_char *) "date";
}
/* Process "Status" header. */
u = r->upstream;
if (u->headers_in.status_n) {
goto done;
}
if (u->headers_in.status) {
status_line = &u->headers_in.status->value;
status = ngx_atoi(status_line->data, 3);
if (status == NGX_ERROR) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"upstream sent invalid status \"%V\"",
status_line);
return NGX_HTTP_UPSTREAM_INVALID_HEADER;
}
u->headers_in.status_n = status;
u->headers_in.status_line = *status_line;
} else if (u->headers_in.location) {
u->headers_in.status_n = 302;
ngx_str_set(&u->headers_in.status_line,
"302 Moved Temporarily");
} else {
u->headers_in.status_n = 200;
ngx_str_set(&u->headers_in.status_line, "200 OK");
}
if (u->state && u->state->status == 0) {
u->state->status = u->headers_in.status_n;
}
done:
/* Supported since Nginx 1.3.15. */
#ifdef NGX_HTTP_SWITCHING_PROTOCOLS
if (u->headers_in.status_n == NGX_HTTP_SWITCHING_PROTOCOLS
&& r->headers_in.upgrade)
{
u->upgrade = 1;
}
#endif
return NGX_OK;
}
if (rc == NGX_AGAIN) {
return NGX_AGAIN;
}
/* there was error while a header line parsing */
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"upstream sent invalid header");
return NGX_HTTP_UPSTREAM_INVALID_HEADER;
}
}
static ngx_int_t ngx_http_cookie_handler(ngx_http_request_t *r)
{
ngx_int_t rc; //存储返回值
ngx_buf_t *b; //缓冲区
ngx_chain_t out; //缓冲区链表
ngx_table_elt_t **cookies;
ngx_uint_t nelts;
ngx_table_elt_t *set_cookie;
u_char ngx_string[2048]={0}; //存储返回的字符串
u_char temp[1024]={0};
ngx_uint_t content_length = 0; //返回的字符串长度
ngx_str_t type = ngx_string("text/html");
ngx_uint_t j;
//在r->headers_in结构有一个ngx_array_t类型成员cookies,这是nginx存储请求cookie的变量。
cookies = r->headers_in.cookies.elts;
nelts = r->headers_in.cookies.nelts;
if (cookies == NULL){
ngx_sprintf(ngx_string,"cookies is not exsit!");
//在r->headers_out中没有cookies成员，需要构造一个ngx_table_elt_t结构添加到r->headers_out.headers中
set_cookie = ngx_list_push(&r->headers_out.headers);
if (set_cookie == NULL){
ngx_log_error(NGX_LOG_EMERG,r->connection->log,0,"set_cookie is NULL nelts is %d",nelts);
}
set_cookie->hash = 1;
ngx_str_set(&set_cookie->key,"Set-Cookie");
i++;
//在nginx中，所有的cookie键值对都格式化为一个字符串value，形式为keyname=valuename
ngx_sprintf(temp,"CookieName%d=Visit %d times! <br>",i,i);
set_cookie->value.data = temp;
set_cookie->value.len = ngx_strlen(temp);
}
else {
ngx_log_error(NGX_LOG_EMERG,r->connection->log,0,"number of cookie is %d",nelts);
for(j=0;j<nelts;j++){
ngx_sprintf(ngx_string+ngx_strlen(ngx_string),"Cookie %d : %V",j+1,&cookies[j]->value);
}
set_cookie = ngx_list_push(&r->headers_out.headers);
set_cookie->hash = 1;
ngx_str_set(&set_cookie->key,"Set-Cookie");
i++;
ngx_sprintf(temp,"CookieName%d=Visit %d times! <br>",i,i);
set_cookie->value.data = temp;
set_cookie->value.len = ngx_strlen(temp);
}
/*
** ngx_sprintf()函数用于拼接字符串，原型如下：
** u_char * ngx_cdecl ngx_sprintf(u_char *buf, const char *fmt, ...)
** u_char *buf: 某个字符串的地址，即拼接后存放的位置
** const char *fmt: 传格式，nginx自定义的格式，最常用的是%V，代表ngx_str_t
*/
content_length = ngx_strlen(ngx_string);
if (!(r->method & (NGX_HTTP_GET | NGX_HTTP_HEAD))){
return NGX_HTTP_NOT_ALLOWED;
}
rc = ngx_http_discard_request_body(r);
if (rc != NGX_OK) {
return rc;
}
r->headers_out.status = NGX_HTTP_OK;
r->headers_out.content_length_n = content_length;
r->headers_out.content_type = type;
/* HTTP框架提供的发送HTTP头部的方法 */
/* 返回NGX_ERROR或返回值大于0就表示不正常 */
rc = ngx_http_send_header(r);
if (rc == NGX_ERROR || rc > NGX_OK || r->header_only){
return rc;
}
// 构造ngx_buf_t结构体准备发送包体
b = ngx_pcalloc(r->pool,sizeof(ngx_buf_t));
if(b==NULL){
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
// 将需要返回的字符串复制到ngx_buf_t指向的内存中
b->pos = ngx_string;
b->last = ngx_string+content_length;
b->memory = 1;
b->last_buf = 1; //最后一块缓冲区
// 缓冲区链表chain把需要往外发送的数据串起来，这里只有一个buf里的数据需要发送
out.buf = b;
out.next = NULL;
// 发送包体，结束请求
return ngx_http_output_filter(r,&out);
}
ngx_shm_zone_t *
ngx_shared_memory_add(ngx_conf_t *cf, ngx_str_t *name, size_t size, void *tag)
{
ngx_uint_t i;
ngx_shm_zone_t *shm_zone;
ngx_list_part_t *part;
part = &cf->cycle->shared_memory.part;
shm_zone = part->elts;
for (i = 0; /* void */ ; i++) {
if (i >= part->nelts) {
if (part->next == NULL) {
break;
}
part = part->next;
shm_zone = part->elts;
i = 0;
}
if (name->len != shm_zone[i].shm.name.len) {
continue;
}
if (ngx_strncmp(name->data, shm_zone[i].shm.name.data, name->len)
!= 0)
{
continue;
}
if (tag != shm_zone[i].tag) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"the shared memory zone \"%V\" is "
"already declared for a different use",
&shm_zone[i].shm.name);
return NULL;
}
if (shm_zone[i].shm.size == 0) {
shm_zone[i].shm.size = size;
}
if (size && size != shm_zone[i].shm.size) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"the size %uz of shared memory zone \"%V\" "
"conflicts with already declared size %uz",
size, &shm_zone[i].shm.name, shm_zone[i].shm.size);
return NULL;
}
return &shm_zone[i];
}
shm_zone = ngx_list_push(&cf->cycle->shared_memory);
if (shm_zone == NULL) {
return NULL;
}
shm_zone->data = NULL;
shm_zone->shm.log = cf->cycle->log;
shm_zone->shm.size = size;
shm_zone->shm.name = *name;
shm_zone->shm.exists = 0;
shm_zone->init = NULL;
shm_zone->tag = tag;
shm_zone->noreuse = 0;
return shm_zone;
}
static ngx_int_t
ngx_http_range_header_filter(ngx_http_request_t *r)
{
time_t if_range;
ngx_int_t rc;
ngx_http_range_filter_ctx_t *ctx;
if (r->http_version < NGX_HTTP_VERSION_10
|| r->headers_out.status != NGX_HTTP_OK
|| r != r->main
|| r->headers_out.content_length_n == -1
|| !r->allow_ranges)
{
return ngx_http_next_header_filter(r);
}
if (r->headers_in.range == NULL
|| r->headers_in.range->value.len < 7
|| ngx_strncasecmp(r->headers_in.range->value.data,
(u_char *) "bytes=", 6)
!= 0)
{
goto next_filter;
}
if (r->headers_in.if_range && r->headers_out.last_modified_time != -1) {
if_range = ngx_http_parse_time(r->headers_in.if_range->value.data,
r->headers_in.if_range->value.len);
ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"http ir:%d lm:%d",
if_range, r->headers_out.last_modified_time);
if (if_range != r->headers_out.last_modified_time) {
goto next_filter;
}
}
ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_range_filter_ctx_t));
if (ctx == NULL) {
return NGX_ERROR;
}
if (ngx_array_init(&ctx->ranges, r->pool, 1, sizeof(ngx_http_range_t))
!= NGX_OK)
{
return NGX_ERROR;
}
rc = ngx_http_range_parse(r, ctx);
if (rc == NGX_OK) {
ngx_http_set_ctx(r, ctx, ngx_http_range_body_filter_module);
r->headers_out.status = NGX_HTTP_PARTIAL_CONTENT;
r->headers_out.status_line.len = 0;
if (ctx->ranges.nelts == 1) {
return ngx_http_range_singlepart_header(r, ctx);
}
return ngx_http_range_multipart_header(r, ctx);
}
if (rc == NGX_HTTP_RANGE_NOT_SATISFIABLE) {
return ngx_http_range_not_satisfiable(r);
}
/* rc == NGX_ERROR */
return rc;
next_filter:
r->headers_out.accept_ranges = ngx_list_push(&r->headers_out.headers);
if (r->headers_out.accept_ranges == NULL) {
return NGX_ERROR;
}
r->headers_out.accept_ranges->hash = 1;
ngx_str_set(&r->headers_out.accept_ranges->key, "Accept-Ranges");
ngx_str_set(&r->headers_out.accept_ranges->value, "bytes");
return ngx_http_next_header_filter(r);
}
//expires配置解析，会触发创建设置r->headers_out.expires r->headers_out.cache_control
static ngx_int_t //expires xx配置存储函数为ngx_http_headers_expires，真正组包生效函数为ngx_http_set_expires
ngx_http_set_expires(ngx_http_request_t *r, ngx_http_headers_conf_t *conf)
{
char *err;
size_t len;
time_t now, expires_time, max_age;
ngx_str_t value;
ngx_int_t rc;
ngx_uint_t i;
ngx_table_elt_t *e, *cc, **ccp;
ngx_http_expires_t expires;
expires = conf->expires;
expires_time = conf->expires_time;
if (conf->expires_value != NULL) { //说明expires配置的是变量类型
if (ngx_http_complex_value(r, conf->expires_value, &value) != NGX_OK) {
return NGX_ERROR;
}
rc = ngx_http_parse_expires(&value, &expires, &expires_time, &err);
if (rc != NGX_OK) {
return NGX_OK;
}
if (expires == NGX_HTTP_EXPIRES_OFF) {
return NGX_OK;
}
}
e = r->headers_out.expires;
if (e == NULL) {
e = ngx_list_push(&r->headers_out.headers);
if (e == NULL) {
return NGX_ERROR;
}
r->headers_out.expires = e;
e->hash = 1;
ngx_str_set(&e->key, "Expires");
}
len = sizeof("Mon, 28 Sep 1970 06:00:00 GMT");
e->value.len = len - 1;
ccp = r->headers_out.cache_control.elts;
if (ccp == NULL) {
if (ngx_array_init(&r->headers_out.cache_control, r->pool,
1, sizeof(ngx_table_elt_t *))
!= NGX_OK)
{
return NGX_ERROR;
}
ccp = ngx_array_push(&r->headers_out.cache_control);
if (ccp == NULL) {
return NGX_ERROR;
}
cc = ngx_list_push(&r->headers_out.headers);
if (cc == NULL) {
return NGX_ERROR;
}
cc->hash = 1;
ngx_str_set(&cc->key, "Cache-Control");
*ccp = cc;
} else {
for (i = 1; i < r->headers_out.cache_control.nelts; i++) {
ccp[i]->hash = 0;
}
cc = ccp[0];
}
if (expires == NGX_HTTP_EXPIRES_EPOCH) {
e->value.data = (u_char *) "Thu, 01 Jan 1970 00:00:01 GMT";
ngx_str_set(&cc->value, "no-cache");//设置r->headers_out.cache_control
return NGX_OK;
}
if (expires == NGX_HTTP_EXPIRES_MAX) {
e->value.data = (u_char *) "Thu, 31 Dec 2037 23:55:55 GMT";
/* 10 years */
ngx_str_set(&cc->value, "max-age=315360000");//设置r->headers_out.cache_control
return NGX_OK;
}
e->value.data = ngx_pnalloc(r->pool, len);
if (e->value.data == NULL) {
return NGX_ERROR;
}
if (expires_time == 0 && expires != NGX_HTTP_EXPIRES_DAILY) {
ngx_memcpy(e->value.data, ngx_cached_http_time.data,
ngx_cached_http_time.len + 1);
ngx_str_set(&cc->value, "max-age=0");//设置r->headers_out.cache_control
return NGX_OK;
}
now = ngx_time();
if (expires == NGX_HTTP_EXPIRES_DAILY) {
expires_time = ngx_next_time(expires_time);
max_age = expires_time - now;
} else if (expires == NGX_HTTP_EXPIRES_ACCESS
|| r->headers_out.last_modified_time == -1)
{
max_age = expires_time;
expires_time += now;
} else {
expires_time += r->headers_out.last_modified_time;
max_age = expires_time - now;
}
ngx_http_time(e->value.data, expires_time);
if (conf->expires_time < 0 || max_age < 0) {
ngx_str_set(&cc->value, "no-cache");//设置r->headers_out.cache_control
return NGX_OK;
}
//设置r->headers_out.cache_control
cc->value.data = ngx_pnalloc(r->pool,
sizeof("max-age=") + NGX_TIME_T_LEN + 1);
if (cc->value.data == NULL) {
return NGX_ERROR;
}
cc->value.len = ngx_sprintf(cc->value.data, "max-age=%T", max_age)
- cc->value.data;
return NGX_OK;
}
static ngx_int_t ngx_http_gridfs_handler(ngx_http_request_t* request) {
ngx_http_gridfs_loc_conf_t* gridfs_conf;
ngx_http_core_loc_conf_t* core_conf;
ngx_buf_t* buffer;
ngx_chain_t out;
ngx_str_t location_name;
ngx_str_t full_uri;
char* value;
ngx_http_mongo_connection_t *mongo_conn;
gridfs gfs;
gridfile gfile;
gridfs_offset length;
ngx_uint_t numchunks;
char* contenttype;
char* md5;
bson_date_t last_modified;
volatile ngx_uint_t i;
ngx_int_t rc = NGX_OK;
bson query;
bson_oid_t oid;
mongo_cursor ** cursors;
gridfs_offset chunk_len;
const char * chunk_data;
bson_iterator it;
bson chunk;
ngx_pool_cleanup_t* gridfs_cln;
ngx_http_gridfs_cleanup_t* gridfs_clndata;
int status;
volatile ngx_uint_t e = FALSE;
volatile ngx_uint_t ecounter = 0;
uint64_t range_start = 0;
uint64_t range_end = 0;
uint64_t current_buf_pos = 0;
gridfs_conf = ngx_http_get_module_loc_conf(request, ngx_http_gridfs_module);
core_conf = ngx_http_get_module_loc_conf(request, ngx_http_core_module);
// ---------- ENSURE MONGO CONNECTION ---------- //
mongo_conn = ngx_http_get_mongo_connection( gridfs_conf->mongo );
if (mongo_conn == NULL) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Mongo Connection not found: \"%V\"", &gridfs_conf->mongo);
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
if (mongo_conn->conn.connected == 0) {
if (ngx_http_mongo_reconnect(request->connection->log, mongo_conn) == NGX_ERROR) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Could not connect to mongo: \"%V\"", &gridfs_conf->mongo);
if(mongo_conn->conn.connected) { mongo_disconnect(&mongo_conn->conn); }
return NGX_HTTP_SERVICE_UNAVAILABLE;
}
if (ngx_http_mongo_reauth(request->connection->log, mongo_conn) == NGX_ERROR) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Failed to reauth to mongo: \"%V\"", &gridfs_conf->mongo);
if(mongo_conn->conn.connected) { mongo_disconnect(&mongo_conn->conn); }
return NGX_HTTP_SERVICE_UNAVAILABLE;
}
}
// ---------- RETRIEVE KEY ---------- //
location_name = core_conf->name;
full_uri = request->uri;
if (full_uri.len < location_name.len) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Invalid location name or uri.");
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
value = (char*)malloc(sizeof(char) * (full_uri.len - location_name.len + 1));
if (value == NULL) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Failed to allocate memory for value buffer.");
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
memcpy(value, full_uri.data + location_name.len, full_uri.len - location_name.len);
value[full_uri.len - location_name.len] = '\0';
if (!url_decode(value)) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Malformed request.");
free(value);
return NGX_HTTP_BAD_REQUEST;
}
// ---------- RETRIEVE GRIDFILE ---------- //
bson_init(&query);
switch (gridfs_conf->type) {
case BSON_OID:
bson_oid_from_string(&oid, value);
bson_append_oid(&query, (char*)gridfs_conf->field.data, &oid);
break;
case BSON_INT:
bson_append_int(&query, (char*)gridfs_conf->field.data, ngx_atoi((u_char*)value, strlen(value)));
break;
case BSON_STRING:
bson_append_string(&query, (char*)gridfs_conf->field.data, value);
break;
}
bson_finish(&query);
do {
e = FALSE;
if (gridfs_init(&mongo_conn->conn,
(const char*)gridfs_conf->db.data,
(const char*)gridfs_conf->root_collection.data,
&gfs) != MONGO_OK
|| (status = gridfs_find_query(&gfs, &query, &gfile) == MONGO_ERROR)) {
e = TRUE; ecounter++;
if (ecounter > MONGO_MAX_RETRIES_PER_REQUEST
|| ngx_http_mongo_reconnect(request->connection->log, mongo_conn) == NGX_ERROR
|| ngx_http_mongo_reauth(request->connection->log, mongo_conn) == NGX_ERROR) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Mongo connection dropped, could not reconnect");
if(&mongo_conn->conn.connected) { mongo_disconnect(&mongo_conn->conn); }
bson_destroy(&query);
free(value);
return NGX_HTTP_SERVICE_UNAVAILABLE;
}
}
} while (e);
bson_destroy(&query);
free(value);
/* Get information about the file */
length = gridfile_get_contentlength(&gfile);
numchunks = gridfile_get_numchunks(&gfile);
// NaN workaround
if (numchunks > INT_MAX)
{
gridfile_destroy(&gfile);
gridfs_destroy(&gfs);
return NGX_HTTP_NOT_FOUND;
}
contenttype = (char*)gridfile_get_contenttype(&gfile);
md5 = (char*)gridfile_get_md5(&gfile);
last_modified = gridfile_get_uploaddate(&gfile);
// ---------- Partial Range
// set follow-fork-mode child
// attach (pid)
// break ngx_http_gridfs_module.c:959
if (request->headers_in.range) {
gridfs_parse_range(request, &request->headers_in.range->value, &range_start, &range_end, length);
}
// ---------- SEND THE HEADERS ---------- //
if (range_start == 0 && range_end == 0) {
request->headers_out.status = NGX_HTTP_OK;
request->headers_out.content_length_n = length;
} else {
request->headers_out.status = NGX_HTTP_PARTIAL_CONTENT;
request->headers_out.content_length_n = length;
//request->headers_out.content_range = range_end - range_start + 1;
ngx_table_elt_t *content_range;
content_range = ngx_list_push(&request->headers_out.headers);
if (content_range == NULL) {
return NGX_ERROR;
}
request->headers_out.content_range = content_range;
content_range->hash = 1;
ngx_str_set(&content_range->key, "Content-Range");
content_range->value.data = ngx_pnalloc(request->pool,sizeof("bytes -/") - 1 + 3 * NGX_OFF_T_LEN);
if (content_range->value.data == NULL) {
return NGX_ERROR;
}
/* "Content-Range: bytes SSSS-EEEE/TTTT" header */
content_range->value.len = ngx_sprintf(content_range->value.data,
"bytes %O-%O/%O",
range_start, range_end,
request->headers_out.content_length_n)
- content_range->value.data;
request->headers_out.content_length_n = range_end - range_start + 1;
}
if (contenttype != NULL) {
request->headers_out.content_type.len = strlen(contenttype);
request->headers_out.content_type.data = (u_char*)contenttype;
}
else ngx_http_set_content_type(request);
// use md5 field as ETag if possible
if (md5 != NULL) {
request->headers_out.etag = ngx_list_push(&request->headers_out.headers);
request->headers_out.etag->hash = 1;
request->headers_out.etag->key.len = sizeof("ETag") - 1;
request->headers_out.etag->key.data = (u_char*)"ETag";
ngx_buf_t *b;
b = ngx_create_temp_buf(request->pool, strlen(md5) + 2);
b->last = ngx_sprintf(b->last, "\"%s\"", md5);
request->headers_out.etag->value.len = strlen(md5) + 2;
request->headers_out.etag->value.data = b->start;
}
// use uploadDate field as last_modified if possible
if (last_modified) {
request->headers_out.last_modified_time = (time_t)(last_modified/1000);
}
/* Determine if content is gzipped, set headers accordingly */
if ( gridfile_get_boolean(&gfile,"gzipped") ) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0, gridfile_get_field(&gfile,"gzipped") );
request->headers_out.content_encoding = ngx_list_push(&request->headers_out.headers);
if (request->headers_out.content_encoding == NULL) {
gridfile_destroy(&gfile);
gridfs_destroy(&gfs);
return NGX_ERROR;
}
request->headers_out.content_encoding->hash = 1;
request->headers_out.content_encoding->key.len = sizeof("Content-Encoding") - 1;
request->headers_out.content_encoding->key.data = (u_char *) "Content-Encoding";
request->headers_out.content_encoding->value.len = sizeof("gzip") - 1;
request->headers_out.content_encoding->value.data = (u_char *) "gzip";
}
ngx_http_send_header(request);
// ---------- SEND THE BODY ---------- //
/* Empty file */
if (numchunks == 0) {
/* Allocate space for the response buffer */
buffer = ngx_pcalloc(request->pool, sizeof(ngx_buf_t));
if (buffer == NULL) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Failed to allocate response buffer");
gridfile_destroy(&gfile);
gridfs_destroy(&gfs);
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
buffer->pos = NULL;
buffer->last = NULL;
buffer->memory = 1;
buffer->last_buf = 1;
out.buf = buffer;
out.next = NULL;
gridfile_destroy(&gfile);
gridfs_destroy(&gfs);
return ngx_http_output_filter(request, &out);
}
cursors = (mongo_cursor **)ngx_pcalloc(request->pool, sizeof(mongo_cursor *) * numchunks);
if (cursors == NULL) {
gridfile_destroy(&gfile);
gridfs_destroy(&gfs);
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
ngx_memzero( cursors, sizeof(mongo_cursor *) * numchunks);
/* Hook in the cleanup function */
gridfs_cln = ngx_pool_cleanup_add(request->pool, sizeof(ngx_http_gridfs_cleanup_t));
if (gridfs_cln == NULL) {
gridfile_destroy(&gfile);
gridfs_destroy(&gfs);
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
gridfs_cln->handler = ngx_http_gridfs_cleanup;
gridfs_clndata = gridfs_cln->data;
gridfs_clndata->cursors = cursors;
gridfs_clndata->numchunks = numchunks;
/* Read and serve chunk by chunk */
for (i = 0; i < numchunks; i++) {
/* Allocate space for the response buffer */
buffer = ngx_pcalloc(request->pool, sizeof(ngx_buf_t));
if (buffer == NULL) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Failed to allocate response buffer");
gridfile_destroy(&gfile);
gridfs_destroy(&gfs);
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
/* Fetch the chunk from mongo */
do {
e = FALSE;
cursors[i] = gridfile_get_chunks(&gfile, i, 1);
if (!(cursors[i] && mongo_cursor_next(cursors[i]) == MONGO_OK)) {
e = TRUE; ecounter++;
if (ecounter > MONGO_MAX_RETRIES_PER_REQUEST
|| ngx_http_mongo_reconnect(request->connection->log, mongo_conn) == NGX_ERROR
|| ngx_http_mongo_reauth(request->connection->log, mongo_conn) == NGX_ERROR) {
ngx_log_error(NGX_LOG_ERR, request->connection->log, 0,
"Mongo connection dropped, could not reconnect");
if(mongo_conn->conn.connected) { mongo_disconnect(&mongo_conn->conn); }
gridfile_destroy(&gfile);
gridfs_destroy(&gfs);
return NGX_HTTP_SERVICE_UNAVAILABLE;
}
}
} while (e);
chunk = cursors[i]->current;
bson_find(&it, &chunk, "data");
chunk_len = bson_iterator_bin_len( &it ); // break ngx_http_gridfs_module.c:1099
chunk_data = bson_iterator_bin_data( &it );
if (range_start == 0 && range_end == 0) {
/* <<no range request>> */
/* Set up the buffer chain */
buffer->pos = (u_char*)chunk_data;
buffer->last = (u_char*)chunk_data + chunk_len;
buffer->memory = 1;
buffer->last_buf = (i == numchunks-1);
out.buf = buffer;
out.next = NULL;
/* Serve the Chunk */
rc = ngx_http_output_filter(request, &out);
} else {
/* <<range request>> */
if ( range_start >= (current_buf_pos+chunk_len) ||
range_end <= current_buf_pos) {
/* no output */
ngx_pfree(request->pool, buffer);
} else {
if (range_start <= current_buf_pos) {
buffer->pos = (u_char*)chunk_data;
} else {
buffer->pos = (u_char*)chunk_data + (range_start - current_buf_pos);
}
if (range_end < (current_buf_pos+chunk_len)) {
buffer->last = (u_char*)chunk_data + (range_end - current_buf_pos + 1);
} else {
buffer->last = (u_char*)chunk_data + chunk_len;
}
if (buffer->pos == buffer->last) {
ngx_log_error(NGX_LOG_ALERT, request->connection->log, 0,
"zero size buf in writer "
"range_start:%d range_end:%d "
"current_buf_pos:%d chunk_len:%d i:%d numchunk:%d",
range_start,range_end,
current_buf_pos, chunk_len,
i,numchunks);
}
buffer->memory = 1;
buffer->last_buf = (i == numchunks-1) || (range_end < (current_buf_pos+chunk_len));
out.buf = buffer;
out.next = NULL;
/* Serve the Chunk */
rc = ngx_http_output_filter(request, &out);
}
}
current_buf_pos += chunk_len;
/* TODO: More Codes to Catch? */
if (rc == NGX_ERROR) {
gridfile_destroy(&gfile);
gridfs_destroy(&gfs);
return NGX_ERROR;
}
}
gridfile_destroy(&gfile);
gridfs_destroy(&gfs);
return rc;
}
static int
ngx_http_lua_ngx_redirect(lua_State *L)
{
ngx_http_lua_ctx_t *ctx;
ngx_int_t rc;
int n;
u_char *p;
u_char *uri;
size_t len;
ngx_http_request_t *r;
n = lua_gettop(L);
if (n != 1 && n != 2) {
return luaL_error(L, "expecting one or two arguments");
}
p = (u_char *) luaL_checklstring(L, 1, &len);
if (n == 2) {
rc = (ngx_int_t) luaL_checknumber(L, 2);
if (rc != NGX_HTTP_MOVED_TEMPORARILY &&
rc != NGX_HTTP_MOVED_PERMANENTLY)
{
return luaL_error(L, "only ngx.HTTP_MOVED_TEMPORARILY and "
"ngx.HTTP_MOVED_PERMANENTLY are allowed");
}
} else {
rc = NGX_HTTP_MOVED_TEMPORARILY;
}
r = ngx_http_lua_get_req(L);
if (r == NULL) {
return luaL_error(L, "no request object found");
}
ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module);
if (ctx == NULL) {
return luaL_error(L, "no request ctx found");
}
ngx_http_lua_check_context(L, ctx, NGX_HTTP_LUA_CONTEXT_REWRITE
| NGX_HTTP_LUA_CONTEXT_ACCESS
| NGX_HTTP_LUA_CONTEXT_CONTENT);
ngx_http_lua_check_if_abortable(L, ctx);
if (r->header_sent) {
return luaL_error(L, "attempt to call ngx.redirect after sending out "
"the headers");
}
uri = ngx_palloc(r->pool, len);
if (uri == NULL) {
return luaL_error(L, "out of memory");
}
ngx_memcpy(uri, p, len);
r->headers_out.location = ngx_list_push(&r->headers_out.headers);
if (r->headers_out.location == NULL) {
return luaL_error(L, "out of memory");
}
r->headers_out.location->hash = ngx_http_lua_location_hash;
#if 0
dd("location hash: %lu == %lu",
(unsigned long) r->headers_out.location->hash,
(unsigned long) ngx_hash_key_lc((u_char *) "Location",
sizeof("Location") - 1));
#endif
r->headers_out.location->value.len = len;
r->headers_out.location->value.data = uri;
ngx_str_set(&r->headers_out.location->key, "Location");
r->headers_out.status = rc;
ctx->exit_code = rc;
ctx->exited = 1;
ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"lua redirect to \"%V\" with code %i",
&r->headers_out.location->value, ctx->exit_code);
return lua_yield(L, 0);
}
static ngx_int_t
process_header(ngx_http_request_t *r)
{
ngx_int_t rc;
ngx_uint_t i;
ngx_table_elt_t *h;
ngx_http_upstream_header_t *hh;
ngx_http_upstream_main_conf_t *umcf;
umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);
for ( ;; ) {
#if NGINX_VERSION_NUM >= 7000
rc = ngx_http_parse_header_line(r, &r->upstream->buffer, 1);
#else
rc = ngx_http_parse_header_line(r, &r->upstream->buffer);
#endif
if (rc == NGX_OK) {
/* a header line has been parsed successfully */
h = ngx_list_push(&r->upstream->headers_in.headers);
if (h == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
h->hash = r->header_hash;
h->key.len = r->header_name_end - r->header_name_start;
h->value.len = r->header_end - r->header_start;
h->key.data = ngx_palloc(r->pool,
h->key.len + 1 + h->value.len + 1 + h->key.len);
if (h->key.data == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
h->value.data = h->key.data + h->key.len + 1;
h->lowcase_key = h->key.data + h->key.len + 1 + h->value.len + 1;
ngx_cpystrn(h->key.data, r->header_name_start, h->key.len + 1);
ngx_cpystrn(h->value.data, r->header_start, h->value.len + 1);
if (h->key.len == r->lowcase_index) {
ngx_memcpy(h->lowcase_key, r->lowcase_header, h->key.len);
} else {
for (i = 0; i < h->key.len; i++) {
h->lowcase_key[i] = ngx_tolower(h->key.data[i]);
}
}
hh = ngx_hash_find(&umcf->headers_in_hash, h->hash,
h->lowcase_key, h->key.len);
if (hh && hh->handler(r, h, hh->offset) != NGX_OK) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"http scgi header: \"%V: %V\"",
&h->key, &h->value);
continue;
}
if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
/* a whole header has been parsed successfully */
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"http scgi header done");
/*
* if no "Server" and "Date" in header line,
* then add the default headers
*/
if (r->upstream->headers_in.server == NULL) {
h = ngx_list_push(&r->upstream->headers_in.headers);
if (h == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
h->hash = ngx_hash(ngx_hash(ngx_hash(ngx_hash(
ngx_hash('s', 'e'), 'r'), 'v'), 'e'), 'r');
h->key.len = sizeof("Server") - 1;
h->key.data = (u_char *) "Server";
h->value.data = (u_char *) (NGINX_VER " + Phusion Passenger " PASSENGER_VERSION " (mod_rails/mod_rack)");
h->value.len = ngx_strlen(h->value.data);
h->lowcase_key = (u_char *) "server";
}
if (r->upstream->headers_in.date == NULL) {
h = ngx_list_push(&r->upstream->headers_in.headers);
if (h == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
h->hash = ngx_hash(ngx_hash(ngx_hash('d', 'a'), 't'), 'e');
h->key.len = sizeof("Date") - 1;
h->key.data = (u_char *) "Date";
h->value.len = 0;
h->value.data = NULL;
h->lowcase_key = (u_char *) "date";
}
return NGX_OK;
}
if (rc == NGX_AGAIN) {
return NGX_AGAIN;
}
/* there was error while a header line parsing */
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"upstream sent invalid header");
return NGX_HTTP_UPSTREAM_INVALID_HEADER;
}
}
