One Level Up Top Level

src/http/modules/ngx_http_charset_filter_module.c - nginx-1.7.10

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_http.h>


  13. ‌#define NGX_HTTP_CHARSET_OFF    -2
  14. ‌#define NGX_HTTP_NO_CHARSET     -3
  15. ‌#define NGX_HTTP_CHARSET_VAR    0x10000

  17. /* 1 byte length and up to 3 bytes for the UTF-8 encoding of the UCS-2 */
  18. ‌#define NGX_UTF_LEN             4

  20. ‌#define NGX_HTML_ENTITY_LEN     (sizeof("&#1114111;") - 1)


  23. typedef struct {
  24.     u_char                    **tables;
  25.     ngx_str_t                   name;

  27.     unsigned                    length:16;
  28.     unsigned                    utf8:1;
  29. ‌} ngx_http_charset_t;


  32. typedef struct {
  33.     ngx_int_t                   src;
  34.     ngx_int_t                   dst;
  35. ‌} ngx_http_charset_recode_t;


  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;


  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;


  53. typedef struct {
  54.     ngx_int_t                   charset;
  55.     ngx_int_t                   source_charset;
  56.     ngx_flag_t                  override_charset;

  58.     ngx_hash_t                  types;
  59.     ngx_array_t                *types_keys;
  60. ‌} ngx_http_charset_loc_conf_t;


  63. typedef struct {
  64.     u_char                     *table;
  65.     ngx_int_t                   charset;
  66.     ngx_str_t                   charset_name;

  68.     ngx_chain_t                *busy;
  69.     ngx_chain_t                *free_bufs;
  70.     ngx_chain_t                *free_buffers;

  72.     size_t                      saved_len;
  73.     u_char                      saved[NGX_UTF_LEN];

  75.     unsigned                    length:16;
  76.     unsigned                    from_utf8:1;
  77.     unsigned                    to_utf8:1;
  78. ‌} ngx_http_charset_ctx_t;


  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;


  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);

  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);

  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);

  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);

  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);


  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/javascript"),
  132.     ngx_string("application/rss+xml"),
  133.     ngx_null_string
  134. };


  137. ‌static ngx_command_t  ngx_http_charset_filter_commands[] = {

  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 },

  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 },

  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 },

  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] },

  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 },

  177.       ngx_null_command
  178. };


  181. ‌static ngx_http_module_t  ngx_http_charset_filter_module_ctx = {
  182.     NULL,                                  /* preconfiguration */
  183.     ngx_http_charset_postconfiguration,    /* postconfiguration */

  185.     ngx_http_charset_create_main_conf,     /* create main configuration */
  186.     NULL,                                  /* init main configuration */

  188.     NULL,                                  /* create server configuration */
  189.     NULL,                                  /* merge server configuration */

  191.     ngx_http_charset_create_loc_conf,      /* create location configuration */
  192.     ngx_http_charset_merge_loc_conf        /* merge location configuration */
  193. };


  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. };


  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;


  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;

  224.     if (r == r->main) {
  225.         charset = ngx_http_destination_charset(r, &dst);

  227.     } else {
  228.         charset = ngx_http_main_request_charset(r, &dst);
  229.     }

  231.     if (charset == NGX_ERROR) {
  232.         return NGX_ERROR;
  233.     }

  235.     if (charset == NGX_DECLINED) {
  236.         return ngx_http_next_header_filter(r);
  237.     }

  239.     /* charset: charset index or NGX_HTTP_NO_CHARSET */

  241.     source_charset = ngx_http_source_charset(r, &src);

  243.     if (source_charset == NGX_ERROR) {
  244.         return NGX_ERROR;
  245.     }

  247.     /*
  248.      * source_charset: charset index, NGX_HTTP_NO_CHARSET,
  249.      *                 or NGX_HTTP_CHARSET_OFF
  250.      */

  252.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  253.                    "charset: \"%V\" > \"%V\"", &src, &dst);

  255.     if (source_charset == NGX_HTTP_CHARSET_OFF) {
  256.         ngx_http_set_charset(r, &dst);

  258.         return ngx_http_next_header_filter(r);
  259.     }

  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.         }

  270.         ngx_http_set_charset(r, &dst);

  272.         return ngx_http_next_header_filter(r);
  273.     }

  275.     if (source_charset == charset) {
  276.         r->headers_out.content_type.len = r->headers_out.content_type_len;

  278.         ngx_http_set_charset(r, &dst);

  280.         return ngx_http_next_header_filter(r);
  281.     }

  283.     /* source_charset != charset */

  285.     if (r->headers_out.content_encoding
  286.         && r->headers_out.content_encoding->value.len)
  287.     {
  288.         return ngx_http_next_header_filter(r);
  289.     }

  291.     mcf = ngx_http_get_module_main_conf(r, ngx_http_charset_filter_module);
  292.     charsets = mcf->charsets.elts;

  294.     if (charsets[source_charset].tables == NULL
  295.         || charsets[source_charset].tables[charset] == NULL)
  296.     {
  297.         goto no_charset_map;
  298.     }

  300.     r->headers_out.content_type.len = r->headers_out.content_type_len;

  302.     ngx_http_set_charset(r, &dst);

  304.     return ngx_http_charset_ctx(r, charsets, charset, source_charset);

  306. no_charset_map:

  308.     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  309.                   "no \"charset_map\" between the charsets \"%V\" and \"%V\"",
  310.                   &src, &dst);

  312.     return ngx_http_next_header_filter(r);
  313. }


  316. static ngx_int_t
  317. ‌ngx_http_destination_charset(ngx_http_request_t *r, ngx_str_t *name)
  318. {
  319.     ngx_int_t                      charset;
  320.     ngx_http_charset_t            *charsets;
  321.     ngx_http_variable_value_t     *vv;
  322.     ngx_http_charset_loc_conf_t   *mlcf;
  323.     ngx_http_charset_main_conf_t  *mcf;

  325.     if (r->headers_out.content_type.len == 0) {
  326.         return NGX_DECLINED;
  327.     }

  329.     if (r->headers_out.override_charset
  330.         && r->headers_out.override_charset->len)
  331.     {
  332.         *name = *r->headers_out.override_charset;

  334.         charset = ngx_http_get_charset(r, name);

  336.         if (charset != NGX_HTTP_NO_CHARSET) {
  337.             return charset;
  338.         }

  340.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  341.                       "unknown charset \"%V\" to override", name);

  343.         return NGX_DECLINED;
  344.     }

  346.     mlcf = ngx_http_get_module_loc_conf(r, ngx_http_charset_filter_module);
  347.     charset = mlcf->charset;

  349.     if (charset == NGX_HTTP_CHARSET_OFF) {
  350.         return NGX_DECLINED;
  351.     }

  353.     if (r->headers_out.charset.len) {
  354.         if (mlcf->override_charset == 0) {
  355.             return NGX_DECLINED;
  356.         }

  358.     } else {
  359.         if (ngx_http_test_content_type(r, &mlcf->types) == NULL) {
  360.             return NGX_DECLINED;
  361.         }
  362.     }

  364.     if (charset < NGX_HTTP_CHARSET_VAR) {
  365.         mcf = ngx_http_get_module_main_conf(r, ngx_http_charset_filter_module);
  366.         charsets = mcf->charsets.elts;
  367.         *name = charsets[charset].name;
  368.         return charset;
  369.     }

  371.     vv = ngx_http_get_indexed_variable(r, charset - NGX_HTTP_CHARSET_VAR);

  373.     if (vv == NULL || vv->not_found) {
  374.         return NGX_ERROR;
  375.     }

  377.     name->len = vv->len;
  378.     name->data = vv->data;

  380.     return ngx_http_get_charset(r, name);
  381. }


  384. static ngx_int_t
  385. ‌ngx_http_main_request_charset(ngx_http_request_t *r, ngx_str_t *src)
  386. {
  387.     ngx_int_t                charset;
  388.     ngx_str_t               *main_charset;
  389.     ngx_http_charset_ctx_t  *ctx;

  391.     ctx = ngx_http_get_module_ctx(r->main, ngx_http_charset_filter_module);

  393.     if (ctx) {
  394.         *src = ctx->charset_name;
  395.         return ctx->charset;
  396.     }

  398.     main_charset = &r->main->headers_out.charset;

  400.     if (main_charset->len == 0) {
  401.         return NGX_DECLINED;
  402.     }

  404.     ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_charset_ctx_t));
  405.     if (ctx == NULL) {
  406.         return NGX_ERROR;
  407.     }

  409.     ngx_http_set_ctx(r->main, ctx, ngx_http_charset_filter_module);

  411.     charset = ngx_http_get_charset(r, main_charset);

  413.     ctx->charset = charset;
  414.     ctx->charset_name = *main_charset;
  415.     *src = *main_charset;

  417.     return charset;
  418. }


  421. static ngx_int_t
  422. ‌ngx_http_source_charset(ngx_http_request_t *r, ngx_str_t *name)
  423. {
  424.     ngx_int_t                      charset;
  425.     ngx_http_charset_t            *charsets;
  426.     ngx_http_variable_value_t     *vv;
  427.     ngx_http_charset_loc_conf_t   *lcf;
  428.     ngx_http_charset_main_conf_t  *mcf;

  430.     if (r->headers_out.charset.len) {
  431.         *name = r->headers_out.charset;
  432.         return ngx_http_get_charset(r, name);
  433.     }

  435.     lcf = ngx_http_get_module_loc_conf(r, ngx_http_charset_filter_module);

  437.     charset = lcf->source_charset;

  439.     if (charset == NGX_HTTP_CHARSET_OFF) {
  440.         name->len = 0;
  441.         return charset;
  442.     }

  444.     if (charset < NGX_HTTP_CHARSET_VAR) {
  445.         mcf = ngx_http_get_module_main_conf(r, ngx_http_charset_filter_module);
  446.         charsets = mcf->charsets.elts;
  447.         *name = charsets[charset].name;
  448.         return charset;
  449.     }

  451.     vv = ngx_http_get_indexed_variable(r, charset - NGX_HTTP_CHARSET_VAR);

  453.     if (vv == NULL || vv->not_found) {
  454.         return NGX_ERROR;
  455.     }

  457.     name->len = vv->len;
  458.     name->data = vv->data;

  460.     return ngx_http_get_charset(r, name);
  461. }


  464. static ngx_int_t
  465. ‌ngx_http_get_charset(ngx_http_request_t *r, ngx_str_t *name)
  466. {
  467.     ngx_uint_t                     i, n;
  468.     ngx_http_charset_t            *charset;
  469.     ngx_http_charset_main_conf_t  *mcf;

  471.     mcf = ngx_http_get_module_main_conf(r, ngx_http_charset_filter_module);

  473.     charset = mcf->charsets.elts;
  474.     n = mcf->charsets.nelts;

  476.     for (i = 0; i < n; i++) {
  477.         if (charset[i].name.len != name->len) {
  478.             continue;
  479.         }

  481.         if (ngx_strncasecmp(charset[i].name.data, name->data, name->len) == 0) {
  482.             return i;
  483.         }
  484.     }

  486.     return NGX_HTTP_NO_CHARSET;
  487. }


  490. static ngx_inline void
  491. ‌ngx_http_set_charset(ngx_http_request_t *r, ngx_str_t *charset)
  492. {
  493.     if (r != r->main) {
  494.         return;
  495.     }

  497.     if (r->headers_out.status == NGX_HTTP_MOVED_PERMANENTLY
  498.         || r->headers_out.status == NGX_HTTP_MOVED_TEMPORARILY)
  499.     {
  500.         /*
  501.          * do not set charset for the redirect because NN 4.x
  502.          * use this charset instead of the next page charset
  503.          */

  505.         r->headers_out.charset.len = 0;
  506.         return;
  507.     }

  509.     r->headers_out.charset = *charset;
  510. }


  513. static ngx_int_t
  514. ‌ngx_http_charset_ctx(ngx_http_request_t *r, ngx_http_charset_t *charsets,
  515.     ngx_int_t charset, ngx_int_t source_charset)
  516. {
  517.     ngx_http_charset_ctx_t  *ctx;

  519.     ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_charset_ctx_t));
  520.     if (ctx == NULL) {
  521.         return NGX_ERROR;
  522.     }

  524.     ngx_http_set_ctx(r, ctx, ngx_http_charset_filter_module);

  526.     ctx->table = charsets[source_charset].tables[charset];
  527.     ctx->charset = charset;
  528.     ctx->charset_name = charsets[charset].name;
  529.     ctx->length = charsets[charset].length;
  530.     ctx->from_utf8 = charsets[source_charset].utf8;
  531.     ctx->to_utf8 = charsets[charset].utf8;

  533.     r->filter_need_in_memory = 1;

  535.     if ((ctx->to_utf8 || ctx->from_utf8) && r == r->main) {
  536.         ngx_http_clear_content_length(r);

  538.     } else {
  539.         r->filter_need_temporary = 1;
  540.     }

  542.     return ngx_http_next_header_filter(r);
  543. }


  546. static ngx_int_t
  547. ‌ngx_http_charset_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
  548. {
  549.     ngx_int_t                rc;
  550.     ngx_buf_t               *b;
  551.     ngx_chain_t             *cl, *out, **ll;
  552.     ngx_http_charset_ctx_t  *ctx;

  554.     ctx = ngx_http_get_module_ctx(r, ngx_http_charset_filter_module);

  556.     if (ctx == NULL || ctx->table == NULL) {
  557.         return ngx_http_next_body_filter(r, in);
  558.     }

  560.     if ((ctx->to_utf8 || ctx->from_utf8) || ctx->busy) {

  562.         out = NULL;
  563.         ll = &out;

  565.         for (cl = in; cl; cl = cl->next) {
  566.             b = cl->buf;

  568.             if (ngx_buf_size(b) == 0) {

  570.                 *ll = ngx_alloc_chain_link(r->pool);
  571.                 if (*ll == NULL) {
  572.                     return NGX_ERROR;
  573.                 }

  575.                 (*ll)->buf = b;
  576.                 (*ll)->next = NULL;

  578.                 ll = &(*ll)->next;

  580.                 continue;
  581.             }

  583.             if (ctx->to_utf8) {
  584.                 *ll = ngx_http_charset_recode_to_utf8(r->pool, b, ctx);

  586.             } else {
  587.                 *ll = ngx_http_charset_recode_from_utf8(r->pool, b, ctx);
  588.             }

  590.             if (*ll == NULL) {
  591.                 return NGX_ERROR;
  592.             }

  594.             while (*ll) {
  595.                 ll = &(*ll)->next;
  596.             }
  597.         }

  599.         rc = ngx_http_next_body_filter(r, out);

  601.         if (out) {
  602.             if (ctx->busy == NULL) {
  603.                 ctx->busy = out;

  605.             } else {
  606.                 for (cl = ctx->busy; cl->next; cl = cl->next) { /* void */ }
  607.                 cl->next = out;
  608.             }
  609.         }

  611.         while (ctx->busy) {

  613.             cl = ctx->busy;
  614.             b = cl->buf;

  616.             if (ngx_buf_size(b) != 0) {
  617.                 break;
  618.             }

  620.             ctx->busy = cl->next;

  622.             if (b->tag != (ngx_buf_tag_t) &ngx_http_charset_filter_module) {
  623.                 continue;
  624.             }

  626.             if (b->shadow) {
  627.                 b->shadow->pos = b->shadow->last;
  628.             }

  630.             if (b->pos) {
  631.                 cl->next = ctx->free_buffers;
  632.                 ctx->free_buffers = cl;
  633.                 continue;
  634.             }

  636.             cl->next = ctx->free_bufs;
  637.             ctx->free_bufs = cl;
  638.         }

  640.         return rc;
  641.     }

  643.     for (cl = in; cl; cl = cl->next) {
  644.         (void) ngx_http_charset_recode(cl->buf, ctx->table);
  645.     }

  647.     return ngx_http_next_body_filter(r, in);
  648. }


  651. static ngx_uint_t
  652. ‌ngx_http_charset_recode(ngx_buf_t *b, u_char *table)
  653. {
  654.     u_char  *p, *last;

  656.     last = b->last;

  658.     for (p = b->pos; p < last; p++) {

  660.         if (*p != table[*p]) {
  661.             goto recode;
  662.         }
  663.     }

  665.     return 0;

  667. recode:

  669.     do {
  670.         if (*p != table[*p]) {
  671.             *p = table[*p];
  672.         }

  674.         p++;

  676.     } while (p < last);

  678.     b->in_file = 0;

  680.     return 1;
  681. }


  684. static ngx_chain_t *
  685. ‌ngx_http_charset_recode_from_utf8(ngx_pool_t *pool, ngx_buf_t *buf,
  686.     ngx_http_charset_ctx_t *ctx)
  687. {
  688.     size_t        len, size;
  689.     u_char        c, *p, *src, *dst, *saved, **table;
  690.     uint32_t      n;
  691.     ngx_buf_t    *b;
  692.     ngx_uint_t    i;
  693.     ngx_chain_t  *out, *cl, **ll;

  695.     src = buf->pos;

  697.     if (ctx->saved_len == 0) {

  699.         for ( /* void */ ; src < buf->last; src++) {

  701.             if (*src < 0x80) {
  702.                 continue;
  703.             }

  705.             len = src - buf->pos;

  707.             if (len > 512) {
  708.                 out = ngx_http_charset_get_buf(pool, ctx);
  709.                 if (out == NULL) {
  710.                     return NULL;
  711.                 }

  713.                 b = out->buf;

  715.                 b->temporary = buf->temporary;
  716.                 b->memory = buf->memory;
  717.                 b->mmap = buf->mmap;
  718.                 b->flush = buf->flush;

  720.                 b->pos = buf->pos;
  721.                 b->last = src;

  723.                 out->buf = b;
  724.                 out->next = NULL;

  726.                 size = buf->last - src;

  728.                 saved = src;
  729.                 n = ngx_utf8_decode(&saved, size);

  731.                 if (n == 0xfffffffe) {
  732.                     /* incomplete UTF-8 symbol */

  734.                     ngx_memcpy(ctx->saved, src, size);
  735.                     ctx->saved_len = size;

  737.                     b->shadow = buf;

  739.                     return out;
  740.                 }

  742.             } else {
  743.                 out = NULL;
  744.                 size = len + buf->last - src;
  745.                 src = buf->pos;
  746.             }

  748.             if (size < NGX_HTML_ENTITY_LEN) {
  749.                 size += NGX_HTML_ENTITY_LEN;
  750.             }

  752.             cl = ngx_http_charset_get_buffer(pool, ctx, size);
  753.             if (cl == NULL) {
  754.                 return NULL;
  755.             }

  757.             if (out) {
  758.                 out->next = cl;

  760.             } else {
  761.                 out = cl;
  762.             }

  764.             b = cl->buf;
  765.             dst = b->pos;

  767.             goto recode;
  768.         }

  770.         out = ngx_alloc_chain_link(pool);
  771.         if (out == NULL) {
  772.             return NULL;
  773.         }

  775.         out->buf = buf;
  776.         out->next = NULL;

  778.         return out;
  779.     }

  781.     /* process incomplete UTF sequence from previous buffer */

  783.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pool->log, 0,
  784.                    "http charset utf saved: %z", ctx->saved_len);

  786.     p = src;

  788.     for (i = ctx->saved_len; i < NGX_UTF_LEN; i++) {
  789.         ctx->saved[i] = *p++;

  791.         if (p == buf->last) {
  792.             break;
  793.         }
  794.     }

  796.     saved = ctx->saved;
  797.     n = ngx_utf8_decode(&saved, i);

  799.     c = '\0';

  801.     if (n < 0x10000) {
  802.         table = (u_char **) ctx->table;
  803.         p = table[n >> 8];

  805.         if (p) {
  806.             c = p[n & 0xff];
  807.         }

  809.     } else if (n == 0xfffffffe) {

  811.         /* incomplete UTF-8 symbol */

  813.         if (i < NGX_UTF_LEN) {
  814.             out = ngx_http_charset_get_buf(pool, ctx);
  815.             if (out == NULL) {
  816.                 return NULL;
  817.             }

  819.             b = out->buf;

  821.             b->pos = buf->pos;
  822.             b->last = buf->last;
  823.             b->sync = 1;
  824.             b->shadow = buf;

  826.             ngx_memcpy(&ctx->saved[ctx->saved_len], src, i);
  827.             ctx->saved_len += i;

  829.             return out;
  830.         }
  831.     }

  833.     size = buf->last - buf->pos;

  835.     if (size < NGX_HTML_ENTITY_LEN) {
  836.         size += NGX_HTML_ENTITY_LEN;
  837.     }

  839.     cl = ngx_http_charset_get_buffer(pool, ctx, size);
  840.     if (cl == NULL) {
  841.         return NULL;
  842.     }

  844.     out = cl;

  846.     b = cl->buf;
  847.     dst = b->pos;

  849.     if (c) {
  850.         *dst++ = c;

  852.     } else if (n == 0xfffffffe) {
  853.         *dst++ = '?';

  855.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pool->log, 0,
  856.                        "http charset invalid utf 0");

  858.         saved = &ctx->saved[NGX_UTF_LEN];

  860.     } else if (n > 0x10ffff) {
  861.         *dst++ = '?';

  863.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pool->log, 0,
  864.                        "http charset invalid utf 1");

  866.     } else {
  867.         dst = ngx_sprintf(dst, "&#%uD;", n);
  868.     }

  870.     src += (saved - ctx->saved) - ctx->saved_len;
  871.     ctx->saved_len = 0;

  873. recode:

  875.     ll = &cl->next;

  877.     table = (u_char **) ctx->table;

  879.     while (src < buf->last) {

  881.         if ((size_t) (b->end - dst) < NGX_HTML_ENTITY_LEN) {
  882.             b->last = dst;

  884.             size = buf->last - src + NGX_HTML_ENTITY_LEN;

  886.             cl = ngx_http_charset_get_buffer(pool, ctx, size);
  887.             if (cl == NULL) {
  888.                 return NULL;
  889.             }

  891.             *ll = cl;
  892.             ll = &cl->next;

  894.             b = cl->buf;
  895.             dst = b->pos;
  896.         }

  898.         if (*src < 0x80) {
  899.             *dst++ = *src++;
  900.             continue;
  901.         }

  903.         len = buf->last - src;

  905.         n = ngx_utf8_decode(&src, len);

  907.         if (n < 0x10000) {

  909.             p = table[n >> 8];

  911.             if (p) {
  912.                 c = p[n & 0xff];

  914.                 if (c) {
  915.                     *dst++ = c;
  916.                     continue;
  917.                 }
  918.             }

  920.             dst = ngx_sprintf(dst, "&#%uD;", n);

  922.             continue;
  923.         }

  925.         if (n == 0xfffffffe) {
  926.             /* incomplete UTF-8 symbol */

  928.             ngx_memcpy(ctx->saved, src, len);
  929.             ctx->saved_len = len;

  931.             if (b->pos == dst) {
  932.                 b->sync = 1;
  933.                 b->temporary = 0;
  934.             }

  936.             break;
  937.         }

  939.         if (n > 0x10ffff) {
  940.             *dst++ = '?';

  942.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pool->log, 0,
  943.                            "http charset invalid utf 2");

  945.             continue;
  946.         }

  948.         /* n > 0xffff */

  950.         dst = ngx_sprintf(dst, "&#%uD;", n);
  951.     }

  953.     b->last = dst;

  955.     b->last_buf = buf->last_buf;
  956.     b->last_in_chain = buf->last_in_chain;
  957.     b->flush = buf->flush;

  959.     b->shadow = buf;

  961.     return out;
  962. }


  965. static ngx_chain_t *
  966. ‌ngx_http_charset_recode_to_utf8(ngx_pool_t *pool, ngx_buf_t *buf,
  967.     ngx_http_charset_ctx_t *ctx)
  968. {
  969.     size_t        len, size;
  970.     u_char       *p, *src, *dst, *table;
  971.     ngx_buf_t    *b;
  972.     ngx_chain_t  *out, *cl, **ll;

  974.     table = ctx->table;

  976.     for (src = buf->pos; src < buf->last; src++) {
  977.         if (table[*src * NGX_UTF_LEN] == '\1') {
  978.             continue;
  979.         }

  981.         goto recode;
  982.     }

  984.     out = ngx_alloc_chain_link(pool);
  985.     if (out == NULL) {
  986.         return NULL;
  987.     }

  989.     out->buf = buf;
  990.     out->next = NULL;

  992.     return out;

  994. recode:

  996.     /*
  997.      * we assume that there are about half of characters to be recoded,
  998.      * so we preallocate "size / 2 + size / 2 * ctx->length"
  999.      */

  1001.     len = src - buf->pos;

  1003.     if (len > 512) {
  1004.         out = ngx_http_charset_get_buf(pool, ctx);
  1005.         if (out == NULL) {
  1006.             return NULL;
  1007.         }

  1009.         b = out->buf;

  1011.         b->temporary = buf->temporary;
  1012.         b->memory = buf->memory;
  1013.         b->mmap = buf->mmap;
  1014.         b->flush = buf->flush;

  1016.         b->pos = buf->pos;
  1017.         b->last = src;

  1019.         out->buf = b;
  1020.         out->next = NULL;

  1022.         size = buf->last - src;
  1023.         size = size / 2 + size / 2 * ctx->length;

  1025.     } else {
  1026.         out = NULL;

  1028.         size = buf->last - src;
  1029.         size = len + size / 2 + size / 2 * ctx->length;

  1031.         src = buf->pos;
  1032.     }

  1034.     cl = ngx_http_charset_get_buffer(pool, ctx, size);
  1035.     if (cl == NULL) {
  1036.         return NULL;
  1037.     }

  1039.     if (out) {
  1040.         out->next = cl;

  1042.     } else {
  1043.         out = cl;
  1044.     }

  1046.     ll = &cl->next;

  1048.     b = cl->buf;
  1049.     dst = b->pos;

  1051.     while (src < buf->last) {

  1053.         p = &table[*src++ * NGX_UTF_LEN];
  1054.         len = *p++;

  1056.         if ((size_t) (b->end - dst) < len) {
  1057.             b->last = dst;

  1059.             size = buf->last - src;
  1060.             size = len + size / 2 + size / 2 * ctx->length;

  1062.             cl = ngx_http_charset_get_buffer(pool, ctx, size);
  1063.             if (cl == NULL) {
  1064.                 return NULL;
  1065.             }

  1067.             *ll = cl;
  1068.             ll = &cl->next;

  1070.             b = cl->buf;
  1071.             dst = b->pos;
  1072.         }

  1074.         while (len) {
  1075.             *dst++ = *p++;
  1076.             len--;
  1077.         }
  1078.     }

  1080.     b->last = dst;

  1082.     b->last_buf = buf->last_buf;
  1083.     b->last_in_chain = buf->last_in_chain;
  1084.     b->flush = buf->flush;

  1086.     b->shadow = buf;

  1088.     return out;
  1089. }


  1092. static ngx_chain_t *
  1093. ‌ngx_http_charset_get_buf(ngx_pool_t *pool, ngx_http_charset_ctx_t *ctx)
  1094. {
  1095.     ngx_chain_t  *cl;

  1097.     cl = ctx->free_bufs;

  1099.     if (cl) {
  1100.         ctx->free_bufs = cl->next;

  1102.         cl->buf->shadow = NULL;
  1103.         cl->next = NULL;

  1105.         return cl;
  1106.     }

  1108.     cl = ngx_alloc_chain_link(pool);
  1109.     if (cl == NULL) {
  1110.         return NULL;
  1111.     }

  1113.     cl->buf = ngx_calloc_buf(pool);
  1114.     if (cl->buf == NULL) {
  1115.         return NULL;
  1116.     }

  1118.     cl->next = NULL;

  1120.     cl->buf->tag = (ngx_buf_tag_t) &ngx_http_charset_filter_module;

  1122.     return cl;
  1123. }


  1126. static ngx_chain_t *
  1127. ‌ngx_http_charset_get_buffer(ngx_pool_t *pool, ngx_http_charset_ctx_t *ctx,
  1128.     size_t size)
  1129. {
  1130.     ngx_buf_t    *b;
  1131.     ngx_chain_t  *cl, **ll;

  1133.     for (ll = &ctx->free_buffers, cl = ctx->free_buffers;
  1134.          cl;
  1135.          ll = &cl->next, cl = cl->next)
  1136.     {
  1137.         b = cl->buf;

  1139.         if ((size_t) (b->end - b->start) >= size) {
  1140.             *ll = cl->next;
  1141.             cl->next = NULL;

  1143.             b->pos = b->start;
  1144.             b->temporary = 1;
  1145.             b->shadow = NULL;

  1147.             return cl;
  1148.         }
  1149.     }

  1151.     cl = ngx_alloc_chain_link(pool);
  1152.     if (cl == NULL) {
  1153.         return NULL;
  1154.     }

  1156.     cl->buf = ngx_create_temp_buf(pool, size);
  1157.     if (cl->buf == NULL) {
  1158.         return NULL;
  1159.     }

  1161.     cl->next = NULL;

  1163.     cl->buf->temporary = 1;
  1164.     cl->buf->tag = (ngx_buf_tag_t) &ngx_http_charset_filter_module;

  1166.     return cl;
  1167. }


  1170. static char *
  1171. ‌ngx_http_charset_map_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1172. {
  1173.     ngx_http_charset_main_conf_t  *mcf = conf;

  1175.     char                         *rv;
  1176.     u_char                       *p, *dst2src, **pp;
  1177.     ngx_int_t                     src, dst;
  1178.     ngx_uint_t                    i, n;
  1179.     ngx_str_t                    *value;
  1180.     ngx_conf_t                    pvcf;
  1181.     ngx_http_charset_t           *charset;
  1182.     ngx_http_charset_tables_t    *table;
  1183.     ngx_http_charset_conf_ctx_t   ctx;

  1185.     value = cf->args->elts;

  1187.     src = ngx_http_add_charset(&mcf->charsets, &value[1]);
  1188.     if (src == NGX_ERROR) {
  1189.         return NGX_CONF_ERROR;
  1190.     }

  1192.     dst = ngx_http_add_charset(&mcf->charsets, &value[2]);
  1193.     if (dst == NGX_ERROR) {
  1194.         return NGX_CONF_ERROR;
  1195.     }

  1197.     if (src == dst) {
  1198.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1199.                            "\"charset_map\" between the same charsets "
  1200.                            "\"%V\" and \"%V\"", &value[1], &value[2]);
  1201.         return NGX_CONF_ERROR;
  1202.     }

  1204.     table = mcf->tables.elts;
  1205.     for (i = 0; i < mcf->tables.nelts; i++) {
  1206.         if ((src == table->src && dst == table->dst)
  1207.              || (src == table->dst && dst == table->src))
  1208.         {
  1209.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1210.                                "duplicate \"charset_map\" between "
  1211.                                "\"%V\" and \"%V\"", &value[1], &value[2]);
  1212.             return NGX_CONF_ERROR;
  1213.         }
  1214.     }

  1216.     table = ngx_array_push(&mcf->tables);
  1217.     if (table == NULL) {
  1218.         return NGX_CONF_ERROR;
  1219.     }

  1221.     table->src = src;
  1222.     table->dst = dst;

  1224.     if (ngx_strcasecmp(value[2].data, (u_char *) "utf-8") == 0) {
  1225.         table->src2dst = ngx_pcalloc(cf->pool, 256 * NGX_UTF_LEN);
  1226.         if (table->src2dst == NULL) {
  1227.             return NGX_CONF_ERROR;
  1228.         }

  1230.         table->dst2src = ngx_pcalloc(cf->pool, 256 * sizeof(void *));
  1231.         if (table->dst2src == NULL) {
  1232.             return NGX_CONF_ERROR;
  1233.         }

  1235.         dst2src = ngx_pcalloc(cf->pool, 256);
  1236.         if (dst2src == NULL) {
  1237.             return NGX_CONF_ERROR;
  1238.         }

  1240.         pp = (u_char **) &table->dst2src[0];
  1241.         pp[0] = dst2src;

  1243.         for (i = 0; i < 128; i++) {
  1244.             p = &table->src2dst[i * NGX_UTF_LEN];
  1245.             p[0] = '\1';
  1246.             p[1] = (u_char) i;
  1247.             dst2src[i] = (u_char) i;
  1248.         }

  1250.         for (/* void */; i < 256; i++) {
  1251.             p = &table->src2dst[i * NGX_UTF_LEN];
  1252.             p[0] = '\1';
  1253.             p[1] = '?';
  1254.         }

  1256.     } else {
  1257.         table->src2dst = ngx_palloc(cf->pool, 256);
  1258.         if (table->src2dst == NULL) {
  1259.             return NGX_CONF_ERROR;
  1260.         }

  1262.         table->dst2src = ngx_palloc(cf->pool, 256);
  1263.         if (table->dst2src == NULL) {
  1264.             return NGX_CONF_ERROR;
  1265.         }

  1267.         for (i = 0; i < 128; i++) {
  1268.             table->src2dst[i] = (u_char) i;
  1269.             table->dst2src[i] = (u_char) i;
  1270.         }

  1272.         for (/* void */; i < 256; i++) {
  1273.             table->src2dst[i] = '?';
  1274.             table->dst2src[i] = '?';
  1275.         }
  1276.     }

  1278.     charset = mcf->charsets.elts;

  1280.     ctx.table = table;
  1281.     ctx.charset = &charset[dst];
  1282.     ctx.characters = 0;

  1284.     pvcf = *cf;
  1285.     cf->ctx = &ctx;
  1286.     cf->handler = ngx_http_charset_map;
  1287.     cf->handler_conf = conf;

  1289.     rv = ngx_conf_parse(cf, NULL);

  1291.     *cf = pvcf;

  1293.     if (ctx.characters) {
  1294.         n = ctx.charset->length;
  1295.         ctx.charset->length /= ctx.characters;

  1297.         if (((n * 10) / ctx.characters) % 10 > 4) {
  1298.             ctx.charset->length++;
  1299.         }
  1300.     }

  1302.     return rv;
  1303. }


  1306. static char *
  1307. ‌ngx_http_charset_map(ngx_conf_t *cf, ngx_command_t *dummy, void *conf)
  1308. {
  1309.     u_char                       *p, *dst2src, **pp;
  1310.     uint32_t                      n;
  1311.     ngx_int_t                     src, dst;
  1312.     ngx_str_t                    *value;
  1313.     ngx_uint_t                    i;
  1314.     ngx_http_charset_tables_t    *table;
  1315.     ngx_http_charset_conf_ctx_t  *ctx;

  1317.     if (cf->args->nelts != 2) {
  1318.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid parameters number");
  1319.         return NGX_CONF_ERROR;
  1320.     }

  1322.     value = cf->args->elts;

  1324.     src = ngx_hextoi(value[0].data, value[0].len);
  1325.     if (src == NGX_ERROR || src > 255) {
  1326.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1327.                            "invalid value \"%V\"", &value[0]);
  1328.         return NGX_CONF_ERROR;
  1329.     }

  1331.     ctx = cf->ctx;
  1332.     table = ctx->table;

  1334.     if (ctx->charset->utf8) {
  1335.         p = &table->src2dst[src * NGX_UTF_LEN];

  1337.         *p++ = (u_char) (value[1].len / 2);

  1339.         for (i = 0; i < value[1].len; i += 2) {
  1340.             dst = ngx_hextoi(&value[1].data[i], 2);
  1341.             if (dst == NGX_ERROR || dst > 255) {
  1342.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1343.                                    "invalid value \"%V\"", &value[1]);
  1344.                 return NGX_CONF_ERROR;
  1345.             }

  1347.             *p++ = (u_char) dst;
  1348.         }

  1350.         i /= 2;

  1352.         ctx->charset->length += i;
  1353.         ctx->characters++;

  1355.         p = &table->src2dst[src * NGX_UTF_LEN] + 1;

  1357.         n = ngx_utf8_decode(&p, i);

  1359.         if (n > 0xffff) {
  1360.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1361.                                "invalid value \"%V\"", &value[1]);
  1362.             return NGX_CONF_ERROR;
  1363.         }

  1365.         pp = (u_char **) &table->dst2src[0];

  1367.         dst2src = pp[n >> 8];

  1369.         if (dst2src == NULL) {
  1370.             dst2src = ngx_pcalloc(cf->pool, 256);
  1371.             if (dst2src == NULL) {
  1372.                 return NGX_CONF_ERROR;
  1373.             }

  1375.             pp[n >> 8] = dst2src;
  1376.         }

  1378.         dst2src[n & 0xff] = (u_char) src;

  1380.     } else {
  1381.         dst = ngx_hextoi(value[1].data, value[1].len);
  1382.         if (dst == NGX_ERROR || dst > 255) {
  1383.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1384.                                "invalid value \"%V\"", &value[1]);
  1385.             return NGX_CONF_ERROR;
  1386.         }

  1388.         table->src2dst[src] = (u_char) dst;
  1389.         table->dst2src[dst] = (u_char) src;
  1390.     }

  1392.     return NGX_CONF_OK;
  1393. }


  1396. static char *
  1397. ‌ngx_http_set_charset_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1398. {
  1399.     char  *p = conf;

  1401.     ngx_int_t                     *cp;
  1402.     ngx_str_t                     *value, var;
  1403.     ngx_http_charset_main_conf_t  *mcf;

  1405.     cp = (ngx_int_t *) (p + cmd->offset);

  1407.     if (*cp != NGX_CONF_UNSET) {
  1408.         return "is duplicate";
  1409.     }

  1411.     value = cf->args->elts;

  1413.     if (cmd->offset == offsetof(ngx_http_charset_loc_conf_t, charset)
  1414.         && ngx_strcmp(value[1].data, "off") == 0)
  1415.     {
  1416.         *cp = NGX_HTTP_CHARSET_OFF;
  1417.         return NGX_CONF_OK;
  1418.     }


  1421.     if (value[1].data[0] == '$') {
  1422.         var.len = value[1].len - 1;
  1423.         var.data = value[1].data + 1;

  1425.         *cp = ngx_http_get_variable_index(cf, &var);

  1427.         if (*cp == NGX_ERROR) {
  1428.             return NGX_CONF_ERROR;
  1429.         }

  1431.         *cp += NGX_HTTP_CHARSET_VAR;

  1433.         return NGX_CONF_OK;
  1434.     }

  1436.     mcf = ngx_http_conf_get_module_main_conf(cf,
  1437.                                              ngx_http_charset_filter_module);

  1439.     *cp = ngx_http_add_charset(&mcf->charsets, &value[1]);
  1440.     if (*cp == NGX_ERROR) {
  1441.         return NGX_CONF_ERROR;
  1442.     }

  1444.     return NGX_CONF_OK;
  1445. }


  1448. static ngx_int_t
  1449. ‌ngx_http_add_charset(ngx_array_t *charsets, ngx_str_t *name)
  1450. {
  1451.     ngx_uint_t           i;
  1452.     ngx_http_charset_t  *c;

  1454.     c = charsets->elts;
  1455.     for (i = 0; i < charsets->nelts; i++) {
  1456.         if (name->len != c[i].name.len) {
  1457.             continue;
  1458.         }

  1460.         if (ngx_strcasecmp(name->data, c[i].name.data) == 0) {
  1461.             break;
  1462.         }
  1463.     }

  1465.     if (i < charsets->nelts) {
  1466.         return i;
  1467.     }

  1469.     c = ngx_array_push(charsets);
  1470.     if (c == NULL) {
  1471.         return NGX_ERROR;
  1472.     }

  1474.     c->tables = NULL;
  1475.     c->name = *name;
  1476.     c->length = 0;

  1478.     if (ngx_strcasecmp(name->data, (u_char *) "utf-8") == 0) {
  1479.         c->utf8 = 1;

  1481.     } else {
  1482.         c->utf8 = 0;
  1483.     }

  1485.     return i;
  1486. }


  1489. static void *
  1490. ‌ngx_http_charset_create_main_conf(ngx_conf_t *cf)
  1491. {
  1492.     ngx_http_charset_main_conf_t  *mcf;

  1494.     mcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_charset_main_conf_t));
  1495.     if (mcf == NULL) {
  1496.         return NULL;
  1497.     }

  1499.     if (ngx_array_init(&mcf->charsets, cf->pool, 2, sizeof(ngx_http_charset_t))
  1500.         != NGX_OK)
  1501.     {
  1502.         return NULL;
  1503.     }

  1505.     if (ngx_array_init(&mcf->tables, cf->pool, 1,
  1506.                        sizeof(ngx_http_charset_tables_t))
  1507.         != NGX_OK)
  1508.     {
  1509.         return NULL;
  1510.     }

  1512.     if (ngx_array_init(&mcf->recodes, cf->pool, 2,
  1513.                        sizeof(ngx_http_charset_recode_t))
  1514.         != NGX_OK)
  1515.     {
  1516.         return NULL;
  1517.     }

  1519.     return mcf;
  1520. }


  1523. static void *
  1524. ‌ngx_http_charset_create_loc_conf(ngx_conf_t *cf)
  1525. {
  1526.     ngx_http_charset_loc_conf_t  *lcf;

  1528.     lcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_charset_loc_conf_t));
  1529.     if (lcf == NULL) {
  1530.         return NULL;
  1531.     }

  1533.     /*
  1534.      * set by ngx_pcalloc():
  1535.      *
  1536.      *     lcf->types = { NULL };
  1537.      *     lcf->types_keys = NULL;
  1538.      */

  1540.     lcf->charset = NGX_CONF_UNSET;
  1541.     lcf->source_charset = NGX_CONF_UNSET;
  1542.     lcf->override_charset = NGX_CONF_UNSET;

  1544.     return lcf;
  1545. }


  1548. static char *
  1549. ‌ngx_http_charset_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  1550. {
  1551.     ngx_http_charset_loc_conf_t *prev = parent;
  1552.     ngx_http_charset_loc_conf_t *conf = child;

  1554.     ngx_uint_t                     i;
  1555.     ngx_http_charset_recode_t     *recode;
  1556.     ngx_http_charset_main_conf_t  *mcf;

  1558.     if (ngx_http_merge_types(cf, &conf->types_keys, &conf->types,
  1559.                              &prev->types_keys, &prev->types,
  1560.                              ngx_http_charset_default_types)
  1561.         != NGX_OK)
  1562.     {
  1563.         return NGX_CONF_ERROR;
  1564.     }

  1566.     ngx_conf_merge_value(conf->override_charset, prev->override_charset, 0);
  1567.     ngx_conf_merge_value(conf->charset, prev->charset, NGX_HTTP_CHARSET_OFF);
  1568.     ngx_conf_merge_value(conf->source_charset, prev->source_charset,
  1569.                          NGX_HTTP_CHARSET_OFF);

  1571.     if (conf->charset == NGX_HTTP_CHARSET_OFF
  1572.         || conf->source_charset == NGX_HTTP_CHARSET_OFF
  1573.         || conf->charset == conf->source_charset)
  1574.     {
  1575.         return NGX_CONF_OK;
  1576.     }

  1578.     if (conf->source_charset >= NGX_HTTP_CHARSET_VAR
  1579.         || conf->charset >= NGX_HTTP_CHARSET_VAR)
  1580.     {
  1581.         return NGX_CONF_OK;
  1582.     }

  1584.     mcf = ngx_http_conf_get_module_main_conf(cf,
  1585.                                              ngx_http_charset_filter_module);
  1586.     recode = mcf->recodes.elts;
  1587.     for (i = 0; i < mcf->recodes.nelts; i++) {
  1588.         if (conf->source_charset == recode[i].src
  1589.             && conf->charset == recode[i].dst)
  1590.         {
  1591.             return NGX_CONF_OK;
  1592.         }
  1593.     }

  1595.     recode = ngx_array_push(&mcf->recodes);
  1596.     if (recode == NULL) {
  1597.         return NGX_CONF_ERROR;
  1598.     }

  1600.     recode->src = conf->source_charset;
  1601.     recode->dst = conf->charset;

  1603.     return NGX_CONF_OK;
  1604. }


  1607. static ngx_int_t
  1608. ‌ngx_http_charset_postconfiguration(ngx_conf_t *cf)
  1609. {
  1610.     u_char                       **src, **dst;
  1611.     ngx_int_t                      c;
  1612.     ngx_uint_t                     i, t;
  1613.     ngx_http_charset_t            *charset;
  1614.     ngx_http_charset_recode_t     *recode;
  1615.     ngx_http_charset_tables_t     *tables;
  1616.     ngx_http_charset_main_conf_t  *mcf;

  1618.     mcf = ngx_http_conf_get_module_main_conf(cf,
  1619.                                              ngx_http_charset_filter_module);

  1621.     recode = mcf->recodes.elts;
  1622.     tables = mcf->tables.elts;
  1623.     charset = mcf->charsets.elts;

  1625.     for (i = 0; i < mcf->recodes.nelts; i++) {

  1627.         c = recode[i].src;

  1629.         for (t = 0; t < mcf->tables.nelts; t++) {

  1631.             if (c == tables[t].src && recode[i].dst == tables[t].dst) {
  1632.                 goto next;
  1633.             }

  1635.             if (c == tables[t].dst && recode[i].dst == tables[t].src) {
  1636.                 goto next;
  1637.             }
  1638.         }

  1640.         ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  1641.                    "no \"charset_map\" between the charsets \"%V\" and \"%V\"",
  1642.                    &charset[c].name, &charset[recode[i].dst].name);
  1643.         return NGX_ERROR;

  1645.     next:
  1646.         continue;
  1647.     }


  1650.     for (t = 0; t < mcf->tables.nelts; t++) {

  1652.         src = charset[tables[t].src].tables;

  1654.         if (src == NULL) {
  1655.             src = ngx_pcalloc(cf->pool, sizeof(u_char *) * mcf->charsets.nelts);
  1656.             if (src == NULL) {
  1657.                 return NGX_ERROR;
  1658.             }

  1660.             charset[tables[t].src].tables = src;
  1661.         }

  1663.         dst = charset[tables[t].dst].tables;

  1665.         if (dst == NULL) {
  1666.             dst = ngx_pcalloc(cf->pool, sizeof(u_char *) * mcf->charsets.nelts);
  1667.             if (dst == NULL) {
  1668.                 return NGX_ERROR;
  1669.             }

  1671.             charset[tables[t].dst].tables = dst;
  1672.         }

  1674.         src[tables[t].dst] = tables[t].src2dst;
  1675.         dst[tables[t].src] = tables[t].dst2src;
  1676.     }

  1678.     ngx_http_next_header_filter = ngx_http_top_header_filter;
  1679.     ngx_http_top_header_filter = ngx_http_charset_header_filter;

  1681.     ngx_http_next_body_filter = ngx_http_top_body_filter;
  1682.     ngx_http_top_body_filter = ngx_http_charset_body_filter;

  1684.     return NGX_OK;
  1685. }

One Level Up Top Level