/* Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You under the Apache License, Version 2.0

 * (the "License"); you may not use this file except in compliance with

 * the License.  You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

/*

 * http_mime.c: Sends/gets MIME headers for requests

 *

 * Rob McCool

 *

 */

#include "apr.h"

#include "apr_strings.h"

#include "apr_lib.h"

#include "apr_hash.h"

#define APR_WANT_STRFUNC

#include "apr_want.h"

#include "ap_config.h"

#include "httpd.h"

#include "http_config.h"

#include "http_log.h"

#include "http_request.h"

#include "http_protocol.h"

/* XXXX - fix me / EBCDIC

 *        there was a cludge here which would use its

 *        own version apr_isascii(). Indicating that

 *        on some platforms that might be needed.

 *

 *        #define OS_ASC(c) (c)             -- for mere mortals

 *     or

 *        #define OS_ASC(c) (ebcdic2ascii[c]) -- for dino's

 *

 *        #define apr_isascii(c) ((OS_ASC(c) & 0x80) == 0)

 */

/* XXXXX - fix me - See note with NOT_PROXY

 */

typedef struct attrib_info {

    char *name;

    int   offset;

} attrib_info;

/* Information to which an extension can be mapped

 */

typedef struct extension_info {

    char *forced_type;                /* Additional AddTyped stuff */

    char *encoding_type;              /* Added with AddEncoding... */

    char *language_type;              /* Added with AddLanguage... */

    char *handler;                    /* Added with AddHandler... */

    char *charset_type;               /* Added with AddCharset... */

    char *input_filters;              /* Added with AddInputFilter... */

    char *output_filters;             /* Added with AddOutputFilter... */

} extension_info;

#define MULTIMATCH_UNSET      0

#define MULTIMATCH_ANY        1

#define MULTIMATCH_NEGOTIATED 2

#define MULTIMATCH_HANDLERS   4

#define MULTIMATCH_FILTERS    8

typedef struct {

    apr_hash_t *extension_mappings;  /* Map from extension name to

                                      * extension_info structure */

    apr_array_header_t *remove_mappings; /* A simple list, walked once */

    char *default_language;     /* Language if no AddLanguage ext found */

    int multimatch;       /* Extensions to include in multiview matching

                           * for filenames, e.g. Filters and Handlers

                           */

    int use_path_info;    /* If set to 0, only use filename.

                           * If set to 1, append PATH_INFO to filename for

                           *   lookups.

                           * If set to 2, this value is unset and is

                           *   effectively 0.

                           */

} mime_dir_config;

typedef struct param_s {

    char *attr;

    char *val;

    struct param_s *next;

} param;

typedef struct {

    const char *type;

    apr_size_t type_len;

    const char *subtype;

    apr_size_t subtype_len;

    param *param;

} content_type;

static char tspecial[] = {

    '(', ')', '<', '>', '@', ',', ';', ':',

    '\\', '"', '/', '[', ']', '?', '=',

    '\0'

};

module AP_MODULE_DECLARE_DATA mime_module;

static void *create_mime_dir_config(apr_pool_t *p, char *dummy)

{

    mime_dir_config *new = apr_palloc(p, sizeof(mime_dir_config));

    new->extension_mappings = NULL;

    new->remove_mappings = NULL;

    new->default_language = NULL;

    new->multimatch = MULTIMATCH_UNSET;

    new->use_path_info = 2;

    return new;

}

/*

 * Overlay one hash table of extension_mappings onto another

 */

static void *overlay_extension_mappings(apr_pool_t *p,

                                        const void *key,

                                        apr_ssize_t klen,

                                        const void *overlay_val,

                                        const void *base_val,

                                        const void *data)

