int dav_svn__proxy_request_fixup(request_rec *r)
{
const char *root_dir, *master_uri, *special_uri;
root_dir = dav_svn__get_root_dir(r);
master_uri = dav_svn__get_master_uri(r);
special_uri = dav_svn__get_special_uri(r);
if (root_dir && master_uri) {
const char *seg;
/* We know we can always safely handle these. */
if (r->method_number == M_REPORT ||
r->method_number == M_OPTIONS) {
return OK;
}
/* These are read-only requests -- the kind we like to handle
ourselves -- but we need to make sure they aren't aimed at
resources that only exist on the master server such as
working resource URIs or the HTTPv2 transaction root and
transaction tree resouces. */
if (r->method_number == M_PROPFIND ||
r->method_number == M_GET) {
if ((seg = ap_strstr(r->uri, root_dir))) {
if (ap_strstr_c(seg, apr_pstrcat(r->pool, special_uri,
"/wrk/", SVN_VA_NULL))
|| ap_strstr_c(seg, apr_pstrcat(r->pool, special_uri,
"/txn/", SVN_VA_NULL))
|| ap_strstr_c(seg, apr_pstrcat(r->pool, special_uri,
"/txr/", SVN_VA_NULL))) {
int rv;
seg += strlen(root_dir);
rv = proxy_request_fixup(r, master_uri, seg);
if (rv) return rv;
}
}
return OK;
}
/* If this is a write request aimed at a public URI (such as
MERGE, LOCK, UNLOCK, etc.) or any as-yet-unhandled request
using a "special URI", we have to doctor it a bit for proxying. */
seg = ap_strstr(r->uri, root_dir);
if (seg && (r->method_number == M_MERGE ||
r->method_number == M_LOCK ||
r->method_number == M_UNLOCK ||
ap_strstr_c(seg, special_uri))) {
int rv;
seg += strlen(root_dir);
rv = proxy_request_fixup(r, master_uri, seg);
if (rv) return rv;
return OK;
}
}
return OK;
}
static const char *compile_command_add_extension(cmd_parms *cmd, void *overrides, const char *value, const char* extension) {
if ( ! ap_strstr(value, "%s")) {
return (char*) apr_psprintf(cmd->pool, "(mod_compile) 'AddCompileCommand %s' does not contain a '%%s'.", value);
}
COMPILE_FIND_CONFIG;
#ifdef _DEBUG
ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, cmd->server, "compile_command_add_extension('%s', '%s')", value, extension);
#endif
compile_extension_config_t *extension_config;
char *value_normalized = apr_pstrdup(cmd->pool, value);
char *extension_normalized = apr_pstrdup(cmd->temp_pool, extension);
ap_str_tolower(value_normalized);
ap_str_tolower(extension_normalized);
if (*extension_normalized == '.') {
++ extension_normalized;
}
if ( ! config->extension_commands) {
config->extension_commands = apr_hash_make(cmd->pool);
extension_config = NULL;
} else {
extension_config = (compile_extension_config_t*) apr_hash_get(config->extension_commands, extension_normalized, APR_HASH_KEY_STRING);
}
if ( ! extension_config) {
extension_config = apr_pcalloc(cmd->pool, sizeof (compile_extension_config_t));
extension_normalized = apr_pstrdup(cmd->pool, extension_normalized);
apr_hash_set(config->extension_commands, extension_normalized, APR_HASH_KEY_STRING, extension_config);
}
extension_config->command_line = value_normalized;
return NULL;
}
static const char* interpolate_env(request_rec *r, const char *str) {
/* Interpolate an env str in a configuration string
* Syntax ${var} --> value_of(var)
* Method: replace one var, and recurse on remainder of string
* Nothing clever here, and crap like nested vars may do silly things
* but we'll at least avoid sending the unwary into a loop
*/
const char *start;
const char *end;
const char *var;
const char *val;
const char *firstpart;
start = ap_strstr(str, "${");
if (start == NULL) {
return str;
}
end = ap_strchr(start+2, '}');
if (end == NULL) {
return str;
}
/* OK, this is syntax we want to interpolate. Is there such a var ? */
var = apr_pstrndup(r->pool, start+2, end-(start+2));
val = apr_table_get(r->subprocess_env, var);
firstpart = apr_pstrndup(r->pool, str, (start-str));
if (val == NULL) {
return apr_pstrcat(r->pool, firstpart, interpolate_env(r, end+1), NULL);
} else {
return apr_pstrcat(r->pool, firstpart, val,
interpolate_env(r, end+1), NULL);
}
}
static int twms_handler(request_rec *r)
{
twms_dir_conf *dcfg;
const char *data;
const char *val;
apr_table_t *tab;
apr_file_t *fh;
apr_size_t nsend;
apr_finfo_t info;
if ((r->method_number != M_GET )||(r->args==0)) return DECLINED;
data=r->args;
// scfg=ap_get_module_config(r->server->module_config,&twms_module);
dcfg=ap_get_module_config(r->per_dir_config,&twms_module);
if (!dcfg) return DECLINED; // Does this ever happen?
if (!ap_strstr(data,"GetTileService")) return DECLINED;
// Do we have a config for this directory
// ap_log_error(APLOG_MARK,APLOG_ERR,0,r->server,"TWMS_handler: args %s, path %s scfg %x dcfg %x dir %s conf %s",
// data,r->parsed_uri.path,scfg,dcfg,dcfg->path,dcfg->Config);
if (!dcfg->Config) return DECLINED;
// This is overkill here, but it works
tab=apr_table_make(r->pool,0);
while (*data && (val=ap_getword(r->pool, &data, '&'))) {
char *key=apr_pstrdup(r->pool,ap_getword(r->pool, &val, '='));
char *ival=apr_pstrdup(r->pool,val);
ap_unescape_url(key);ap_unescape_url(ival);
apr_table_merge(tab,key,ival);
}
if (!(val=apr_table_get(tab,"request"))) return DECLINED;
if (apr_strnatcmp(val,"GetTileService")) return DECLINED;
if (APR_SUCCESS!=apr_file_open(&fh,apr_pstrcat(r->pool,dcfg->path,dcfg->Config,0),
APR_READ,APR_OS_DEFAULT,r->pool)) {
ap_log_error(APLOG_MARK,APLOG_ERR,0,r->server,"TWMS file can't be read");
return HTTP_CONFLICT;
}
ap_log_error(APLOG_MARK,APLOG_ERR,0,r->server,"TWMS Sending GTS file");
apr_file_info_get(&info,APR_FINFO_SIZE,fh);
ap_set_content_type(r,"text/xml");
ap_send_fd(fh,r,0,info.size,&nsend);
apr_file_close(fh);
return OK;
}
/* Routine to perform the actual construction and execution of the relevant
* INSERT statements.
*/
static int log_sql_transaction(request_rec *orig)
{
char **ptrptr, **ptrptr2;
logsql_state *cls = ap_get_module_config(orig->server->module_config, &log_sql_module);
const char *access_query;
request_rec *r;
const char *transfer_tablename = cls->transfer_table_name;
const char *notes_tablename = cls->notes_table_name;
const char *hout_tablename = cls->hout_table_name;
const char *hin_tablename = cls->hin_table_name;
const char *cookie_tablename = cls->cookie_table_name;
if (global_config.driver == NULL) {
return OK;
}
/* We handle mass virtual hosting differently. Dynamically determine the name
* of the table from the virtual server's name, and flag it for creation.
*/
if (global_config.massvirtual) {
/* TODO: Make these configurable? */
char *access_base = "access_";
char *notes_base = "notes_";
char *hout_base = "headout_";
char *hin_base = "headin_";
char *cookie_base = "cookies_";
/* Determine the hostname and convert it to all lower-case; */
char *servername = apr_pstrdup(orig->pool,(char *)ap_get_server_name(orig));
char *p=servername;
while (*p) {
*p = apr_tolower(*p);
if (*p == '.') *p = '_';
if (*p == '-') *p = '_';
++p;
}
/* Find memory long enough to hold the table name + \0. */
transfer_tablename = apr_pstrcat(orig->pool, access_base, servername, NULL);
notes_tablename = apr_pstrcat(orig->pool, notes_base, servername, NULL);
hin_tablename = apr_pstrcat(orig->pool, hin_base, servername, NULL);
hout_tablename = apr_pstrcat(orig->pool, hout_base, servername, NULL);
cookie_tablename = apr_pstrcat(orig->pool, cookie_base, servername, NULL);
/* Tell this virtual server its transfer table name, and
* turn on create_tables, which is implied by massvirtual.
*/
global_config.createtables = 1;
}
/* Do we have enough info to log? */
if (!transfer_tablename) {
return DECLINED;
} else {
const char *thehost;
const char *theitem;
char *fields = "", *values = "";
char *itemsets = "";
char *note_query = NULL;
char *hin_query = NULL;
char *hout_query = NULL;
char *cookie_query = NULL;
const char *unique_id;
const char *formatted_item;
int i,length;
int proceed;
for (r = orig; r->next; r = r->next) {
continue;
}
/* The following is a stolen upsetting mess of pointers, I'm sorry.
* Anyone with the motiviation and/or the time should feel free
* to make this cleaner. :) */
ptrptr2 = (char **) (cls->transfer_accept_list->elts + (cls->transfer_accept_list->nelts * cls->transfer_accept_list->elt_size));
/* Go through each element of the accept list and compare it to the
* request_uri. If we don't get a match, return without logging */
if ((r->uri) && (cls->transfer_accept_list->nelts)) {
proceed = 0;
for (ptrptr = (char **) cls->transfer_accept_list->elts; ptrptr < ptrptr2; ptrptr = (char **) ((char *) ptrptr + cls->transfer_accept_list->elt_size))
if (ap_strstr(r->uri, *ptrptr)) {
proceed = 1;
break;
}
if (!proceed)
return OK;
}
/* Go through each element of the ignore list and compare it to the
* request_uri. If we get a match, return without logging */
ptrptr2 = (char **) (cls->transfer_ignore_list->elts + (cls->transfer_ignore_list->nelts * cls->transfer_ignore_list->elt_size));
if (r->uri) {
for (ptrptr = (char **) cls->transfer_ignore_list->elts; ptrptr < ptrptr2; ptrptr = (char **) ((char *) ptrptr + cls->transfer_ignore_list->elt_size))
if (ap_strstr(r->uri, *ptrptr)) {
return OK;
}
}
/* Go through each element of the ignore list and compare it to the
* remote host. If we get a match, return without logging */
ptrptr2 = (char **) (cls->remhost_ignore_list->elts + (cls->remhost_ignore_list->nelts * cls->remhost_ignore_list->elt_size));
thehost = ap_get_remote_host(r->connection, r->per_dir_config, REMOTE_NAME, NULL);
if (thehost) {
for (ptrptr = (char **) cls->remhost_ignore_list->elts; ptrptr < ptrptr2; ptrptr = (char **) ((char *) ptrptr + cls->remhost_ignore_list->elt_size))
if (ap_strstr(thehost, *ptrptr)) {
return OK;
}
}
/* Iterate through the format characters and set up the INSERT string according to
* what the user has configured. */
length = strlen(cls->transfer_log_format);
for (i = 0; i<length; i++) {
logsql_item *item = cls->parsed_log_format[i];
if (item==NULL) {
log_error(APLOG_MARK, APLOG_ERR, 0, orig->server,
"Log Format '%c' unknown",cls->transfer_log_format[i]);
continue;
}
/* Yes, this key is one of the configured keys.
* Call the key's function and put the returned value into 'formatted_item' */
formatted_item = item->func(item->want_orig_default ? orig : r, "");
/* Massage 'formatted_item' for proper SQL eligibility... */
if (!formatted_item) {
formatted_item = "";
} else if (formatted_item[0] == '-' && formatted_item[1] == '\0' && !item->string_contents) {
/* If apache tried to log a '-' character for a numeric field, convert that to a zero
* because the database expects a numeral and will reject the '-' character. */
formatted_item = "0";
}
/* Append the fieldname and value-to-insert to the appropriate strings, quoting stringvals with ' as appropriate */
fields = apr_pstrcat(r->pool, fields, (i ? "," : ""),
item->sql_field_name, NULL);
values = apr_pstrcat(r->pool, values, (i ? "," : ""),
global_config.driver->escape(formatted_item, r->pool,&global_config.db), NULL);
}
/* Work through the list of notes defined by LogSQLWhichNotes */
i = 0;
unique_id = extract_unique_id(r, "");
ptrptr2 = (char **) (cls->notes_list->elts + (cls->notes_list->nelts * cls->notes_list->elt_size));
for (ptrptr = (char **) cls->notes_list->elts; ptrptr < ptrptr2; ptrptr = (char **) ((char *) ptrptr + cls->notes_list->elt_size)) {
/* If the specified note (*ptrptr) exists for the current request... */
if ((theitem = apr_table_get(r->notes, *ptrptr))) {
itemsets = apr_pstrcat(r->pool, itemsets,
(i > 0 ? "," : ""),
"(",
global_config.driver->escape(unique_id, r->pool, &global_config.db),
",",
global_config.driver->escape(*ptrptr, r->pool,&global_config.db),
",",
global_config.driver->escape(theitem, r->pool,&global_config.db),
")",
NULL);
i++;
}
}
if ( *itemsets != '\0' ) {
note_query = apr_psprintf(r->pool, "insert %s into %s (id, item, val) values %s",
/*global_config.insertdelayed?"delayed":*/"", notes_tablename, itemsets);
log_error(APLOG_MARK,APLOG_DEBUG,0, orig->server,"mod_log_sql: note string: %s", note_query);
}
/* Work through the list of headers-out defined by LogSQLWhichHeadersOut*/
i = 0;
itemsets = "";
ptrptr2 = (char **) (cls->hout_list->elts + (cls->hout_list->nelts * cls->hout_list->elt_size));
for (ptrptr = (char **) cls->hout_list->elts; ptrptr < ptrptr2; ptrptr = (char **) ((char *) ptrptr + cls->hout_list->elt_size)) {
/* If the specified header (*ptrptr) exists for the current request... */
if ((theitem = apr_table_get(r->headers_out, *ptrptr))) {
itemsets = apr_pstrcat(r->pool, itemsets,
(i > 0 ? "," : ""),
"(",
global_config.driver->escape(unique_id, r->pool, &global_config.db),
",",
global_config.driver->escape(*ptrptr, r->pool,&global_config.db),
",",
global_config.driver->escape(theitem, r->pool,&global_config.db),
")",
NULL);
i++;
}
}
if ( *itemsets != '\0' ) {
hout_query = apr_psprintf(r->pool, "insert %s into %s (id, item, val) values %s",
/*global_config.insertdelayed?"delayed":*/"", hout_tablename, itemsets);
log_error(APLOG_MARK,APLOG_DEBUG,0, orig->server,"mod_log_sql: header_out string: %s", hout_query);
}
/* Work through the list of headers-in defined by LogSQLWhichHeadersIn */
i = 0;
itemsets = "";
ptrptr2 = (char **) (cls->hin_list->elts + (cls->hin_list->nelts * cls->hin_list->elt_size));
for (ptrptr = (char **) cls->hin_list->elts; ptrptr < ptrptr2; ptrptr = (char **) ((char *) ptrptr + cls->hin_list->elt_size)) {
/* If the specified header (*ptrptr) exists for the current request... */
if ((theitem = apr_table_get(r->headers_in, *ptrptr))) {
itemsets = apr_pstrcat(r->pool, itemsets,
(i > 0 ? "," : ""),
"(",
global_config.driver->escape(unique_id, r->pool, &global_config.db),
",",
global_config.driver->escape(*ptrptr, r->pool,&global_config.db),
",",
global_config.driver->escape(theitem, r->pool,&global_config.db),
")",
NULL);
i++;
}
}
if ( *itemsets != '\0' ) {
hin_query = apr_psprintf(r->pool, "insert %s into %s (id, item, val) values %s",
/*global_config.insertdelayed?"delayed":*/"", hin_tablename, itemsets);
log_error(APLOG_MARK,APLOG_DEBUG,0, orig->server,"mod_log_sql: header_in string: %s", hin_query);
}
/* Work through the list of cookies defined by LogSQLWhichCookies */
i = 0;
itemsets = "";
ptrptr2 = (char **) (cls->cookie_list->elts + (cls->cookie_list->nelts * cls->cookie_list->elt_size));
for (ptrptr = (char **) cls->cookie_list->elts; ptrptr < ptrptr2; ptrptr = (char **) ((char *) ptrptr + cls->cookie_list->elt_size)) {
/* If the specified cookie (*ptrptr) exists for the current request... */
if ( strncmp((theitem = extract_specific_cookie(r, *ptrptr)), "-", 1) ) {
itemsets = apr_pstrcat(r->pool, itemsets,
(i > 0 ? "," : ""),
"(",
global_config.driver->escape(unique_id, r->pool, &global_config.db),
",",
global_config.driver->escape(*ptrptr, r->pool,&global_config.db),
",",
global_config.driver->escape(theitem, r->pool,&global_config.db),
")",
NULL);
i++;
}
}
if ( *itemsets != '\0' ) {
cookie_query = apr_psprintf(r->pool, "insert %s into %s (id, item, val) values %s",
/*global_config.insertdelayed?"delayed":*/"", cookie_tablename, itemsets);
log_error(APLOG_MARK,APLOG_DEBUG,0, orig->server,"mod_log_sql: cookie string: %s", cookie_query);
}
/* Set up the actual INSERT statement */
access_query = apr_psprintf(r->pool, "insert %s into %s (%s) values (%s)",
/*global_config.insertdelayed?"delayed":*/"", transfer_tablename, fields, values);
log_error(APLOG_MARK,APLOG_DEBUG,0, r->server,"mod_log_sql: access string: %s", access_query);
/* If the person activated force-preserve, go ahead and push all the entries
* into the preserve file, then return.
*/
if (global_config.forcepreserve) {
log_error(APLOG_MARK,APLOG_DEBUG,0, orig->server,"mod_log_sql: preservation forced");
preserve_entry(orig, access_query);
if ( note_query != NULL )
preserve_entry(orig, note_query);
if ( hin_query != NULL )
preserve_entry(orig, hin_query);
if ( hout_query != NULL )
preserve_entry(orig, hout_query);
if ( cookie_query != NULL )
preserve_entry(orig, cookie_query);
return OK;
}
/* How's our mysql link integrity? */
if (!global_config.db.connected) {
if (!global_config.forcepreserve) {
/* Make a try to establish the link */
log_sql_opendb_link(r->server);
}
if (!global_config.db.connected) {
/* Unable to re-establish a DB link, so assume that it's really
* gone and send the entry to the preserve file instead.
* This short-circuits safe_sql_query() during a db outage and therefore
* we don't keep logging the db error over and over.
*/
preserve_entry(orig, access_query);
if ( note_query != NULL )
preserve_entry(orig, note_query);
if ( hin_query != NULL )
preserve_entry(orig, hin_query);
if ( hout_query != NULL )
preserve_entry(orig, hout_query);
if ( cookie_query != NULL )
preserve_entry(orig, cookie_query);
return OK;
} else {
/* Whew, we got the DB link back */
log_error(APLOG_MARK,APLOG_NOTICE,0, orig->server,"mod_log_sql: child established database connection");
}
}
/* ---> So as of here we have a non-null value of mysql_log. <--- */
/* ---> i.e. we have a good MySQL connection. <--- */
/* Make the access-table insert */
safe_sql_insert(orig,LOGSQL_TABLE_ACCESS,transfer_tablename,access_query);
/* Log the optional notes, headers, etc. */
if (note_query)
safe_sql_insert(orig, LOGSQL_TABLE_NOTES,notes_tablename,note_query);
if (hout_query)
safe_sql_insert(orig, LOGSQL_TABLE_HEADERSOUT,hout_tablename,hout_query);
if (hin_query)
safe_sql_insert(orig, LOGSQL_TABLE_HEADERSIN,hin_tablename,hin_query);
if (cookie_query)
safe_sql_insert(orig, LOGSQL_TABLE_COOKIES,cookie_tablename,cookie_query);
return OK;
}
}
/**
* The output filter routine. This one gets called whenever a response is
* generated that passes this filter. Returns APR_SUCCESS if everything works
* out.
*
* @param f The filter definition.
* @param bb The bucket brigade containing the data.
*/
static apr_status_t replace_output_filter(ap_filter_t *f, apr_bucket_brigade *bb)
{
request_rec *r = f->r;
conn_rec *c = r->connection;
replace_ctx_t *ctx = f->ctx;
apr_bucket *b;
apr_size_t len;
const char *data;
const char *header;
apr_status_t rv;
int re_vector[RE_VECTOR_SIZE]; // 3 elements per matched pattern
replace_pattern_t *next;
header_replace_pattern_t *next_header;
int modified = 0; // flag to determine if a replacement has
// occured.
if (!ctx) {
/* Initialize context */
ctx = apr_pcalloc(f->r->pool, sizeof(replace_ctx_t));
f->ctx = ctx;
ctx->bb = apr_brigade_create(r->pool, c->bucket_alloc);
}
/* parse config settings */
/* look for the user-defined filter */
ctx->filter = find_filter_def(f->r->server, f->frec->name);
if (!ctx->filter) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, f->r,
"couldn't find definition of filter '%s'",
f->frec->name);
return APR_EINVAL;
}
ctx->p = f->r->pool;
if (ctx->filter->intype &&
ctx->filter->intype != INTYPE_ALL) {
if (!f->r->content_type) {
ctx->noop = 1;
}
else {
const char *ctypes = f->r->content_type;
const char *ctype = ap_getword(f->r->pool, &ctypes, ';');
if (strcasecmp(ctx->filter->intype, ctype)) {
/* wrong IMT for us; don't mess with the output */
ctx->noop = 1;
}
}
}
/* exit immediately if there are indications that the filter shouldn't be
* executed.
*/
if (ctx->noop == 1) {
ap_pass_brigade(f->next, bb);
return APR_SUCCESS;
}
/**
* Loop through the configured header patterns.
*/
for (next_header = ctx->filter->header_pattern;
next_header != NULL;
next_header = next_header->next) {
// create a separate table with the requested HTTP header entries and
// unset those headers in the original request.
apr_table_t *header_table;
header_table = apr_table_make(r->pool, 2);
// create a data structure for the callback function
header_replace_cb_t *hrcb;
hrcb = apr_palloc(r->pool, sizeof(header_replace_cb_t));
hrcb->header_table = header_table;
hrcb->pattern = next_header->pattern;
hrcb->extra = next_header->extra;
hrcb->replacement = next_header->replacement;
hrcb->r = r;
// pass any header that is defined to be processed to the callback
// function and unset those headers in the original outgoing record.
apr_table_do(replace_header_cb, hrcb, r->headers_out,
next_header->header, NULL);
// only touch the header if the changed header table is not empty.
if (!apr_is_empty_table(header_table)) {
apr_table_unset(r->headers_out, next_header->header);
// overlay the original header table with the new one to reintegrate
// the changed headers.
r->headers_out = apr_table_overlay(r->pool, r->headers_out,
header_table);
}
}
/* Not nice but neccessary: Unset the ETag , because we cannot adjust the
* value correctly, because we do not know how.
*/
apr_table_unset(f->r->headers_out, "ETag");
int eos = 0; // flag to check if an EOS bucket is in the brigade.
apr_bucket *eos_bucket;
// Backup for the EOS bucket.
/* Interate through the available data. Stop if there is an EOS */
for (b = APR_BRIGADE_FIRST(bb); b != APR_BRIGADE_SENTINEL(bb); b = APR_BUCKET_NEXT(b)) {
if (APR_BUCKET_IS_EOS(b)) {
eos = 1;
ap_save_brigade(f, &ctx->bb, &bb, ctx->p);
APR_BUCKET_REMOVE(b);
eos_bucket = b;
break;
}
}
/* If the iteration over the brigade hasn't found an EOS bucket, just save
* the brigade and return.
*/
if (eos != 1) {
ap_save_brigade(f, &ctx->bb, &bb, ctx->p);
return APR_SUCCESS;
}
if ((rv = apr_brigade_pflatten(ctx->bb, (char **)&data, &len, ctx->p))
!= APR_SUCCESS) {
/* Return if the flattening didn't work. */
return rv;
} else {
/* Remove the original data from the bucket brigade. Otherwise it would
* be passed twice (original data and the processed, flattened copy) to
* the next filter.
*/
apr_brigade_cleanup(ctx->bb);
}
/* Good cast, we just tested len isn't negative or zero */
if (len > 0) {
/* start checking for the regex's. */
for (next = ctx->filter->pattern;
next != NULL;
next = next->next)
{
int rc = 0;
int offset = 0;
/* loop through the configured patterns */
do {
rc = pcre_exec(next->pattern, next->extra, data,
len, offset, 0,
re_vector, RE_VECTOR_SIZE);
if (rc < 0 && rc != PCRE_ERROR_NOMATCH) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rc, r,
"Matching Error %d", rc);
return rc;
}
/* This shouldn´t happen */
if (rc == 0) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rc, r,
"PCRE output vector too small (%d)",
RE_VECTOR_SIZE/3-1);
}
/* If the result count is greater than 0 then there are
* matches in the data string. Thus we try to replace those
* strings with the user provided string.
*/
if (rc > 0) {
char *prefix; // the string before the matching part.
char *postfix; // the string after the matching part.
char *newdata; // the concatenated string of prefix,
// the replaced string and postfix.
char *replacement;
// the string with the data to replace
// (after the subpattern processing has
// been done).
char *to_replace[10];
// the string array containing the
// strings that are to be replaced.
int match_diff; // the difference between the matching
// string and its replacement.
int x; // a simple counter.
char *pos; // the starting position within the
// replacement string, where there is a
// subpattern to replace.
/* start with building the replacement string */
replacement = apr_pstrcat(ctx->p, next->replacement,
NULL);
/* look for the subpatterns \0 to \9 */
for (x = 0; x < rc && x < 10; x++) {
/* extract the x'ths subpattern */
to_replace[x] = substr(data, re_vector[x*2],
re_vector[x*2+1] -
re_vector[x*2], r);
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"Found match: %s", to_replace[x]);
/* the token ( \0 to \9) we are looking for */
char *token = apr_pstrcat(ctx->p, "\\",
apr_itoa(ctx->p, x), NULL);
/* allocate memory for the replacement operation */
char *tmp;
if (!to_replace[x] || strlen(to_replace[x]) < 2) {
tmp = malloc(strlen(replacement) + 1);
} else {
tmp = malloc(strlen(replacement) - 1 +
strlen(to_replace[x]));
}
/* copy the replacement string to the new
* location.
*/
memcpy(tmp, replacement, strlen(replacement) + 1);
replacement = tmp;
/* try to replace each occurence of the token with
* its matched subpattern. */
pos = ap_strstr(replacement, token);
while (pos) {
if (!to_replace[x]) {
break;
}
substr_replace(pos, to_replace[x],
strlen(pos),
strlen(to_replace[x]));
if (strlen(to_replace[x]) < 2) {
tmp = malloc(strlen(replacement) + 1);
} else {
tmp = malloc(strlen(replacement) - 1 +
strlen(to_replace[x]));
}
memcpy(tmp, replacement,
strlen(replacement) + 1);
/* clean up. */
free(replacement);
replacement = tmp;
pos = ap_strstr(replacement, token);
}
}
match_diff = strlen(replacement) -
(re_vector[1] - re_vector[0]);
/* Allocate memory for a buffer to copy the first part
* of the data string up to (but not including) the
* the matching pattern.
*/
prefix = apr_pcalloc(ctx->p, re_vector[0] + 1);
if (prefix == NULL) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
"Unable to allocate memory for prefix",
NULL);
return -1;
}
/* Copy the string from the offset (beginning of
* pattern matching) to the first occurence of the
* pattern and add a trailing \0.
*/
memcpy(prefix, data, (size_t)re_vector[0]);
/* Copy the string from the end of the pattern to the
* end of the data string itself.
*/
postfix = apr_pcalloc(ctx->p, len);
if (postfix == NULL) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
"Unable to allocate memory for postfix",
NULL);
return -1;
}
memcpy(postfix,
(data + re_vector[1]),
len - re_vector[1]);
/* Create the new data string, replace the old one
* and clean up.
*/
newdata = apr_pstrcat(ctx->p, prefix,
replacement, postfix,
NULL);
/* update the point of the data and free the allocated
* memory for the replacement string.
*/
data = newdata;
free(replacement);
/* Calculate the new offset in the data string, where
* the new matching round is to begin.
*/
offset = re_vector[1] + match_diff;
len += match_diff;
modified = 1;
}
} while (rc > 0);
}
/* Adjust the real length of the processed data. */
if (apr_table_get(f->r->headers_out, "Content-Length") != NULL) {
apr_table_set(f->r->headers_out, "Content-Length",
apr_itoa(ctx->p, len));
}
/* If an Entity Tag is set, change the mtime and generate a new ETag.*/
if (apr_table_get(f->r->headers_out, "ETag") != NULL) {
r->mtime = time(NULL);
ap_set_etag(r);
}
}
/* Create a new bucket with the processed data, insert that one into our
* brigade, then insert the saved EOS bucket at the end of the brigade
* and pass the brigade to the next filter.
*/
APR_BRIGADE_INSERT_TAIL(ctx->bb, apr_bucket_transient_create(data, len, apr_bucket_alloc_create(ctx->p)));
APR_BRIGADE_INSERT_TAIL(ctx->bb, eos_bucket);
ap_pass_brigade(f->next, ctx->bb);
return APR_SUCCESS;
}
/* Decode a multipart (or not) email. In order to support multiple
* levels of MIME parts, this function is recursive.
*/
mbox_mime_message_t *mbox_mime_decode_multipart(request_rec *r, apr_pool_t *p, char *body,
char *ct, char *charset,
mbox_cte_e cte, char *boundary)
{
mbox_mime_message_t *mail;
char *tmp = NULL, *end_bound = NULL;
char *headers_bound = NULL;
if (!body) {
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"mbox_mime_decode_multipart: no body");
return NULL;
}
/* Locate the end of part headers */
if (!ct) {
headers_bound = ap_strstr(body, "\n\n");
if (!headers_bound) {
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"no '\\n\\n' header separator found");
return NULL;
}
}
else {
headers_bound = body;
}
mail = apr_pcalloc(p, sizeof(mbox_mime_message_t));
/* make sure the memory allocated by realloc() below is cleaned up */
apr_pool_cleanup_register(p, mail, cleanup_mime_msg, apr_pool_cleanup_null);
if (!ct) {
/* If no Content-Type is provided, it means that we are parsing a
* sub-part of the multipart message. The Content-Type header
* should then be the first line of the part. If not, use
* text/plain as default for the sub-part.
*/
tmp = body;
ct = mbox_mime_get_header(p, "Content-Type", &tmp, headers_bound);
if (!ct) {
ct = "text/plain";
}
else {
if (!charset)
charset = mbox_mime_get_parameter(p, "charset", tmp, headers_bound);
mail->content_name = mbox_mime_get_parameter(p, "name", tmp, headers_bound);
}
mail->content_type = ct;
}
else {
mail->content_type = ct;
if (!charset)
charset = mbox_mime_get_parameter(p, "charset", ct, ct + strlen(ct));
}
mail->charset = charset;
/* Now we have a Content-Type. Look for other useful header information */
/* Check Content-Disposition if the match is within the headers */
tmp = body;
mail->content_disposition = mbox_mime_get_header(p, "Content-Disposition", &tmp, headers_bound);
if (!mail->content_disposition)
mail->content_disposition = "inline";
/* Check Content-Transfer-Encoding, if needed */
if (cte == CTE_NONE) {
tmp = body;
tmp = mbox_mime_get_header(p, "Content-Transfer-Encoding", &tmp, headers_bound);
if (tmp)
mail->cte = mbox_parse_cte_header(tmp);
}
else {
mail->cte = cte;
}
/* Now we have all the headers we need. Start processing the body */
if (headers_bound == body)
mail->body = body;
else
mail->body = headers_bound + 2; /* skip double new line */
/* If the mail is a multipart message, search for the boundary,
and process its sub parts by recursive calls. */
if (strncmp(mail->content_type, "multipart/", strlen("multipart/")) == 0) {
int end = 0, count = 0;
char *search, *bound, *boundary_line;
/* If the boundary was not given, we must look for it in the headers */
if (!boundary) {
boundary = mbox_mime_get_parameter(p, "boundary", body, headers_bound);
if (!boundary) {
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"invalid multipart message: no boundary defined");
return NULL;
}
}
mail->boundary = boundary;
ap_log_rerror(APLOG_MARK, APLOG_TRACE1, 0, r,
"decoding multipart message: boundary %s", boundary);
/* Now we have our boundary string. We must : look for it once
(begining of MIME part) and then look for the end boundary :
--boundary-- to mark the end of the MIME part.
In order to handle empty boundaries, we'll look for the
boundary plus the \n. */
boundary_line = apr_pstrcat(p, "--", mail->boundary, NULL);
/* The start boundary */
bound = ap_strstr(mail->body, boundary_line);
if (!bound) {
return NULL;
}
/* The end boudary */
end_bound = apr_psprintf(p, "--%s--", mail->boundary);
tmp = ap_strstr(mail->body, end_bound);
if (!tmp) {
return NULL;
}
*tmp = 0;
/* Set the search begining to the line after the start boundary. */
search = bound + strlen(boundary_line) + 1;
/* While the MIME part is not finished, go through all sub parts */
while (!end) {
char *inbound;
inbound = ap_strstr(search, boundary_line);
if (inbound) {
*inbound = 0;
}
/* Allocate a new pointer for the sub part, and parse it. */
mail->sub =
realloc(mail->sub, ++count * sizeof(struct mimemsg *));
ap_log_rerror(APLOG_MARK, APLOG_TRACE2, 0, r,
"decoding part %d", count);
mail->sub[count - 1] =
mbox_mime_decode_multipart(r, p, search, NULL, NULL, CTE_NONE, NULL);
/* If the boudary is found again, it means we have another
MIME part in the same multipart message. Set the new
search begining to the line after this new start
boundary */
if (inbound) {
*inbound = '-';
search = inbound + strlen(boundary_line) + 1;
}
/* Otherwise, the MIME part is finished. */
else {
mail->sub_count = count;
end = 1;
}
}
/* Finally reset the end-body pointer. */
// *tmp = '-';
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"done decoding multipart message (boundary %s)",
boundary);
}
/* If the parsed body is not multipart or is a MIME part, the body
length is the length of the body string (no surprise here). If
it's a MIME part, its correct length will be set after the call
to mbox_mime_decode_multipart just a dozen lines above. */
else {
if (mail->body != NULL) {
mail->body_len = strlen(mail->body);
}
else {
mail->body_len = 0;
}
}
return mail;
}
