/* 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.

 */

/*

 * mod_autoindex.c: Handles the on-the-fly html index generation

 *

 * Rob McCool

 * 3/23/93

 *

 * Adapted to Apache by rst.

 *

 * Version sort added by Martin Pool <mbp@humbug.org.au>.

 */

#include "apr_strings.h"

#include "apr_fnmatch.h"

#include "apr_strings.h"

#include "apr_lib.h"

#define APR_WANT_STRFUNC

#include "apr_want.h"

#include "ap_config.h"

#include "httpd.h"

#include "http_config.h"

#include "http_core.h"

#include "http_request.h"

#include "http_protocol.h"

#include "http_log.h"

#include "http_main.h"

#include "util_script.h"

#include "mod_core.h"

module AP_MODULE_DECLARE_DATA autoindex_module;

/****************************************************************

 *

 * Handling configuration directives...

 */

#define NO_OPTIONS          (1 <<  0)  /* Indexing options */

#define ICONS_ARE_LINKS     (1 <<  1)

#define SCAN_HTML_TITLES    (1 <<  2)

#define SUPPRESS_ICON       (1 <<  3)

#define SUPPRESS_LAST_MOD   (1 <<  4)

#define SUPPRESS_SIZE       (1 <<  5)

#define SUPPRESS_DESC       (1 <<  6)

#define SUPPRESS_PREAMBLE   (1 <<  7)

#define SUPPRESS_COLSORT    (1 <<  8)

#define SUPPRESS_RULES      (1 <<  9)

#define FOLDERS_FIRST       (1 << 10)

#define VERSION_SORT        (1 << 11)

#define TRACK_MODIFIED      (1 << 12)

#define FANCY_INDEXING      (1 << 13)

#define TABLE_INDEXING      (1 << 14)

#define IGNORE_CLIENT       (1 << 15)

#define IGNORE_CASE         (1 << 16)

#define EMIT_XHTML          (1 << 17)

#define SHOW_FORBIDDEN      (1 << 18)

#define ADDALTCLASS         (1 << 19)

#define OPTION_UNSET        (1 << 20)

#define K_NOADJUST 0

#define K_ADJUST 1

#define K_UNSET 2

/*

 * Define keys for sorting.

 */

#define K_NAME 'N'              /* Sort by file name (default) */

#define K_LAST_MOD 'M'          /* Last modification date */

#define K_SIZE 'S'              /* Size (absolute, not as displayed) */

#define K_DESC 'D'              /* Description */

#define K_VALID "NMSD"          /* String containing _all_ valid K_ opts */

#define D_ASCENDING 'A'

#define D_DESCENDING 'D'

#define D_VALID "AD"            /* String containing _all_ valid D_ opts */

/*

 * These are the dimensions of the default icons supplied with Apache.

 */

#define DEFAULT_ICON_WIDTH 20

#define DEFAULT_ICON_HEIGHT 22

/*

 * Other default dimensions.

 */

#define DEFAULT_NAME_WIDTH 23

#define DEFAULT_DESC_WIDTH 23

struct item {

    char *type;

    char *apply_to;

    char *apply_path;

    char *data;

};

typedef struct ai_desc_t {

    char *pattern;

    char *description;

    int full_path;

    int wildcards;

} ai_desc_t;

typedef struct autoindex_config_struct {

    char *default_icon;

    char *style_sheet;

    char *head_insert;

    char *header;

    char *readme;

    apr_int32_t opts;

    apr_int32_t incremented_opts;

    apr_int32_t decremented_opts;

    int name_width;

    int name_adjust;

    int desc_width;

    int desc_adjust;

    int icon_width;

    int icon_height;

    char default_keyid;

    char default_direction;

    apr_array_header_t *icon_list;

    apr_array_header_t *alt_list;

    apr_array_header_t *desc_list;

    apr_array_header_t *ign_list;

    int ign_noinherit;

    char *ctype;

    char *charset;

    char *datetime_format;

} autoindex_config_rec;

static char c_by_encoding, c_by_type, c_by_path;

#define BY_ENCODING &c_by_encoding

#define BY_TYPE &c_by_type

#define BY_PATH &c_by_path

static APR_INLINE int response_is_html(request_rec *r)