{

    const extension_info *overlay_info = (const extension_info *)overlay_val;

    const extension_info *base_info = (const extension_info *)base_val;

    extension_info *new_info = apr_pmemdup(p, base_info, sizeof(extension_info));

    if (overlay_info->forced_type) {

        new_info->forced_type = overlay_info->forced_type;

    }

    if (overlay_info->encoding_type) {

        new_info->encoding_type = overlay_info->encoding_type;

    }

    if (overlay_info->language_type) {

        new_info->language_type = overlay_info->language_type;

    }

    if (overlay_info->handler) {

        new_info->handler = overlay_info->handler;

    }

    if (overlay_info->charset_type) {

        new_info->charset_type = overlay_info->charset_type;

    }

    if (overlay_info->input_filters) {

        new_info->input_filters = overlay_info->input_filters;

    }

    if (overlay_info->output_filters) {

        new_info->output_filters = overlay_info->output_filters;

    }

    return new_info;

}

/* Member is the offset within an extension_info of the pointer to reset

 */

static void remove_items(apr_pool_t *p, apr_array_header_t *remove,

                         apr_hash_t *mappings)

{

    attrib_info *suffix = (attrib_info *) remove->elts;

    int i;

    for (i = 0; i < remove->nelts; i++) {

        extension_info *exinfo = apr_hash_get(mappings,

                                              suffix[i].name,

                                              APR_HASH_KEY_STRING);

        if (exinfo && *(const char**)((char *)exinfo + suffix[i].offset)) {

            extension_info *copyinfo = exinfo;

            exinfo = apr_pmemdup(p, copyinfo, sizeof(*exinfo));

            apr_hash_set(mappings, suffix[i].name,

                         APR_HASH_KEY_STRING, exinfo);

            *(const char**)((char *)exinfo + suffix[i].offset) = NULL;

        }

    }

}

static void *merge_mime_dir_configs(apr_pool_t *p, void *basev, void *addv)

{

    mime_dir_config *base = (mime_dir_config *)basev;

    mime_dir_config *add = (mime_dir_config *)addv;

    mime_dir_config *new = apr_palloc(p, sizeof(mime_dir_config));

    if (base->extension_mappings && add->extension_mappings) {

        new->extension_mappings = apr_hash_merge(p, add->extension_mappings,

                                                 base->extension_mappings,

                                                 overlay_extension_mappings,

                                                 NULL);

    }

    else {

        if (base->extension_mappings == NULL) {

            new->extension_mappings = add->extension_mappings;

        }

        else {

            new->extension_mappings = base->extension_mappings;

        }

        /* We may not be merging the tables, but if we potentially will change

         * an exinfo member, then we are about to trounce it anyways.

         * We must have a copy for safety.

         */

        if (new->extension_mappings && add->remove_mappings) {

            new->extension_mappings =

                apr_hash_copy(p, new->extension_mappings);

        }

    }

    if (new->extension_mappings) {

        if (add->remove_mappings)

            remove_items(p, add->remove_mappings, new->extension_mappings);

    }

    new->remove_mappings = NULL;

    new->default_language = add->default_language ?

        add->default_language : base->default_language;

    new->multimatch = (add->multimatch != MULTIMATCH_UNSET) ?

        add->multimatch : base->multimatch;

    if ((add->use_path_info & 2) == 0) {

        new->use_path_info = add->use_path_info;

    }

    else {

        new->use_path_info = base->use_path_info;

    }

    return new;

}

static const char *add_extension_info(cmd_parms *cmd, void *m_,

                                      const char *value_, const char* ext)

{

    mime_dir_config *m=m_;

    extension_info *exinfo;

    int offset = (int) (long) cmd->info;

    char *key = apr_pstrdup(cmd->temp_pool, ext);

    char *value = apr_pstrdup(cmd->pool, value_);

    ap_str_tolower(value);

    ap_str_tolower(key);

    if (*key == '.') {

        ++key;

    }

    if (!m->extension_mappings) {

        m->extension_mappings = apr_hash_make(cmd->pool);

        exinfo = NULL;

    }

    else {

        exinfo = (extension_info*)apr_hash_get(m->extension_mappings, key,

                                               APR_HASH_KEY_STRING);

    }

    if (!exinfo) {

        exinfo = apr_pcalloc(cmd->pool, sizeof(extension_info));

        key = apr_pstrdup(cmd->pool, key);

        apr_hash_set(m->extension_mappings, key, APR_HASH_KEY_STRING, exinfo);

    }

    *(const char**)((char *)exinfo + offset) = value;

    return NULL;

}

