Mercurial > hg > nginx

comparison src/http/ngx_http_output_filter.c @ 8:708f8bb772ec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
nginx-0.0.1-2002-09-02-18:48:24 import
author Igor Sysoev <igor@sysoev.ru>
date Mon, 02 Sep 2002 14:48:24 +0000
parents src/http/ngx_http_filter.c@b5481d6fbbd4
children 6f58641241bb
comparison
equal deleted inserted replaced
7:b5481d6fbbd4 8:708f8bb772ec
1
2
3 #include <ngx_core.h>
4 #include <ngx_files.h>
5 #include <ngx_string.h>
6 #include <ngx_hunk.h>
7 #include <ngx_http.h>
8 #include <ngx_http_output_filter.h>
9
10
11 /* STUB */
12 int ngx_http_write_filter(ngx_http_request_t *r, ngx_chain_t *in);
13
14
15
16 static int ngx_http_output_filter_copy_hunk(ngx_hunk_t *dst, ngx_hunk_t *src);
17
18 ngx_http_module_t ngx_http_output_filter_module;
19
20
21 /* STUB */
22 static ngx_http_output_filter_ctx_t module_ctx;
23
24 void ngx_http_output_filter_init()
25 {
26 module_ctx.hunk_size = 32 * 1024;
27 module_ctx.out.hunk = NULL;
28 module_ctx.out.next = NULL;
29 module_ctx.next_filter = ngx_http_write_filter;
30
31 ngx_http_output_filter_module.ctx = &module_ctx;
32 }
33 /* */
34
35
36 /*
37 flags NGX_HUNK_RECYCLED, NGX_HUNK_FLUSH, NGX_HUNK_LAST
38 */
39
40 int ngx_http_output_filter(ngx_http_request_t *r, ngx_hunk_t *hunk)
41 {
42 int rc, first;
43 size_t size;
44 ssize_t n;
45 ngx_chain_t *ce;
46 ngx_http_output_filter_ctx_t *ctx;
47
48 ctx = (ngx_http_output_filter_ctx_t *)
49 ngx_get_module_ctx(r->main ? r->main : r,
50 &ngx_http_output_filter_module);
51
52 if (hunk && (hunk->type & NGX_HUNK_LAST))
53 ctx->last = 1;
54
55 first = 1;
56
57 while (first || ctx->in) {
58
59 /* input chain is not empty */
60 if (ctx->in) {
61
62 /* add hunk to input chain */
63 if (first && hunk) {
64 for (ce = ctx->in; ce->next; ce = ce->next)
65 /* void */ ;
66
67 ngx_add_hunk_to_chain(ce->next, hunk, r->pool, NGX_ERROR);
68 }
69
70 first = 0;
71
72 /* our hunk is still busy */
73 if (ctx->hunk->pos.mem < ctx->hunk->last.mem) {
74 rc = ctx->next_filter(r, NULL);
75
76 /* our hunk is free */
77 } else {
78 ctx->out.hunk = ctx->hunk;
79
80 rc = ngx_http_output_filter_copy_hunk(ctx->hunk, ctx->in->hunk);
81 #if (NGX_FILE_AIO)
82 if (rc == NGX_AGAIN)
83 return rc;
84 #endif
85 if (rc == NGX_ERROR)
86 return rc;
87
88 /* whole hunk is copied so we send to next filter chain part
89 up to next hunk that need to be copied */
90 if (ctx->in->hunk->pos.mem == ctx->in->hunk->last.mem) {
91 ctx->out.next = ctx->in->next;
92
93 for (ce = ctx->in->next; ce; ce = ce->next) {
94 if (ce->hunk->type & NGX_HUNK_FILE)
95 break;
96
97 if ((ce->hunk->type & NGX_HUNK_MEMORY|NGX_HUNK_MMAP)
98 && (r->filter & NGX_HTTP_FILTER_NEED_TEMP))
99 break;
100 }
101
102 ctx->out.next = ce;
103
104 } else {
105 ctx->out.next = NULL;
106 }
107
108 rc = ctx->next_filter(r, &ctx->out);
109 }
110
111 /* delete completed hunks from input chain */
112 for (ce = ctx->in; ce; ce = ce->next) {
113 if (ce->hunk->pos.file == ce->hunk->last.file)
114 ctx->in = ce->next;
115 }
116
117 if (rc == NGX_OK)
118 ctx->hunk->pos.mem = ctx->hunk->last.mem = ctx->hunk->start;
119 else
120 return rc;
121
122 /* input chain is empty */
123 } else {
124
125 first = 0;
126
127 if (hunk == NULL) {
128 rc = ctx->next_filter(r, NULL);
129
130 } else {
131
132 /* we need to copy hunk to our hunk */
133 if (((r->filter & NGX_HTTP_FILTER_NEED_IN_MEMORY)
134 && (hunk->type & NGX_HUNK_FILE))
135 || ((r->filter & NGX_HTTP_FILTER_NEED_TEMP)
136 && (hunk->type & NGX_HUNK_MEMORY|NGX_HUNK_MMAP))
137 ) {
138
139 /* out hunk is still busy */
140 if (ctx->hunk && ctx->hunk->pos.mem < ctx->hunk->last.mem) {
141 ngx_add_hunk_to_chain(ctx->in, hunk, r->pool,
142 NGX_ERROR);
143
144 rc = ctx->next_filter(r, NULL);
145
146 } else {
147 if (ctx->hunk == NULL) {
148
149 if (hunk->type & NGX_HUNK_LAST) {
150 size = hunk->last.mem - hunk->pos.mem;
151 if (size > ctx->hunk_size)
152 size = ctx->hunk_size;
153
154 } else {
155 size = ctx->hunk_size;
156 }
157
158 ngx_test_null(ctx->hunk,
159 ngx_create_temp_hunk(r->pool, size,
160 50, 50),
161 NGX_ERROR);
162 ctx->hunk->type |= NGX_HUNK_RECYCLED;
163
164 rc = ngx_http_output_filter_copy_hunk(ctx->hunk,
165 hunk);
166 #if (NGX_FILE_AIO)
167 if (rc == NGX_AGAIN) {
168 /* add hunk to input chain */
169 ngx_add_hunk_to_chain(ctx->in, hunk, r->pool,
170 NGX_ERROR);
171
172 return rc;
173 }
174 #endif
175 if (rc == NGX_ERROR)
176 return rc;
177
178 if (hunk->pos.mem < hunk->last.mem)
179 ngx_add_hunk_to_chain(ctx->in, hunk, r->pool,
180 NGX_ERROR);
181
182 ctx->out.hunk = ctx->hunk;
183 ctx->out.next = NULL;
184
185 rc = ctx->next_filter(r, &ctx->out);
186 }
187 }
188
189 } else {
190 ctx->out.hunk = hunk;
191 ctx->out.next = NULL;
192
193 rc = ctx->next_filter(r, &ctx->out);
194 }
195 }
196 }
197
198 if (rc == NGX_OK && ctx->hunk)
199 ctx->hunk->pos.mem = ctx->hunk->last.mem = ctx->hunk->start;
200 }
201
202 if (rc == NGX_OK && ctx->last)
203 return NGX_OK;
204
205 if (rc == NGX_OK) {
206 ctx->hunk->pos.mem = ctx->hunk->last.mem = ctx->hunk->start;
207 #if level_event
208 ngx_del_event(r->connection->write, NGX_WRITE_EVENT);
209 #endif
210 }
211
212 return rc;
213 }
214
215
216 static int ngx_http_output_filter_copy_hunk(ngx_hunk_t *dst, ngx_hunk_t *src)
217 {
218 size_t size;
219 ssize_t n;
220
221 size = src->last.mem - src->pos.mem;
222 if (size > dst->end - dst->pos.mem)
223 size = dst->end - dst->pos.mem;
224
225 if (src->type & NGX_HUNK_FILE) {
226 n = ngx_read_file(src->file, dst->pos.mem, size, src->pos.file);
227
228 if (n == NGX_ERROR) {
229 return n;
230
231 #if (NGX_FILE_AIO)
232 } else if (n == NGX_AGAIN) {
233 return n;
234 #endif
235
236 } else {
237 ngx_assert((n == size), /* void */ ; , src->file->log,
238 ngx_read_file_n " reads only %d of %d" _
239 n _ size);
240 }
241
242 src->pos.mem += n;
243 dst->last.mem += n;
244
245 } else {
246 ngx_memcpy(src->pos.mem, dst->pos.mem, size);
247
248 src->pos.mem += size;
249 dst->last.mem += size;
250 }
251
252 return NGX_OK;
253 }