{

    char *ctype = ap_field_noparam(r->pool, r->content_type);

    return !ap_cstr_casecmp(ctype, "text/html")

        || !ap_cstr_casecmp(ctype, "application/xhtml+xml");

}

/*

 * This routine puts the standard HTML header at the top of the index page.

 * We include the DOCTYPE because we may be using features therefrom (i.e.,

 * HEIGHT and WIDTH attributes on the icons if we're FancyIndexing).

 */

static void emit_preamble(request_rec *r, int xhtml, const char *title)

{

    autoindex_config_rec *d;

    d = (autoindex_config_rec *) ap_get_module_config(r->per_dir_config,

                                                      &autoindex_module);

    if (xhtml) {

        ap_rvputs(r, DOCTYPE_XHTML_1_0T,

                  "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n"

                  " <head>\n  <title>Index of ", title,

                  "</title>\n", NULL);

    } else {

        ap_rvputs(r, DOCTYPE_HTML_3_2,

                  "<html>\n <head>\n"

                  "  <title>Index of ", title,

                  "</title>\n", NULL);

    }

    if (d->style_sheet != NULL) {

        ap_rvputs(r, "  <link rel=\"stylesheet\" href=\"", d->style_sheet,

                "\" type=\"text/css\"", xhtml ? " />\n" : ">\n", NULL);

    }

    if (d->head_insert != NULL) {

        ap_rputs(d->head_insert, r);

    }

    ap_rputs(" </head>\n <body>\n", r);

}

static void push_item(apr_array_header_t *arr, char *type, const char *to,

                      const char *path, const char *data)

{

    struct item *p = (struct item *) apr_array_push(arr);

    if (!to) {

        to = "";

    }

    if (!path) {

        path = "";

    }

    p->type = type;

    p->data = apr_pstrdup(arr->pool, data);

    p->apply_path = apr_pstrcat(arr->pool, path, "*", NULL);

    if ((type == BY_PATH) && (!ap_is_matchexp(to))) {

        p->apply_to = apr_pstrcat(arr->pool, "*", to, NULL);

    }

    else {

        p->apply_to = apr_pstrdup(arr->pool, to);

    }

}

static const char *add_alt(cmd_parms *cmd, void *d, const char *alt,

                           const char *to)

{

    if (cmd->info == BY_PATH) {

        if (!strcmp(to, "**DIRECTORY**")) {

            to = "^^DIRECTORY^^";

        }

    }

    if (cmd->info == BY_ENCODING) {

        char *tmp = apr_pstrdup(cmd->temp_pool, to);

        ap_str_tolower(tmp);

        to = tmp;

    }

    push_item(((autoindex_config_rec *) d)->alt_list, cmd->info, to,

              cmd->path, alt);

    return NULL;

}

static const char *add_icon(cmd_parms *cmd, void *d, const char *icon,

                            const char *to)

{

    char *iconbak = apr_pstrdup(cmd->temp_pool, icon);

    if (icon[0] == '(') {

        char *alt;

        char *cl = strchr(iconbak, ')');

        if (cl == NULL) {

            return "missing closing paren";

        }

        alt = ap_getword_nc(cmd->temp_pool, &iconbak, ',');

        *cl = '\0';                             /* Lose closing paren */

        add_alt(cmd, d, &alt[1], to);

    }

    if (cmd->info == BY_PATH) {

        if (!strcmp(to, "**DIRECTORY**")) {

            to = "^^DIRECTORY^^";

        }

    }

    if (cmd->info == BY_ENCODING) {

        char *tmp = apr_pstrdup(cmd->temp_pool, to);

        ap_str_tolower(tmp);

        to = tmp;

    }

    push_item(((autoindex_config_rec *) d)->icon_list, cmd->info, to,

              cmd->path, iconbak);

    return NULL;

}

/*

 * Add description text for a filename pattern.  If the pattern has

 * wildcards already (or we need to add them), add leading and

 * trailing wildcards to it to ensure substring processing.  If the

 * pattern contains a '/' anywhere, force wildcard matching mode,

 * add a slash to the prefix so that "bar/bletch" won't be matched

 * by "foobar/bletch", and make a note that there's a delimiter;

 * the matching routine simplifies to just the actual filename

 * whenever it can.  This allows definitions in parent directories

 * to be made for files in subordinate ones using relative paths.

 */

/*

 * Absent a strcasestr() function, we have to force wildcards on

 * systems for which "AAA" and "aaa" mean the same file.

 */