/*

 * As RemoveType should also override the info from TypesConfig, we add an

 * empty string as type instead of actually removing the type.

 */

static const char *remove_extension_type(cmd_parms *cmd, void *m_,

                                         const char *ext)

{

    return add_extension_info(cmd, m_, "", ext);

}

/*

 * Note handler names are un-added with each per_dir_config merge.

 * This keeps the association from being inherited, but not

 * from being re-added at a subordinate level.

 */

static const char *remove_extension_info(cmd_parms *cmd, void *m_,

                                         const char *ext)

{

    mime_dir_config *m = (mime_dir_config *) m_;

    attrib_info *suffix;

    if (*ext == '.') {

        ++ext;

    }

    if (!m->remove_mappings) {

        m->remove_mappings = apr_array_make(cmd->pool, 4, sizeof(*suffix));

    }

    suffix = (attrib_info *)apr_array_push(m->remove_mappings);

    suffix->name = apr_pstrdup(cmd->pool, ext);

    ap_str_tolower(suffix->name);

    suffix->offset = (int) (long) cmd->info;

    return NULL;

}

/* The sole bit of server configuration that the MIME module has is

 * the name of its config file, so...

 */

static const char *set_types_config(cmd_parms *cmd, void *dummy,

                                    const char *arg)

{

    ap_set_module_config(cmd->server->module_config, &mime_module,

                         (void *)arg);

    return NULL;

}

static const char *multiviews_match(cmd_parms *cmd, void *m_,

                                    const char *include)

{

    mime_dir_config *m = (mime_dir_config *) m_;

    const char *errmsg;

    errmsg = ap_check_cmd_context(cmd, NOT_IN_LOCATION);

    if (errmsg != NULL) {

        return errmsg;

    }

    if (strcasecmp(include, "Any") == 0) {

        if (m->multimatch && (m->multimatch & ~MULTIMATCH_ANY)) {

            return "Any is incompatible with NegotiatedOnly, "

                   "Filters and Handlers";

        }

        m->multimatch |= MULTIMATCH_ANY;

    }

    else if (strcasecmp(include, "NegotiatedOnly") == 0) {

        if (m->multimatch && (m->multimatch & ~MULTIMATCH_NEGOTIATED)) {

            return "NegotiatedOnly is incompatible with Any, "

                   "Filters and Handlers";

        }

        m->multimatch |= MULTIMATCH_NEGOTIATED;

    }

    else if (strcasecmp(include, "Filters") == 0) {

        if (m->multimatch && (m->multimatch & (MULTIMATCH_NEGOTIATED

                                             | MULTIMATCH_ANY))) {

            return "Filters is incompatible with Any and NegotiatedOnly";

        }

        m->multimatch |= MULTIMATCH_FILTERS;

    }

    else if (strcasecmp(include, "Handlers") == 0) {

        if (m->multimatch && (m->multimatch & (MULTIMATCH_NEGOTIATED

                                             | MULTIMATCH_ANY))) {

            return "Handlers is incompatible with Any and NegotiatedOnly";

        }

        m->multimatch |= MULTIMATCH_HANDLERS;

    }

    else {

        return apr_psprintf(cmd->pool, "Unrecognized option '%s'", include);

    }

    return NULL;

}

static const command_rec mime_cmds[] =

