Annotation of embedaddon/lighttpd/src/mod_indexfile.c, revision 1.1

1.1     ! misho       1: #include "base.h"
        !             2: #include "log.h"
        !             3: #include "buffer.h"
        !             4: 
        !             5: #include "plugin.h"
        !             6: 
        !             7: #include "stat_cache.h"
        !             8: 
        !             9: #include <ctype.h>
        !            10: #include <stdlib.h>
        !            11: #include <string.h>
        !            12: #include <errno.h>
        !            13: 
        !            14: /* plugin config for all request/connections */
        !            15: 
        !            16: typedef struct {
        !            17:        array *indexfiles;
        !            18: } plugin_config;
        !            19: 
        !            20: typedef struct {
        !            21:        PLUGIN_DATA;
        !            22: 
        !            23:        buffer *tmp_buf;
        !            24: 
        !            25:        plugin_config **config_storage;
        !            26: 
        !            27:        plugin_config conf;
        !            28: } plugin_data;
        !            29: 
        !            30: /* init the plugin data */
        !            31: INIT_FUNC(mod_indexfile_init) {
        !            32:        plugin_data *p;
        !            33: 
        !            34:        p = calloc(1, sizeof(*p));
        !            35: 
        !            36:        p->tmp_buf = buffer_init();
        !            37: 
        !            38:        return p;
        !            39: }
        !            40: 
        !            41: /* detroy the plugin data */
        !            42: FREE_FUNC(mod_indexfile_free) {
        !            43:        plugin_data *p = p_d;
        !            44: 
        !            45:        UNUSED(srv);
        !            46: 
        !            47:        if (!p) return HANDLER_GO_ON;
        !            48: 
        !            49:        if (p->config_storage) {
        !            50:                size_t i;
        !            51:                for (i = 0; i < srv->config_context->used; i++) {
        !            52:                        plugin_config *s = p->config_storage[i];
        !            53: 
        !            54:                        if (!s) continue;
        !            55: 
        !            56:                        array_free(s->indexfiles);
        !            57: 
        !            58:                        free(s);
        !            59:                }
        !            60:                free(p->config_storage);
        !            61:        }
        !            62: 
        !            63:        buffer_free(p->tmp_buf);
        !            64: 
        !            65:        free(p);
        !            66: 
        !            67:        return HANDLER_GO_ON;
        !            68: }
        !            69: 
        !            70: /* handle plugin config and check values */
        !            71: 
        !            72: SETDEFAULTS_FUNC(mod_indexfile_set_defaults) {
        !            73:        plugin_data *p = p_d;
        !            74:        size_t i = 0;
        !            75: 
        !            76:        config_values_t cv[] = {
        !            77:                { "index-file.names",           NULL, T_CONFIG_ARRAY, T_CONFIG_SCOPE_CONNECTION },       /* 0 */
        !            78:                { "server.indexfiles",          NULL, T_CONFIG_ARRAY, T_CONFIG_SCOPE_CONNECTION },       /* 1 */
        !            79:                { NULL,                         NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }
        !            80:        };
        !            81: 
        !            82:        if (!p) return HANDLER_ERROR;
        !            83: 
        !            84:        p->config_storage = calloc(1, srv->config_context->used * sizeof(specific_config *));
        !            85: 
        !            86:        for (i = 0; i < srv->config_context->used; i++) {
        !            87:                plugin_config *s;
        !            88: 
        !            89:                s = calloc(1, sizeof(plugin_config));
        !            90:                s->indexfiles    = array_init();
        !            91: 
        !            92:                cv[0].destination = s->indexfiles;
        !            93:                cv[1].destination = s->indexfiles; /* old name for [0] */
        !            94: 
        !            95:                p->config_storage[i] = s;
        !            96: 
        !            97:                if (0 != config_insert_values_global(srv, ((data_config *)srv->config_context->data[i])->value, cv)) {
        !            98:                        return HANDLER_ERROR;
        !            99:                }
        !           100:        }
        !           101: 
        !           102:        return HANDLER_GO_ON;
        !           103: }
        !           104: 
        !           105: #define PATCH(x) \
        !           106:        p->conf.x = s->x;
        !           107: static int mod_indexfile_patch_connection(server *srv, connection *con, plugin_data *p) {
        !           108:        size_t i, j;
        !           109:        plugin_config *s = p->config_storage[0];
        !           110: 
        !           111:        PATCH(indexfiles);
        !           112: 
        !           113:        /* skip the first, the global context */
        !           114:        for (i = 1; i < srv->config_context->used; i++) {
        !           115:                data_config *dc = (data_config *)srv->config_context->data[i];
        !           116:                s = p->config_storage[i];
        !           117: 
        !           118:                /* condition didn't match */
        !           119:                if (!config_check_cond(srv, con, dc)) continue;
        !           120: 
        !           121:                /* merge config */
        !           122:                for (j = 0; j < dc->value->used; j++) {
        !           123:                        data_unset *du = dc->value->data[j];
        !           124: 
        !           125:                        if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.indexfiles"))) {
        !           126:                                PATCH(indexfiles);
        !           127:                        } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("index-file.names"))) {
        !           128:                                PATCH(indexfiles);
        !           129:                        }
        !           130:                }
        !           131:        }
        !           132: 
        !           133:        return 0;
        !           134: }
        !           135: #undef PATCH
        !           136: 
        !           137: URIHANDLER_FUNC(mod_indexfile_subrequest) {
        !           138:        plugin_data *p = p_d;
        !           139:        size_t k;
        !           140:        stat_cache_entry *sce = NULL;
        !           141: 
        !           142:        if (con->mode != DIRECT) return HANDLER_GO_ON;
        !           143: 
        !           144:        if (con->uri.path->used == 0) return HANDLER_GO_ON;
        !           145:        if (con->uri.path->ptr[con->uri.path->used - 2] != '/') return HANDLER_GO_ON;
        !           146: 
        !           147:        mod_indexfile_patch_connection(srv, con, p);
        !           148: 
        !           149:        if (con->conf.log_request_handling) {
        !           150:                log_error_write(srv, __FILE__, __LINE__,  "s",  "-- handling the request as Indexfile");
        !           151:                log_error_write(srv, __FILE__, __LINE__,  "sb", "URI          :", con->uri.path);
        !           152:        }
        !           153: 
        !           154:        /* indexfile */
        !           155:        for (k = 0; k < p->conf.indexfiles->used; k++) {
        !           156:                data_string *ds = (data_string *)p->conf.indexfiles->data[k];
        !           157: 
        !           158:                if (ds->value && ds->value->ptr[0] == '/') {
        !           159:                        /* if the index-file starts with a prefix as use this file as
        !           160:                         * index-generator */
        !           161:                        buffer_copy_string_buffer(p->tmp_buf, con->physical.doc_root);
        !           162:                } else {
        !           163:                        buffer_copy_string_buffer(p->tmp_buf, con->physical.path);
        !           164:                }
        !           165:                buffer_append_string_buffer(p->tmp_buf, ds->value);
        !           166: 
        !           167:                if (HANDLER_ERROR == stat_cache_get_entry(srv, con, p->tmp_buf, &sce)) {
        !           168:                        if (errno == EACCES) {
        !           169:                                con->http_status = 403;
        !           170:                                buffer_reset(con->physical.path);
        !           171: 
        !           172:                                return HANDLER_FINISHED;
        !           173:                        }
        !           174: 
        !           175:                        if (errno != ENOENT &&
        !           176:                            errno != ENOTDIR) {
        !           177:                                /* we have no idea what happend. let's tell the user so. */
        !           178: 
        !           179:                                con->http_status = 500;
        !           180: 
        !           181:                                log_error_write(srv, __FILE__, __LINE__, "ssbsb",
        !           182:                                                "file not found ... or so: ", strerror(errno),
        !           183:                                                con->uri.path,
        !           184:                                                "->", con->physical.path);
        !           185: 
        !           186:                                buffer_reset(con->physical.path);
        !           187: 
        !           188:                                return HANDLER_FINISHED;
        !           189:                        }
        !           190:                        continue;
        !           191:                }
        !           192: 
        !           193:                /* rewrite uri.path to the real path (/ -> /index.php) */
        !           194:                buffer_append_string_buffer(con->uri.path, ds->value);
        !           195:                buffer_copy_string_buffer(con->physical.path, p->tmp_buf);
        !           196: 
        !           197:                /* fce is already set up a few lines above */
        !           198: 
        !           199:                return HANDLER_GO_ON;
        !           200:        }
        !           201: 
        !           202:        /* not found */
        !           203:        return HANDLER_GO_ON;
        !           204: }
        !           205: 
        !           206: /* this function is called at dlopen() time and inits the callbacks */
        !           207: 
        !           208: int mod_indexfile_plugin_init(plugin *p);
        !           209: int mod_indexfile_plugin_init(plugin *p) {
        !           210:        p->version     = LIGHTTPD_VERSION_ID;
        !           211:        p->name        = buffer_init_string("indexfile");
        !           212: 
        !           213:        p->init        = mod_indexfile_init;
        !           214:        p->handle_subrequest_start = mod_indexfile_subrequest;
        !           215:        p->set_defaults  = mod_indexfile_set_defaults;
        !           216:        p->cleanup     = mod_indexfile_free;
        !           217: 
        !           218:        p->data        = NULL;
        !           219: 
        !           220:        return 0;
        !           221: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>