Annotation of embedaddon/nginx/src/http/modules/ngx_http_charset_filter_module.c, revision 1.1
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: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[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