{

    AP_INIT_ITERATE2("AddCharset", add_extension_info,

        (void *)APR_OFFSETOF(extension_info, charset_type), OR_FILEINFO,

        "a charset (e.g., iso-2022-jp), followed by one or more "

        "file extensions"),

    AP_INIT_ITERATE2("AddEncoding", add_extension_info,

        (void *)APR_OFFSETOF(extension_info, encoding_type), OR_FILEINFO,

        "an encoding (e.g., gzip), followed by one or more file extensions"),

    AP_INIT_ITERATE2("AddHandler", add_extension_info,

        (void *)APR_OFFSETOF(extension_info, handler), OR_FILEINFO,

        "a handler name followed by one or more file extensions"),

    AP_INIT_ITERATE2("AddInputFilter", add_extension_info,

        (void *)APR_OFFSETOF(extension_info, input_filters), OR_FILEINFO,

        "input filter name (or ; delimited names) followed by one or "

        "more file extensions"),

    AP_INIT_ITERATE2("AddLanguage", add_extension_info,

        (void *)APR_OFFSETOF(extension_info, language_type), OR_FILEINFO,

        "a language (e.g., fr), followed by one or more file extensions"),

    AP_INIT_ITERATE2("AddOutputFilter", add_extension_info,

        (void *)APR_OFFSETOF(extension_info, output_filters), OR_FILEINFO,

        "output filter name (or ; delimited names) followed by one or "

        "more file extensions"),

    AP_INIT_ITERATE2("AddType", add_extension_info,

        (void *)APR_OFFSETOF(extension_info, forced_type), OR_FILEINFO,

        "a mime type followed by one or more file extensions"),

    AP_INIT_TAKE1("DefaultLanguage", ap_set_string_slot,

        (void*)APR_OFFSETOF(mime_dir_config, default_language), OR_FILEINFO,

        "language to use for documents with no other language file extension"),

    AP_INIT_ITERATE("MultiviewsMatch", multiviews_match, NULL, OR_FILEINFO,

        "NegotiatedOnly (default), Handlers and/or Filters, or Any"),

    AP_INIT_ITERATE("RemoveCharset", remove_extension_info,

        (void *)APR_OFFSETOF(extension_info, charset_type), OR_FILEINFO,

        "one or more file extensions"),

    AP_INIT_ITERATE("RemoveEncoding", remove_extension_info,

        (void *)APR_OFFSETOF(extension_info, encoding_type), OR_FILEINFO,

        "one or more file extensions"),

    AP_INIT_ITERATE("RemoveHandler", remove_extension_info,

        (void *)APR_OFFSETOF(extension_info, handler), OR_FILEINFO,

        "one or more file extensions"),

    AP_INIT_ITERATE("RemoveInputFilter", remove_extension_info,

        (void *)APR_OFFSETOF(extension_info, input_filters), OR_FILEINFO,

        "one or more file extensions"),

    AP_INIT_ITERATE("RemoveLanguage", remove_extension_info,

        (void *)APR_OFFSETOF(extension_info, language_type), OR_FILEINFO,

        "one or more file extensions"),

    AP_INIT_ITERATE("RemoveOutputFilter", remove_extension_info,

        (void *)APR_OFFSETOF(extension_info, output_filters), OR_FILEINFO,

        "one or more file extensions"),

    AP_INIT_ITERATE("RemoveType", remove_extension_type,

        (void *)APR_OFFSETOF(extension_info, forced_type), OR_FILEINFO,

        "one or more file extensions"),

    AP_INIT_TAKE1("TypesConfig", set_types_config, NULL, RSRC_CONF,

        "the MIME types config file"),

    AP_INIT_FLAG("ModMimeUsePathInfo", ap_set_flag_slot,

        (void *)APR_OFFSETOF(mime_dir_config, use_path_info), ACCESS_CONF,

        "Set to 'yes' to allow mod_mime to use path info for type checking"),

    {NULL}

};

static apr_hash_t *mime_type_extensions;

static int mime_post_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s)

{

    ap_configfile_t *f;

    char l[MAX_STRING_LEN];

    const char *types_confname = ap_get_module_config(s->module_config,

                                                      &mime_module);

    apr_status_t status;

    if (!types_confname) {

        types_confname = AP_TYPES_CONFIG_FILE;

    }

    types_confname = ap_server_root_relative(p, types_confname);

    if (!types_confname) {

        ap_log_error(APLOG_MARK, APLOG_ERR, APR_EBADPATH, s, APLOGNO(01596)

                     "Invalid mime types config path %s",

                     (const char *)ap_get_module_config(s->module_config,

                                                        &mime_module));

        return HTTP_INTERNAL_SERVER_ERROR;

    }

    if ((status = ap_pcfg_openfile(&f, ptemp, types_confname))

                != APR_SUCCESS) {

        ap_log_error(APLOG_MARK, APLOG_ERR, status, s, APLOGNO(01597)

                     "could not open mime types config file %s.",

                     types_confname);

        return HTTP_INTERNAL_SERVER_ERROR;

    }

    mime_type_extensions = apr_hash_make(p);

    while (!(ap_cfg_getline(l, MAX_STRING_LEN, f))) {

        const char *ll = l, *ct;

        if (l[0] == '#') {

            continue;

        }

        ct = ap_getword_conf(p, &ll);

        while (ll[0]) {

            char *ext = ap_getword_conf(p, &ll);

            ap_str_tolower(ext);

            apr_hash_set(mime_type_extensions, ext, APR_HASH_KEY_STRING, ct);

        }

    }

    ap_cfg_closefile(f);

    return OK;

}