#ifdef CASE_BLIND_FILESYSTEM

#define WILDCARDS_REQUIRED 1

#else

#define WILDCARDS_REQUIRED 0

#endif

static const char *add_desc(cmd_parms *cmd, void *d, const char *desc,

                            const char *to)

{

    autoindex_config_rec *dcfg = (autoindex_config_rec *) d;

    ai_desc_t *desc_entry;

    char *prefix = "";

    desc_entry = (ai_desc_t *) apr_array_push(dcfg->desc_list);

    desc_entry->full_path = (ap_strchr_c(to, '/') == NULL) ? 0 : 1;

    desc_entry->wildcards = (WILDCARDS_REQUIRED

                             || desc_entry->full_path

                             || apr_fnmatch_test(to));

    if (desc_entry->wildcards) {

        prefix = desc_entry->full_path ? "*/" : "*";

        desc_entry->pattern = apr_pstrcat(dcfg->desc_list->pool,

                                          prefix, to, "*", NULL);

    }

    else {

        desc_entry->pattern = apr_pstrdup(dcfg->desc_list->pool, to);

    }

    desc_entry->description = apr_pstrdup(dcfg->desc_list->pool, desc);

    return NULL;

}

static const char *add_ignore(cmd_parms *cmd, void *d, const char *ext)

{

    push_item(((autoindex_config_rec *) d)->ign_list, 0, ext, cmd->path, NULL);

    return NULL;

}

static const char *add_opts(cmd_parms *cmd, void *d, int argc, char *const argv[])

