Fijxu
/
nginx-quic
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

nginx-0.0.1-2002-09-11-19:18:33 import

This commit is contained in:
Igor Sysoev 2002-09-11 15:18:33 +00:00
parent 465a2b28ae
commit 28db32ce4f
18 changed files with 419 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/core/ngx_alloc.c
View File

@ -15,7 +15,7 @@ void *ngx_alloc(size_t size, ngx_log_t *log)
ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
"malloc() %d bytes failed", size);
ngx_log_debug(log, "malloc: %x" _ p);
ngx_log_debug(log, "malloc: %x:%d" _ p _ size);
return p;
}
@ -51,10 +51,13 @@ void ngx_destroy_pool(ngx_pool_t *pool)
ngx_pool_t *p, *n;
ngx_pool_large_t *l;
for (l = pool->large; l; l = l->next)
for (l = pool->large; l; l = l->next) {
ngx_log_debug(pool->log, "free: %x" _ l->alloc);
free(l->alloc);
}
for (p = pool, n = pool->next; /* void */; p = n, n = n->next) {
ngx_log_debug(pool->log, "free: %x" _ p);
free(p);
if (n == NULL)
@ -110,6 +113,7 @@ void *ngx_palloc(ngx_pool_t *pool, size_t size)
if (large == NULL) {
ngx_test_null(large, ngx_palloc(pool, sizeof(ngx_pool_large_t)),
NULL);
large->next = NULL;
}
ngx_test_null(p, ngx_alloc(size, pool->log), NULL);

14
src/core/ngx_config_command.c Normal file
View File

@ -0,0 +1,14 @@
#include <ngx_config.h>
char *ngx_conf_set_size_slot(char *conf, int offset, char *value)
{
int size;
size = atoi(value);
if (size < 0)
return "value must be greater or equal to zero";
*(int *) (conf + offset) = size;
return NULL;
}

22
src/core/ngx_config_command.h Normal file
View File

@ -0,0 +1,22 @@
#ifndef _NGX_HTTP_CONFIG_COMMAND_H_INCLUDED_
#define _NGX_HTTP_CONFIG_COMMAND_H_INCLUDED_
#define NGX_CONF_TAKE1 0
#define NGX_CONF_ITERATE 0
#define NGX_CONF_UNSET -1
typedef struct {
char *name;
char *(*set)();
int offset;
int zone;
int type;
char *description;
} ngx_command_t;
char *ngx_conf_set_size_slot(char *conf, int offset, char *value);
#endif _NGX_HTTP_CONFIG_COMMAND_H_INCLUDED_

7
src/core/ngx_core.h
View File

@ -2,9 +2,10 @@
#define _NGX_CORE_H_INCLUDED_
#define NGX_OK 0
#define NGX_ERROR -1
#define NGX_AGAIN -2
#define NGX_OK 0
#define NGX_ERROR -1
#define NGX_AGAIN -2
#define NGX_DECLINED -3
#endif /* _NGX_CORE_H_INCLUDED_ */

169
src/http/modules/ngx_http_index_handler.c
View File

@ -1,23 +1,53 @@
#include <ngx_config.h>
#include <ngx_strings.h>
#include <ngx_open.h>
#include <ngx_stat.h>
#include <ngx_core.h>
#include <ngx_errno.h>
#include <ngx_string.h>
#include <ngx_files.h>
#include <ngx_config_command.h>
#include <ngx_http.h>
#include <ngx_http_config.h>
#include <ngx_http_index_handler.h>
static void *ngx_http_index_create_conf(ngx_pool_t *pool);
static char *ngx_http_index_set_index(ngx_pool_t *p, void *conf, char *value);
static ngx_command_t ngx_http_index_commands[];
ngx_http_module_t ngx_http_index_module = {
NGX_HTTP_MODULE,
NULL, /* create server config */
ngx_http_index_create_conf, /* create location config */
ngx_http_index_commands, /* module directives */
NULL, /* init module */
NULL, /* init output body filter */
};
static ngx_command_t ngx_http_index_commands[] = {
{"index", ngx_http_index_set_index, NULL,
NGX_HTTP_LOC_CONF, NGX_CONF_ITERATE,
"set index files"},
{NULL}
};
int ngx_http_index_handler(ngx_http_request_t *r)
{
int index_len, err, i;
char *name, *loc, *file
ngx_file_t fd;
int index_len, i;
char *name, *loc, *file;
ngx_err_t err;
ngx_fd_t fd;
ngx_http_index_t *index;
ngx_http_index_handler_loc_conf_t *cf;
ngx_http_index_file_t *index;
ngx_http_index_conf_t *cf;
cf = (ngx_http_index_handler_loc_conf_t *)
ngx_get_module_loc_conf(r, &ngx_http_index_handler_module);
cf = (ngx_http_index_conf_t *)
ngx_get_module_loc_conf(r, ngx_http_index_module);
index_len = (*(r->uri_end - 1) == '/') ? cf->max_index_len : 0;
@ -29,96 +59,73 @@ int ngx_http_index_handler(ngx_http_request_t *r)
loc = ngx_cpystrn(name, r->server->doc_root, r->server->doc_root_len);
file = ngx_cpystrn(loc, r->uri_start, r->uri_end - r->uri_start + 1);
/* URI without / on the end - check directory */
if (index_len == 0) {
if (ngx_stat(name, &r->stat) == -1) {
err = ngx_errno;
ngx_log_error(GX_LOG_ERR, r->connection->log, err,
"ngx_http_handler: " ngx_stat_n " %s failed", name);
if (err == NGX_ENOENT)
return NGX_HTTP_NOT_FOUND;
else
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
if (ngx_is_dir(r->stat)) {
*file++ = '/';
*file = '\0';
r->headers_out->location = loc;
return NGX_HTTP_MOVED_PERMANENTLY;
}
r->file = name;
r->stat_valid = 1;
return NGX_OK;
}
/* look for index file */
index = (ngx_http_index_t *) cf->indices->elts;
index = (ngx_http_index_file_t *) cf->indices->elts;
for (i = 0; i < cf->indices->nelts; i++) {
ngx_memcpy(file, index[i].name; index[i].len);
ngx_memcpy(file, index[i].name, index[i].len);
fd = ngx_open(name, O_RDONLY);
if (fd != -1) {
r->file = name;
r->fd = fd;
return NGX_OK;
fd = ngx_open_file(name, NGX_FILE_RDONLY);
if (fd == -1) {
err = ngx_errno;
if (err == NGX_ENOENT)
continue;
ngx_log_error(NGX_LOG_ERR, r->connection->log, err,
ngx_open_file_n " %s failed", name);
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
r->filename = name;
r->fd = fd;
return ngx_http_internal_redirect(r, loc);
}
return NGX_HTTP_FORBIDDEN;
return NGX_DECLINED;
}
/*
static void *ngx_create_index_config()
static void *ngx_http_index_create_conf(ngx_pool_t *pool)
{
ngx_http_index_handler_loc_conf_t *cf;
ngx_http_index_conf_t *conf;
ngx_check_null(cf, ngx_alloc(p, sizeof(ngx_http_index_handler_loc_conf)),
NULL);
ngx_test_null(conf, ngx_pcalloc(pool, sizeof(ngx_http_index_conf_t)), NULL);
cf->indices = ngx_create_array(p, sizeof(ngx_http_index_t), 5);
if (cf->indices == NULL)
return NULL;
ngx_test_null(conf->indices,
ngx_create_array(pool, sizeof(ngx_http_index_file_t), 3),
NULL);
cf->max_index_len = 0;
return cf;
return conf;
}
static void *ngx_merge_index_config()
static void *ngx_http_index_merge_conf(ngx_pool_t *p, void *parent, void *child)
{
if (p->indices->nelts > 0) {
ngx_http_index_conf_t *prev = (ngx_http_index_conf_t *) parent;
ngx_http_index_conf_t *conf = (ngx_http_index_conf_t *) child;
ngx_http_index_file_t *index;
copy and check dups
if (conf->max_index_len == 0) {
if (prev->max_index_len != 0)
return prev;
if (c->max_index_len < c->max_index_len)
c->max_index_len < c->max_index_len);
ngx_test_null(index, ngx_push_array(conf->indices), NULL);
index->name = NGX_HTTP_INDEX;
conf->max_index_len = index->len = sizeof(NGX_HTTP_INDEX);
}
return conf;
}
static void *ngx_set_index()
static char *ngx_http_index_set_index(ngx_pool_t *p, void *conf, char *value)
{
if (*conf == NULL) {
cf = ngx_create_index_conf();
if (cf == NULL)
return "can not create config";
}
ngx_http_index_conf_t *cf = (ngx_http_index_conf_t *) conf;
ngx_http_index_file_t *index;
while (args) {
index = ngx_push_array(cf->indices);
index->name = arg;
index->len = ngx_strlen(arg) + 1;
ngx_test_null(index, ngx_push_array(cf->indices), NULL);
index->name = value;
index->len = strlen(value);
if (cf->max_index_len < index->len)
cf->max_index_len = index->len;
}
if (cf->max_index_len < index->len)
cf->max_index_len = index->len;
*conf = cf;
return NULL;
}
*/

26
src/http/modules/ngx_http_index_handler.h Normal file
View File

@ -0,0 +1,26 @@
#ifndef _NGX_HTTP_INDEX_HANDLER_H_INCLUDED_
#define _NGX_HTTP_INDEX_HANDLER_H_INCLUDED_
#include <ngx_config.h>
#include <ngx_array.h>
#include <ngx_http.h>
#define NGX_HTTP_INDEX "index.html"
typedef struct {
ngx_array_t *indices;
size_t max_index_len;
} ngx_http_index_conf_t;
typedef struct {
char *name;
size_t len;
} ngx_http_index_file_t;
extern ngx_http_module_t ngx_http_index_module;
#endif /* _NGX_HTTP_INDEX_HANDLER_H_INCLUDED_ */

9
src/http/modules/ngx_http_static_handler.c
View File

@ -45,16 +45,17 @@ int ngx_http_static_handler(ngx_http_request_t *r)
ngx_log_error(NGX_LOG_ERR, r->connection->log, ngx_errno,
"ngx_http_static_handler: "
ngx_open_file_n " %s failed", r->filename);
/* STUB */
return -1;
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
if (ngx_stat_fd(r->fd, &r->fileinfo) == -1) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, ngx_errno,
"ngx_http_static_handler: "
ngx_stat_fd_n " %s failed", r->filename);
/* STUB */
return -1;
/* close fd */
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
r->headers_out->status = NGX_HTTP_OK;

12
src/http/ngx_http.c
View File

@ -4,6 +4,7 @@
#include <ngx_socket.h>
#include <ngx_listen.h>
#include <ngx_http.h>
#include <ngx_http_config.h>
extern ngx_array_t *ngx_listening_sockets;
@ -28,13 +29,18 @@ int ngx_http_init(ngx_pool_t *pool, ngx_log_t *log)
#else
ngx_http_server.doc_root = "/home/is/work/xml/site-1.0.0/html";
#endif
ngx_http_server.doc_root = "html";
ngx_http_server.doc_root_len = strlen(ngx_http_server.doc_root) + 1;
ngx_http_output_filter_init();
ngx_http_write_filter_init();
ngx_http_config_modules(pool, ngx_http_modules);
/* STUB */
ngx_http_output_filter_set_stub(pool, ngx_http_modules);
ngx_http_write_filter_set_stub(pool, ngx_http_modules);
ngx_http_index_set_stub(pool, ngx_http_modules);
ngx_http_init_modules(pool, ngx_http_modules);
ngx_http_init_filters(pool, ngx_http_modules);
ls = ngx_push_array(ngx_listening_sockets);
ngx_memzero(ls, sizeof(ngx_listen_t));

21
src/http/ngx_http.h
View File

@ -7,6 +7,7 @@
#include <ngx_hunk.h>
#include <ngx_files.h>
#include <ngx_connection.h>
#include <ngx_config_command.h>
#define NGX_HTTP_GET 1
@ -139,7 +140,13 @@ typedef struct {
typedef struct {
int index;
int index;
void *(*create_srv_conf)(ngx_pool_t *p);
void *(*create_loc_conf)(ngx_pool_t *p);
ngx_command_t *commands;
int (*init_module)(ngx_pool_t *p);
int (*init_output_body_filter)(int (**next_filter)
(ngx_http_request_t *r, ngx_chain_t *ch));
} ngx_http_module_t;
#define NGX_HTTP_MODULE 0
@ -147,6 +154,12 @@ typedef struct {
#define ngx_get_module_loc_conf(r, module) r->loc_conf[module.index]
#define ngx_get_module_ctx(r, module) r->ctx[module.index]
#define ngx_http_create_ctx(r, ctx, module, size) \
do { \
ngx_test_null(ctx, ngx_pcalloc(r->pool, size), NGX_ERROR); \
r->ctx[module.index] = ctx; \
} while (0)
/* STUB */
@ -159,4 +172,10 @@ int ngx_http_init(ngx_pool_t *pool, ngx_log_t *log);
int ngx_http_init_connection(ngx_connection_t *c);
extern int ngx_max_module;
extern ngx_http_module_t *ngx_http_modules[];
#endif /* _NGX_HTTP_H_INCLUDED_ */

114
src/http/ngx_http_config.c Normal file
View File

@ -0,0 +1,114 @@
#include <ngx_core.h>
#include <ngx_config_command.h>
#include <ngx_http.h>
#include <ngx_http_write_filter.h>
#include <ngx_http_output_filter.h>
#include <ngx_http_index_handler.h>
int ngx_max_module;
/* STUB: gobal srv and loc conf */
void **ngx_srv_conf;
void **ngx_loc_conf;
int ngx_http_config_modules(ngx_pool_t *pool, ngx_http_module_t **modules)
{
int i;
for (i = 0; modules[i]; i++) {
modules[i]->index = i;
}
ngx_max_module = i;
ngx_test_null(ngx_srv_conf,
ngx_pcalloc(pool, sizeof(void *) * ngx_max_module),
NGX_ERROR);
ngx_test_null(ngx_loc_conf,
ngx_pcalloc(pool, sizeof(void *) * ngx_max_module),
NGX_ERROR);
for (i = 0; modules[i]; i++) {
if (modules[i]->create_srv_conf)
ngx_srv_conf[i] = modules[i]->create_srv_conf(pool);
if (modules[i]->create_loc_conf)
ngx_loc_conf[i] = modules[i]->create_loc_conf(pool);
}
}
int ngx_http_init_modules(ngx_pool_t *pool, ngx_http_module_t **modules)
{
int i;
for (i = 0; modules[i]; i++) {
if (modules[i]->init_module)
modules[i]->init_module(pool);
}
}
int ngx_http_init_filters(ngx_pool_t *pool, ngx_http_module_t **modules)
{
int i;
int (*filter)(ngx_http_request_t *r, ngx_chain_t *ch);
filter = ngx_http_write_filter;
for (i = 0; modules[i]; i++) {
if (modules[i]->init_output_body_filter)
modules[i]->init_output_body_filter(&filter);
}
}
/* STUB */
ngx_http_output_filter_set_stub(ngx_pool_t *pool, ngx_http_module_t **modules)
{
int i;
ngx_command_t *cmd;
for (i = 0; modules[i]; i++) {
if (modules[i] == &ngx_http_output_filter_module) {
for (cmd = modules[i]->commands; cmd->name; cmd++) {
if (strcmp(cmd->name, "output_buffer") == 0) {
cmd->set(ngx_loc_conf[i], cmd->offset, "32768");
}
}
}
}
}
ngx_http_write_filter_set_stub(ngx_pool_t *pool, ngx_http_module_t **modules)
{
int i;
ngx_command_t *cmd;
for (i = 0; modules[i]; i++) {
if (modules[i] == &ngx_http_write_filter_module) {
for (cmd = modules[i]->commands; cmd->name; cmd++) {
if (strcmp(cmd->name, "write_buffer") == 0) {
cmd->set(ngx_loc_conf[i], cmd->offset, "1500");
}
}
}
}
}
ngx_http_index_set_stub(ngx_pool_t *pool, ngx_http_module_t **modules)
{
int i;
ngx_command_t *cmd;
for (i = 0; modules[i]; i++) {
if (modules[i] == &ngx_http_index_module) {
for (cmd = modules[i]->commands; cmd->name; cmd++) {
if (strcmp(cmd->name, "index") == 0) {
cmd->set(pool, ngx_loc_conf[i], "index.html");
}
}
}
}
}

17
src/http/ngx_http_config.h Normal file
View File

@ -0,0 +1,17 @@
#ifndef _NGX_HTTP_CONFIG_H_INCLUDED_
#define _NGX_HTTP_CONFIG_H_INCLUDED_
#include <ngx_alloc.h>
#include <ngx_http.h>
#define NGX_HTTP_LOC_CONF 0
int ngx_http_config_modules(ngx_pool_t *pool, ngx_http_module_t **modules);
extern void **ngx_srv_conf;
extern void **ngx_loc_conf;
#endif _NGX_HTTP_CONFIG_H_INCLUDED_

24
src/http/ngx_http_event.c
View File

@ -7,13 +7,14 @@
#include <ngx_alloc.h>
#include <ngx_hunk.h>
#include <ngx_connection.h>
#include <ngx_http.h>
#include <ngx_http_config.h>
/* STUB */
#include <ngx_http_output_filter.h>
int ngx_http_static_handler(ngx_http_request_t *r);
int ngx_http_index_handler(ngx_http_request_t *r);
/* */
int ngx_http_init_connection(ngx_connection_t *c);
@ -131,9 +132,15 @@ int ngx_http_init_request(ngx_event_t *ev)
r->connection = c;
r->server = srv;
r->srv_conf = ngx_srv_conf;
r->loc_conf = ngx_loc_conf;
ngx_test_null(r->pool, ngx_create_pool(srv->request_pool_size, ev->log),
ngx_http_close_request(r));
ngx_test_null(r->ctx, ngx_pcalloc(r->pool, sizeof(void *) * ngx_max_module),
ngx_http_close_request(r));
ngx_test_null(r->header_in,
ngx_create_temp_hunk(r->pool, srv->header_buffer_size, 0, 0),
ngx_http_close_request(r));
@ -432,6 +439,16 @@ static int ngx_http_handler(ngx_http_request_t *r)
*/
}
int ngx_http_internal_redirect(ngx_http_request_t *r, char *uri)
{
ngx_log_debug(r->connection->log, "internal redirect: '%s'" _ uri);
r->uri = uri;
r->uri_start = uri;
r->uri_end = uri + strlen(uri);
return ngx_http_handler(r);
}
static int ngx_http_set_default_handler(ngx_http_request_t *r)
{
int err, rc;
@ -442,11 +459,8 @@ static int ngx_http_set_default_handler(ngx_http_request_t *r)
NGX_HTTP_INTERNAL_SERVER_ERROR);
if (*(r->uri_end - 1) == '/') {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
#if 0
r->handler = ngx_http_index_handler;
return NGX_OK;
#endif
}
/* 20 bytes is spare space for some index name, i.e. index.html */

0
src/http/modules/ngx_http_header_filter.c → src/http/ngx_http_header_filter.c
View File

8
src/http/ngx_http_modules.c
View File

@ -1,7 +1,13 @@
#include <ngx_http.h>
extern ngx_http_module_t ngx_http_output_filter_module;
extern ngx_http_module_t ngx_http_write_filter_module;
extern ngx_http_module_t ngx_http_index_module;
ngx_http_module_t *ngx_http_modules[] = {
ngx_http_output_filter_module,
&ngx_http_write_filter_module,
&ngx_http_output_filter_module,
&ngx_http_index_module,
NULL
};

78
src/http/ngx_http_output_filter.c
View File

@ -1,44 +1,48 @@
#include <ngx_core.h>
#include <ngx_files.h>
#include <ngx_string.h>
#include <ngx_hunk.h>
#include <ngx_config_command.h>
#include <ngx_http.h>
#include <ngx_http_config.h>
#include <ngx_http_output_filter.h>
static int ngx_http_output_filter_copy_hunk(ngx_hunk_t *dst, ngx_hunk_t *src);
static int ngx_http_output_filter_init(
int (*next_filter)(ngx_http_request_t *r, ngx_chain_t *ch));
int (**next_filter)(ngx_http_request_t *r, ngx_chain_t *ch));
static void *ngx_http_output_filter_create_conf(ngx_pool_t *pool);
static void *ngx_http_output_filter_set_hunk_size(ngx_pool_t *pool, void *conf,
char *size);
static ngx_command_t ngx_http_output_filter_commands[];
ngx_http_module_t ngx_http_output_filter_module = {
NGX_HTTP_MODULE
NGX_HTTP_MODULE,
NULL, /* create server config */
ngx_http_output_filter_create_conf, /* create location config */
ngx_http_output_filter_commands, /* module directives */
NULL, /* init module */
ngx_http_output_filter_init /* init output body filter */
};
static ngx_command_t ngx_http_output_filter_commands[] = {
{"output_buffer", ngx_conf_set_size_slot,
offsetof(ngx_http_output_filter_conf_t, hunk_size),
NGX_HTTP_LOC_CONF, NGX_CONF_TAKE1,
"set output filter buffer size"},
{NULL}
};
static int (*ngx_http_output_next_filter)(ngx_http_request_t *r,
ngx_chain_t *ch);
/* STUB */
int ngx_http_write_filter(ngx_http_request_t *r, ngx_chain_t *ch);
int ngx_http_output_filter_stub_init(ngx_pool_t *pool, void *loc_conf)
{
ngx_http_output_filter_conf_t *conf;
ngx_http_output_filter_init(ngx_http_write_filter);
conf = ngx_http_output_filter_create_conf(pool);
ngx_http_output_filter_set_hunk_size(pool, conf, "32");
loc_conf = conf;
}
/* */
int ngx_http_output_filter(ngx_http_request_t *r, ngx_hunk_t *hunk)
{
@ -54,9 +58,9 @@ int ngx_http_output_filter(ngx_http_request_t *r, ngx_hunk_t *hunk)
ngx_http_output_filter_module);
if (ctx == NULL) {
ngx_test_null(ctx,
ngx_pcalloc(r->pool, sizeof(ngx_http_output_filter_ctx_t)),
NGX_ERROR);
ngx_http_create_ctx(r, ctx,
ngx_http_output_filter_module,
sizeof(ngx_http_output_filter_ctx_t));
ctx->next_filter = ngx_http_output_next_filter;
}
@ -67,7 +71,7 @@ int ngx_http_output_filter(ngx_http_request_t *r, ngx_hunk_t *hunk)
if (hunk && (hunk->type & NGX_HUNK_LAST))
ctx->last = 1;
for (once = 1; once || ctx->in; once--) {
for (once = 1; once || ctx->in; once = 0) {
/* input chain is not empty */
if (ctx->in) {
@ -267,14 +271,6 @@ static int ngx_http_output_filter_copy_hunk(ngx_hunk_t *dst, ngx_hunk_t *src)
}
static int ngx_http_output_filter_init(
int (*next_filter)(ngx_http_request_t *r, ngx_chain_t *ch))
{
ngx_http_output_next_filter = next_filter;
return NGX_OK;
}
static void *ngx_http_output_filter_create_conf(ngx_pool_t *pool)
{
ngx_http_output_filter_conf_t *conf;
@ -283,18 +279,16 @@ static void *ngx_http_output_filter_create_conf(ngx_pool_t *pool)
ngx_pcalloc(pool, sizeof(ngx_http_output_filter_conf_t)),
NULL);
conf->hunk_size = 16384;
conf->hunk_size = NGX_CONF_UNSET;
return conf;
}
static void *ngx_http_output_filter_set_hunk_size(ngx_pool_t *pool, void *conf,
char *size)
static int ngx_http_output_filter_init(
int (**next_filter)(ngx_http_request_t *r, ngx_chain_t *ch))
{
ngx_http_output_filter_conf_t *cf = (ngx_http_output_filter_conf_t *) conf;
ngx_http_output_next_filter = *next_filter;
*next_filter = NULL;
cf->hunk_size = atoi(size);
if (cf->hunk_size <= 0)
return "Error";
cf->hunk_size *= 1024;
return NULL;
return NGX_OK;
}

2
src/http/ngx_http_output_filter.h
View File

@ -25,5 +25,7 @@ typedef struct {
int ngx_http_output_filter(ngx_http_request_t *r, ngx_hunk_t *hunk);
extern ngx_http_module_t ngx_http_output_filter_module;
#endif /* _NGX_HTTP_OUTPUT_FILTER_H_INCLUDED_ */

50
src/http/ngx_http_write_filter.c
View File

@ -4,17 +4,35 @@
#include <ngx_hunk.h>
#include <ngx_event_write.h>
#include <ngx_http.h>
#include <ngx_http_config.h>
#include <ngx_http_output_filter.h>
#include <ngx_http_write_filter.h>
static ngx_command_t ngx_http_write_filter_commands[];
static void *ngx_http_write_filter_create_conf(ngx_pool_t *pool);
ngx_http_module_t ngx_http_write_filter_module = {
NGX_HTTP_MODULE
NGX_HTTP_MODULE,
NULL, /* create server config */
ngx_http_write_filter_create_conf, /* create location config */
ngx_http_write_filter_commands, /* module directives */
NULL, /* init module */
NULL /* init output body filter */
};
/* STUB */
/* */
static ngx_command_t ngx_http_write_filter_commands[] = {
{"write_buffer", ngx_conf_set_size_slot,
offsetof(ngx_http_write_filter_conf_t, buffer_output),
NGX_HTTP_LOC_CONF, NGX_CONF_TAKE1,
"set write filter size to buffer output"},
{NULL}
};
int ngx_http_write_filter(ngx_http_request_t *r, ngx_chain_t *in)
@ -30,9 +48,9 @@ int ngx_http_write_filter(ngx_http_request_t *r, ngx_chain_t *in)
ngx_get_module_ctx(r->main ? r->main : r,
ngx_http_write_filter_module);
if (ctx == NULL)
ngx_test_null(ctx,
ngx_pcalloc(r->pool, sizeof(ngx_http_write_filter_ctx_t)),
NGX_ERROR);
ngx_http_create_ctx(r, ctx,
ngx_http_write_filter_module,
sizeof(ngx_http_write_filter_ctx_t));
size = flush = 0;
last = 0;
@ -99,22 +117,10 @@ static void *ngx_http_write_filter_create_conf(ngx_pool_t *pool)
ngx_http_write_filter_conf_t *conf;
ngx_test_null(conf,
ngx_pcalloc(pool, sizeof(ngx_http_write_filter_conf_t)),
ngx_palloc(pool, sizeof(ngx_http_write_filter_conf_t)),
NULL);
conf->buffer_output = 16384;
conf->buffer_output = NGX_CONF_UNSET;
return conf;
}
static void *ngx_http_write_filter_set_hunk_size(ngx_pool_t *pool, void *conf,
char *size)
{
ngx_http_write_filter_conf_t *cf = (ngx_http_write_filter_conf_t *) conf;
cf->buffer_output = atoi(size);
if (cf->buffer_output <= 0)
return "Error";
cf->buffer_output *= 1024;
return NULL;
}

2
src/http/ngx_http_write_filter.h
View File

@ -17,5 +17,7 @@ typedef struct {
int ngx_http_write_filter(ngx_http_request_t *r, ngx_chain_t *in);
extern ngx_http_module_t ngx_http_write_filter_module;
#endif /* _NGX_HTTP_WRITE_FILTER_H_INCLUDED_ */