static const char *zap_sp(const char *s)

{

    if (s == NULL) {

        return (NULL);

    }

    if (*s == '\0') {

        return (s);

    }

    /* skip prefixed white space */

    for (; *s == ' ' || *s == '\t' || *s == '\n'; s++)

        ;

    return (s);

}

static char *zap_sp_and_dup(apr_pool_t *p, const char *start,

                            const char *end, apr_size_t *len)

{

    while ((start < end) && apr_isspace(*start)) {

        start++;

    }

    while ((end > start) && apr_isspace(*(end - 1))) {

        end--;

    }

    if (len) {

        *len = end - start;

    }

    return apr_pstrmemdup(p, start, end - start);

}

static int is_token(char c)

{

    int res;

    res = (apr_isascii(c) && apr_isgraph(c)

           && (strchr(tspecial, c) == NULL)) ? 1 : -1;

    return res;

}

static int is_qtext(char c)

{

    int res;

    res = (apr_isascii(c) && (c != '"') && (c != '\\') && (c != '\n'))

        ? 1 : -1;

    return res;

}

static int is_quoted_pair(const char *s)

{

    int res = -1;

    int c;

    if (*s == '\\') {

        c = (int) *(s + 1);

        if (c && apr_isascii(c)) {

            res = 1;

        }

    }

    return (res);

}

static content_type *analyze_ct(request_rec *r, const char *s)

