nginx-0.0.1-2002-08-15-21:20:26 import
diff --git a/src/http/modules/ngx_http_header_filter.c b/src/http/modules/ngx_http_header_filter.c
new file mode 100644
index 0000000..1742b8b
--- /dev/null
+++ b/src/http/modules/ngx_http_header_filter.c
@@ -0,0 +1,55 @@
+
+
+typedef struct {
+ int len;
+ char *line;
+} line;
+
+
+static line http_codes[] = {
+ { 6, "200 OK" }
+};
+
+
+
+
+int ngx_http_header_filter(ngx_http_request_t *r)
+{
+ int status;
+ ngx_hunk_t *h;
+
+ ngx_test_null(h, ngx_get_hunk(r->pool, 1024, 0, 64), NGX_HTTP_FILTER_ERROR);
+
+ status = r->headers_out->status - GX_HTTP_OK;
+
+ ngx_memcpy(h->pos.mem, "HTTP/1.0 ", 9);
+ h->pos.mem += 9;
+ ngx_memcpy(h->pos.mem, http_codes[status].line, http_codes[status].len);
+ h->pos.mem += http_codes[status].len;
+ *(h->pos.mem++) = CR; *(h->pos.mem++) = LF;
+
+ memcpy(h->pos.mem, "Date: ", 6);
+ h->pos.mem += 6;
+ h->pos.mem += ngx_http_get_time(h->pos.mem, time());
+ *(h->pos.mem++) = CR; *(h->pos.mem++) = LF;
+
+ /* 2^64 is 20 characters */
+ if (r->headers_out->content_length)
+ h->pos.mem += ngx_snprintf(h->pos.mem, 49, "Content-Length: %d" CRLF,
+ r->headers_out->content_length);
+
+ /* check */
+
+ memcpy(h->pos.mem, "Server: ", 8);
+ h->pos.mem += 8;
+ if (r->headers_out->server) {
+ h->pos.mem = ngx_cpystrn(h->pos.mem, r->headers_out->server,
+ h->last.mem - h->pos.mem);
+ check space
+ } else {
+ ngx_memcpy(h->pos.mem, NGINX_VER, sizeof(NGINX_VER));
+ h->pos.mem += sizeof(NGINX_VER);
+ }
+ *(h->pos.mem++) = CR; *(h->pos.mem++) = LF;
+
+}
diff --git a/src/http/modules/ngx_http_index_handler.c b/src/http/modules/ngx_http_index_handler.c
index 498dda6..2d3f366 100644
--- a/src/http/modules/ngx_http_index_handler.c
+++ b/src/http/modules/ngx_http_index_handler.c
@@ -20,10 +20,11 @@
ngx_get_module_loc_conf(r, &ngx_http_index_handler_module);
index_len = (*(r->uri_end - 1) == '/') ? cf->max_index_len : 0;
- name = ngx_palloc(r->pool, r->uri_end - r->uri_start + index_len
- + r->server->doc_root_len);
- if (name == NULL)
- return NGX_ERROR;
+
+ ngx_test_null(name,
+ ngx_palloc(r->pool, r->uri_end - r->uri_start + index_len
+ + r->server->doc_root_len),
+ NGX_HTTP_INTERNAL_SERVER_ERROR);
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);
@@ -39,7 +40,7 @@
if (err == NGX_ENOENT)
return NGX_HTTP_NOT_FOUND;
else
- return NGX_ERROR;
+ return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
if (ngx_is_dir(r->stat)) {
diff --git a/src/http/modules/ngx_http_static_handler.c b/src/http/modules/ngx_http_static_handler.c
new file mode 100644
index 0000000..f2053c4
--- /dev/null
+++ b/src/http/modules/ngx_http_static_handler.c
@@ -0,0 +1,101 @@
+
+#include <ngx_config.h>
+
+#include <ngx_strings.h>
+#include <ngx_open.h>
+#include <ngx_stat.h>
+
+#include <ngx_http.h>
+
+int ngx_http_static_handler(ngx_http_request_t *r)
+{
+ int index_len, err, i;
+ char *name, *loc, *file
+ ngx_file_t fd;
+
+ ngx_http_header_out_t out;
+ ngx_http_event_static_handler_loc_conf_t *cf;
+
+ cf = (ngx_http_event_static_handler_loc_conf_t *)
+ ngx_get_module_loc_conf(r, &ngx_http_event_static_handler_module);
+
+ ngx_assert(r->fd, return NGX_HTTP_INTERNAL_SERVER_ERROR,
+ r->connection->log, "ngx_http_static_handler: no file");
+
+ out.status = NGX_HTTP_OK;
+ out.content_length = r->stat.sb_size;
+ out.last_modified = r->stat.sb_mtime;
+
+ /* */
+ out.content_type = "text/html";
+
+ rc = ngx_send_http_header(&out);
+ if (r->header_only)
+ return rc;
+
+ /* NGX_HTTP_INTERNAL_SERVER_ERROR is too late */
+
+ ngx_test_null(h, ngx_create_hunk(r->pool), NGX_HTTP_INTERNAL_SERVER_ERROR);
+ h->type = NGX_HUNK_FILE | NGX_HUNK_LAST;
+ h->fd = r->fd;
+ h->pos.file = 0;
+ h->end.file = r->stat.sb_size;
+
+ ngx_test_null(ch, ngx_create_chain(r->pool),
+ NGX_HTTP_INTERNAL_SERVER_ERROR);
+ ch->hunk = h;
+ ch->next = NULL;
+
+ return ngx_http_filter(ch);
+}
+
+/*
+
+static void *ngx_create_index_config()
+{
+ ngx_http_index_handler_loc_conf_t *cf;
+
+ ngx_check_null(cf, ngx_alloc(p, sizeof(ngx_http_index_handler_loc_conf)),
+ NULL);
+
+ cf->indices = ngx_create_array(p, sizeof(ngx_http_index_t), 5);
+ if (cf->indices == NULL)
+ return NULL;
+
+ cf->max_index_len = 0;
+
+ return cf;
+}
+
+static void *ngx_merge_index_config()
+{
+ if (p->indices->nelts > 0) {
+
+ copy and check dups
+
+ if (c->max_index_len < c->max_index_len)
+ c->max_index_len < c->max_index_len);
+ }
+}
+
+static void *ngx_set_index()
+{
+ if (*conf == NULL) {
+ cf = ngx_create_index_conf();
+ if (cf == NULL)
+ return "can not create config";
+ }
+
+ while (args) {
+ index = ngx_push_array(cf->indices);
+ index->name = arg;
+ index->len = ngx_strlen(arg) + 1;
+
+ if (cf->max_index_len < index->len)
+ cf->max_index_len = index->len;
+ }
+
+ *conf = cf;
+}
+
+*/
diff --git a/src/http/ngx_http.h b/src/http/ngx_http.h
index 62e10f7..6fa0f78 100644
--- a/src/http/ngx_http.h
+++ b/src/http/ngx_http.h
@@ -23,6 +23,13 @@
typedef struct {
+ void *ctx; /* STUB */
+} ngx_http_module_t;
+
+/* STUB */
+#define ngx_get_module_ctx(r, module) (module)->ctx
+
+typedef struct {
char *buff;
char *pos;
char *last;
diff --git a/src/http/ngx_http_event.c b/src/http/ngx_http_event.c
index 8c3ada8..24cbb56 100644
--- a/src/http/ngx_http_event.c
+++ b/src/http/ngx_http_event.c
@@ -38,10 +38,7 @@
ngx_event_t *ev;
ev = c->read;
-/*
ev->event_handler = ngx_http_init_request;
-*/
- ev->event_handler = NULL;
ev->log->action = "reading client request line";
ngx_log_debug(ev->log, "ngx_http_init_connection: entered");
@@ -62,8 +59,6 @@
#endif
}
-#if 0
-
int ngx_http_init_request(ngx_event_t *ev)
{
ngx_connection_t *c = (ngx_connection_t *) ev->data;
@@ -71,11 +66,13 @@
ngx_log_debug(ev->log, "ngx_http_init_request: entered");
+ ngx_test_null(c->pool, ngx_create_pool(16384, ev->log), -1);
ngx_test_null(r, ngx_pcalloc(c->pool, sizeof(ngx_http_request_t)), -1);
c->data = r;
r->connection = c;
+ ngx_test_null(r->pool, ngx_create_pool(16384, ev->log), -1);
ngx_test_null(r->buff, ngx_palloc(r->pool, sizeof(ngx_buff_t)), -1);
ngx_test_null(r->buff->buff,
ngx_pcalloc(r->pool, sizeof(c->server->buff_size)), -1);
@@ -99,33 +96,15 @@
ngx_log_debug(ev->log, "http process request");
- ngx_log_debug(ev->log, "http: eof:%d, avail:%d", ev->eof, ev->available);
+ n = ngx_event_recv(ev, r->buff->last, r->buff->end - r->buff->last);
- if (ev->eof && ev->available == 0) {
- if (ev->err_no)
- ngx_log_error(NGX_LOG_ERR, ev->log, ev->err_no,
- "ngx_http_process_request: "
- "read failed while %s", ev->action);
+ if (n == -2)
+ return 0;
+ if (n == -1)
return -1;
- }
- if ((n = read(c->fd, r->buff->last, r->buff->end - r->buff->last)) == -1) {
-
- if (errno == NGX_EWOULDBLOCK) {
- ngx_log_error(NGX_LOG_INFO, ev->log, errno,
- "ngx_http_process_request: "
- "EAGAIN while %s", ev->action);
- return 0;
- }
-
- ngx_log_error(NGX_LOG_ERR, ev->log, errno,
- "ngx_http_process_request: "
- "read failed while %s", ev->action);
- return -1;
- }
-
- ngx_log_debug(ev->log, "http read %d", n);
+ ngx_log_debug(ev->log, "http read %d" _ n);
if (n == 0) {
if (ev->unexpected_eof) {
@@ -138,8 +117,6 @@
return ngx_http_close_request(ev);
}
- n == r->buff->end - r->buff->last;
-
if (!ev->read_discarded) {
r->buff->last += n;
@@ -168,8 +145,8 @@
if ((n = ngx_read_http_request_line(r)) == 1) {
*r->uri_end = '\0';
- ngx_log_debug(r->connection->log, "HTTP: %d, %d, %s",
- r->method, r->http_version, r->uri_start);
+ ngx_log_debug(r->connection->log, "HTTP: %d, %d, %s" _
+ r->method _ r->http_version _ r->uri_start);
r->state_handler = ngx_process_http_request_header;
r->connection->read->action = "reading client request headers";
}
@@ -184,8 +161,8 @@
while ((n = ngx_read_http_header_line(r)) == 1) {
*r->header_name_end = '\0';
*r->header_end = '\0';
- ngx_log_debug(r->connection->log, "HTTP header: '%s: %s'",
- r->header_name_start, r->header_start);
+ ngx_log_debug(r->connection->log, "HTTP header: '%s: %s'" _
+ r->header_name_start _ r->header_start);
}
if (n != 2)
@@ -203,6 +180,13 @@
static int ngx_process_http_request(ngx_http_request_t *r)
{
+ return -1;
+}
+
+#if 0
+
+static int ngx_process_http_request(ngx_http_request_t *r)
+{
int fd;
struct stat sb;
ngx_http_header_out_t *header_out;
@@ -258,6 +242,8 @@
return 0;
}
+#endif
+
static int ngx_http_close_request(ngx_event_t *ev)
{
ngx_connection_t *c = (ngx_connection_t *) ev->data;
@@ -269,5 +255,3 @@
return ngx_event_close(ev);
}
-
-#endif
diff --git a/src/http/ngx_http_filter.h b/src/http/ngx_http_filter.h
new file mode 100644
index 0000000..9d0a53b
--- /dev/null
+++ b/src/http/ngx_http_filter.h
@@ -0,0 +1,10 @@
+#ifndef _NGX_HTTP_FILTER_H_INCLUDED_
+#define _NGX_HTTP_FILTER_H_INCLUDED_
+
+
+#define NGX_HTTP_FILTER_ERROR -1
+#define NGX_HTTP_FILTER_AGAIN 0
+#define NGX_HTTP_FILTER_DONE 1
+
+
+#endif /* _NGX_HTTP_FILTER_H_INCLUDED_ */
diff --git a/src/http/ngx_http_parse.c b/src/http/ngx_http_parse.c
new file mode 100644
index 0000000..6bfab9b
--- /dev/null
+++ b/src/http/ngx_http_parse.c
@@ -0,0 +1,475 @@
+
+#include <ngx_config.h>
+#include <ngx_http.h>
+
+int ngx_read_http_request_line(ngx_http_request_t *r)
+{
+ char ch;
+ char *buff = r->buff->buff;
+ char *p = r->buff->pos;
+ enum {
+ rl_start = 0,
+ rl_space_after_method,
+ rl_spaces_before_uri,
+ rl_after_slash_in_uri,
+ rl_check_uri,
+ rl_uri,
+ rl_http_09,
+ rl_http_version,
+ rl_first_major_digit,
+ rl_major_digit,
+ rl_first_minor_digit,
+ rl_minor_digit,
+ rl_almost_done,
+ rl_done
+ } state = r->state;
+
+ while (p < r->buff->last && state < rl_done) {
+ ch = *p++;
+
+/*
+printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
+ state, p, r->buff->last, ch, p);
+*/
+
+ /* GCC complie it as jump table */
+
+ switch (state) {
+
+ /* HTTP methods: GET, HEAD, POST */
+ case rl_start:
+ switch (ch) {
+ case 'G':
+ if (p + 1 >= r->buff->last)
+ return 0;
+
+ if (*p != 'E' || *(p + 1) != 'T')
+ return NGX_HTTP_INVALID_METHOD;
+
+ r->method = NGX_HTTP_GET;
+ p += 2;
+ break;
+
+ case 'H':
+ if (p + 2 >= r->buff->last)
+ return 0;
+
+ if (*p != 'E' || *(p + 1) != 'A' || *(p + 2) != 'D')
+ return NGX_HTTP_INVALID_METHOD;
+
+ r->method = NGX_HTTP_HEAD;
+ p += 3;
+ break;
+
+ case 'P':
+ if (p + 2 >= r->buff->last)
+ return 0;
+
+ if (*p != 'O' || *(p + 1) != 'S' || *(p + 2) != 'T')
+ return NGX_HTTP_INVALID_METHOD;
+
+ r->method = NGX_HTTP_POST;
+ p += 3;
+ break;
+
+ default:
+ return NGX_HTTP_INVALID_METHOD;
+ }
+
+ state = rl_space_after_method;
+ break;
+
+ /* single space after method */
+ case rl_space_after_method:
+ switch (ch) {
+ case ' ':
+ state = rl_spaces_before_uri;
+ break;
+ default:
+ return NGX_HTTP_INVALID_METHOD;
+ }
+ break;
+
+ /* space* before URI */
+ case rl_spaces_before_uri:
+ switch (ch) {
+ case '/':
+ r->uri_start = p - 1;
+ state = rl_after_slash_in_uri;
+ break;
+ case ' ':
+ break;
+ default:
+ r->unusual_uri = 1;
+ r->uri_start = p - 1;
+ state = rl_uri;
+ break;
+ }
+ break;
+
+ /* check dot after slash */
+ case rl_after_slash_in_uri:
+ switch (ch) {
+ case CR:
+ r->uri_end = p - 1;
+ r->http_minor = 9;
+ state = rl_almost_done;
+ break;
+ case LF:
+ r->uri_end = p - 1;
+ r->http_minor = 9;
+ state = rl_done;
+ break;
+ case ' ':
+ r->uri_end = p - 1;
+ state = rl_http_09;
+ break;
+ case '.':
+ r->complex_uri = 1;
+ state = rl_uri;
+ break;
+ case '/':
+ r->complex_uri = 1;
+ state = rl_uri;
+ break;
+ case '?':
+ r->args_start = p;
+ state = rl_uri;
+ break;
+ default:
+ state = rl_check_uri;
+ break;
+ }
+ break;
+
+ /* check slash in URI */
+ case rl_check_uri:
+ switch (ch) {
+ case CR:
+ r->uri_end = p - 1;
+ r->http_minor = 9;
+ state = rl_almost_done;
+ break;
+ case LF:
+ r->uri_end = p - 1;
+ r->http_minor = 9;
+ state = rl_done;
+ break;
+ case ' ':
+ r->uri_end = p - 1;
+ state = rl_http_09;
+ break;
+ case '.':
+ r->uri_ext = p;
+ break;
+ case '/':
+ r->uri_ext = NULL;
+ state = rl_after_slash_in_uri;
+ break;
+ case '?':
+ r->args_start = p;
+ state = rl_uri;
+ break;
+ }
+ break;
+
+ /* URI */
+ case rl_uri:
+ switch (ch) {
+ case CR:
+ r->uri_end = p - 1;
+ r->http_minor = 9;
+ state = rl_almost_done;
+ break;
+ case LF:
+ r->uri_end = p - 1;
+ r->http_minor = 9;
+ state = rl_done;
+ break;
+ case ' ':
+ r->uri_end = p - 1;
+ state = rl_http_09;
+ break;
+ }
+ break;
+
+ /* space+ after URI */
+ case rl_http_09:
+ switch (ch) {
+ case ' ':
+ break;
+ case CR:
+ r->http_minor = 9;
+ state = rl_almost_done;
+ break;
+ case LF:
+ r->http_minor = 9;
+ state = rl_done;
+ break;
+ case 'H':
+ state = rl_http_version;
+ break;
+ default:
+ return NGX_HTTP_INVALID_REQUEST;
+ }
+ break;
+
+ /* TTP/ */
+ case rl_http_version:
+ if (p + 2 >= r->buff->last) {
+ r->state = rl_http_version;
+ r->buff->pos = p - 1;
+ return 0;
+ }
+
+ if (ch != 'T' || *p != 'T' || *(p + 1) != 'P' || *(p + 2) != '/')
+ return NGX_HTTP_INVALID_REQUEST;
+
+ p += 3;
+ state = rl_first_major_digit;
+ break;
+
+ /* first digit of major HTTP version */
+ case rl_first_major_digit:
+ if (ch < '1' || ch > '9')
+ return NGX_HTTP_INVALID_REQUEST;
+
+ r->http_major = ch - '0';
+ state = rl_major_digit;
+ break;
+
+ /* major HTTP version or dot */
+ case rl_major_digit:
+ if (ch == '.') {
+ state = rl_first_minor_digit;
+ break;
+ }
+
+ if (ch < '0' || ch > '9')
+ return NGX_HTTP_INVALID_REQUEST;
+
+ r->http_major = r->http_major * 10 + ch - '0';
+ break;
+
+ /* first digit of minor HTTP version */
+ case rl_first_minor_digit:
+ if (ch < '0' || ch > '9')
+ return NGX_HTTP_INVALID_REQUEST;
+
+ r->http_minor = ch - '0';
+
+ state = rl_minor_digit;
+ break;
+
+ /* minor HTTP version or end of request line */
+ case rl_minor_digit:
+ if (ch == CR) {
+ state = rl_almost_done;
+ break;
+ }
+
+ if (ch == LF) {
+ state = rl_done;
+ break;
+ }
+
+ if (ch < '0' || ch > '9')
+ return NGX_HTTP_INVALID_REQUEST;
+
+ r->http_minor = r->http_minor * 10 + ch - '0';
+ break;
+
+ /* end of request line */
+ case rl_almost_done:
+ switch (ch) {
+ case LF:
+ state = rl_done;
+ break;
+ default:
+ return NGX_HTTP_INVALID_METHOD;
+ }
+ break;
+ }
+ }
+
+ r->buff->pos = p;
+
+ if (state == rl_done) {
+ r->http_version = r->http_major * 1000 + r->http_minor;
+ r->state = rl_start;
+ return 1;
+ } else {
+ r->state = state;
+ return 0;
+ }
+}
+
+int ngx_read_http_header_line(ngx_http_request_t *r)
+{
+ char c, ch;
+ char *buff = r->buff->buff;
+ char *p = r->buff->pos;
+ enum {
+ hl_start = 0,
+ hl_name,
+ hl_space_before_value,
+ hl_value,
+ hl_space_after_value,
+ hl_almost_done,
+ header_almost_done,
+ hl_done,
+ header_done
+ } state = r->state;
+
+ while (p < r->buff->last && state < hl_done) {
+ ch = *p++;
+
+/*
+printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
+ state, p, r->buff->last, ch, p);
+*/
+
+ switch (state) {
+
+ /* first char */
+ case hl_start:
+ switch (ch) {
+ case CR:
+ r->header_end = p - 1;
+ state = header_almost_done;
+ break;
+ case LF:
+ r->header_end = p - 1;
+ state = header_done;
+ break;
+ default:
+ state = hl_name;
+ r->header_name_start = p - 1;
+
+ c = ch | 0x20;
+ if (c >= 'a' && c <= 'z')
+ break;
+
+ if (ch == '-')
+ break;
+
+ if (ch >= '0' && ch <= '9')
+ break;
+
+ return NGX_HTTP_INVALID_HEADER;
+
+ }
+ break;
+
+ /* header name */
+ case hl_name:
+ c = ch | 0x20;
+ if (c >= 'a' && c <= 'z')
+ break;
+
+ if (ch == ':') {
+ r->header_name_end = p - 1;
+ state = hl_space_before_value;
+ break;
+ }
+
+ if (ch == '-')
+ break;
+
+ if (ch >= '0' && ch <= '9')
+ break;
+
+ return NGX_HTTP_INVALID_HEADER;
+
+ /* space* before header value */
+ case hl_space_before_value:
+ switch (ch) {
+ case ' ':
+ break;
+ case CR:
+ r->header_start = r->header_end = p - 1;
+ state = hl_almost_done;
+ break;
+ case LF:
+ r->header_start = r->header_end = p - 1;
+ state = hl_done;
+ break;
+ default:
+ r->header_start = p - 1;
+ state = hl_value;
+ break;
+ }
+ break;
+
+ /* header value */
+ case hl_value:
+ switch (ch) {
+ case ' ':
+ r->header_end = p - 1;
+ state = hl_space_after_value;
+ break;
+ case CR:
+ r->header_end = p - 1;
+ state = hl_almost_done;
+ break;
+ case LF:
+ r->header_end = p - 1;
+ state = hl_done;
+ break;
+ }
+ break;
+
+ /* space* before end of header line */
+ case hl_space_after_value:
+ switch (ch) {
+ case ' ':
+ break;
+ case CR:
+ state = hl_almost_done;
+ break;
+ case LF:
+ state = hl_done;
+ break;
+ default:
+ state = hl_value;
+ break;
+ }
+ break;
+
+ /* end of header line */
+ case hl_almost_done:
+ switch (ch) {
+ case LF:
+ state = hl_done;
+ break;
+ default:
+ return NGX_HTTP_INVALID_HEADER;
+ }
+ break;
+
+ /* end of header */
+ case header_almost_done:
+ switch (ch) {
+ case LF:
+ state = header_done;
+ break;
+ default:
+ return NGX_HTTP_INVALID_HEADER;
+ }
+ break;
+ }
+ }
+
+ r->buff->pos = p;
+
+ if (state == hl_done) {
+ r->state = hl_start;
+ return 1;
+ } else if (state == header_done) {
+ r->state = hl_start;
+ return 2;
+ } else {
+ r->state = state;
+ return 0;
+ }
+}
diff --git a/src/http/ngx_http_write_filter.c b/src/http/ngx_http_write_filter.c
new file mode 100644
index 0000000..5e4eaa6
--- /dev/null
+++ b/src/http/ngx_http_write_filter.c
@@ -0,0 +1,82 @@
+
+#include <ngx_config.h>
+
+#include <ngx_hunk.h>
+#include <ngx_http.h>
+#include <ngx_http_filter.h>
+#include <ngx_event_write.h>
+
+#include <ngx_http_write_filter.h>
+
+
+ngx_http_module_t ngx_http_write_filter_module;
+
+
+/* STUB */
+static ngx_http_write_filter_ctx_t module_ctx;
+
+void ngx_http_write_filter_init()
+{
+ module_ctx.buffer_output = 10240;
+ module_ctx.out = NULL;
+
+ ngx_http_write_filter_module.ctx = &module_ctx;
+}
+/* */
+
+
+int ngx_http_write_filter(ngx_http_request_t *r, ngx_chain_t *in)
+{
+ int last;
+ off_t size, flush;
+ ngx_chain_t *ch, **prev, *chain;
+ ngx_http_write_filter_ctx_t *ctx;
+
+ ctx = (ngx_http_write_filter_ctx_t *)
+ ngx_get_module_ctx(r->main ? r->main : r,
+ &ngx_http_write_filter_module);
+ size = flush = 0;
+ last = 0;
+ prev = &ctx->out;
+
+ /* find size, flush point and last link of saved chain */
+ for (ch = ctx->out; ch; ch = ch->next) {
+ prev = &ch->next;
+ size += ch->hunk->last.file - ch->hunk->pos.file;
+
+ if (ch->hunk->type & NGX_HUNK_FLUSH)
+ flush = size;
+
+ if (ch->hunk->type & NGX_HUNK_LAST)
+ last = 1;
+ }
+
+ /* add new chain to existent one */
+ for (/* void */; in; in = in->next) {
+ ngx_test_null(ch, ngx_palloc(r->pool, sizeof(ngx_chain_t)),
+ NGX_HTTP_FILTER_ERROR);
+
+ ch->hunk = in->hunk;
+ ch->next = NULL;
+ *prev = ch;
+ prev = &ch->next;
+ size += ch->hunk->last.file - ch->hunk->pos.file;
+
+ if (ch->hunk->type & NGX_HUNK_FLUSH)
+ flush = size;
+
+ if (ch->hunk->type & NGX_HUNK_LAST)
+ last = 1;
+ }
+
+ if (flush == 0 && size < ctx->buffer_output)
+ return NGX_HTTP_FILTER_DONE;
+
+ chain = ngx_event_write(r->connection, ctx->out, flush);
+ if (chain == (ngx_chain_t *) -1)
+ return NGX_HTTP_FILTER_ERROR;
+
+ ctx->out = chain;
+
+ return (chain ? NGX_HTTP_FILTER_AGAIN : NGX_HTTP_FILTER_DONE);
+}
diff --git a/src/http/ngx_http_write_filter.h b/src/http/ngx_http_write_filter.h
new file mode 100644
index 0000000..6a2c6f2
--- /dev/null
+++ b/src/http/ngx_http_write_filter.h
@@ -0,0 +1,11 @@
+#ifndef _NGX_HTTP_WRITE_FILTER_H_INCLUDED_
+#define _NGX_HTTP_WRITE_FILTER_H_INCLUDED_
+
+
+typedef struct {
+ ngx_chain_t *out;
+ size_t buffer_output;
+} ngx_http_write_filter_ctx_t;
+
+
+#endif /* _NGX_HTTP_WRITE_FILTER_H_INCLUDED_ */
