e655a84bbb62bb1c66993fda5e74b04feda14dc6kess

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#include "httpd.h"

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#include "http_config.h"

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#define CORE_PRIVATE

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#include "http_core.h"

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#include "http_log.h"

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#include "http_main.h"

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#include "http_protocol.h"

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#include "http_request.h"

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#include "util_charset.h"

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#include "apr_buckets.h"

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#include "util_filter.h"

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#include "apr_strings.h"

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#include "apr_lib.h"

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#include "apr_xlate.h"

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#define APR_WANT_STRFUNC

d1348237b33bc1755b9f1165eea52317465a7671nd#include "apr_want.h"

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#define OUTPUT_XLATE_BUF_SIZE (16*1024) /* size of translation buffer used on output */

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#define INPUT_XLATE_BUF_SIZE (8*1024) /* size of translation buffer used on input */

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#define XLATE_MIN_BUFF_LEFT 128 /* flush once there is no more than this much

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#define FATTEST_CHAR 8 /* we don't handle chars wider than this that straddle

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess

e655a84bbb62bb1c66993fda5e74b04feda14dc6kesstypedef enum {

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess EES_INIT = 0, /* no error info yet; value must be 0 for easy init */

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess EES_LIMIT, /* built-in restriction encountered */

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess EES_INCOMPLETE_CHAR, /* incomplete multi-byte char at end of content */

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess EES_BUCKET_READ,

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess EES_DOWNSTREAM, /* something bad happened in a filter below xlate */

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess EES_BAD_INPUT /* input data invalid */

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess} ees_t;

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#define XLATEOUT_FILTER_NAME "XLATEOUT"

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess#define XLATEIN_FILTER_NAME "XLATEIN"

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess

e655a84bbb62bb1c66993fda5e74b04feda14dc6kesstypedef struct charset_dir_t {

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess /** debug level; -1 means uninitialized, 0 means no debug */

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess int debug;

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess const char *charset_source; /* source encoding */

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess const char *charset_default; /* how to ship on wire */

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess /** module does ap_add_*_filter()? */

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess enum {IA_INIT, IA_IMPADD, IA_NOIMPADD} implicit_add;

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess} charset_dir_t;

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess

e655a84bbb62bb1c66993fda5e74b04feda14dc6kesstypedef struct charset_filter_ctx_t {

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess apr_xlate_t *xlate;

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess charset_dir_t *dc;

1c8f2418892d98febb00a06b9a4f45f8bcfd80a3nd ees_t ees; /* extended error status */

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess apr_size_t saved;

fac8c35bfb158112226ab43ddf84d59daca5dc30nd char buf[FATTEST_CHAR]; /* we want to be able to build a complete char here */

d474d8ef01ec5c2a09341cd148851ed383c3287crbowen int ran; /* has filter instance run before? */

d474d8ef01ec5c2a09341cd148851ed383c3287crbowen int noop; /* should we pass brigades through unchanged? */

727872d18412fc021f03969b8641810d8896820bhumbedooh char *tmp; /* buffer for input filtering */

0d0ba3a410038e179b695446bb149cce6264e0abnd apr_bucket_brigade *bb; /* input buckets we couldn't finish translating */

727872d18412fc021f03969b8641810d8896820bhumbedooh} charset_filter_ctx_t;

cc7e1025de9ac63bd4db6fe7f71c158b2cf09fe4humbedooh

0d0ba3a410038e179b695446bb149cce6264e0abndtypedef struct charset_req_t {

0d0ba3a410038e179b695446bb149cce6264e0abnd charset_dir_t *dc;

0d0ba3a410038e179b695446bb149cce6264e0abnd charset_filter_ctx_t *output_ctx, *input_ctx;

ac082aefa89416cbdc9a1836eaf3bed9698201c8humbedooh} charset_req_t;