{

    int i;

    char *w;

    apr_int32_t opts;

    apr_int32_t opts_add;

    apr_int32_t opts_remove;

    char action;

    autoindex_config_rec *d_cfg = (autoindex_config_rec *) d;

    opts = d_cfg->opts;

    opts_add = d_cfg->incremented_opts;

    opts_remove = d_cfg->decremented_opts;

    for (i = 0; i < argc; i++) {

        int option = 0;

        w = argv[i];

        if ((*w == '+') || (*w == '-')) {

            action = *(w++);

        }

        else {

            action = '\0';

        }

        if (!strcasecmp(w, "FancyIndexing")) {

            option = FANCY_INDEXING;

        }

        else if (!strcasecmp(w, "FoldersFirst")) {

            option = FOLDERS_FIRST;

        }

        else if (!strcasecmp(w, "HTMLTable")) {

            option = TABLE_INDEXING;

        }

        else if (!strcasecmp(w, "IconsAreLinks")) {

            option = ICONS_ARE_LINKS;

        }

        else if (!strcasecmp(w, "IgnoreCase")) {

            option = IGNORE_CASE;

        }

        else if (!strcasecmp(w, "IgnoreClient")) {

            option = IGNORE_CLIENT;

        }

        else if (!strcasecmp(w, "ScanHTMLTitles")) {

            option = SCAN_HTML_TITLES;

        }

        else if (!strcasecmp(w, "SuppressColumnSorting")) {

            option = SUPPRESS_COLSORT;

        }

        else if (!strcasecmp(w, "SuppressDescription")) {

            option = SUPPRESS_DESC;

        }

        else if (!strcasecmp(w, "SuppressHTMLPreamble")) {

            option = SUPPRESS_PREAMBLE;

        }

        else if (!strcasecmp(w, "SuppressIcon")) {

            option = SUPPRESS_ICON;

        }

        else if (!strcasecmp(w, "SuppressLastModified")) {

            option = SUPPRESS_LAST_MOD;

        }

        else if (!strcasecmp(w, "SuppressSize")) {

            option = SUPPRESS_SIZE;

        }

        else if (!strcasecmp(w, "SuppressRules")) {

            option = SUPPRESS_RULES;

        }

        else if (!strcasecmp(w, "TrackModified")) {

            option = TRACK_MODIFIED;

        }

        else if (!strcasecmp(w, "VersionSort")) {

            option = VERSION_SORT;

        }

        else if (!strcasecmp(w, "XHTML")) {

            option = EMIT_XHTML;

        }

        else if (!strcasecmp(w, "ShowForbidden")) {

            option = SHOW_FORBIDDEN;

        }

        else if (!strcasecmp(w, "AddAltClass")) {

            option = ADDALTCLASS;

        }

        else if (!strcasecmp(w, "None")) {

            if (action != '\0') {

                return "Cannot combine '+' or '-' with 'None' keyword";

            }

            opts = NO_OPTIONS;

            opts_add = 0;

            opts_remove = 0;

        }

        else if (!strcasecmp(w, "IconWidth")) {

            if (action != '-') {

                d_cfg->icon_width = DEFAULT_ICON_WIDTH;

            }

            else {

                d_cfg->icon_width = 0;

            }

        }

        else if (!strncasecmp(w, "IconWidth=", 10)) {

            if (action == '-') {

                return "Cannot combine '-' with IconWidth=n";

            }

            d_cfg->icon_width = atoi(&w[10]);

        }

        else if (!strcasecmp(w, "IconHeight")) {

            if (action != '-') {

                d_cfg->icon_height = DEFAULT_ICON_HEIGHT;

            }

            else {

                d_cfg->icon_height = 0;

            }

        }

        else if (!strncasecmp(w, "IconHeight=", 11)) {

            if (action == '-') {

                return "Cannot combine '-' with IconHeight=n";

            }

            d_cfg->icon_height = atoi(&w[11]);

        }

        else if (!strcasecmp(w, "NameWidth")) {

            if (action != '-') {

                return "NameWidth with no value may only appear as "

                       "'-NameWidth'";

            }

            d_cfg->name_width = DEFAULT_NAME_WIDTH;

            d_cfg->name_adjust = K_NOADJUST;

        }

        else if (!strncasecmp(w, "NameWidth=", 10)) {

            if (action == '-') {

                return "Cannot combine '-' with NameWidth=n";

            }

            if (w[10] == '*') {

                d_cfg->name_adjust = K_ADJUST;

            }

            else {

                int width = atoi(&w[10]);

                if (width && (width < 5)) {

                    return "NameWidth value must be greater than 5";

                }

                d_cfg->name_width = width;

                d_cfg->name_adjust = K_NOADJUST;

            }

        }

        else if (!strcasecmp(w, "DescriptionWidth")) {

            if (action != '-') {

                return "DescriptionWidth with no value may only appear as "

                       "'-DescriptionWidth'";

            }

            d_cfg->desc_width = DEFAULT_DESC_WIDTH;

            d_cfg->desc_adjust = K_NOADJUST;

        }

        else if (!strncasecmp(w, "DescriptionWidth=", 17)) {

            if (action == '-') {

                return "Cannot combine '-' with DescriptionWidth=n";

            }

            if (w[17] == '*') {

                d_cfg->desc_adjust = K_ADJUST;

            }

            else {

                int width = atoi(&w[17]);

                if (width && (width < 12)) {

                    return "DescriptionWidth value must be greater than 12";

                }

                d_cfg->desc_width = width;

                d_cfg->desc_adjust = K_NOADJUST;

            }

        }

        else if (!strncasecmp(w, "Type=", 5)) {

            d_cfg->ctype = apr_pstrdup(cmd->pool, &w[5]);

        }

        else if (!strncasecmp(w, "Charset=", 8)) {

            d_cfg->charset = apr_pstrdup(cmd->pool, &w[8]);

        }

        else if (!strcasecmp(w, "UseOldDateFormat")) {

            d_cfg->datetime_format = "%d-%b-%Y %H:%M";

        }

        else {

            return "Invalid directory indexing option";

        }

        if (action == '\0') {

            opts |= option;

            opts_add = 0;

            opts_remove = 0;

        }

        else if (action == '+') {

            opts_add |= option;

            opts_remove &= ~option;

        }

        else {

            opts_remove |= option;

            opts_add &= ~option;

        }

    }

    if ((opts & NO_OPTIONS) && (opts & ~NO_OPTIONS)) {

        return "Cannot combine other IndexOptions keywords with 'None'";

    }

    d_cfg->incremented_opts = opts_add;

    d_cfg->decremented_opts = opts_remove;

    d_cfg->opts = opts;

    return NULL;

}

static const char *set_default_order(cmd_parms *cmd, void *m,

                                     const char *direction, const char *key)