{

    const char *cp, *mp;

    char *attribute, *value;

    int quoted = 0;

    server_rec * ss = r->server;

    apr_pool_t * p = r->pool;

    content_type *ctp;

    param *pp, *npp;

    /* initialize ctp */

    ctp = (content_type *)apr_palloc(p, sizeof(content_type));

    ctp->type = NULL;

    ctp->subtype = NULL;

    ctp->param = NULL;

    mp = s;

    /* getting a type */

    cp = mp;

    while (apr_isspace(*cp)) {

        cp++;

    }

    if (!*cp) {

        ap_log_error(APLOG_MARK, APLOG_WARNING, 0, ss, APLOGNO(01598)

                     "mod_mime: analyze_ct: cannot get media type from '%s'",

                     (const char *) mp);

        return (NULL);

    }

    ctp->type = cp;

    do {

        cp++;

    } while (*cp && (*cp != '/') && !apr_isspace(*cp) && (*cp != ';'));

    if (!*cp || (*cp == ';')) {

        ap_log_error(APLOG_MARK, APLOG_WARNING, 0, ss, APLOGNO(01599)

                     "Cannot get media type from '%s'",

                     (const char *) mp);

        return (NULL);

    }

    while (apr_isspace(*cp)) {

        cp++;

    }

    if (*cp != '/') {

        ap_log_error(APLOG_MARK, APLOG_WARNING, 0, ss, APLOGNO(01600)

                     "mod_mime: analyze_ct: cannot get media type from '%s'",

                     (const char *) mp);

        return (NULL);

    }

    ctp->type_len = cp - ctp->type;

    cp++; /* skip the '/' */

    /* getting a subtype */

    while (apr_isspace(*cp)) {

        cp++;

    }

    if (!*cp) {

        ap_log_error(APLOG_MARK, APLOG_WARNING, 0, ss, APLOGNO(01601)

                     "Cannot get media subtype.");

        return (NULL);

    }

    ctp->subtype = cp;

    do {

        cp++;

    } while (*cp && !apr_isspace(*cp) && (*cp != ';'));

    ctp->subtype_len = cp - ctp->subtype;

    while (apr_isspace(*cp)) {

        cp++;

    }

    if (*cp == '\0') {

        return (ctp);

    }

    /* getting parameters */

    cp++; /* skip the ';' */

    cp = zap_sp(cp);

    if (cp == NULL || *cp == '\0') {

        ap_log_error(APLOG_MARK, APLOG_WARNING, 0, ss, APLOGNO(01602)

                     "Cannot get media parameter.");

        return (NULL);

    }

    mp = cp;

    attribute = NULL;

    value = NULL;

    while (cp != NULL && *cp != '\0') {

        if (attribute == NULL) {

            if (is_token(*cp) > 0) {

                cp++;

                continue;

            }

            else if (*cp == ' ' || *cp == '\t' || *cp == '\n') {

                cp++;

                continue;

            }

            else if (*cp == '=') {

                attribute = zap_sp_and_dup(p, mp, cp, NULL);

                if (attribute == NULL || *attribute == '\0') {

                    ap_log_error(APLOG_MARK, APLOG_WARNING, 0, ss, APLOGNO(01603)

                                 "Cannot get media parameter.");

                    return (NULL);

                }

                cp++;

                cp = zap_sp(cp);

                if (cp == NULL || *cp == '\0') {

                    ap_log_error(APLOG_MARK, APLOG_WARNING, 0, ss, APLOGNO(01604)

                                 "Cannot get media parameter.");

                    return (NULL);

                }

                mp = cp;

                continue;

            }

            else {

                ap_log_error(APLOG_MARK, APLOG_WARNING, 0, ss, APLOGNO(01605)

                             "Cannot get media parameter.");

                return (NULL);

            }

        }

        else {

            if (mp == cp) {

                if (*cp == '"') {

                    quoted = 1;

                    cp++;

                }

                else {

                    quoted = 0;

                }

            }

            if (quoted > 0) {

                while (quoted && *cp != '\0') {

                    if (is_qtext(*cp) > 0) {

                        cp++;

                    }

                    else if (is_quoted_pair(cp) > 0) {

                        cp += 2;

                    }

                    else if (*cp == '"') {

                        cp++;

                        while (*cp == ' ' || *cp == '\t' || *cp == '\n') {

                            cp++;

                        }

                        if (*cp != ';' && *cp != '\0') {

                            ap_log_error(APLOG_MARK, APLOG_WARNING, 0, ss, APLOGNO(01606)

                                         "Cannot get media parameter.");

                            return(NULL);

                        }

                        quoted = 0;

                    }

                    else {

                        ap_log_error(APLOG_MARK, APLOG_WARNING, 0, ss, APLOGNO(01607)

                                     "Cannot get media parameter.");

                        return (NULL);

                    }

                }

            }

            else {

                while (1) {

                    if (is_token(*cp) > 0) {

                        cp++;

                    }

                    else if (*cp == '\0' || *cp == ';') {

                        break;

                    }

                    else {

                        ap_log_error(APLOG_MARK, APLOG_WARNING, 0, ss, APLOGNO(01608)

                                     "Cannot get media parameter.");

                        return (NULL);

                    }

                }

            }

            value = zap_sp_and_dup(p, mp, cp, NULL);

            if (value == NULL || *value == '\0') {

                ap_log_error(APLOG_MARK, APLOG_WARNING, 0, ss, APLOGNO(01609)

                             "Cannot get media parameter.");

                return (NULL);

            }

            pp = apr_palloc(p, sizeof(param));

            pp->attr = attribute;

            pp->val = value;

            pp->next = NULL;

            if (ctp->param == NULL) {

                ctp->param = pp;

            }

            else {

                npp = ctp->param;

                while (npp->next) {

                    npp = npp->next;

                }

                npp->next = pp;

            }

            quoted = 0;

            attribute = NULL;

            value = NULL;

            if (*cp == '\0') {

                break;

            }

            cp++;

            mp = cp;

        }

    }

    return (ctp);

}