0d0ba3a410038e179b695446bb149cce6264e0abnd

0d0ba3a410038e179b695446bb149cce6264e0abnd#define DBGLVL_GORY 9 /* gory details */

727872d18412fc021f03969b8641810d8896820bhumbedooh#define DBGLVL_FLOW 4 /* enough messages to see what happens on

0d0ba3a410038e179b695446bb149cce6264e0abnd#define DBGLVL_PMC 2 /* messages about possible misconfiguration */

30471a4650391f57975f60bbb6e4a90be7b284bfhumbedooh

205f749042ed530040a4f0080dbcb47ceae8a374rjungmodule AP_MODULE_DECLARE_DATA charset_lite_module;

af33a4994ae2ff15bc67d19ff1a7feb906745bf8rbowen

0d0ba3a410038e179b695446bb149cce6264e0abndstatic void *create_charset_dir_conf(apr_pool_t *p,char *dummy)

7fec19672a491661b2fe4b29f685bc7f4efa64d4nd{

7fec19672a491661b2fe4b29f685bc7f4efa64d4nd charset_dir_t *dc = (charset_dir_t *)apr_pcalloc(p,sizeof(charset_dir_t));

7fec19672a491661b2fe4b29f685bc7f4efa64d4nd

e655a84bbb62bb1c66993fda5e74b04feda14dc6kess dc->debug = -1;

return dc;

}

static void *merge_charset_dir_conf(apr_pool_t *p, void *basev, void *overridesv)

{

charset_dir_t *a = (charset_dir_t *)apr_pcalloc (p, sizeof(charset_dir_t));

charset_dir_t *base = (charset_dir_t *)basev,

*over = (charset_dir_t *)overridesv;

/* If it is defined in the current container, use it. Otherwise, use the one

a->debug =

over->debug != -1 ? over->debug : base->debug;

a->charset_default =

over->charset_default ? over->charset_default : base->charset_default;

a->charset_source =

over->charset_source ? over->charset_source : base->charset_source;

a->implicit_add =

over->implicit_add != IA_INIT ? over->implicit_add : base->implicit_add;

return a;

}

static const char *add_charset_source(cmd_parms *cmd, void *in_dc,

const char *name)

{

charset_dir_t *dc = in_dc;

dc->charset_source = name;

return NULL;

}

static const char *add_charset_default(cmd_parms *cmd, void *in_dc,

const char *name)

{

charset_dir_t *dc = in_dc;

dc->charset_default = name;

return NULL;

}

static const char *add_charset_options(cmd_parms *cmd, void *in_dc,

const char *flag)

{

charset_dir_t *dc = in_dc;

if (!strcasecmp(flag, "ImplicitAdd")) {

dc->implicit_add = IA_IMPADD;

}

else if (!strcasecmp(flag, "NoImplicitAdd")) {

dc->implicit_add = IA_NOIMPADD;

}

else if (!strncasecmp(flag, "DebugLevel=", 11)) {

dc->debug = atoi(flag + 11);

}

else {

return apr_pstrcat(cmd->temp_pool,

"Invalid CharsetOptions option: ",

flag,

NULL);

}

return NULL;

}

static int find_code_page(request_rec *r)

{

charset_dir_t *dc = ap_get_module_config(r->per_dir_config,

&charset_lite_module);

charset_req_t *reqinfo;

charset_filter_ctx_t *input_ctx, *output_ctx;

apr_status_t rv;

const char *mime_type;

if (dc->debug >= DBGLVL_FLOW) {

ap_log_rerror(APLOG_MARK,APLOG_DEBUG|APLOG_NOERRNO, 0, r,

"uri: %s file: %s method: %d "

"imt: %s flags: %s%s%s %s->%s",

r->uri, r->filename, r->method_number,

r->content_type ? r->content_type : "(unknown)",

r->main ? "S" : "", /* S if subrequest */

r->prev ? "R" : "", /* R if redirect */

r->proxyreq ? "P" : "", /* P if proxy */

dc->charset_source, dc->charset_default);

}

