text: #include "first.h"
  
  #include "base.h"
  #include "log.h"
  #include "buffer.h"
  
  #include "plugin.h"
  
  #include <stdlib.h>
  #include <string.h>
  
  /* plugin config for all request/connections */
  typedef struct {
  	array *alias;
  } plugin_config;
  
  typedef struct {
  	PLUGIN_DATA;
  
  	plugin_config **config_storage;
  
  	plugin_config conf;
  } plugin_data;
  
  /* init the plugin data */
  INIT_FUNC(mod_alias_init) {
  	plugin_data *p;
  
  	p = calloc(1, sizeof(*p));
  
  
  
  	return p;
  }
  
  /* detroy the plugin data */
  FREE_FUNC(mod_alias_free) {
  	plugin_data *p = p_d;
  
  	if (!p) return HANDLER_GO_ON;
  
  	if (p->config_storage) {
  		size_t i;
  
  		for (i = 0; i < srv->config_context->used; i++) {
  			plugin_config *s = p->config_storage[i];
  
  			if (NULL == s) continue;
  
  			array_free(s->alias);
  
  			free(s);
  		}
  		free(p->config_storage);
  	}
  
  	free(p);
  
  	return HANDLER_GO_ON;
  }
  
  /* handle plugin config and check values */
  
  SETDEFAULTS_FUNC(mod_alias_set_defaults) {
  	plugin_data *p = p_d;
  	size_t i = 0;
  
  	config_values_t cv[] = {
  		{ "alias.url",                  NULL, T_CONFIG_ARRAY, T_CONFIG_SCOPE_CONNECTION },       /* 0 */
  		{ NULL,                         NULL, T_CONFIG_UNSET,  T_CONFIG_SCOPE_UNSET }
  	};
  
  	if (!p) return HANDLER_ERROR;
  
  	p->config_storage = calloc(1, srv->config_context->used * sizeof(plugin_config *));
  
  	for (i = 0; i < srv->config_context->used; i++) {
  		data_config const* config = (data_config const*)srv->config_context->data[i];
  		plugin_config *s;
  
  		s = calloc(1, sizeof(plugin_config));
  		s->alias = array_init();
  		cv[0].destination = s->alias;
  
  		p->config_storage[i] = s;
  
  		if (0 != config_insert_values_global(srv, config->value, cv, i == 0 ? T_CONFIG_SCOPE_SERVER : T_CONFIG_SCOPE_CONNECTION)) {
  			return HANDLER_ERROR;
  		}
  
  		if (!array_is_kvstring(s->alias)) {
  			log_error_write(srv, __FILE__, __LINE__, "s",
  					"unexpected value for alias.url; expected list of \"urlpath\" => \"filepath\"");
  			return HANDLER_ERROR;
  		}
  
  		if (s->alias->used >= 2) {
  			const array *a = s->alias;
  			size_t j, k;
  
  			for (j = 0; j < a->used; j ++) {
  				const buffer *prefix = a->data[a->sorted[j]]->key;
  				for (k = j + 1; k < a->used; k ++) {
  					const buffer *key = a->data[a->sorted[k]]->key;
  
  					if (buffer_string_length(key) < buffer_string_length(prefix)) {
  						break;
  					}
  					if (memcmp(key->ptr, prefix->ptr, buffer_string_length(prefix)) != 0) {
  						break;
  					}
  					/* ok, they have same prefix. check position */
  					if (a->sorted[j] < a->sorted[k]) {
  						log_error_write(srv, __FILE__, __LINE__, "SBSBS",
  							"url.alias: `", key, "' will never match as `", prefix, "' matched first");
  						return HANDLER_ERROR;
  					}
  				}
  			}
  		}
  	}
  
  	return HANDLER_GO_ON;
  }
  
  #define PATCH(x) \
  	p->conf.x = s->x;
  static int mod_alias_patch_connection(server *srv, connection *con, plugin_data *p) {
  	size_t i, j;
  	plugin_config *s = p->config_storage[0];
  
  	PATCH(alias);
  
  	/* skip the first, the global context */
  	for (i = 1; i < srv->config_context->used; i++) {
  		data_config *dc = (data_config *)srv->config_context->data[i];
  		s = p->config_storage[i];
  
  		/* condition didn't match */
  		if (!config_check_cond(srv, con, dc)) continue;
  
  		/* merge config */
  		for (j = 0; j < dc->value->used; j++) {
  			data_unset *du = dc->value->data[j];
  
  			if (buffer_is_equal_string(du->key, CONST_STR_LEN("alias.url"))) {
  				PATCH(alias);
  			}
  		}
  	}
  
  	return 0;
  }
  #undef PATCH
  
  PHYSICALPATH_FUNC(mod_alias_physical_handler) {
  	plugin_data *p = p_d;
  	char *uri_ptr;
  	size_t uri_len = buffer_string_length(con->physical.path);
  	size_t basedir_len, alias_len;
  	data_string *ds;
  
  	if (0 == uri_len) return HANDLER_GO_ON;
  
  	mod_alias_patch_connection(srv, con, p);
  
  	/* do not include trailing slash on basedir */
  	basedir_len = buffer_string_length(con->physical.basedir);
  	if ('/' == con->physical.basedir->ptr[basedir_len-1]) --basedir_len;
  	uri_len -= basedir_len;
  	uri_ptr = con->physical.path->ptr + basedir_len;
  
  	ds = (!con->conf.force_lowercase_filenames)
  	   ? (data_string *)array_match_key_prefix_klen(p->conf.alias, uri_ptr, uri_len)
  	   : (data_string *)array_match_key_prefix_nc_klen(p->conf.alias, uri_ptr, uri_len);
  	if (NULL == ds) { return HANDLER_GO_ON; }
  
  			/* matched */
  
  			/* check for path traversal in url-path following alias if key
  			 * does not end in slash, but replacement value ends in slash */
  			alias_len = buffer_string_length(ds->key);
  			if (uri_ptr[alias_len] == '.') {
  				char *s = uri_ptr + alias_len + 1;
  				if (*s == '.') ++s;
  				if (*s == '/' || *s == '\0') {
  					size_t vlen = buffer_string_length(ds->value);
  					if (0 != alias_len && ds->key->ptr[alias_len-1] != '/'
  					    && 0 != vlen && ds->value->ptr[vlen-1] == '/') {
  						con->http_status = 403;
  						return HANDLER_FINISHED;
  					}
  				}
  			}
  
  			buffer_copy_buffer(con->physical.basedir, ds->value);
  			buffer_copy_buffer(srv->tmp_buf, ds->value);
  			buffer_append_string(srv->tmp_buf, uri_ptr + alias_len);
  			buffer_copy_buffer(con->physical.path, srv->tmp_buf);
  
  			return HANDLER_GO_ON;
  }
  
  /* this function is called at dlopen() time and inits the callbacks */
  
  int mod_alias_plugin_init(plugin *p);
  int mod_alias_plugin_init(plugin *p) {
  	p->version     = LIGHTTPD_VERSION_ID;
  	p->name        = buffer_init_string("alias");
  
  	p->init           = mod_alias_init;
  	p->handle_physical= mod_alias_physical_handler;
  	p->set_defaults   = mod_alias_set_defaults;
  	p->cleanup        = mod_alias_free;
  
  	p->data        = NULL;
  
  	return 0;
  }
  