* </pre>
*/
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
#define MODULE "mod_domaintree"
-#define AUTHOR "mike@php.net"
-#define VERSION "1.3"
+#define AUTHOR "<mike@iworks.at>"
+#define VERSION "1.4"
/* {{{ Includes */
/* }}} */
/* {{{ Macros & Types */
-#define MOD_DT_CNF domaintree_conf
-#define MOD_DT_PTR (&domaintree_module)
+#define DBG 0
+
+#define MDT_CNF domaintree_conf
+#define MDT_PTR (&domaintree_module)
-#define GET_MOD_DT_CNF(srv) ((MOD_DT_CNF *) ap_get_module_config((srv)->module_config, MOD_DT_PTR))
+#define GET_MDT_CNF(srv) ((MDT_CNF *) ap_get_module_config((srv)->module_config, MDT_PTR))
+
+#define IF_SET_ELSE(a, b) (a != -1) ? (a) : (b)
#define NUL '\0'
#define EMPTY(str) ((str == NULL) || (*(str) == NUL))
-#define local static APR_INLINE
+#if DBG
+# define local static
+#else
+# define local static APR_INLINE
+#endif
-#define DT_LOG_ERR ap_log_error(APLOG_MARK, APLOG_ERR, APR_SUCCESS, DT->server,
-#define DT_LOG_WRN ap_log_error(APLOG_MARK, APLOG_WARNING, APR_SUCCESS, DT->server,
-#define DT_LOG_DBG ap_log_error(APLOG_MARK, APLOG_DEBUG, APR_SUCCESS, DT->server,
+#define DT_LOG_ERR ap_log_error(APLOG_MARK, APLOG_ERR, APR_SUCCESS, DT->server, "DomainTree: "
+#define DT_LOG_WRN ap_log_error(APLOG_MARK, APLOG_WARNING, APR_SUCCESS, DT->server, "DomainTree: "
+#define DT_LOG_DBG ap_log_error(APLOG_MARK, APLOG_DEBUG, APR_SUCCESS, DT->server, "DomainTree: "
#define DT_LOG_END );
typedef int STATUS;
apr_table_t *faketable;
} aliases_t;
-struct dircache_entry {
+typedef struct {
char *host;
char *path;
apr_time_t lacc;
apr_pool_t *pool;
-};
+} dircache_entry_t;
typedef struct {
long clim;
*end = string;
return 0;
}
- break;
+ break;
case '?':
if (!*begin) {
}
++string;
++match;
- break;
+ break;
default:
if (*match == *string) {
}
}
++string;
- break;
+ break;
}
}
{
char *ptr = string;
- while (*ptr) {
- if (*ptr == uniq && *(ptr + 1) == uniq) {
- char *pos = ptr + 1;
+ while (ptr[0]) {
+ if (ptr[0] == uniq && ptr[1] == uniq) {
+ char *pos = &ptr[1];
- while (*(pos + 1) == uniq) {
- ++pos;
+ for (; pos[1] == uniq; ++pos);
+ for (; pos[0]; ++pos) {
+ pos[0] = pos[1];
}
-
- memmove(ptr, pos, strlen(pos) + 1);
}
++ptr;
}
return string;
}
-local char *domaintree_host(apr_pool_t *pool, MOD_DT_CNF *DT, const char *host_name)
+local char *domaintree_host(apr_pool_t *pool, MDT_CNF *DT, const char *host_name)
{
size_t len;
char *port, *host;
if (EMPTY(host_name)) {
DT_LOG_WRN
- "DomainTree: no host/server name"
+ "no host/server name"
DT_LOG_END
return NULL;
}
host = trim(host, len, '.', TRIM_BOTH);
DT_LOG_DBG
- "DomainTree: host name = %s for %s", host, host_name
+ "host name = %s for %s", host, host_name
DT_LOG_END
return host;
}
-local char *domaintree_path(apr_pool_t *pool, MOD_DT_CNF *DT, const char *host_name)
+local char *domaintree_path(apr_pool_t *pool, MDT_CNF *DT, const char *host_name)
{
- long depth = 0;
+ long depth = 0, maxdepth = IF_SET_ELSE(DT->maxdepth, 20);
const char *host = host_name;
char *path = NULL, *host_ptr;
while ((host_ptr = strchr(host, '.'))) {
/* check max depth */
- if (++depth > DT->maxdepth) {
+ if (++depth > maxdepth) {
DT_LOG_ERR
- "DomainTree: maxdepth exceeded (%ld)", DT->maxdepth
+ "maxdepth exceeded (%ld)", maxdepth
DT_LOG_END
return NULL;
}
if (host_ptr - host) {
/* strip WWW */
- if (DT->stripwww && (depth == 1) && (!strncmp(host, "www.", sizeof("www")))) {
+ if ((DT->stripwww > 0) && (depth == 1) && (!strncmp(host, "www.", sizeof("www")))) {
DT_LOG_DBG
- "DomainTree: strip www"
+ "strip www"
DT_LOG_END
} else {
path = apr_pstrcat(pool, apr_pstrndup(pool, host, host_ptr - host), "/", path, NULL);
}
DT_LOG_DBG
- "DomainTree: path name = %s for %s", path, host_name
+ "path name = %s for %s", path, host_name
DT_LOG_END
return path;
}
-local void domaintree_fake(apr_pool_t *pool, MOD_DT_CNF *DT, char **path)
+local void domaintree_fake(apr_pool_t *pool, MDT_CNF *DT, char **path)
{
int i, more;
long recurlevel = 0;
if (recurlevel++ > DT->aliases.recursion) {
DT_LOG_ERR
- "DomainTree: maximum alias recursion level (%ld) exceeded! "
+ "maximum alias recursion level (%ld) exceeded! "
"Check if you have recursive definitions of DomainTreeAlias directives.",
DT->aliases.recursion
DT_LOG_END
const char *begin, *end;
DT_LOG_DBG
- "DomainTree: fake test = %s on %s", array[i].key, *path
+ "fake test = %s on %s", array[i].key, *path
DT_LOG_END
if (strmatch(array[i].key, *path, &begin, &end)) {
*path = apr_pstrcat(local_pool, "/", apr_pstrndup(local_pool, *path, begin - *path), "/", array[i].val, "/", end, NULL);
DT_LOG_DBG
- "DomainTree: fake done = %s (%s <> %s)", *path, array[i].key, array[i].val
+ "fake done = %s (%s <> %s)", *path, array[i].key, array[i].val
DT_LOG_END
}
}
- } while (more && DT->aliases.recursion);
+ } while (more && (DT->aliases.recursion > 0));
*path = apr_pstrdup(pool, struniqchr(*path, '/'));
apr_pool_destroy(local_pool);
}
-local char *domaintree_cache_get(MOD_DT_CNF *DT, apr_time_t atime, const char *host)
+local char *domaintree_cache_get(MDT_CNF *DT, apr_time_t atime, const char *host)
{
char *path = NULL;
- struct dircache_entry *cache_entry;
+ dircache_entry_t *cache_entry;
apr_global_mutex_lock(DT->dircache.lock);
if (path) {
DT_LOG_DBG
- "DomainTree: cache hit = %s for %s", path, host
+ "cache hit = %s for %s", path, host
DT_LOG_END
}
return path;
}
-local void domaintree_cache_set(MOD_DT_CNF *DT, apr_time_t atime, const char *host, const char *path)
+local void domaintree_cache_set(MDT_CNF *DT, apr_time_t atime, const char *host, const char *path)
{
apr_pool_t *pool;
- struct dircache_entry *cache_entry;
+ dircache_entry_t *cache_entry;
apr_pool_create(&pool, DT->dircache.pool);
- cache_entry = apr_palloc(pool, sizeof(struct dircache_entry));
+ cache_entry = apr_palloc(pool, sizeof(dircache_entry_t));
cache_entry->pool = pool;
cache_entry->lacc = atime;
if (apr_hash_count(DT->dircache.hmap) >= DT->dircache.clim) {
apr_hash_index_t *idx;
- struct dircache_entry *purge_this = NULL;
+ dircache_entry_t *purge_this = NULL;
DT_LOG_WRN
- "DomainTree: reached cache limit (%ld)", DT->dircache.clim
+ "reached cache limit (%ld)", DT->dircache.clim
DT_LOG_END
for (idx = apr_hash_first(DT->dircache.pool, DT->dircache.hmap); idx; idx = apr_hash_next(idx)) {
- struct dircache_entry *current;
+ dircache_entry_t *current;
- apr_hash_this(idx, NULL, NULL, (void **) ¤t);
+ apr_hash_this(idx, NULL, NULL, (void *) ¤t);
if ((!purge_this) || (purge_this->lacc > current->lacc)) {
purge_this = current;
}
if (purge_this) {
DT_LOG_DBG
- "DomainTree: cache del = %s", purge_this->host
+ "cache del = %s", purge_this->host
DT_LOG_END
apr_hash_set(DT->dircache.hmap, purge_this->host, APR_HASH_KEY_STRING, NULL);
apr_pool_destroy(purge_this->pool);
apr_global_mutex_unlock(DT->dircache.lock);
DT_LOG_DBG
- "DomainTree: cache set = %s for %s", path, host
+ "cache set = %s for %s", path, host
DT_LOG_END
}
static STATUS domaintree_hook_translate_name(request_rec *r)
{
- MOD_DT_CNF *DT = NULL;
+ MDT_CNF *DT = NULL;
char *host, *path, *docroot;
- if ((!(DT = GET_MOD_DT_CNF(r->server))) || (!DT->enabled)) {
+ if ((!(DT = GET_MDT_CNF(r->server))) || (DT->enabled < 1)) {
return DECLINED;
}
+#if DBG
DT_LOG_DBG
- "DomainTree: processid = %d", (int) getpid()
+ "processid = %d", (int) getpid()
DT_LOG_END
+#endif
/* get a usable host name */
if (!(host = domaintree_host(r->pool, DT, ap_get_server_name(r)))) {
}
/* check cache */
- if ((!DT->dircache.clim) || (!(path = domaintree_cache_get(DT, r->request_time, host)))) {
+ if ((DT->dircache.clim < 1) || (!(path = domaintree_cache_get(DT, r->request_time, host)))) {
/* build path */
if (!(path = domaintree_path(r->pool, DT, host))) {
return DECLINED;
}
/* add to cache */
- if (DT->dircache.clim) {
+ if (DT->dircache.clim > 0) {
domaintree_cache_set(DT, r->request_time, host, path);
}
}
docroot = struniqchr(apr_pstrcat(r->pool, DT->prefix, "/", path, "/", DT->suffix, "/", NULL), '/');
/* stat docroot */
- if (DT->statroot) {
+ if (DT->statroot > 0) {
apr_finfo_t sb;
switch (apr_stat(&sb, docroot, APR_FINFO_MIN, r->pool))
case APR_SUCCESS:
case APR_INCOMPLETE:
DT_LOG_DBG
- "DomainTree: stat path = %s (success)", docroot
+ "stat path = %s (success)", docroot
DT_LOG_END
break;
default:
DT_LOG_DBG
- "DomainTree: stat path = %s (failure)", docroot
+ "stat path = %s (failure)", docroot
DT_LOG_END
return DECLINED;
break;
r->filename = apr_pstrcat(r->pool, docroot, EMPTY(r->uri) ? NULL : ('/' == *r->uri ? r->uri + 1 : r->uri), NULL);
DT_LOG_DBG
- "DomainTree: path done = %s", r->filename
+ "path done = %s", r->filename
DT_LOG_END
return OK;
static void *domaintree_create_srv(apr_pool_t *p, server_rec *s)
{
- MOD_DT_CNF *DT;
-
- DT = (MOD_DT_CNF *) apr_palloc(p, sizeof(MOD_DT_CNF));
+ MDT_CNF *DT= (MDT_CNF *) apr_palloc(p, sizeof(MDT_CNF));
DT->server = s;
- DT->enabled = 0;
- DT->stripwww = 1;
- DT->statroot = 0;
- DT->maxdepth = 20;
+ DT->enabled = -1;
+ DT->stripwww = -1;
+ DT->statroot = -1;
+ DT->maxdepth = -1;
DT->prefix = "/var/www";
DT->suffix = "public_html";
- DT->aliases.recursion = 0;
+ DT->aliases.recursion = -1;
DT->aliases.faketable = apr_table_make(p, 0);
- DT->dircache.clim = 0;
+ DT->dircache.clim = -1;
DT->dircache.hmap = apr_hash_make(p);
apr_pool_create(&DT->dircache.pool, p);
apr_global_mutex_create(&DT->dircache.lock, __FILE__, APR_LOCK_DEFAULT, p);
-
+#if DBG
+ fprintf(stderr, "MDT: cfg create %p\n", DT);
+#endif
+ return DT;
+}
+
+static void *domaintree_merge_srv(apr_pool_t *p, void *old_cfg_ptr, void *new_cfg_ptr)
+{
+ MDT_CNF *old_cfg = (MDT_CNF *) old_cfg_ptr, *new_cfg = (MDT_CNF *) new_cfg_ptr;
+ MDT_CNF *DT = (MDT_CNF *) apr_palloc(p, sizeof(MDT_CNF));
+
+ DT->server = new_cfg->server;
+ DT->enabled = IF_SET_ELSE(new_cfg->enabled, old_cfg->enabled);
+ DT->stripwww = IF_SET_ELSE(new_cfg->stripwww, old_cfg->stripwww);
+ DT->statroot = IF_SET_ELSE(new_cfg->statroot, old_cfg->statroot);
+ DT->maxdepth = IF_SET_ELSE(new_cfg->maxdepth, old_cfg->maxdepth);
+
+ DT->prefix = EMPTY(new_cfg->prefix) ? EMPTY(old_cfg->prefix) ? "/var/www" : old_cfg->prefix : new_cfg->prefix;
+ DT->suffix = EMPTY(new_cfg->suffix) ? EMPTY(old_cfg->suffix) ? "public_html" : old_cfg->suffix : new_cfg->suffix;
+
+ DT->aliases.recursion = IF_SET_ELSE(new_cfg->aliases.recursion, old_cfg->aliases.recursion);
+ DT->aliases.faketable = apr_table_overlay(p, new_cfg->aliases.faketable, old_cfg->aliases.faketable);
+
+ DT->dircache.clim = IF_SET_ELSE(new_cfg->dircache.clim, old_cfg->dircache.clim);
+ DT->dircache.hmap = apr_hash_overlay(p, new_cfg->dircache.hmap, old_cfg->dircache.hmap);
+ apr_global_mutex_create(&new_cfg->dircache.lock, __FILE__, APR_LOCK_DEFAULT, p);
+#if DBG
+ fprintf(stderr, "MDT: cfg merge %p + %p = %p\n", old_cfg, new_cfg, DT);
+#endif
return DT;
}
static const char *domaintree_enable(cmd_parms *cmd, void *conf, int flag)
{
- GET_MOD_DT_CNF(cmd->server)->enabled = flag;
+ GET_MDT_CNF(cmd->server)->enabled = flag;
return NULL;
}
static const char *domaintree_stripwww(cmd_parms *cmd, void *conf, int flag)
{
- GET_MOD_DT_CNF(cmd->server)->stripwww = flag;
+ GET_MDT_CNF(cmd->server)->stripwww = flag;
return NULL;
}
static const char *domaintree_statroot(cmd_parms *cmd, void *conf, int flag)
{
- GET_MOD_DT_CNF(cmd->server)->statroot = flag;
+ GET_MDT_CNF(cmd->server)->statroot = flag;
return NULL;
}
static const char *domaintree_prefix(cmd_parms *cmd, void *conf, const char *prefix)
{
- GET_MOD_DT_CNF(cmd->server)->prefix = EMPTY(prefix) ? "/" : trim(apr_pstrdup(cmd->pool, prefix), strlen(prefix), '/', TRIM_RIGHT);
+ GET_MDT_CNF(cmd->server)->prefix = EMPTY(prefix) ? "/" : trim(apr_pstrdup(cmd->pool, prefix), strlen(prefix), '/', TRIM_RIGHT);
return NULL;
}
static const char *domaintree_suffix(cmd_parms *cmd, void *conf, const char *suffix)
{
- GET_MOD_DT_CNF(cmd->server)->suffix = EMPTY(suffix) ? "" : trim(apr_pstrdup(cmd->pool, suffix), strlen(suffix), '/', TRIM_BOTH);
+ GET_MDT_CNF(cmd->server)->suffix = EMPTY(suffix) ? "" : trim(apr_pstrdup(cmd->pool, suffix), strlen(suffix), '/', TRIM_BOTH);
return NULL;
}
long depth;
if ((depth = atol(max_depth))) {
- if (depth > 0L) {
- GET_MOD_DT_CNF(cmd->server)->maxdepth = depth;
+ if (depth >= 0L) {
+ GET_MDT_CNF(cmd->server)->maxdepth = depth;
} else {
return "Maximum DomainTree depth cannot be negative.";
}
long recursion;
if ((recursion = atol(alias_recursion))) {
- if (recursion > 0L) {
- GET_MOD_DT_CNF(cmd->server)->aliases.recursion = recursion;
+ if (recursion >= 0L) {
+ GET_MDT_CNF(cmd->server)->aliases.recursion = recursion;
} else {
return "DomainTree alias recursion cannot be negative.";
}
{
char *f = strtr(apr_pstrdup(cmd->pool, fake), '.', '/'), *r = strtr(apr_pstrdup(cmd->pool, real), '.', '/');
- apr_table_set(GET_MOD_DT_CNF(cmd->server)->aliases.faketable, trim(f, strlen(f), '/', TRIM_BOTH), trim(r, strlen(r), '/', TRIM_BOTH));
+ apr_table_set(GET_MDT_CNF(cmd->server)->aliases.faketable, trim(f, strlen(f), '/', TRIM_BOTH), trim(r, strlen(r), '/', TRIM_BOTH));
return NULL;
}
long limit;
if ((limit = atol(cache))) {
- if (limit > 0L) {
- GET_MOD_DT_CNF(cmd->server)->dircache.clim = limit;
+ if (limit >= 0L) {
+ GET_MDT_CNF(cmd->server)->dircache.clim = limit;
} else {
return "DomainTree cache limit cannot be negative.";
}
"DomainTreeCache", domaintree_cache, NULL, RSRC_CONF,
"DomainTree server-wide host to directory cache; specify how many cache entries to allow (default: 0 = turned off)"
),
-
+
{ NULL }
};
NULL, /* create per-dir */
NULL, /* merge per-dir */
domaintree_create_srv, /* create per-server */
- NULL, /* merge per-server */
+ domaintree_merge_srv, /* merge per-server */
domaintree_commands, /* config commands */
domaintree_hooks /* hooks */
};