/* If we don't have a full directory configuration, bail out.

if (!dc->charset_source || !dc->charset_default) {

if (dc->debug >= DBGLVL_PMC) {

ap_log_rerror(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0, r,

"incomplete configuration: src %s, dst %s",

dc->charset_source ? dc->charset_source : "unspecified",

dc->charset_default ? dc->charset_default : "unspecified");

}

return DECLINED;

}

/* catch proxy requests */

if (r->proxyreq) return DECLINED;

/* mod_rewrite indicators */

if (!strncmp(r->filename, "redirect:", 9)) return DECLINED;

if (!strncmp(r->filename, "gone:", 5)) return DECLINED;

if (!strncmp(r->filename, "passthrough:", 12)) return DECLINED;

if (!strncmp(r->filename, "forbidden:", 10)) return DECLINED;

mime_type = r->content_type ? r->content_type : ap_default_type(r);

/* If mime type isn't text or message, bail out.

if (strncasecmp(mime_type, "text/", 5) &&

#if APR_CHARSET_EBCDIC

/* On an EBCDIC machine, be willing to translate mod_autoindex-

strcmp(mime_type, DIR_MAGIC_TYPE) &&

#endif

strncasecmp(mime_type, "message/", 8)) {

if (dc->debug >= DBGLVL_GORY) {

ap_log_rerror(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0, r,

"mime type is %s; no translation selected",

mime_type);

}

return DECLINED;

}

if (dc->debug >= DBGLVL_GORY) {

ap_log_rerror(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0, r,

"charset_source: %s charset_default: %s",

dc && dc->charset_source ? dc->charset_source : "(none)",

dc && dc->charset_default ? dc->charset_default : "(none)");

}

/* Get storage for the request data and the output filter context.

reqinfo = (charset_req_t *)apr_pcalloc(r->pool,

sizeof(charset_req_t) +

sizeof(charset_filter_ctx_t));

output_ctx = (charset_filter_ctx_t *)(reqinfo + 1);

reqinfo->dc = dc;

output_ctx->dc = dc;

ap_set_module_config(r->request_config, &charset_lite_module, reqinfo);

reqinfo->output_ctx = output_ctx;

rv = apr_xlate_open(&output_ctx->xlate,

dc->charset_default, dc->charset_source, r->pool);

if (rv != APR_SUCCESS) {

ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,

"can't open translation %s->%s",

dc->charset_source, dc->charset_default);

return HTTP_INTERNAL_SERVER_ERROR;

}

switch (r->method_number) {

case M_PUT:

case M_POST:

/* Set up input translation. Note: A request body can be included

input_ctx = apr_pcalloc(r->pool, sizeof(charset_filter_ctx_t));

input_ctx->bb = apr_brigade_create(r->pool,

r->connection->bucket_alloc);

input_ctx->tmp = apr_palloc(r->pool, INPUT_XLATE_BUF_SIZE);

input_ctx->dc = dc;

reqinfo->input_ctx = input_ctx;

rv = apr_xlate_open(&input_ctx->xlate, dc->charset_source,

dc->charset_default, r->pool);

if (rv != APR_SUCCESS) {

ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,

"can't open translation %s->%s",

dc->charset_default, dc->charset_source);

return HTTP_INTERNAL_SERVER_ERROR;

}

}

return DECLINED;

}

static int configured_in_list(request_rec *r, const char *filter_name,

struct ap_filter_t *filter_list)

{

struct ap_filter_t *filter = filter_list;

while (filter) {

if (!strcasecmp(filter_name, filter->frec->name)) {

return 1;

}

filter = filter->next;

}

return 0;

}

static int configured_on_input(request_rec *r, const char *filter_name)

{

return configured_in_list(r, filter_name, r->input_filters);

}

static int configured_on_output(request_rec *r, const char *filter_name)

{

return configured_in_list(r, filter_name, r->output_filters);

}

static void xlate_insert_filter(request_rec *r)

{

/* Hey... don't be so quick to use reqinfo->dc here; reqinfo may be NULL */

