1
2 /*
3 * Copyright (C) Igor Sysoev
4 * Copyright (C) Nginx, Inc.
5 */
6
7
8 #include <ngx_config.h>
9 #include <ngx_core.h>
10 #include <ngx_http.h>
11
12
13 typedef struct {
14 ngx_str_t match;
15 ngx_http_complex_value_t value;
16
17 ngx_hash_t types;
18
19 ngx_flag_t once;
20
21 ngx_array_t *types_keys;
22 } ngx_http_sub_loc_conf_t;
23
24
25 typedef enum {
26 sub_start_state = 0,
27 sub_match_state,
28 } ngx_http_sub_state_e;
29
30
31 typedef struct {
32 ngx_str_t match;
33 ngx_str_t saved;
34 ngx_str_t looked;
35
36 ngx_uint_t once; /* unsigned once:1 */
37
38 ngx_buf_t *buf;
39
40 u_char *pos;
41 u_char *copy_start;
42 u_char *copy_end;
43
44 ngx_chain_t *in;
45 ngx_chain_t *out;
46 ngx_chain_t **last_out;
47 ngx_chain_t *busy;
48 ngx_chain_t *free;
49
50 ngx_str_t sub;
51
52 ngx_uint_t state;
53 } ngx_http_sub_ctx_t;
54
55
56 static ngx_int_t ngx_http_sub_output(ngx_http_request_t *r,
57 ngx_http_sub_ctx_t *ctx);
58 static ngx_int_t ngx_http_sub_parse(ngx_http_request_t *r,
59 ngx_http_sub_ctx_t *ctx);
60
61 static char * ngx_http_sub_filter(ngx_conf_t *cf, ngx_command_t *cmd,
62 void *conf);
63 static void *ngx_http_sub_create_conf(ngx_conf_t *cf);
64 static char *ngx_http_sub_merge_conf(ngx_conf_t *cf,
65 void *parent, void *child);
66 static ngx_int_t ngx_http_sub_filter_init(ngx_conf_t *cf);
67
68
69 static ngx_command_t ngx_http_sub_filter_commands[] = {
70
71 { ngx_string("sub_filter"),
72 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
73 ngx_http_sub_filter,
74 NGX_HTTP_LOC_CONF_OFFSET,
75 0,
76 NULL },
77
78 { ngx_string("sub_filter_types"),
79 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
80 ngx_http_types_slot,
81 NGX_HTTP_LOC_CONF_OFFSET,
82 offsetof(ngx_http_sub_loc_conf_t, types_keys),
83 &ngx_http_html_default_types[0] },
84
85 { ngx_string("sub_filter_once"),
86 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
87 ngx_conf_set_flag_slot,
88 NGX_HTTP_LOC_CONF_OFFSET,
89 offsetof(ngx_http_sub_loc_conf_t, once),
90 NULL },
91
92 ngx_null_command
93 };
94
95
96 static ngx_http_module_t ngx_http_sub_filter_module_ctx = {
97 NULL, /* preconfiguration */
98 ngx_http_sub_filter_init, /* postconfiguration */
99
100 NULL, /* create main configuration */
101 NULL, /* init main configuration */
102
103 NULL, /* create server configuration */
104 NULL, /* merge server configuration */
105
106 ngx_http_sub_create_conf, /* create location configuration */
107 ngx_http_sub_merge_conf /* merge location configuration */
108 };
109
110
111 ngx_module_t ngx_http_sub_filter_module = {
112 NGX_MODULE_V1,
113 &ngx_http_sub_filter_module_ctx, /* module context */
114 ngx_http_sub_filter_commands, /* module directives */
115 NGX_HTTP_MODULE, /* module type */
116 NULL, /* init master */
117 NULL, /* init module */
118 NULL, /* init process */
119 NULL, /* init thread */
120 NULL, /* exit thread */
121 NULL, /* exit process */
122 NULL, /* exit master */
123 NGX_MODULE_V1_PADDING
124 };
125
126
127 static ngx_http_output_header_filter_pt ngx_http_next_header_filter;
128 static ngx_http_output_body_filter_pt ngx_http_next_body_filter;
129
130
131 static ngx_int_t
132 ngx_http_sub_header_filter(ngx_http_request_t *r)
133 {
134 ngx_http_sub_ctx_t *ctx;
135 ngx_http_sub_loc_conf_t *slcf;
136
137 slcf = ngx_http_get_module_loc_conf(r, ngx_http_sub_filter_module);
138
139 if (slcf->match.len == 0
140 || r->headers_out.content_length_n == 0
141 || ngx_http_test_content_type(r, &slcf->types) == NULL)
142 {
143 return ngx_http_next_header_filter(r);
144 }
145
146 ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_sub_ctx_t));
147 if (ctx == NULL) {
148 return NGX_ERROR;
149 }
150
151 ctx->saved.data = ngx_pnalloc(r->pool, slcf->match.len);
152 if (ctx->saved.data == NULL) {
153 return NGX_ERROR;
154 }
155
156 ctx->looked.data = ngx_pnalloc(r->pool, slcf->match.len);
157 if (ctx->looked.data == NULL) {
158 return NGX_ERROR;
159 }
160
161 ngx_http_set_ctx(r, ctx, ngx_http_sub_filter_module);
162
163 ctx->match = slcf->match;
164 ctx->last_out = &ctx->out;
165
166 r->filter_need_in_memory = 1;
167
168 if (r == r->main) {
169 ngx_http_clear_content_length(r);
170 ngx_http_clear_last_modified(r);
171 ngx_http_clear_etag(r);
172 }
173
174 return ngx_http_next_header_filter(r);
175 }
176
177
178 static ngx_int_t
179 ngx_http_sub_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
180 {
181 ngx_int_t rc;
182 ngx_buf_t *b;
183 ngx_chain_t *cl;
184 ngx_http_sub_ctx_t *ctx;
185 ngx_http_sub_loc_conf_t *slcf;
186
187 ctx = ngx_http_get_module_ctx(r, ngx_http_sub_filter_module);
188
189 if (ctx == NULL) {
190 return ngx_http_next_body_filter(r, in);
191 }
192
193 if ((in == NULL
194 && ctx->buf == NULL
195 && ctx->in == NULL
196 && ctx->busy == NULL))
197 {
198 return ngx_http_next_body_filter(r, in);
199 }
200
201 if (ctx->once && (ctx->buf == NULL || ctx->in == NULL)) {
202
203 if (ctx->busy) {
204 if (ngx_http_sub_output(r, ctx) == NGX_ERROR) {
205 return NGX_ERROR;
206 }
207 }
208
209 return ngx_http_next_body_filter(r, in);
210 }
211
212 /* add the incoming chain to the chain ctx->in */
213
214 if (in) {
215 if (ngx_chain_add_copy(r->pool, &ctx->in, in) != NGX_OK) {
216 return NGX_ERROR;
217 }
218 }
219
220 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
221 "http sub filter \"%V\"", &r->uri);
222
223 while (ctx->in || ctx->buf) {
224
225 if (ctx->buf == NULL) {
226 ctx->buf = ctx->in->buf;
227 ctx->in = ctx->in->next;
228 ctx->pos = ctx->buf->pos;
229 }
230
231 if (ctx->state == sub_start_state) {
232 ctx->copy_start = ctx->pos;
233 ctx->copy_end = ctx->pos;
234 }
235
236 b = NULL;
237
238 while (ctx->pos < ctx->buf->last) {
239
240 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
241 "saved: \"%V\" state: %d", &ctx->saved, ctx->state);
242
243 rc = ngx_http_sub_parse(r, ctx);
244
245 ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
246 "parse: %d, looked: \"%V\" %p-%p",
247 rc, &ctx->looked, ctx->copy_start, ctx->copy_end);
248
249 if (rc == NGX_ERROR) {
250 return rc;
251 }
252
253 if (ctx->copy_start != ctx->copy_end) {
254
255 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
256 "saved: \"%V\"", &ctx->saved);
257
258 if (ctx->saved.len) {
259
260 if (ctx->free) {
261 cl = ctx->free;
262 ctx->free = ctx->free->next;
263 b = cl->buf;
264 ngx_memzero(b, sizeof(ngx_buf_t));
265
266 } else {
267 b = ngx_calloc_buf(r->pool);
268 if (b == NULL) {
269 return NGX_ERROR;
270 }
271
272 cl = ngx_alloc_chain_link(r->pool);
273 if (cl == NULL) {
274 return NGX_ERROR;
275 }
276
277 cl->buf = b;
278 }
279
280 b->pos = ngx_pnalloc(r->pool, ctx->saved.len);
281 if (b->pos == NULL) {
282 return NGX_ERROR;
283 }
284
285 ngx_memcpy(b->pos, ctx->saved.data, ctx->saved.len);
286 b->last = b->pos + ctx->saved.len;
287 b->memory = 1;
288
289 *ctx->last_out = cl;
290 ctx->last_out = &cl->next;
291
292 ctx->saved.len = 0;
293 }
294
295 if (ctx->free) {
296 cl = ctx->free;
297 ctx->free = ctx->free->next;
298 b = cl->buf;
299
300 } else {
301 b = ngx_alloc_buf(r->pool);
302 if (b == NULL) {
303 return NGX_ERROR;
304 }
305
306 cl = ngx_alloc_chain_link(r->pool);
307 if (cl == NULL) {
308 return NGX_ERROR;
309 }
310
311 cl->buf = b;
312 }
313
314 ngx_memcpy(b, ctx->buf, sizeof(ngx_buf_t));
315
316 b->pos = ctx->copy_start;
317 b->last = ctx->copy_end;
318 b->shadow = NULL;
319 b->last_buf = 0;
320 b->recycled = 0;
321
322 if (b->in_file) {
323 b->file_last = b->file_pos + (b->last - ctx->buf->pos);
324 b->file_pos += b->pos - ctx->buf->pos;
325 }
326
327 cl->next = NULL;
328 *ctx->last_out = cl;
329 ctx->last_out = &cl->next;
330 }
331
332 if (ctx->state == sub_start_state) {
333 ctx->copy_start = ctx->pos;
334 ctx->copy_end = ctx->pos;
335
336 } else {
337 ctx->copy_start = NULL;
338 ctx->copy_end = NULL;
339 }
340
341 if (rc == NGX_AGAIN) {
342 continue;
343 }
344
345
346 /* rc == NGX_OK */
347
348 b = ngx_calloc_buf(r->pool);
349 if (b == NULL) {
350 return NGX_ERROR;
351 }
352
353 cl = ngx_alloc_chain_link(r->pool);
354 if (cl == NULL) {
355 return NGX_ERROR;
356 }
357
358 slcf = ngx_http_get_module_loc_conf(r, ngx_http_sub_filter_module);
359
360 if (ctx->sub.data == NULL) {
361
362 if (ngx_http_complex_value(r, &slcf->value, &ctx->sub)
363 != NGX_OK)
364 {
365 return NGX_ERROR;
366 }
367 }
368
369 if (ctx->sub.len) {
370 b->memory = 1;
371 b->pos = ctx->sub.data;
372 b->last = ctx->sub.data + ctx->sub.len;
373
374 } else {
375 b->sync = 1;
376 }
377
378 cl->buf = b;
379 cl->next = NULL;
380 *ctx->last_out = cl;
381 ctx->last_out = &cl->next;
382
383 ctx->once = slcf->once;
384
385 continue;
386 }
387
388 if (ctx->buf->last_buf || ngx_buf_in_memory(ctx->buf)) {
389 if (b == NULL) {
390 if (ctx->free) {
391 cl = ctx->free;
392 ctx->free = ctx->free->next;
393 b = cl->buf;
394 ngx_memzero(b, sizeof(ngx_buf_t));
395
396 } else {
397 b = ngx_calloc_buf(r->pool);
398 if (b == NULL) {
399 return NGX_ERROR;
400 }
401
402 cl = ngx_alloc_chain_link(r->pool);
403 if (cl == NULL) {
404 return NGX_ERROR;
405 }
406
407 cl->buf = b;
408 }
409
410 b->sync = 1;
411
412 cl->next = NULL;
413 *ctx->last_out = cl;
414 ctx->last_out = &cl->next;
415 }
416
417 b->last_buf = ctx->buf->last_buf;
418 b->shadow = ctx->buf;
419
420 b->recycled = ctx->buf->recycled;
421 }
422
423 ctx->buf = NULL;
424
425 ctx->saved.len = ctx->looked.len;
426 ngx_memcpy(ctx->saved.data, ctx->looked.data, ctx->looked.len);
427 }
428
429 if (ctx->out == NULL && ctx->busy == NULL) {
430 return NGX_OK;
431 }
432
433 return ngx_http_sub_output(r, ctx);
434 }
435
436
437 static ngx_int_t
438 ngx_http_sub_output(ngx_http_request_t *r, ngx_http_sub_ctx_t *ctx)
439 {
440 ngx_int_t rc;
441 ngx_buf_t *b;
442 ngx_chain_t *cl;
443
444 #if 1
445 b = NULL;
446 for (cl = ctx->out; cl; cl = cl->next) {
447 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
448 "sub out: %p %p", cl->buf, cl->buf->pos);
449 if (cl->buf == b) {
450 ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
451 "the same buf was used in sub");
452 ngx_debug_point();
453 return NGX_ERROR;
454 }
455 b = cl->buf;
456 }
457 #endif
458
459 rc = ngx_http_next_body_filter(r, ctx->out);
460
461 if (ctx->busy == NULL) {
462 ctx->busy = ctx->out;
463
464 } else {
465 for (cl = ctx->busy; cl->next; cl = cl->next) { /* void */ }
466 cl->next = ctx->out;
467 }
468
469 ctx->out = NULL;
470 ctx->last_out = &ctx->out;
471
472 while (ctx->busy) {
473
474 cl = ctx->busy;
475 b = cl->buf;
476
477 if (ngx_buf_size(b) != 0) {
478 break;
479 }
480
481 if (b->shadow) {
482 b->shadow->pos = b->shadow->last;
483 }
484
485 ctx->busy = cl->next;
486
487 if (ngx_buf_in_memory(b) || b->in_file) {
488 /* add data bufs only to the free buf chain */
489
490 cl->next = ctx->free;
491 ctx->free = cl;
492 }
493 }
494
495 if (ctx->in || ctx->buf) {
496 r->buffered |= NGX_HTTP_SUB_BUFFERED;
497
498 } else {
499 r->buffered &= ~NGX_HTTP_SUB_BUFFERED;
500 }
501
502 return rc;
503 }
504
505
506 static ngx_int_t
507 ngx_http_sub_parse(ngx_http_request_t *r, ngx_http_sub_ctx_t *ctx)
508 {
509 u_char *p, *last, *copy_end, ch, match;
510 size_t looked;
511 ngx_http_sub_state_e state;
512
513 if (ctx->once) {
514 ctx->copy_start = ctx->pos;
515 ctx->copy_end = ctx->buf->last;
516 ctx->pos = ctx->buf->last;
517 ctx->looked.len = 0;
518
519 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "once");
520
521 return NGX_AGAIN;
522 }
523
524 state = ctx->state;
525 looked = ctx->looked.len;
526 last = ctx->buf->last;
527 copy_end = ctx->copy_end;
528
529 for (p = ctx->pos; p < last; p++) {
530
531 ch = *p;
532 ch = ngx_tolower(ch);
533
534 if (state == sub_start_state) {
535
536 /* the tight loop */
537
538 match = ctx->match.data[0];
539
540 for ( ;; ) {
541 if (ch == match) {
542 copy_end = p;
543 ctx->looked.data[0] = *p;
544 looked = 1;
545 state = sub_match_state;
546
547 goto match_started;
548 }
549
550 if (++p == last) {
551 break;
552 }
553
554 ch = *p;
555 ch = ngx_tolower(ch);
556 }
557
558 ctx->state = state;
559 ctx->pos = p;
560 ctx->looked.len = looked;
561 ctx->copy_end = p;
562
563 if (ctx->copy_start == NULL) {
564 ctx->copy_start = ctx->buf->pos;
565 }
566
567 return NGX_AGAIN;
568
569 match_started:
570
571 continue;
572 }
573
574 /* state == sub_match_state */
575
576 if (ch == ctx->match.data[looked]) {
577 ctx->looked.data[looked] = *p;
578 looked++;
579
580 if (looked == ctx->match.len) {
581 if ((size_t) (p - ctx->pos) < looked) {
582 ctx->saved.len = 0;
583 }
584
585 ctx->state = sub_start_state;
586 ctx->pos = p + 1;
587 ctx->looked.len = 0;
588 ctx->copy_end = copy_end;
589
590 if (ctx->copy_start == NULL && copy_end) {
591 ctx->copy_start = ctx->buf->pos;
592 }
593
594 return NGX_OK;
595 }
596
597 } else if (ch == ctx->match.data[0]) {
598 copy_end = p;
599 ctx->looked.data[0] = *p;
600 looked = 1;
601
602 } else {
603 copy_end = p;
604 looked = 0;
605 state = sub_start_state;
606 }
607 }
608
609 ctx->state = state;
610 ctx->pos = p;
611 ctx->looked.len = looked;
612
613 ctx->copy_end = (state == sub_start_state) ? p : copy_end;
614
615 if (ctx->copy_start == NULL && ctx->copy_end) {
616 ctx->copy_start = ctx->buf->pos;
617 }
618
619 return NGX_AGAIN;
620 }
621
622
623 static char *
624 ngx_http_sub_filter(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
625 {
626 ngx_http_sub_loc_conf_t *slcf = conf;
627
628 ngx_str_t *value;
629 ngx_http_compile_complex_value_t ccv;
630
631 if (slcf->match.data) {
632 return "is duplicate";
633 }
634
635 value = cf->args->elts;
636
637 ngx_strlow(value[1].data, value[1].data, value[1].len);
638
639 slcf->match = value[1];
640
641 ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));
642
643 ccv.cf = cf;
644 ccv.value = &value[2];
645 ccv.complex_value = &slcf->value;
646
647 if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
648 return NGX_CONF_ERROR;
649 }
650
651 return NGX_CONF_OK;
652 }
653
654
655 static void *
656 ngx_http_sub_create_conf(ngx_conf_t *cf)
657 {
658 ngx_http_sub_loc_conf_t *slcf;
659
660 slcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_sub_loc_conf_t));
661 if (slcf == NULL) {
662 return NULL;
663 }
664
665 /*
666 * set by ngx_pcalloc():
667 *
668 * conf->match = { 0, NULL };
669 * conf->sub = { 0, NULL };
670 * conf->sub_lengths = NULL;
671 * conf->sub_values = NULL;
672 * conf->types = { NULL };
673 * conf->types_keys = NULL;
674 */
675
676 slcf->once = NGX_CONF_UNSET;
677
678 return slcf;
679 }
680
681
682 static char *
683 ngx_http_sub_merge_conf(ngx_conf_t *cf, void *parent, void *child)
684 {
685 ngx_http_sub_loc_conf_t *prev = parent;
686 ngx_http_sub_loc_conf_t *conf = child;
687
688 ngx_conf_merge_value(conf->once, prev->once, 1);
689 ngx_conf_merge_str_value(conf->match, prev->match, "");
690
691 if (conf->value.value.data == NULL) {
692 conf->value = prev->value;
693 }
694
695 if (ngx_http_merge_types(cf, &conf->types_keys, &conf->types,
696 &prev->types_keys, &prev->types,
697 ngx_http_html_default_types)
698 != NGX_OK)
699 {
700 return NGX_CONF_ERROR;
701 }
702
703 return NGX_CONF_OK;
704 }
705
706
707 static ngx_int_t
708 ngx_http_sub_filter_init(ngx_conf_t *cf)
709 {
710 ngx_http_next_header_filter = ngx_http_top_header_filter;
711 ngx_http_top_header_filter = ngx_http_sub_header_filter;
712
713 ngx_http_next_body_filter = ngx_http_top_body_filter;
714 ngx_http_top_body_filter = ngx_http_sub_body_filter;
715
716 return NGX_OK;
717 }
718
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.