{

    autoindex_config_rec *d_cfg = (autoindex_config_rec *) m;

    if (!strcasecmp(direction, "Ascending")) {

        d_cfg->default_direction = D_ASCENDING;

    }

    else if (!strcasecmp(direction, "Descending")) {

        d_cfg->default_direction = D_DESCENDING;

    }

    else {

        return "First keyword must be 'Ascending' or 'Descending'";

    }

    if (!strcasecmp(key, "Name")) {

        d_cfg->default_keyid = K_NAME;

    }

    else if (!strcasecmp(key, "Date")) {

        d_cfg->default_keyid = K_LAST_MOD;

    }

    else if (!strcasecmp(key, "Size")) {

        d_cfg->default_keyid = K_SIZE;

    }

    else if (!strcasecmp(key, "Description")) {

        d_cfg->default_keyid = K_DESC;

    }

    else {

        return "Second keyword must be 'Name', 'Date', 'Size', or "

               "'Description'";

    }

    return NULL;

}

#define DIR_CMD_PERMS OR_INDEXES

static const command_rec autoindex_cmds[] =

{

    AP_INIT_ITERATE2("AddIcon", add_icon, BY_PATH, DIR_CMD_PERMS,

                     "an icon URL followed by one or more filenames"),

    AP_INIT_ITERATE2("AddIconByType", add_icon, BY_TYPE, DIR_CMD_PERMS,

                     "an icon URL followed by one or more MIME types"),

    AP_INIT_ITERATE2("AddIconByEncoding", add_icon, BY_ENCODING, DIR_CMD_PERMS,

                     "an icon URL followed by one or more content encodings"),

    AP_INIT_ITERATE2("AddAlt", add_alt, BY_PATH, DIR_CMD_PERMS,

                     "alternate descriptive text followed by one or more "

                     "filenames"),

    AP_INIT_ITERATE2("AddAltByType", add_alt, BY_TYPE, DIR_CMD_PERMS,

                     "alternate descriptive text followed by one or more MIME "

                     "types"),

    AP_INIT_ITERATE2("AddAltByEncoding", add_alt, BY_ENCODING, DIR_CMD_PERMS,

                     "alternate descriptive text followed by one or more "

                     "content encodings"),

    AP_INIT_TAKE_ARGV("IndexOptions", add_opts, NULL, DIR_CMD_PERMS,

                      "one or more index options [+|-][]"),

    AP_INIT_TAKE2("IndexOrderDefault", set_default_order, NULL, DIR_CMD_PERMS,

                  "{Ascending,Descending} {Name,Size,Description,Date}"),

    AP_INIT_ITERATE("IndexIgnore", add_ignore, NULL, DIR_CMD_PERMS,

                    "one or more file extensions"),

    AP_INIT_FLAG("IndexIgnoreReset", ap_set_flag_slot,

                 (void *)APR_OFFSETOF(autoindex_config_rec, ign_noinherit),

                 DIR_CMD_PERMS,

                 "Reset the inherited list of IndexIgnore filenames"),

    AP_INIT_ITERATE2("AddDescription", add_desc, BY_PATH, DIR_CMD_PERMS,

                     "Descriptive text followed by one or more filenames"),

    AP_INIT_TAKE1("HeaderName", ap_set_string_slot,

                  (void *)APR_OFFSETOF(autoindex_config_rec, header),

                  DIR_CMD_PERMS, "a filename"),

    AP_INIT_TAKE1("ReadmeName", ap_set_string_slot,

                  (void *)APR_OFFSETOF(autoindex_config_rec, readme),

                  DIR_CMD_PERMS, "a filename"),

    AP_INIT_RAW_ARGS("FancyIndexing", ap_set_deprecated, NULL, OR_ALL,

                     "The FancyIndexing directive is no longer supported. "

                     "Use IndexOptions FancyIndexing."),

    AP_INIT_TAKE1("DefaultIcon", ap_set_string_slot,

                  (void *)APR_OFFSETOF(autoindex_config_rec, default_icon),

                  DIR_CMD_PERMS, "an icon URL"),

    AP_INIT_TAKE1("IndexStyleSheet", ap_set_string_slot,

                  (void *)APR_OFFSETOF(autoindex_config_rec, style_sheet),

                  DIR_CMD_PERMS, "URL to style sheet"),

    AP_INIT_TAKE1("IndexHeadInsert", ap_set_string_slot,

                  (void *)APR_OFFSETOF(autoindex_config_rec, head_insert),

                  DIR_CMD_PERMS, "String to insert in HTML HEAD section"),

    {NULL}

};

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