charset_req_t *reqinfo = ap_get_module_config(r->request_config,

&charset_lite_module);

charset_dir_t *dc = ap_get_module_config(r->per_dir_config,

&charset_lite_module);

if (reqinfo) {

if (reqinfo->output_ctx && !configured_on_output(r, XLATEOUT_FILTER_NAME)) {

ap_add_output_filter(XLATEOUT_FILTER_NAME, reqinfo->output_ctx, r,

r->connection);

}

else if (dc->debug >= DBGLVL_FLOW) {

ap_log_rerror(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0, r,

"xlate output filter not added implicitly because %s",

!reqinfo->output_ctx ?

"no output configuration available" :

"another module added the filter");

}

if (reqinfo->input_ctx && !configured_on_input(r, XLATEIN_FILTER_NAME)) {

ap_add_input_filter(XLATEIN_FILTER_NAME, reqinfo->input_ctx, r,

r->connection);

}

else if (dc->debug >= DBGLVL_FLOW) {

ap_log_rerror(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0, r,

"xlate input filter not added implicitly because %s",

!reqinfo->input_ctx ?

"no input configuration available" :

"another module added the filter");

}

}

}

static apr_status_t send_downstream(ap_filter_t *f, const char *tmp, apr_size_t len)

{

request_rec *r = f->r;

conn_rec *c = r->connection;

apr_bucket_brigade *bb;

apr_bucket *b;

charset_filter_ctx_t *ctx = f->ctx;

apr_status_t rv;

bb = apr_brigade_create(r->pool, c->bucket_alloc);

b = apr_bucket_transient_create(tmp, len, c->bucket_alloc);

APR_BRIGADE_INSERT_TAIL(bb, b);

rv = ap_pass_brigade(f->next, bb);

if (rv != APR_SUCCESS) {

ctx->ees = EES_DOWNSTREAM;

}

return rv;

}

static apr_status_t send_eos(ap_filter_t *f)

{

request_rec *r = f->r;

conn_rec *c = r->connection;

apr_bucket_brigade *bb;

apr_bucket *b;

charset_filter_ctx_t *ctx = f->ctx;

apr_status_t rv;

bb = apr_brigade_create(r->pool, c->bucket_alloc);

b = apr_bucket_eos_create(c->bucket_alloc);

APR_BRIGADE_INSERT_TAIL(bb, b);

rv = ap_pass_brigade(f->next, bb);

if (rv != APR_SUCCESS) {

ctx->ees = EES_DOWNSTREAM;

}

return rv;

}

static apr_status_t set_aside_partial_char(charset_filter_ctx_t *ctx,

const char *partial,

apr_size_t partial_len)