/*

 * find_ct is the hook routine for determining content-type and other

 * MIME-related metadata.  It assumes that r->filename has already been

 * set and stat has been called for r->finfo.  It also assumes that the

 * non-path base file name is not the empty string unless it is a dir.

 */

static int find_ct(request_rec *r)

{

    mime_dir_config *conf;

    apr_array_header_t *exception_list;

    char *ext;

    const char *fn, *fntmp, *type, *charset = NULL, *resource_name;

    int found_metadata = 0;

    if (r->finfo.filetype == APR_DIR) {

        ap_set_content_type(r, DIR_MAGIC_TYPE);

        return OK;

    }

    if (!r->filename) {

        return DECLINED;

    }

    conf = (mime_dir_config *)ap_get_module_config(r->per_dir_config,

                                                   &mime_module);

    exception_list = apr_array_make(r->pool, 2, sizeof(char *));

    /* If use_path_info is explicitly set to on (value & 1 == 1), append. */

    if (conf->use_path_info & 1) {

        resource_name = apr_pstrcat(r->pool, r->filename, r->path_info, NULL);

    }

    else {

        resource_name = r->filename;

    }

    /* Always drop the path leading up to the file name.

     */

    if ((fn = ap_strrchr_c(resource_name, '/')) == NULL) {

        fn = resource_name;

    }

    else {

        ++fn;

    }

    /* The exception list keeps track of those filename components that

     * are not associated with extensions indicating metadata.

     * The base name is always the first exception (i.e., "txt.html" has

     * a basename of "txt" even though it might look like an extension).

     * Leading dots are considered to be part of the base name (a file named

     * ".png" is likely not a png file but just a hidden file called png).

     */

    fntmp = fn;

    while (*fntmp == '.')

        fntmp++;

    fntmp = ap_strchr_c(fntmp, '.');

    if (fntmp) {

        ext = apr_pstrmemdup(r->pool, fn, fntmp - fn);

        fn = fntmp + 1;

    }

    else {

        ext = apr_pstrdup(r->pool, fn);

        fn += strlen(fn);

    }

    *((const char **)apr_array_push(exception_list)) = ext;

    /* Parse filename extensions which can be in any order

     */

    while (*fn && (ext = ap_getword(r->pool, &fn, '.'))) {

        const extension_info *exinfo = NULL;

        int found;

        char *extcase;

        if (*ext == '\0') {  /* ignore empty extensions "bad..html" */

            continue;

        }

        found = 0;

        /* Save the ext in extcase before converting it to lower case.

         */

        extcase = apr_pstrdup(r->pool, ext);

        ap_str_tolower(ext);

        if (conf->extension_mappings != NULL) {

            exinfo = (extension_info*)apr_hash_get(conf->extension_mappings,

                                                   ext, APR_HASH_KEY_STRING);

        }

        if (exinfo == NULL || !exinfo->forced_type) {

            if ((type = apr_hash_get(mime_type_extensions, ext,

                                     APR_HASH_KEY_STRING)) != NULL) {

                ap_set_content_type(r, (char*) type);

                found = 1;

            }

        }

        if (exinfo != NULL) {

            /* empty string is treated as special case for RemoveType */

            if (exinfo->forced_type && *exinfo->forced_type) {

                ap_set_content_type(r, exinfo->forced_type);

                found = 1;

            }

            if (exinfo->charset_type) {

                charset = exinfo->charset_type;

                found = 1;

            }

            if (exinfo->language_type) {

                if (!r->content_languages) {

                    r->content_languages = apr_array_make(r->pool, 2,

                                                          sizeof(char *));

                }

                *((const char **)apr_array_push(r->content_languages))

                    = exinfo->language_type;

                found = 1;

            }

            if (exinfo->encoding_type) {

                if (!r->content_encoding) {

                    r->content_encoding = exinfo->encoding_type;

                }

                else {

                    /* XXX should eliminate duplicate entities

                     *

                     * ah no. Order is important and double encoding is neither

                     * forbidden nor impossible. -- nd

                     */

                    r->content_encoding = apr_pstrcat(r->pool,

                                                      r->content_encoding,

                                                      ", ",

                                                      exinfo->encoding_type,

                                                      NULL);