{

    autoindex_config_rec *new =

    (autoindex_config_rec *) apr_pcalloc(p, sizeof(autoindex_config_rec));

    new->icon_width = 0;

    new->icon_height = 0;

    new->name_width = DEFAULT_NAME_WIDTH;

    new->name_adjust = K_UNSET;

    new->desc_width = DEFAULT_DESC_WIDTH;

    new->desc_adjust = K_UNSET;

    new->icon_list = apr_array_make(p, 4, sizeof(struct item));

    new->alt_list = apr_array_make(p, 4, sizeof(struct item));

    new->desc_list = apr_array_make(p, 4, sizeof(ai_desc_t));

    new->ign_list = apr_array_make(p, 4, sizeof(struct item));

    new->opts = OPTION_UNSET;

    new->incremented_opts = 0;

    new->decremented_opts = 0;

    new->default_keyid = '\0';

    new->default_direction = '\0';

    return (void *) new;

}

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

{

    autoindex_config_rec *new;

    autoindex_config_rec *base = (autoindex_config_rec *) basev;

    autoindex_config_rec *add = (autoindex_config_rec *) addv;

    new = (autoindex_config_rec *) apr_pcalloc(p, sizeof(autoindex_config_rec));

    new->default_icon = add->default_icon ? add->default_icon

                                          : base->default_icon;

    new->style_sheet = add->style_sheet ? add->style_sheet

                                          : base->style_sheet;

    new->head_insert = add->head_insert ? add->head_insert

                                          : base->head_insert;

    new->header = add->header ? add->header

                                : base->header;

    new->readme = add->readme ? add->readme

                                : base->readme;

    new->icon_height = add->icon_height ? add->icon_height : base->icon_height;

    new->icon_width = add->icon_width ? add->icon_width : base->icon_width;

    new->ctype = add->ctype ? add->ctype : base->ctype;

    new->charset = add->charset ? add->charset : base->charset;

    new->datetime_format = add->datetime_format ? add->datetime_format : base->datetime_format;

    new->alt_list = apr_array_append(p, add->alt_list, base->alt_list);

    new->desc_list = apr_array_append(p, add->desc_list, base->desc_list);

    new->icon_list = apr_array_append(p, add->icon_list, base->icon_list);

    new->ign_list = add->ign_noinherit ? add->ign_list : apr_array_append(p, add->ign_list, base->ign_list);

    if (add->opts == NO_OPTIONS) {

        /*

         * If the current directory explicitly says 'no options' then we also

         * clear any incremental mods from being inheritable further down.

         */

        new->opts = NO_OPTIONS;

        new->incremented_opts = 0;

        new->decremented_opts = 0;

    }

    else {

        /*

         * If there were any nonincremental options selected for

         * this directory, they dominate and we don't inherit *anything.*

         * Contrariwise, we *do* inherit if the only settings here are

         * incremental ones.

         */

        if (add->opts == OPTION_UNSET) {

            new->incremented_opts = (base->incremented_opts

                                     | add->incremented_opts)

                                    & ~add->decremented_opts;

            new->decremented_opts = (base->decremented_opts

                                     | add->decremented_opts);

            /*

             * We may have incremental settings, so make sure we don't

             * inadvertently inherit an IndexOptions None from above.

             */

            new->opts = (base->opts & ~NO_OPTIONS);

        }

        else {

            /*

             * There are local nonincremental settings, which clear

             * all inheritance from above.  They *are* the new base settings.

             */

            new->opts = add->opts;

        }

        /*

         * We're guaranteed that there'll be no overlap between

         * the add-options and the remove-options.

         */

        new->opts |= new->incremented_opts;

        new->opts &= ~new->decremented_opts;

    }

    /*

     * Inherit the NameWidth settings if there aren't any specific to

     * the new location; otherwise we'll end up using the defaults set in the

     * config-rec creation routine.

     */

    if (add->name_adjust == K_UNSET) {

        new->name_width = base->name_width;

        new->name_adjust = base->name_adjust;

    }

    else {

        new->name_width = add->name_width;

        new->name_adjust = add->name_adjust;

    }

    /*

     * Likewise for DescriptionWidth.

     */

    if (add->desc_adjust == K_UNSET) {

        new->desc_width = base->desc_width;

        new->desc_adjust = base->desc_adjust;

    }

    else {

        new->desc_width = add->desc_width;

        new->desc_adjust = add->desc_adjust;

    }

    new->default_keyid = add->default_keyid ? add->default_keyid

                                            : base->default_keyid;

    new->default_direction = add->default_direction ? add->default_direction

                                                    : base->default_direction;

    return new;

}