{

apr_status_t rv;

if (sizeof(ctx->buf) > partial_len) {

ctx->saved = partial_len;

memcpy(ctx->buf, partial, partial_len);

rv = APR_SUCCESS;

}

else {

rv = APR_INCOMPLETE;

ctx->ees = EES_LIMIT; /* we don't handle chars this wide which straddle

}

return rv;

}

static apr_status_t finish_partial_char(charset_filter_ctx_t *ctx,

/* input buffer: */

const char **cur_str,

apr_size_t *cur_len,

/* output buffer: */

char **out_str,

apr_size_t *out_len)

{

apr_status_t rv;

apr_size_t tmp_input_len;

/* Keep adding bytes from the input string to the saved string until we

do {

ctx->buf[ctx->saved] = **cur_str;

++ctx->saved;

++*cur_str;

--*cur_len;

tmp_input_len = ctx->saved;

rv = apr_xlate_conv_buffer(ctx->xlate,

ctx->buf,

&tmp_input_len,

*out_str,

out_len);

} while (rv == APR_INCOMPLETE && *cur_len);

if (rv == APR_SUCCESS) {

ctx->saved = 0;

}

else {

ctx->ees = EES_LIMIT; /* code isn't smart enough to handle chars

}

return rv;

}

static void log_xlate_error(ap_filter_t *f, apr_status_t rv)

{

charset_filter_ctx_t *ctx = f->ctx;

const char *msg;

char msgbuf[100];

int cur;

int flags = APLOG_ERR;

switch(ctx->ees) {

case EES_LIMIT:

flags |= APLOG_NOERRNO;

msg = "xlate filter - a built-in restriction was encountered";

break;

case EES_BAD_INPUT:

flags |= APLOG_NOERRNO;

msg = "xlate filter - an input character was invalid";

break;

case EES_BUCKET_READ:

msg = "xlate filter - bucket read routine failed";

break;

case EES_INCOMPLETE_CHAR:

flags |= APLOG_NOERRNO;

strcpy(msgbuf, "xlate filter - incomplete char at end of input - ");

cur = 0;

while (cur < ctx->saved) {

apr_snprintf(msgbuf + strlen(msgbuf), sizeof(msgbuf) - strlen(msgbuf),

"%02X", (unsigned)ctx->buf[cur]);

++cur;

}

msg = msgbuf;

break;

case EES_DOWNSTREAM:

msg = "xlate filter - an error occurred in a lower filter";

break;

default:

msg = "xlate filter - returning error";

}

ap_log_rerror(APLOG_MARK, flags, rv, f->r,

"%s", msg);

}

static void chk_filter_chain(ap_filter_t *f)

{

ap_filter_t *curf;

charset_filter_ctx_t *curctx, *last_xlate_ctx = NULL,

*ctx = f->ctx;

int debug = ctx->dc->debug;

int output = !strcasecmp(f->frec->name, XLATEOUT_FILTER_NAME);

if (ctx->noop) {

return;

}

/* walk the filter chain; see if it makes sense for our filter to

curf = output ? f->r->output_filters : f->r->input_filters;

while (curf) {

if (!strcasecmp(curf->frec->name, f->frec->name) &&

curf->ctx) {

curctx = (charset_filter_ctx_t *)curf->ctx;

if (!last_xlate_ctx) {

last_xlate_ctx = curctx;

}

else {

if (strcmp(last_xlate_ctx->dc->charset_default,

curctx->dc->charset_source)) {

/* incompatible translation

if (last_xlate_ctx == f->ctx) {

last_xlate_ctx->noop = 1;

if (debug >= DBGLVL_PMC) {

const char *symbol = output ? "->" : "<-";

ap_log_rerror(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO,

0, f->r,

"%s %s - disabling "

"translation %s%s%s; existing "

"translation %s%s%s",

f->r->uri ? "uri" : "file",

f->r->uri ? f->r->uri : f->r->filename,

last_xlate_ctx->dc->charset_source,

symbol,

last_xlate_ctx->dc->charset_default,

curctx->dc->charset_source,

symbol,

curctx->dc->charset_default);

}

}

else {

const char *symbol = output ? "->" : "<-";

ap_log_rerror(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO,

0, f->r,

"chk_filter_chain() - can't disable "

"translation %s%s%s; existing "

"translation %s%s%s",

last_xlate_ctx->dc->charset_source,

symbol,

last_xlate_ctx->dc->charset_default,

curctx->dc->charset_source,

symbol,

curctx->dc->charset_default);

}

break;

}

}

}

curf = curf->next;

}

}

static apr_status_t xlate_brigade(charset_filter_ctx_t *ctx,

apr_bucket_brigade *bb,

char *buffer,

apr_size_t *buffer_avail,

int *hit_eos)

{

apr_bucket *b = NULL; /* set to NULL only to quiet some gcc */

apr_bucket *consumed_bucket;

const char *bucket;

apr_size_t bytes_in_bucket; /* total bytes read from current bucket */

apr_size_t bucket_avail; /* bytes left in current bucket */

apr_status_t rv = APR_SUCCESS;

*hit_eos = 0;

bucket_avail = 0;

consumed_bucket = NULL;

while (1) {

if (!bucket_avail) { /* no bytes left to process in the current bucket... */

if (consumed_bucket) {

apr_bucket_delete(consumed_bucket);

consumed_bucket = NULL;

}

b = APR_BRIGADE_FIRST(bb);

if (b == APR_BRIGADE_SENTINEL(bb) ||

APR_BUCKET_IS_EOS(b)) {

break;

}

rv = apr_bucket_read(b, &bucket, &bytes_in_bucket, APR_BLOCK_READ);

if (rv != APR_SUCCESS) {

ctx->ees = EES_BUCKET_READ;

break;

}

bucket_avail = bytes_in_bucket;

consumed_bucket = b; /* for axing when we're done reading it */

}

if (bucket_avail) {

/* We've got data, so translate it. */

if (ctx->saved) {

/* Rats... we need to finish a partial character from the previous

apr_size_t old_buffer_avail = *buffer_avail;

rv = finish_partial_char(ctx,

&bucket, &bucket_avail,

&buffer, buffer_avail);

buffer += old_buffer_avail - *buffer_avail;

}

else {

apr_size_t old_buffer_avail = *buffer_avail;

apr_size_t old_bucket_avail = bucket_avail;

rv = apr_xlate_conv_buffer(ctx->xlate,

bucket, &bucket_avail,

buffer,

buffer_avail);

buffer += old_buffer_avail - *buffer_avail;

bucket += old_bucket_avail - bucket_avail;

if (rv == APR_INCOMPLETE) { /* partial character at end of input */

/* We need to save the final byte(s) for next time; we can't

rv = set_aside_partial_char(ctx, bucket, bucket_avail);

bucket_avail = 0;

}

}

if (rv != APR_SUCCESS) {

/* bad input byte or partial char too big to store */

break;

}

if (*buffer_avail < XLATE_MIN_BUFF_LEFT) {

/* if any data remains in the current bucket, split there */

if (bucket_avail) {

apr_bucket_split(b, bytes_in_bucket - bucket_avail);

}

apr_bucket_delete(b);

break;

}

}

}

if (!APR_BRIGADE_EMPTY(bb)) {

b = APR_BRIGADE_FIRST(bb);

if (APR_BUCKET_IS_EOS(b)) {

/* Leave the eos bucket in the brigade for reporting to

*hit_eos = 1;

if (ctx->saved) {

/* Oops... we have a partial char from the previous bucket

rv = APR_INCOMPLETE;

ctx->ees = EES_INCOMPLETE_CHAR;

}

}

}

return rv;

}

static apr_status_t xlate_out_filter(ap_filter_t *f, apr_bucket_brigade *bb)

{

charset_req_t *reqinfo = ap_get_module_config(f->r->request_config,

&charset_lite_module);

charset_dir_t *dc = ap_get_module_config(f->r->per_dir_config,

&charset_lite_module);

charset_filter_ctx_t *ctx = f->ctx;

apr_bucket *dptr, *consumed_bucket;

const char *cur_str;

apr_size_t cur_len, cur_avail;

char tmp[OUTPUT_XLATE_BUF_SIZE];

apr_size_t space_avail;

int done;

apr_status_t rv = APR_SUCCESS;

if (!ctx) {

/* this is SetOutputFilter path; grab the preallocated context,

if (reqinfo) {

ctx = f->ctx = reqinfo->output_ctx;

reqinfo->output_ctx = NULL; /* prevent SNAFU if user coded us twice

}

if (!ctx) { /* no idea how to translate; don't do anything */

ctx = f->ctx = apr_pcalloc(f->r->pool, sizeof(charset_filter_ctx_t));

ctx->dc = dc;

ctx->noop = 1;

}

}

if (dc->debug >= DBGLVL_GORY) {

ap_log_rerror(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0, f->r,

"xlate_out_filter() - "

"charset_source: %s charset_default: %s",

dc && dc->charset_source ? dc->charset_source : "(none)",

dc && dc->charset_default ? dc->charset_default : "(none)");

}

if (!ctx->ran) { /* filter never ran before */

chk_filter_chain(f);

ctx->ran = 1;

}

if (ctx->noop) {

return ap_pass_brigade(f->next, bb);

}

dptr = APR_BRIGADE_FIRST(bb);

done = 0;

cur_len = 0;

space_avail = sizeof(tmp);

consumed_bucket = NULL;

while (!done) {

if (!cur_len) { /* no bytes left to process in the current bucket... */

if (consumed_bucket) {

apr_bucket_delete(consumed_bucket);

consumed_bucket = NULL;

}

if (dptr == APR_BRIGADE_SENTINEL(bb)) {

done = 1;

break;

}

if (APR_BUCKET_IS_EOS(dptr)) {

done = 1;

cur_len = -1; /* XXX yuck, but that tells us to send

if (ctx->saved) {

/* Oops... we have a partial char from the previous bucket

rv = APR_INCOMPLETE;

ctx->ees = EES_INCOMPLETE_CHAR;

}

break;

}

rv = apr_bucket_read(dptr, &cur_str, &cur_len, APR_BLOCK_READ);

if (rv != APR_SUCCESS) {

done = 1;

ctx->ees = EES_BUCKET_READ;

break;

}

consumed_bucket = dptr; /* for axing when we're done reading it */

dptr = APR_BUCKET_NEXT(dptr); /* get ready for when we access the

}

/* Try to fill up our tmp buffer with translated data. */

cur_avail = cur_len;

if (cur_len) { /* maybe we just hit the end of a pipe (len = 0) ? */

if (ctx->saved) {

/* Rats... we need to finish a partial character from the previous

char *tmp_tmp;

tmp_tmp = tmp + sizeof(tmp) - space_avail;

rv = finish_partial_char(ctx,

&cur_str, &cur_len,

&tmp_tmp, &space_avail);

}

else {

rv = apr_xlate_conv_buffer(ctx->xlate,

cur_str, &cur_avail,

tmp + sizeof(tmp) - space_avail, &space_avail);

/* Update input ptr and len after consuming some bytes */

cur_str += cur_len - cur_avail;

cur_len = cur_avail;

if (rv == APR_INCOMPLETE) { /* partial character at end of input */

/* We need to save the final byte(s) for next time; we can't

rv = set_aside_partial_char(ctx, cur_str, cur_len);

cur_len = 0;

}

}

}

if (rv != APR_SUCCESS) {

/* bad input byte or partial char too big to store */

done = 1;

}

if (space_avail < XLATE_MIN_BUFF_LEFT) {

/* It is time to flush, as there is not enough space left in the

rv = send_downstream(f, tmp, sizeof(tmp) - space_avail);

if (rv != APR_SUCCESS) {

done = 1;

}

/* tmp is now empty */

space_avail = sizeof(tmp);

}

}

if (rv == APR_SUCCESS) {

if (space_avail < sizeof(tmp)) { /* gotta write out what we converted */

rv = send_downstream(f, tmp, sizeof(tmp) - space_avail);

}

}

if (rv == APR_SUCCESS) {

if (cur_len == -1) {

rv = send_eos(f);

}

}

else {

log_xlate_error(f, rv);

}

return rv;

}

static int xlate_in_filter(ap_filter_t *f, apr_bucket_brigade *bb,

ap_input_mode_t mode, apr_read_type_e block,

apr_off_t readbytes)

{

apr_status_t rv;

charset_req_t *reqinfo = ap_get_module_config(f->r->request_config,

&charset_lite_module);

charset_dir_t *dc = ap_get_module_config(f->r->per_dir_config,

&charset_lite_module);

charset_filter_ctx_t *ctx = f->ctx;

apr_size_t buffer_size;

int hit_eos;

if (!ctx) {

/* this is SetInputFilter path; grab the preallocated context,

if (reqinfo) {

ctx = f->ctx = reqinfo->input_ctx;

reqinfo->input_ctx = NULL; /* prevent SNAFU if user coded us twice

}

if (!ctx) { /* no idea how to translate; don't do anything */

ctx = f->ctx = apr_pcalloc(f->r->pool, sizeof(charset_filter_ctx_t));

ctx->dc = dc;

ctx->noop = 1;

}

}

if (dc->debug >= DBGLVL_GORY) {

ap_log_rerror(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0, f->r,

"xlate_in_filter() - "

"charset_source: %s charset_default: %s",

dc && dc->charset_source ? dc->charset_source : "(none)",

dc && dc->charset_default ? dc->charset_default : "(none)");

}

if (!ctx->ran) { /* filter never ran before */

chk_filter_chain(f);

ctx->ran = 1;

}

if (ctx->noop) {

return ap_get_brigade(f->next, bb, mode, block, readbytes);

}

if (APR_BRIGADE_EMPTY(ctx->bb)) {

if ((rv = ap_get_brigade(f->next, bb, mode, block,

readbytes)) != APR_SUCCESS) {

return rv;

}

}

else {

APR_BRIGADE_PREPEND(bb, ctx->bb); /* first use the leftovers */

}

buffer_size = INPUT_XLATE_BUF_SIZE;

rv = xlate_brigade(ctx, bb, ctx->tmp, &buffer_size, &hit_eos);

if (rv == APR_SUCCESS) {

if (!hit_eos) {

/* move anything leftover into our context for next time;

APR_BRIGADE_CONCAT(ctx->bb, bb);

}

if (buffer_size < INPUT_XLATE_BUF_SIZE) { /* do we have output? */

apr_bucket *e;

e = apr_bucket_heap_create(ctx->tmp,

INPUT_XLATE_BUF_SIZE - buffer_size,

NULL, f->r->connection->bucket_alloc);

/* make sure we insert at the head, because there may be

APR_BRIGADE_INSERT_HEAD(bb, e);

}

else {

/* XXX need to get some more data... what if the last brigade

}

}

else {

log_xlate_error(f, rv);

}

return rv;

}

static const command_rec cmds[] =

{

AP_INIT_TAKE1("CharsetSourceEnc",

add_charset_source,

NULL,

OR_FILEINFO,

"source (html,cgi,ssi) file charset"),

AP_INIT_TAKE1("CharsetDefault",

add_charset_default,

NULL,

OR_FILEINFO,

"name of default charset"),

AP_INIT_ITERATE("CharsetOptions",

add_charset_options,

NULL,

OR_FILEINFO,

"valid options: ImplicitAdd, NoImplicitAdd, DebugLevel=n"),

{NULL}

};

static void charset_register_hooks(apr_pool_t *p)

{

ap_hook_fixups(find_code_page, NULL, NULL, APR_HOOK_MIDDLE);

ap_hook_insert_filter(xlate_insert_filter, NULL, NULL, APR_HOOK_REALLY_LAST);

ap_register_output_filter(XLATEOUT_FILTER_NAME, xlate_out_filter,

AP_FTYPE_RESOURCE);

ap_register_input_filter(XLATEIN_FILTER_NAME, xlate_in_filter,

AP_FTYPE_RESOURCE);

}

module AP_MODULE_DECLARE_DATA charset_lite_module =

{

STANDARD20_MODULE_STUFF,

create_charset_dir_conf,

merge_charset_dir_conf,

NULL,

NULL,

cmds,

charset_register_hooks

};