![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ngx_http_charset_filter_module.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / http / modules|
Return to ngx_http_charset_filter_module.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / http / modules |
1.1 misho 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: #define NGX_HTTP_CHARSET_OFF -2
14: #define NGX_HTTP_NO_CHARSET -3
15: #define NGX_HTTP_CHARSET_VAR 0x10000
16:
17: /* 1 byte length and up to 3 bytes for the UTF-8 encoding of the UCS-2 */
18: #define NGX_UTF_LEN 4
19:
20: #define NGX_HTML_ENTITY_LEN (sizeof("") - 1)
21:
22:
23: typedef struct {
24: u_char **tables;
25: ngx_str_t name;
26:
27: unsigned length:16;
28: unsigned utf8:1;
29: } ngx_http_charset_t;
30:
31:
32: typedef struct {
33: ngx_int_t src;
34: ngx_int_t dst;
35: } ngx_http_charset_recode_t;
36:
37:
38: typedef struct {
39: ngx_int_t src;
40: ngx_int_t dst;
41: u_char *src2dst;
42: u_char *dst2src;
43: } ngx_http_charset_tables_t;
44:
45:
46: typedef struct {
47: ngx_array_t charsets; /* ngx_http_charset_t */
48: ngx_array_t tables; /* ngx_http_charset_tables_t */
49: ngx_array_t recodes; /* ngx_http_charset_recode_t */
50: } ngx_http_charset_main_conf_t;
51:
52:
53: typedef struct {
54: ngx_int_t charset;
55: ngx_int_t source_charset;
56: ngx_flag_t override_charset;
57:
58: ngx_hash_t types;
59: ngx_array_t *types_keys;
60: } ngx_http_charset_loc_conf_t;
61:
62:
63: typedef struct {
64: u_char *table;
65: ngx_int_t charset;
66: ngx_str_t charset_name;
67:
68: ngx_chain_t *busy;
69: ngx_chain_t *free_bufs;
70: ngx_chain_t *free_buffers;
71:
72: size_t saved_len;
73: u_char saved[NGX_UTF_LEN];
74:
75: unsigned length:16;
76: unsigned from_utf8:1;
77: unsigned to_utf8:1;
78: } ngx_http_charset_ctx_t;
79:
80:
81: typedef struct {
82: ngx_http_charset_tables_t *table;
83: ngx_http_charset_t *charset;
84: ngx_uint_t characters;
85: } ngx_http_charset_conf_ctx_t;
86:
87:
88: static ngx_int_t ngx_http_destination_charset(ngx_http_request_t *r,
89: ngx_str_t *name);
90: static ngx_int_t ngx_http_main_request_charset(ngx_http_request_t *r,
91: ngx_str_t *name);
92: static ngx_int_t ngx_http_source_charset(ngx_http_request_t *r,
93: ngx_str_t *name);
94: static ngx_int_t ngx_http_get_charset(ngx_http_request_t *r, ngx_str_t *name);
95: static ngx_inline void ngx_http_set_charset(ngx_http_request_t *r,
96: ngx_str_t *charset);
97: static ngx_int_t ngx_http_charset_ctx(ngx_http_request_t *r,
98: ngx_http_charset_t *charsets, ngx_int_t charset, ngx_int_t source_charset);
99: static ngx_uint_t ngx_http_charset_recode(ngx_buf_t *b, u_char *table);
100: static ngx_chain_t *ngx_http_charset_recode_from_utf8(ngx_pool_t *pool,
101: ngx_buf_t *buf, ngx_http_charset_ctx_t *ctx);
102: static ngx_chain_t *ngx_http_charset_recode_to_utf8(ngx_pool_t *pool,
103: ngx_buf_t *buf, ngx_http_charset_ctx_t *ctx);
104:
105: static ngx_chain_t *ngx_http_charset_get_buf(ngx_pool_t *pool,
106: ngx_http_charset_ctx_t *ctx);
107: static ngx_chain_t *ngx_http_charset_get_buffer(ngx_pool_t *pool,
108: ngx_http_charset_ctx_t *ctx, size_t size);
109:
110: static char *ngx_http_charset_map_block(ngx_conf_t *cf, ngx_command_t *cmd,
111: void *conf);
112: static char *ngx_http_charset_map(ngx_conf_t *cf, ngx_command_t *dummy,
113: void *conf);
114:
115: static char *ngx_http_set_charset_slot(ngx_conf_t *cf, ngx_command_t *cmd,
116: void *conf);
117: static ngx_int_t ngx_http_add_charset(ngx_array_t *charsets, ngx_str_t *name);
118:
119: static void *ngx_http_charset_create_main_conf(ngx_conf_t *cf);
120: static void *ngx_http_charset_create_loc_conf(ngx_conf_t *cf);
121: static char *ngx_http_charset_merge_loc_conf(ngx_conf_t *cf,
122: void *parent, void *child);
123: static ngx_int_t ngx_http_charset_postconfiguration(ngx_conf_t *cf);
124:
125:
126: ngx_str_t ngx_http_charset_default_types[] = {
127: ngx_string("text/html"),
128: ngx_string("text/xml"),
129: ngx_string("text/plain"),
130: ngx_string("text/vnd.wap.wml"),
131: ngx_string("application/x-javascript"),
132: ngx_string("application/rss+xml"),
133: ngx_null_string
134: };
135:
136:
137: static ngx_command_t ngx_http_charset_filter_commands[] = {
138:
139: { ngx_string("charset"),
140: NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF
141: |NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
142: ngx_http_set_charset_slot,
143: NGX_HTTP_LOC_CONF_OFFSET,
144: offsetof(ngx_http_charset_loc_conf_t, charset),
145: NULL },
146:
147: { ngx_string("source_charset"),
148: NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF
149: |NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
150: ngx_http_set_charset_slot,
151: NGX_HTTP_LOC_CONF_OFFSET,
152: offsetof(ngx_http_charset_loc_conf_t, source_charset),
153: NULL },
154:
155: { ngx_string("override_charset"),
156: NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF
157: |NGX_HTTP_LIF_CONF|NGX_CONF_FLAG,
158: ngx_conf_set_flag_slot,
159: NGX_HTTP_LOC_CONF_OFFSET,
160: offsetof(ngx_http_charset_loc_conf_t, override_charset),
161: NULL },
162:
163: { ngx_string("charset_types"),
164: NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
165: ngx_http_types_slot,
166: NGX_HTTP_LOC_CONF_OFFSET,
167: offsetof(ngx_http_charset_loc_conf_t, types_keys),
168: &ngx_http_charset_default_types[0] },
169:
170: { ngx_string("charset_map"),
171: NGX_HTTP_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_TAKE2,
172: ngx_http_charset_map_block,
173: NGX_HTTP_MAIN_CONF_OFFSET,
174: 0,
175: NULL },
176:
177: ngx_null_command
178: };
179:
180:
181: static ngx_http_module_t ngx_http_charset_filter_module_ctx = {
182: NULL, /* preconfiguration */
183: ngx_http_charset_postconfiguration, /* postconfiguration */
184:
185: ngx_http_charset_create_main_conf, /* create main configuration */
186: NULL, /* init main configuration */
187:
188: NULL, /* create server configuration */
189: NULL, /* merge server configuration */
190:
191: ngx_http_charset_create_loc_conf, /* create location configuration */
192: ngx_http_charset_merge_loc_conf /* merge location configuration */
193: };
194:
195:
196: ngx_module_t ngx_http_charset_filter_module = {
197: NGX_MODULE_V1,
198: &ngx_http_charset_filter_module_ctx, /* module context */
199: ngx_http_charset_filter_commands, /* module directives */
200: NGX_HTTP_MODULE, /* module type */
201: NULL, /* init master */
202: NULL, /* init module */
203: NULL, /* init process */
204: NULL, /* init thread */
205: NULL, /* exit thread */
206: NULL, /* exit process */
207: NULL, /* exit master */
208: NGX_MODULE_V1_PADDING
209: };
210:
211:
212: static ngx_http_output_header_filter_pt ngx_http_next_header_filter;
213: static ngx_http_output_body_filter_pt ngx_http_next_body_filter;
214:
215:
216: static ngx_int_t
217: ngx_http_charset_header_filter(ngx_http_request_t *r)
218: {
219: ngx_int_t charset, source_charset;
220: ngx_str_t dst, src;
221: ngx_http_charset_t *charsets;
222: ngx_http_charset_main_conf_t *mcf;
223:
224: if (r == r->main) {
225: charset = ngx_http_destination_charset(r, &dst);
226:
227: } else {
228: charset = ngx_http_main_request_charset(r, &dst);
229: }
230:
231: if (charset == NGX_ERROR) {
232: return NGX_ERROR;
233: }
234:
235: if (charset == NGX_DECLINED) {
236: return ngx_http_next_header_filter(r);
237: }
238:
239: /* charset: charset index or NGX_HTTP_NO_CHARSET */
240:
241: source_charset = ngx_http_source_charset(r, &src);
242:
243: if (source_charset == NGX_ERROR) {
244: return NGX_ERROR;
245: }
246:
247: /*
248: * source_charset: charset index, NGX_HTTP_NO_CHARSET,
249: * or NGX_HTTP_CHARSET_OFF
250: */
251:
252: ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
253: "charset: \"%V\" > \"%V\"", &src, &dst);
254:
255: if (source_charset == NGX_HTTP_CHARSET_OFF) {
256: ngx_http_set_charset(r, &dst);
257:
258: return ngx_http_next_header_filter(r);
259: }
260:
261: if (charset == NGX_HTTP_NO_CHARSET
262: || source_charset == NGX_HTTP_NO_CHARSET)
263: {
264: if (source_charset != charset
265: || ngx_strncasecmp(dst.data, src.data, dst.len) != 0)
266: {
267: goto no_charset_map;
268: }
269:
270: ngx_http_set_charset(r, &dst);
271:
272: return ngx_http_next_header_filter(r);
273: }
274:
275: mcf = ngx_http_get_module_main_conf(r, ngx_http_charset_filter_module);
276: charsets = mcf->charsets.elts;
277:
278: if (source_charset != charset
279: && (charsets[source_charset].tables == NULL
280: || charsets[source_charset].tables[charset] == NULL))
281: {
282: goto no_charset_map;
283: }
284:
285: r->headers_out.content_type.len = r->headers_out.content_type_len;
286:
287: ngx_http_set_charset(r, &dst);
288:
289: if (source_charset != charset) {
290: return ngx_http_charset_ctx(r, charsets, charset, source_charset);
291: }
292:
293: return ngx_http_next_header_filter(r);
294:
295: no_charset_map:
296:
297: ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
298: "no \"charset_map\" between the charsets \"%V\" and \"%V\"",
299: &src, &dst);
300:
301: return ngx_http_next_header_filter(r);
302: }
303:
304:
305: static ngx_int_t
306: ngx_http_destination_charset(ngx_http_request_t *r, ngx_str_t *name)
307: {
308: ngx_int_t charset;
309: ngx_http_charset_t *charsets;
310: ngx_http_variable_value_t *vv;
311: ngx_http_charset_loc_conf_t *mlcf;
312: ngx_http_charset_main_conf_t *mcf;
313:
314: if (!r->ignore_content_encoding
315: && r->headers_out.content_encoding
316: && r->headers_out.content_encoding->value.len)
317: {
318: return NGX_DECLINED;
319: }
320:
321: if (r->headers_out.content_type.len == 0) {
322: return NGX_DECLINED;
323: }
324:
325: if (r->headers_out.override_charset
326: && r->headers_out.override_charset->len)
327: {
328: *name = *r->headers_out.override_charset;
329:
330: charset = ngx_http_get_charset(r, name);
331:
332: if (charset != NGX_HTTP_NO_CHARSET) {
333: return charset;
334: }
335:
336: ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
337: "unknown charset \"%V\" to override", name);
338:
339: return NGX_DECLINED;
340: }
341:
342: mlcf = ngx_http_get_module_loc_conf(r, ngx_http_charset_filter_module);
343: charset = mlcf->charset;
344:
345: if (charset == NGX_HTTP_CHARSET_OFF) {
346: return NGX_DECLINED;
347: }
348:
349: if (r->headers_out.charset.len) {
350: if (mlcf->override_charset == 0) {
351: return NGX_DECLINED;
352: }
353:
354: } else {
355: if (ngx_http_test_content_type(r, &mlcf->types) == NULL) {
356: return NGX_DECLINED;
357: }
358: }
359:
360: if (charset < NGX_HTTP_CHARSET_VAR) {
361: mcf = ngx_http_get_module_main_conf(r, ngx_http_charset_filter_module);
362: charsets = mcf->charsets.elts;
363: *name = charsets[charset].name;
364: return charset;
365: }
366:
367: vv = ngx_http_get_indexed_variable(r, charset - NGX_HTTP_CHARSET_VAR);
368:
369: if (vv == NULL || vv->not_found) {
370: return NGX_ERROR;
371: }
372:
373: name->len = vv->len;
374: name->data = vv->data;
375:
376: return ngx_http_get_charset(r, name);
377: }
378:
379:
380: static ngx_int_t
381: ngx_http_main_request_charset(ngx_http_request_t *r, ngx_str_t *src)
382: {
383: ngx_int_t charset;
384: ngx_str_t *main_charset;
385: ngx_http_charset_ctx_t *ctx;
386:
387: ctx = ngx_http_get_module_ctx(r->main, ngx_http_charset_filter_module);
388:
389: if (ctx) {
390: *src = ctx->charset_name;
391: return ctx->charset;
392: }
393:
394: main_charset = &r->main->headers_out.charset;
395:
396: if (main_charset->len == 0) {
397: return NGX_DECLINED;
398: }
399:
400: ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_charset_ctx_t));
401: if (ctx == NULL) {
402: return NGX_ERROR;
403: }
404:
405: ngx_http_set_ctx(r->main, ctx, ngx_http_charset_filter_module);
406:
407: charset = ngx_http_get_charset(r, main_charset);
408:
409: ctx->charset = charset;
410: ctx->charset_name = *main_charset;
411: *src = *main_charset;
412:
413: return charset;
414: }
415:
416:
417: static ngx_int_t
418: ngx_http_source_charset(ngx_http_request_t *r, ngx_str_t *name)
419: {
420: ngx_int_t charset;
421: ngx_http_charset_t *charsets;
422: ngx_http_variable_value_t *vv;
423: ngx_http_charset_loc_conf_t *lcf;
424: ngx_http_charset_main_conf_t *mcf;
425:
426: if (r->headers_out.charset.len) {
427: *name = r->headers_out.charset;
428: return ngx_http_get_charset(r, name);
429: }
430:
431: lcf = ngx_http_get_module_loc_conf(r, ngx_http_charset_filter_module);
432:
433: charset = lcf->source_charset;
434:
435: if (charset == NGX_HTTP_CHARSET_OFF) {
436: name->len = 0;
437: return charset;
438: }
439:
440: if (charset < NGX_HTTP_CHARSET_VAR) {
441: mcf = ngx_http_get_module_main_conf(r, ngx_http_charset_filter_module);
442: charsets = mcf->charsets.elts;
443: *name = charsets[charset].name;
444: return charset;
445: }
446:
447: vv = ngx_http_get_indexed_variable(r, charset - NGX_HTTP_CHARSET_VAR);
448:
449: if (vv == NULL || vv->not_found) {
450: return NGX_ERROR;
451: }
452:
453: name->len = vv->len;
454: name->data = vv->data;
455:
456: return ngx_http_get_charset(r, name);
457: }
458:
459:
460: static ngx_int_t
461: ngx_http_get_charset(ngx_http_request_t *r, ngx_str_t *name)
462: {
463: ngx_uint_t i, n;
464: ngx_http_charset_t *charset;
465: ngx_http_charset_main_conf_t *mcf;
466:
467: mcf = ngx_http_get_module_main_conf(r, ngx_http_charset_filter_module);
468:
469: charset = mcf->charsets.elts;
470: n = mcf->charsets.nelts;
471:
472: for (i = 0; i < n; i++) {
473: if (charset[i].name.len != name->len) {
474: continue;
475: }
476:
477: if (ngx_strncasecmp(charset[i].name.data, name->data, name->len) == 0) {
478: return i;
479: }
480: }
481:
482: return NGX_HTTP_NO_CHARSET;
483: }
484:
485:
486: static ngx_inline void
487: ngx_http_set_charset(ngx_http_request_t *r, ngx_str_t *charset)
488: {
489: if (r != r->main) {
490: return;
491: }
492:
493: if (r->headers_out.status == NGX_HTTP_MOVED_PERMANENTLY
494: || r->headers_out.status == NGX_HTTP_MOVED_TEMPORARILY)
495: {
496: /*
497: * do not set charset for the redirect because NN 4.x
498: * use this charset instead of the next page charset
499: */
500:
501: r->headers_out.charset.len = 0;
502: return;
503: }
504:
505: r->headers_out.charset = *charset;
506: }
507:
508:
509: static ngx_int_t
510: ngx_http_charset_ctx(ngx_http_request_t *r, ngx_http_charset_t *charsets,
511: ngx_int_t charset, ngx_int_t source_charset)
512: {
513: ngx_http_charset_ctx_t *ctx;
514:
515: ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_charset_ctx_t));
516: if (ctx == NULL) {
517: return NGX_ERROR;
518: }
519:
520: ngx_http_set_ctx(r, ctx, ngx_http_charset_filter_module);
521:
522: ctx->table = charsets[source_charset].tables[charset];
523: ctx->charset = charset;
524: ctx->charset_name = charsets[charset].name;
525: ctx->length = charsets[charset].length;
526: ctx->from_utf8 = charsets[source_charset].utf8;
527: ctx->to_utf8 = charsets[charset].utf8;
528:
529: r->filter_need_in_memory = 1;
530:
531: if ((ctx->to_utf8 || ctx->from_utf8) && r == r->main) {
532: ngx_http_clear_content_length(r);
533:
534: } else {
535: r->filter_need_temporary = 1;
536: }
537:
538: return ngx_http_next_header_filter(r);
539: }
540:
541:
542: static ngx_int_t
543: ngx_http_charset_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
544: {
545: ngx_int_t rc;
546: ngx_buf_t *b;
547: ngx_chain_t *cl, *out, **ll;
548: ngx_http_charset_ctx_t *ctx;
549:
550: ctx = ngx_http_get_module_ctx(r, ngx_http_charset_filter_module);
551:
552: if (ctx == NULL || ctx->table == NULL) {
553: return ngx_http_next_body_filter(r, in);
554: }
555:
556: if ((ctx->to_utf8 || ctx->from_utf8) || ctx->busy) {
557:
558: out = NULL;
559: ll = &out;
560:
561: for (cl = in; cl; cl = cl->next) {
562: b = cl->buf;
563:
564: if (ngx_buf_size(b) == 0) {
565:
566: *ll = ngx_alloc_chain_link(r->pool);
567: if (*ll == NULL) {
568: return NGX_ERROR;
569: }
570:
571: (*ll)->buf = b;
572: (*ll)->next = NULL;
573:
574: ll = &(*ll)->next;
575:
576: continue;
577: }
578:
579: if (ctx->to_utf8) {
580: *ll = ngx_http_charset_recode_to_utf8(r->pool, b, ctx);
581:
582: } else {
583: *ll = ngx_http_charset_recode_from_utf8(r->pool, b, ctx);
584: }
585:
586: if (*ll == NULL) {
587: return NGX_ERROR;
588: }
589:
590: while (*ll) {
591: ll = &(*ll)->next;
592: }
593: }
594:
595: rc = ngx_http_next_body_filter(r, out);
596:
597: if (out) {
598: if (ctx->busy == NULL) {
599: ctx->busy = out;
600:
601: } else {
602: for (cl = ctx->busy; cl->next; cl = cl->next) { /* void */ }
603: cl->next = out;
604: }
605: }
606:
607: while (ctx->busy) {
608:
609: cl = ctx->busy;
610: b = cl->buf;
611:
612: if (ngx_buf_size(b) != 0) {
613: break;
614: }
615:
616: ctx->busy = cl->next;
617:
618: if (b->tag != (ngx_buf_tag_t) &ngx_http_charset_filter_module) {
619: continue;
620: }
621:
622: if (b->shadow) {
623: b->shadow->pos = b->shadow->last;
624: }
625:
626: if (b->pos) {
627: cl->next = ctx->free_buffers;
628: ctx->free_buffers = cl;
629: continue;
630: }
631:
632: cl->next = ctx->free_bufs;
633: ctx->free_bufs = cl;
634: }
635:
636: return rc;
637: }
638:
639: for (cl = in; cl; cl = cl->next) {
640: (void) ngx_http_charset_recode(cl->buf, ctx->table);
641: }
642:
643: return ngx_http_next_body_filter(r, in);
644: }
645:
646:
647: static ngx_uint_t
648: ngx_http_charset_recode(ngx_buf_t *b, u_char *table)
649: {
650: u_char *p, *last;
651:
652: last = b->last;
653:
654: for (p = b->pos; p < last; p++) {
655:
656: if (*p != table[*p]) {
657: goto recode;
658: }
659: }
660:
661: return 0;
662:
663: recode:
664:
665: do {
666: if (*p != table[*p]) {
667: *p = table[*p];
668: }
669:
670: p++;
671:
672: } while (p < last);
673:
674: b->in_file = 0;
675:
676: return 1;
677: }
678:
679:
680: static ngx_chain_t *
681: ngx_http_charset_recode_from_utf8(ngx_pool_t *pool, ngx_buf_t *buf,
682: ngx_http_charset_ctx_t *ctx)
683: {
684: size_t len, size;
685: u_char c, *p, *src, *dst, *saved, **table;
686: uint32_t n;
687: ngx_buf_t *b;
688: ngx_uint_t i;
689: ngx_chain_t *out, *cl, **ll;
690:
691: src = buf->pos;
692:
693: if (ctx->saved_len == 0) {
694:
695: for ( /* void */ ; src < buf->last; src++) {
696:
697: if (*src < 0x80) {
698: continue;
699: }
700:
701: len = src - buf->pos;
702:
703: if (len > 512) {
704: out = ngx_http_charset_get_buf(pool, ctx);
705: if (out == NULL) {
706: return NULL;
707: }
708:
709: b = out->buf;
710:
711: b->temporary = buf->temporary;
712: b->memory = buf->memory;
713: b->mmap = buf->mmap;
714: b->flush = buf->flush;
715:
716: b->pos = buf->pos;
717: b->last = src;
718:
719: out->buf = b;
720: out->next = NULL;
721:
722: size = buf->last - src;
723:
724: saved = src;
725: n = ngx_utf8_decode(&saved, size);
726:
727: if (n == 0xfffffffe) {
728: /* incomplete UTF-8 symbol */
729:
730: ngx_memcpy(ctx->saved, src, size);
731: ctx->saved_len = size;
732:
733: b->shadow = buf;
734:
735: return out;
736: }
737:
738: } else {
739: out = NULL;
740: size = len + buf->last - src;
741: src = buf->pos;
742: }
743:
744: if (size < NGX_HTML_ENTITY_LEN) {
745: size += NGX_HTML_ENTITY_LEN;
746: }
747:
748: cl = ngx_http_charset_get_buffer(pool, ctx, size);
749: if (cl == NULL) {
750: return NULL;
751: }
752:
753: if (out) {
754: out->next = cl;
755:
756: } else {
757: out = cl;
758: }
759:
760: b = cl->buf;
761: dst = b->pos;
762:
763: goto recode;
764: }
765:
766: out = ngx_alloc_chain_link(pool);
767: if (out == NULL) {
768: return NULL;
769: }
770:
771: out->buf = buf;
772: out->next = NULL;
773:
774: return out;
775: }
776:
777: /* process incomplete UTF sequence from previous buffer */
778:
779: ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pool->log, 0,
780: "http charset utf saved: %z", ctx->saved_len);
781:
782: p = src;
783:
784: for (i = ctx->saved_len; i < NGX_UTF_LEN; i++) {
785: ctx->saved[i] = *p++;
786:
787: if (p == buf->last) {
788: break;
789: }
790: }
791:
792: saved = ctx->saved;
793: n = ngx_utf8_decode(&saved, i);
794:
795: c = '\0';
796:
797: if (n < 0x10000) {
798: table = (u_char **) ctx->table;
799: p = table[n >> 8];
800:
801: if (p) {
802: c = p[n & 0xff];
803: }
804:
805: } else if (n == 0xfffffffe) {
806:
807: /* incomplete UTF-8 symbol */
808:
809: if (i < NGX_UTF_LEN) {
810: out = ngx_http_charset_get_buf(pool, ctx);
811: if (out == NULL) {
812: return NULL;
813: }
814:
815: b = out->buf;
816:
817: b->pos = buf->pos;
818: b->last = buf->last;
819: b->sync = 1;
820: b->shadow = buf;
821:
822: ngx_memcpy(&ctx->saved[ctx->saved_len], src, i);
823: ctx->saved_len += i;
824:
825: return out;
826: }
827: }
828:
829: size = buf->last - buf->pos;
830:
831: if (size < NGX_HTML_ENTITY_LEN) {
832: size += NGX_HTML_ENTITY_LEN;
833: }
834:
835: cl = ngx_http_charset_get_buffer(pool, ctx, size);
836: if (cl == NULL) {
837: return NULL;
838: }
839:
840: out = cl;
841:
842: b = cl->buf;
843: dst = b->pos;
844:
845: if (c) {
846: *dst++ = c;
847:
848: } else if (n == 0xfffffffe) {
849: *dst++ = '?';
850:
851: ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pool->log, 0,
852: "http charset invalid utf 0");
853:
854: saved = &ctx->saved[NGX_UTF_LEN];
855:
856: } else if (n > 0x10ffff) {
857: *dst++ = '?';
858:
859: ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pool->log, 0,
860: "http charset invalid utf 1");
861:
862: } else {
863: dst = ngx_sprintf(dst, "&#%uD;", n);
864: }
865:
866: src += (saved - ctx->saved) - ctx->saved_len;
867: ctx->saved_len = 0;
868:
869: recode:
870:
871: ll = &cl->next;
872:
873: table = (u_char **) ctx->table;
874:
875: while (src < buf->last) {
876:
877: if ((size_t) (b->end - dst) < NGX_HTML_ENTITY_LEN) {
878: b->last = dst;
879:
880: size = buf->last - src + NGX_HTML_ENTITY_LEN;
881:
882: cl = ngx_http_charset_get_buffer(pool, ctx, size);
883: if (cl == NULL) {
884: return NULL;
885: }
886:
887: *ll = cl;
888: ll = &cl->next;
889:
890: b = cl->buf;
891: dst = b->pos;
892: }
893:
894: if (*src < 0x80) {
895: *dst++ = *src++;
896: continue;
897: }
898:
899: len = buf->last - src;
900:
901: n = ngx_utf8_decode(&src, len);
902:
903: if (n < 0x10000) {
904:
905: p = table[n >> 8];
906:
907: if (p) {
908: c = p[n & 0xff];
909:
910: if (c) {
911: *dst++ = c;
912: continue;
913: }
914: }
915:
916: dst = ngx_sprintf(dst, "&#%uD;", n);
917:
918: continue;
919: }
920:
921: if (n == 0xfffffffe) {
922: /* incomplete UTF-8 symbol */
923:
924: ngx_memcpy(ctx->saved, src, len);
925: ctx->saved_len = len;
926:
927: if (b->pos == dst) {
928: b->sync = 1;
929: b->temporary = 0;
930: }
931:
932: break;
933: }
934:
935: if (n > 0x10ffff) {
936: *dst++ = '?';
937:
938: ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pool->log, 0,
939: "http charset invalid utf 2");
940:
941: continue;
942: }
943:
944: /* n > 0xffff */
945:
946: dst = ngx_sprintf(dst, "&#%uD;", n);
947: }
948:
949: b->last = dst;
950:
951: b->last_buf = buf->last_buf;
952: b->last_in_chain = buf->last_in_chain;
953: b->flush = buf->flush;
954:
955: b->shadow = buf;
956:
957: return out;
958: }
959:
960:
961: static ngx_chain_t *
962: ngx_http_charset_recode_to_utf8(ngx_pool_t *pool, ngx_buf_t *buf,
963: ngx_http_charset_ctx_t *ctx)
964: {
965: size_t len, size;
966: u_char *p, *src, *dst, *table;
967: ngx_buf_t *b;
968: ngx_chain_t *out, *cl, **ll;
969:
970: table = ctx->table;
971:
972: for (src = buf->pos; src < buf->last; src++) {
973: if (table[*src * NGX_UTF_LEN] == '\1') {
974: continue;
975: }
976:
977: goto recode;
978: }
979:
980: out = ngx_alloc_chain_link(pool);
981: if (out == NULL) {
982: return NULL;
983: }
984:
985: out->buf = buf;
986: out->next = NULL;
987:
988: return out;
989:
990: recode:
991:
992: /*
993: * we assume that there are about half of characters to be recoded,
994: * so we preallocate "size / 2 + size / 2 * ctx->length"
995: */
996:
997: len = src - buf->pos;
998:
999: if (len > 512) {
1000: out = ngx_http_charset_get_buf(pool, ctx);
1001: if (out == NULL) {
1002: return NULL;
1003: }
1004:
1005: b = out->buf;
1006:
1007: b->temporary = buf->temporary;
1008: b->memory = buf->memory;
1009: b->mmap = buf->mmap;
1010: b->flush = buf->flush;
1011:
1012: b->pos = buf->pos;
1013: b->last = src;
1014:
1015: out->buf = b;
1016: out->next = NULL;
1017:
1018: size = buf->last - src;
1019: size = size / 2 + size / 2 * ctx->length;
1020:
1021: } else {
1022: out = NULL;
1023:
1024: size = buf->last - src;
1025: size = len + size / 2 + size / 2 * ctx->length;
1026:
1027: src = buf->pos;
1028: }
1029:
1030: cl = ngx_http_charset_get_buffer(pool, ctx, size);
1031: if (cl == NULL) {
1032: return NULL;
1033: }
1034:
1035: if (out) {
1036: out->next = cl;
1037:
1038: } else {
1039: out = cl;
1040: }
1041:
1042: ll = &cl->next;
1043:
1044: b = cl->buf;
1045: dst = b->pos;
1046:
1047: while (src < buf->last) {
1048:
1049: p = &table[*src++ * NGX_UTF_LEN];
1050: len = *p++;
1051:
1052: if ((size_t) (b->end - dst) < len) {
1053: b->last = dst;
1054:
1055: size = buf->last - src;
1056: size = len + size / 2 + size / 2 * ctx->length;
1057:
1058: cl = ngx_http_charset_get_buffer(pool, ctx, size);
1059: if (cl == NULL) {
1060: return NULL;
1061: }
1062:
1063: *ll = cl;
1064: ll = &cl->next;
1065:
1066: b = cl->buf;
1067: dst = b->pos;
1068: }
1069:
1070: while (len) {
1071: *dst++ = *p++;
1072: len--;
1073: }
1074: }
1075:
1076: b->last = dst;
1077:
1078: b->last_buf = buf->last_buf;
1079: b->last_in_chain = buf->last_in_chain;
1080: b->flush = buf->flush;
1081:
1082: b->shadow = buf;
1083:
1084: return out;
1085: }
1086:
1087:
1088: static ngx_chain_t *
1089: ngx_http_charset_get_buf(ngx_pool_t *pool, ngx_http_charset_ctx_t *ctx)
1090: {
1091: ngx_chain_t *cl;
1092:
1093: cl = ctx->free_bufs;
1094:
1095: if (cl) {
1096: ctx->free_bufs = cl->next;
1097:
1098: cl->buf->shadow = NULL;
1099: cl->next = NULL;
1100:
1101: return cl;
1102: }
1103:
1104: cl = ngx_alloc_chain_link(pool);
1105: if (cl == NULL) {
1106: return NULL;
1107: }
1108:
1109: cl->buf = ngx_calloc_buf(pool);
1110: if (cl->buf == NULL) {
1111: return NULL;
1112: }
1113:
1114: cl->next = NULL;
1115:
1116: cl->buf->tag = (ngx_buf_tag_t) &ngx_http_charset_filter_module;
1117:
1118: return cl;
1119: }
1120:
1121:
1122: static ngx_chain_t *
1123: ngx_http_charset_get_buffer(ngx_pool_t *pool, ngx_http_charset_ctx_t *ctx,
1124: size_t size)
1125: {
1126: ngx_buf_t *b;
1127: ngx_chain_t *cl, **ll;
1128:
1129: for (ll = &ctx->free_buffers, cl = ctx->free_buffers;
1130: cl;
1131: ll = &cl->next, cl = cl->next)
1132: {
1133: b = cl->buf;
1134:
1135: if ((size_t) (b->end - b->start) >= size) {
1136: *ll = cl->next;
1137: cl->next = NULL;
1138:
1139: b->pos = b->start;
1140: b->temporary = 1;
1141: b->shadow = NULL;
1142:
1143: return cl;
1144: }
1145: }
1146:
1147: cl = ngx_alloc_chain_link(pool);
1148: if (cl == NULL) {
1149: return NULL;
1150: }
1151:
1152: cl->buf = ngx_create_temp_buf(pool, size);
1153: if (cl->buf == NULL) {
1154: return NULL;
1155: }
1156:
1157: cl->next = NULL;
1158:
1159: cl->buf->temporary = 1;
1160: cl->buf->tag = (ngx_buf_tag_t) &ngx_http_charset_filter_module;
1161:
1162: return cl;
1163: }
1164:
1165:
1166: static char *
1167: ngx_http_charset_map_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1168: {
1169: ngx_http_charset_main_conf_t *mcf = conf;
1170:
1171: char *rv;
1172: u_char *p, *dst2src, **pp;
1173: ngx_int_t src, dst;
1174: ngx_uint_t i, n;
1175: ngx_str_t *value;
1176: ngx_conf_t pvcf;
1177: ngx_http_charset_t *charset;
1178: ngx_http_charset_tables_t *table;
1179: ngx_http_charset_conf_ctx_t ctx;
1180:
1181: value = cf->args->elts;
1182:
1183: src = ngx_http_add_charset(&mcf->charsets, &value[1]);
1184: if (src == NGX_ERROR) {
1185: return NGX_CONF_ERROR;
1186: }
1187:
1188: dst = ngx_http_add_charset(&mcf->charsets, &value[2]);
1189: if (dst == NGX_ERROR) {
1190: return NGX_CONF_ERROR;
1191: }
1192:
1193: if (src == dst) {
1194: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1195: "\"charset_map\" between the same charsets "
1196: "\"%V\" and \"%V\"", &value[1], &value[2]);
1197: return NGX_CONF_ERROR;
1198: }
1199:
1200: table = mcf->tables.elts;
1201: for (i = 0; i < mcf->tables.nelts; i++) {
1202: if ((src == table->src && dst == table->dst)
1203: || (src == table->dst && dst == table->src))
1204: {
1205: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1206: "duplicate \"charset_map\" between "
1207: "\"%V\" and \"%V\"", &value[1], &value[2]);
1208: return NGX_CONF_ERROR;
1209: }
1210: }
1211:
1212: table = ngx_array_push(&mcf->tables);
1213: if (table == NULL) {
1214: return NGX_CONF_ERROR;
1215: }
1216:
1217: table->src = src;
1218: table->dst = dst;
1219:
1220: if (ngx_strcasecmp(value[2].data, (u_char *) "utf-8") == 0) {
1221: table->src2dst = ngx_pcalloc(cf->pool, 256 * NGX_UTF_LEN);
1222: if (table->src2dst == NULL) {
1223: return NGX_CONF_ERROR;
1224: }
1225:
1226: table->dst2src = ngx_pcalloc(cf->pool, 256 * sizeof(void *));
1227: if (table->dst2src == NULL) {
1228: return NGX_CONF_ERROR;
1229: }
1230:
1231: dst2src = ngx_pcalloc(cf->pool, 256);
1232: if (dst2src == NULL) {
1233: return NGX_CONF_ERROR;
1234: }
1235:
1236: pp = (u_char **) &table->dst2src[0];
1237: pp[0] = dst2src;
1238:
1239: for (i = 0; i < 128; i++) {
1240: p = &table->src2dst[i * NGX_UTF_LEN];
1241: p[0] = '\1';
1242: p[1] = (u_char) i;
1243: dst2src[i] = (u_char) i;
1244: }
1245:
1246: for (/* void */; i < 256; i++) {
1247: p = &table->src2dst[i * NGX_UTF_LEN];
1248: p[0] = '\1';
1249: p[1] = '?';
1250: }
1251:
1252: } else {
1253: table->src2dst = ngx_palloc(cf->pool, 256);
1254: if (table->src2dst == NULL) {
1255: return NGX_CONF_ERROR;
1256: }
1257:
1258: table->dst2src = ngx_palloc(cf->pool, 256);
1259: if (table->dst2src == NULL) {
1260: return NGX_CONF_ERROR;
1261: }
1262:
1263: for (i = 0; i < 128; i++) {
1264: table->src2dst[i] = (u_char) i;
1265: table->dst2src[i] = (u_char) i;
1266: }
1267:
1268: for (/* void */; i < 256; i++) {
1269: table->src2dst[i] = '?';
1270: table->dst2src[i] = '?';
1271: }
1272: }
1273:
1274: charset = mcf->charsets.elts;
1275:
1276: ctx.table = table;
1277: ctx.charset = &charset[dst];
1278: ctx.characters = 0;
1279:
1280: pvcf = *cf;
1281: cf->ctx = &ctx;
1282: cf->handler = ngx_http_charset_map;
1283: cf->handler_conf = conf;
1284:
1285: rv = ngx_conf_parse(cf, NULL);
1286:
1287: *cf = pvcf;
1288:
1289: if (ctx.characters) {
1290: n = ctx.charset->length;
1291: ctx.charset->length /= ctx.characters;
1292:
1293: if (((n * 10) / ctx.characters) % 10 > 4) {
1294: ctx.charset->length++;
1295: }
1296: }
1297:
1298: return rv;
1299: }
1300:
1301:
1302: static char *
1303: ngx_http_charset_map(ngx_conf_t *cf, ngx_command_t *dummy, void *conf)
1304: {
1305: u_char *p, *dst2src, **pp;
1306: uint32_t n;
1307: ngx_int_t src, dst;
1308: ngx_str_t *value;
1309: ngx_uint_t i;
1310: ngx_http_charset_tables_t *table;
1311: ngx_http_charset_conf_ctx_t *ctx;
1312:
1313: if (cf->args->nelts != 2) {
1314: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid parameters number");
1315: return NGX_CONF_ERROR;
1316: }
1317:
1318: value = cf->args->elts;
1319:
1320: src = ngx_hextoi(value[0].data, value[0].len);
1321: if (src == NGX_ERROR || src > 255) {
1322: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1323: "invalid value \"%V\"", &value[0]);
1324: return NGX_CONF_ERROR;
1325: }
1326:
1327: ctx = cf->ctx;
1328: table = ctx->table;
1329:
1330: if (ctx->charset->utf8) {
1331: p = &table->src2dst[src * NGX_UTF_LEN];
1332:
1333: *p++ = (u_char) (value[1].len / 2);
1334:
1335: for (i = 0; i < value[1].len; i += 2) {
1336: dst = ngx_hextoi(&value[1].data[i], 2);
1337: if (dst == NGX_ERROR || dst > 255) {
1338: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1339: "invalid value \"%V\"", &value[1]);
1340: return NGX_CONF_ERROR;
1341: }
1342:
1343: *p++ = (u_char) dst;
1344: }
1345:
1346: i /= 2;
1347:
1348: ctx->charset->length += i;
1349: ctx->characters++;
1350:
1351: p = &table->src2dst[src * NGX_UTF_LEN] + 1;
1352:
1353: n = ngx_utf8_decode(&p, i);
1354:
1355: if (n > 0xffff) {
1356: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1357: "invalid value \"%V\"", &value[1]);
1358: return NGX_CONF_ERROR;
1359: }
1360:
1361: pp = (u_char **) &table->dst2src[0];
1362:
1363: dst2src = pp[n >> 8];
1364:
1365: if (dst2src == NULL) {
1366: dst2src = ngx_pcalloc(cf->pool, 256);
1367: if (dst2src == NULL) {
1368: return NGX_CONF_ERROR;
1369: }
1370:
1371: pp[n >> 8] = dst2src;
1372: }
1373:
1374: dst2src[n & 0xff] = (u_char) src;
1375:
1376: } else {
1377: dst = ngx_hextoi(value[1].data, value[1].len);
1378: if (dst == NGX_ERROR || dst > 255) {
1379: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1380: "invalid value \"%V\"", &value[1]);
1381: return NGX_CONF_ERROR;
1382: }
1383:
1384: table->src2dst[src] = (u_char) dst;
1385: table->dst2src[dst] = (u_char) src;
1386: }
1387:
1388: return NGX_CONF_OK;
1389: }
1390:
1391:
1392: static char *
1393: ngx_http_set_charset_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1394: {
1395: char *p = conf;
1396:
1397: ngx_int_t *cp;
1398: ngx_str_t *value, var;
1399: ngx_http_charset_main_conf_t *mcf;
1400:
1401: cp = (ngx_int_t *) (p + cmd->offset);
1402:
1403: if (*cp != NGX_CONF_UNSET) {
1404: return "is duplicate";
1405: }
1406:
1407: value = cf->args->elts;
1408:
1409: if (cmd->offset == offsetof(ngx_http_charset_loc_conf_t, charset)
1410: && ngx_strcmp(value[1].data, "off") == 0)
1411: {
1412: *cp = NGX_HTTP_CHARSET_OFF;
1413: return NGX_CONF_OK;
1414: }
1415:
1416:
1417: if (value[1].data[0] == '$') {
1418: var.len = value[1].len - 1;
1419: var.data = value[1].data + 1;
1420:
1421: *cp = ngx_http_get_variable_index(cf, &var);
1422:
1423: if (*cp == NGX_ERROR) {
1424: return NGX_CONF_ERROR;
1425: }
1426:
1427: *cp += NGX_HTTP_CHARSET_VAR;
1428:
1429: return NGX_CONF_OK;
1430: }
1431:
1432: mcf = ngx_http_conf_get_module_main_conf(cf,
1433: ngx_http_charset_filter_module);
1434:
1435: *cp = ngx_http_add_charset(&mcf->charsets, &value[1]);
1436: if (*cp == NGX_ERROR) {
1437: return NGX_CONF_ERROR;
1438: }
1439:
1440: return NGX_CONF_OK;
1441: }
1442:
1443:
1444: static ngx_int_t
1445: ngx_http_add_charset(ngx_array_t *charsets, ngx_str_t *name)
1446: {
1447: ngx_uint_t i;
1448: ngx_http_charset_t *c;
1449:
1450: c = charsets->elts;
1451: for (i = 0; i < charsets->nelts; i++) {
1452: if (name->len != c[i].name.len) {
1453: continue;
1454: }
1455:
1456: if (ngx_strcasecmp(name->data, c[i].name.data) == 0) {
1457: break;
1458: }
1459: }
1460:
1461: if (i < charsets->nelts) {
1462: return i;
1463: }
1464:
1465: c = ngx_array_push(charsets);
1466: if (c == NULL) {
1467: return NGX_ERROR;
1468: }
1469:
1470: c->tables = NULL;
1471: c->name = *name;
1472: c->length = 0;
1473:
1474: if (ngx_strcasecmp(name->data, (u_char *) "utf-8") == 0) {
1475: c->utf8 = 1;
1476:
1477: } else {
1478: c->utf8 = 0;
1479: }
1480:
1481: return i;
1482: }
1483:
1484:
1485: static void *
1486: ngx_http_charset_create_main_conf(ngx_conf_t *cf)
1487: {
1488: ngx_http_charset_main_conf_t *mcf;
1489:
1490: mcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_charset_main_conf_t));
1491: if (mcf == NULL) {
1492: return NULL;
1493: }
1494:
1495: if (ngx_array_init(&mcf->charsets, cf->pool, 2, sizeof(ngx_http_charset_t))
1496: != NGX_OK)
1497: {
1498: return NULL;
1499: }
1500:
1501: if (ngx_array_init(&mcf->tables, cf->pool, 1,
1502: sizeof(ngx_http_charset_tables_t))
1503: != NGX_OK)
1504: {
1505: return NULL;
1506: }
1507:
1508: if (ngx_array_init(&mcf->recodes, cf->pool, 2,
1509: sizeof(ngx_http_charset_recode_t))
1510: != NGX_OK)
1511: {
1512: return NULL;
1513: }
1514:
1515: return mcf;
1516: }
1517:
1518:
1519: static void *
1520: ngx_http_charset_create_loc_conf(ngx_conf_t *cf)
1521: {
1522: ngx_http_charset_loc_conf_t *lcf;
1523:
1524: lcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_charset_loc_conf_t));
1525: if (lcf == NULL) {
1526: return NULL;
1527: }
1528:
1529: /*
1530: * set by ngx_pcalloc():
1531: *
1532: * lcf->types = { NULL };
1533: * lcf->types_keys = NULL;
1534: */
1535:
1536: lcf->charset = NGX_CONF_UNSET;
1537: lcf->source_charset = NGX_CONF_UNSET;
1538: lcf->override_charset = NGX_CONF_UNSET;
1539:
1540: return lcf;
1541: }
1542:
1543:
1544: static char *
1545: ngx_http_charset_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
1546: {
1547: ngx_http_charset_loc_conf_t *prev = parent;
1548: ngx_http_charset_loc_conf_t *conf = child;
1549:
1550: ngx_uint_t i;
1551: ngx_http_charset_recode_t *recode;
1552: ngx_http_charset_main_conf_t *mcf;
1553:
1554: if (ngx_http_merge_types(cf, &conf->types_keys, &conf->types,
1555: &prev->types_keys, &prev->types,
1556: ngx_http_charset_default_types)
1557: != NGX_OK)
1558: {
1559: return NGX_CONF_ERROR;
1560: }
1561:
1562: ngx_conf_merge_value(conf->override_charset, prev->override_charset, 0);
1563: ngx_conf_merge_value(conf->charset, prev->charset, NGX_HTTP_CHARSET_OFF);
1564: ngx_conf_merge_value(conf->source_charset, prev->source_charset,
1565: NGX_HTTP_CHARSET_OFF);
1566:
1567: if (conf->charset == NGX_HTTP_CHARSET_OFF
1568: || conf->source_charset == NGX_HTTP_CHARSET_OFF
1569: || conf->charset == conf->source_charset)
1570: {
1571: return NGX_CONF_OK;
1572: }
1573:
1574: if (conf->source_charset >= NGX_HTTP_CHARSET_VAR
1575: || conf->charset >= NGX_HTTP_CHARSET_VAR)
1576: {
1577: return NGX_CONF_OK;
1578: }
1579:
1580: mcf = ngx_http_conf_get_module_main_conf(cf,
1581: ngx_http_charset_filter_module);
1582: recode = mcf->recodes.elts;
1583: for (i = 0; i < mcf->recodes.nelts; i++) {
1584: if (conf->source_charset == recode[i].src
1585: && conf->charset == recode[i].dst)
1586: {
1587: return NGX_CONF_OK;
1588: }
1589: }
1590:
1591: recode = ngx_array_push(&mcf->recodes);
1592: if (recode == NULL) {
1593: return NGX_CONF_ERROR;
1594: }
1595:
1596: recode->src = conf->source_charset;
1597: recode->dst = conf->charset;
1598:
1599: return NGX_CONF_OK;
1600: }
1601:
1602:
1603: static ngx_int_t
1604: ngx_http_charset_postconfiguration(ngx_conf_t *cf)
1605: {
1606: u_char **src, **dst;
1607: ngx_int_t c;
1608: ngx_uint_t i, t;
1609: ngx_http_charset_t *charset;
1610: ngx_http_charset_recode_t *recode;
1611: ngx_http_charset_tables_t *tables;
1612: ngx_http_charset_main_conf_t *mcf;
1613:
1614: mcf = ngx_http_conf_get_module_main_conf(cf,
1615: ngx_http_charset_filter_module);
1616:
1617: recode = mcf->recodes.elts;
1618: tables = mcf->tables.elts;
1619: charset = mcf->charsets.elts;
1620:
1621: for (i = 0; i < mcf->recodes.nelts; i++) {
1622:
1623: c = recode[i].src;
1624:
1625: for (t = 0; t < mcf->tables.nelts; t++) {
1626:
1627: if (c == tables[t].src && recode[i].dst == tables[t].dst) {
1628: goto next;
1629: }
1630:
1631: if (c == tables[t].dst && recode[i].dst == tables[t].src) {
1632: goto next;
1633: }
1634: }
1635:
1636: ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
1637: "no \"charset_map\" between the charsets \"%V\" and \"%V\"",
1638: &charset[c].name, &charset[recode[i].dst].name);
1639: return NGX_ERROR;
1640:
1641: next:
1642: continue;
1643: }
1644:
1645:
1646: for (t = 0; t < mcf->tables.nelts; t++) {
1647:
1648: src = charset[tables[t].src].tables;
1649:
1650: if (src == NULL) {
1651: src = ngx_pcalloc(cf->pool, sizeof(u_char *) * mcf->charsets.nelts);
1652: if (src == NULL) {
1653: return NGX_ERROR;
1654: }
1655:
1656: charset[tables[t].src].tables = src;
1657: }
1658:
1659: dst = charset[tables[t].dst].tables;
1660:
1661: if (dst == NULL) {
1662: dst = ngx_pcalloc(cf->pool, sizeof(u_char *) * mcf->charsets.nelts);
1663: if (dst == NULL) {
1664: return NGX_ERROR;
1665: }
1666:
1667: charset[tables[t].dst].tables = dst;
1668: }
1669:
1670: src[tables[t].dst] = tables[t].src2dst;
1671: dst[tables[t].src] = tables[t].dst2src;
1672: }
1673:
1674: ngx_http_next_header_filter = ngx_http_top_header_filter;
1675: ngx_http_top_header_filter = ngx_http_charset_header_filter;
1676:
1677: ngx_http_next_body_filter = ngx_http_top_body_filter;
1678: ngx_http_top_body_filter = ngx_http_charset_body_filter;
1679:
1680: return NGX_OK;
1681: }