/****************************************************************

 *

 * Looking things up in config entries...

 */

/* Structure used to hold entries when we're actually building an index */

struct ent {

    char *name;

    char *icon;

    char *alt;

    char *desc;

    apr_off_t size;

    apr_time_t lm;

    struct ent *next;

    int ascending, ignore_case, version_sort;

    char key;

    int isdir;

};

static char *find_item(const char *content_type, const char *content_encoding,

                       char *path, apr_array_header_t *list, int path_only)

{

    struct item *items = (struct item *) list->elts;

    int i;

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

        struct item *p = &items[i];

        /* Special cased for ^^DIRECTORY^^ and ^^BLANKICON^^ */

        if ((path[0] == '^') || (!ap_strcmp_match(path, p->apply_path))) {

            if (!*(p->apply_to)) {

                return p->data;

            }

            else if (p->type == BY_PATH || path[0] == '^') {

                if (!ap_strcmp_match(path, p->apply_to)) {

                    return p->data;

                }

            }

            else if (!path_only) {

                if (!content_encoding) {

                    if (p->type == BY_TYPE) {

                        if (content_type

                            && !ap_strcasecmp_match(content_type,

                                                    p->apply_to)) {

                            return p->data;

                        }

                    }

                }

                else {

                    if (p->type == BY_ENCODING) {

                        if (!ap_strcasecmp_match(content_encoding,

                                                 p->apply_to)) {

                            return p->data;

                        }

                    }

                }

            }

        }

    }

    return NULL;

}

static char *find_item_by_request(request_rec *r, apr_array_header_t *list, int path_only)

{

    return find_item(ap_field_noparam(r->pool, r->content_type),

                     r->content_encoding, r->filename, list, path_only);

}

#define find_icon(d,p,t) find_item_by_request(p,d->icon_list,t)

#define find_alt(d,p,t) find_item_by_request(p,d->alt_list,t)

#define find_default_icon(d,n) find_item(NULL, NULL, n, d->icon_list, 1)

#define find_default_alt(d,n) find_item(NULL, NULL, n, d->alt_list, 1)

/*

 * Look through the list of pattern/description pairs and return the first one

 * if any) that matches the filename in the request.  If multiple patterns

 * match, only the first one is used; since the order in the array is the

 * same as the order in which directives were processed, earlier matching

 * directives will dominate.

 */

#ifdef CASE_BLIND_FILESYSTEM

#define MATCH_FLAGS APR_FNM_CASE_BLIND

#else

#define MATCH_FLAGS 0

#endif

static char *find_desc(autoindex_config_rec *dcfg, const char *filename_full)

{

    int i;

    ai_desc_t *list = (ai_desc_t *) dcfg->desc_list->elts;

    const char *filename_only;

    const char *filename;

    /*

     * If the filename includes a path, extract just the name itself

     * for the simple matches.

     */

    if ((filename_only = ap_strrchr_c(filename_full, '/')) == NULL) {

        filename_only = filename_full;

    }

    else {

        filename_only++;

    }

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

        ai_desc_t *tuple = &list[i];

        int found;

        /*

         * Only use the full-path filename if the pattern contains '/'s.

         */

        filename = (tuple->full_path) ? filename_full : filename_only;

        /*

         * Make the comparison using the cheapest method; only do

         * wildcard checking if we must.

         */

        if (tuple->wildcards) {

            found = (apr_fnmatch(tuple->pattern, filename, MATCH_FLAGS) == 0);

        }

        else {

            found = (ap_strstr_c(filename, tuple->pattern) != NULL);

        }

        if (found) {

            return tuple->description;

        }

    }

    return NULL;

}

static int ignore_entry(autoindex_config_rec *d, char *path)

{

    apr_array_header_t *list = d->ign_list;

    struct item *items = (struct item *) list->elts;

    char *tt;

    int i;

    if ((tt = strrchr(path, '/')) == NULL) {

        tt = path;

    }