|
|
|
@ -7,33 +7,14 @@
|
|
|
|
|
#include "plugin.h" |
|
|
|
|
#include "stat_cache.h" |
|
|
|
|
|
|
|
|
|
#include <ctype.h> |
|
|
|
|
#include <stdlib.h> |
|
|
|
|
#include <string.h> |
|
|
|
|
|
|
|
|
|
#ifdef HAVE_PCRE_H |
|
|
|
|
|
|
|
|
|
#include <pcre.h> |
|
|
|
|
|
|
|
|
|
typedef struct { |
|
|
|
|
pcre *key; |
|
|
|
|
|
|
|
|
|
buffer *value; |
|
|
|
|
|
|
|
|
|
int once; |
|
|
|
|
} rewrite_rule; |
|
|
|
|
|
|
|
|
|
typedef struct { |
|
|
|
|
rewrite_rule **ptr; |
|
|
|
|
|
|
|
|
|
size_t used; |
|
|
|
|
size_t size; |
|
|
|
|
} rewrite_rule_buffer; |
|
|
|
|
|
|
|
|
|
typedef struct { |
|
|
|
|
rewrite_rule_buffer *rewrite; |
|
|
|
|
rewrite_rule_buffer *rewrite_NF; |
|
|
|
|
pcre_keyvalue_buffer *rewrite; |
|
|
|
|
pcre_keyvalue_buffer *rewrite_NF; |
|
|
|
|
data_config *context, *context_NF; /* to which apply me */ |
|
|
|
|
int rewrite_repeat_idx, rewrite_NF_repeat_idx; |
|
|
|
|
} plugin_config; |
|
|
|
|
|
|
|
|
|
typedef struct { |
|
|
|
@ -43,10 +24,7 @@ typedef struct {
|
|
|
|
|
|
|
|
|
|
typedef struct { |
|
|
|
|
PLUGIN_DATA; |
|
|
|
|
buffer *match_buf; |
|
|
|
|
|
|
|
|
|
plugin_config **config_storage; |
|
|
|
|
|
|
|
|
|
plugin_config conf; |
|
|
|
|
} plugin_data; |
|
|
|
|
|
|
|
|
@ -65,109 +43,31 @@ static void handler_ctx_free(handler_ctx *hctx) {
|
|
|
|
|
free(hctx); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static rewrite_rule_buffer *rewrite_rule_buffer_init(void) { |
|
|
|
|
rewrite_rule_buffer *kvb; |
|
|
|
|
|
|
|
|
|
kvb = calloc(1, sizeof(*kvb)); |
|
|
|
|
|
|
|
|
|
return kvb; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static int rewrite_rule_buffer_append(rewrite_rule_buffer *kvb, buffer *key, buffer *value, int once) { |
|
|
|
|
size_t i; |
|
|
|
|
const char *errptr; |
|
|
|
|
int erroff; |
|
|
|
|
|
|
|
|
|
if (!key) return -1; |
|
|
|
|
|
|
|
|
|
if (kvb->size == 0) { |
|
|
|
|
kvb->size = 4; |
|
|
|
|
kvb->used = 0; |
|
|
|
|
|
|
|
|
|
kvb->ptr = malloc(kvb->size * sizeof(*kvb->ptr)); |
|
|
|
|
|
|
|
|
|
for(i = 0; i < kvb->size; i++) { |
|
|
|
|
kvb->ptr[i] = calloc(1, sizeof(**kvb->ptr)); |
|
|
|
|
} |
|
|
|
|
} else if (kvb->used == kvb->size) { |
|
|
|
|
kvb->size += 4; |
|
|
|
|
|
|
|
|
|
kvb->ptr = realloc(kvb->ptr, kvb->size * sizeof(*kvb->ptr)); |
|
|
|
|
|
|
|
|
|
for(i = kvb->used; i < kvb->size; i++) { |
|
|
|
|
kvb->ptr[i] = calloc(1, sizeof(**kvb->ptr)); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (NULL == (kvb->ptr[kvb->used]->key = pcre_compile(key->ptr, |
|
|
|
|
0, &errptr, &erroff, NULL))) { |
|
|
|
|
|
|
|
|
|
return -1; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
kvb->ptr[kvb->used]->value = buffer_init(); |
|
|
|
|
buffer_copy_buffer(kvb->ptr[kvb->used]->value, value); |
|
|
|
|
kvb->ptr[kvb->used]->once = once; |
|
|
|
|
|
|
|
|
|
kvb->used++; |
|
|
|
|
|
|
|
|
|
return 0; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static void rewrite_rule_buffer_free(rewrite_rule_buffer *kvb) { |
|
|
|
|
size_t i; |
|
|
|
|
|
|
|
|
|
for (i = 0; i < kvb->size; i++) { |
|
|
|
|
if (kvb->ptr[i]->key) pcre_free(kvb->ptr[i]->key); |
|
|
|
|
if (kvb->ptr[i]->value) buffer_free(kvb->ptr[i]->value); |
|
|
|
|
free(kvb->ptr[i]); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (kvb->ptr) free(kvb->ptr); |
|
|
|
|
|
|
|
|
|
free(kvb); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
INIT_FUNC(mod_rewrite_init) { |
|
|
|
|
plugin_data *p; |
|
|
|
|
|
|
|
|
|
p = calloc(1, sizeof(*p)); |
|
|
|
|
|
|
|
|
|
p->match_buf = buffer_init(); |
|
|
|
|
|
|
|
|
|
return p; |
|
|
|
|
return calloc(1, sizeof(plugin_data)); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
FREE_FUNC(mod_rewrite_free) { |
|
|
|
|
plugin_data *p = p_d; |
|
|
|
|
|
|
|
|
|
UNUSED(srv); |
|
|
|
|
|
|
|
|
|
if (!p) return HANDLER_GO_ON; |
|
|
|
|
|
|
|
|
|
buffer_free(p->match_buf); |
|
|
|
|
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; |
|
|
|
|
|
|
|
|
|
rewrite_rule_buffer_free(s->rewrite); |
|
|
|
|
rewrite_rule_buffer_free(s->rewrite_NF); |
|
|
|
|
|
|
|
|
|
pcre_keyvalue_buffer_free(s->rewrite); |
|
|
|
|
pcre_keyvalue_buffer_free(s->rewrite_NF); |
|
|
|
|
free(s); |
|
|
|
|
} |
|
|
|
|
free(p->config_storage); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
free(p); |
|
|
|
|
|
|
|
|
|
return HANDLER_GO_ON; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static int parse_config_entry(server *srv, array *ca, rewrite_rule_buffer *kvb, const char *option, size_t olen, int once) { |
|
|
|
|
static int parse_config_entry(server *srv, array *ca, pcre_keyvalue_buffer *kvb, const char *option, size_t olen) { |
|
|
|
|
data_unset *du; |
|
|
|
|
|
|
|
|
|
if (NULL != (du = array_get_element_klen(ca, option, olen))) { |
|
|
|
@ -183,12 +83,10 @@ static int parse_config_entry(server *srv, array *ca, rewrite_rule_buffer *kvb,
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
for (j = 0; j < da->value->used; j++) { |
|
|
|
|
if (0 != rewrite_rule_buffer_append(kvb, |
|
|
|
|
((data_string *)(da->value->data[j]))->key, |
|
|
|
|
((data_string *)(da->value->data[j]))->value, |
|
|
|
|
once)) { |
|
|
|
|
data_string *ds = (data_string *)da->value->data[j]; |
|
|
|
|
if (0 != pcre_keyvalue_buffer_append(srv, kvb, ds->key, ds->value)) { |
|
|
|
|
log_error_write(srv, __FILE__, __LINE__, "sb", |
|
|
|
|
"pcre-compile failed for", da->value->data[j]->key); |
|
|
|
|
"pcre-compile failed for", ds->key); |
|
|
|
|
return HANDLER_ERROR; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
@ -196,18 +94,6 @@ static int parse_config_entry(server *srv, array *ca, rewrite_rule_buffer *kvb,
|
|
|
|
|
|
|
|
|
|
return 0; |
|
|
|
|
} |
|
|
|
|
#else |
|
|
|
|
static int parse_config_entry(server *srv, array *ca, const char *option, size_t olen) { |
|
|
|
|
static int logged_message = 0; |
|
|
|
|
if (logged_message) return 0; |
|
|
|
|
if (NULL != array_get_element_klen(ca, option, olen)) { |
|
|
|
|
logged_message = 1; |
|
|
|
|
log_error_write(srv, __FILE__, __LINE__, "s", |
|
|
|
|
"pcre support is missing, please install libpcre and the headers"); |
|
|
|
|
} |
|
|
|
|
return 0; |
|
|
|
|
} |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
SETDEFAULTS_FUNC(mod_rewrite_set_defaults) { |
|
|
|
|
size_t i = 0; |
|
|
|
@ -235,48 +121,39 @@ SETDEFAULTS_FUNC(mod_rewrite_set_defaults) {
|
|
|
|
|
{ NULL, NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET } |
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
#ifdef HAVE_PCRE_H |
|
|
|
|
plugin_data *p = p_d; |
|
|
|
|
|
|
|
|
|
if (!p) return HANDLER_ERROR; |
|
|
|
|
|
|
|
|
|
/* 0 */ |
|
|
|
|
p->config_storage = calloc(1, srv->config_context->used * sizeof(plugin_config *)); |
|
|
|
|
#else |
|
|
|
|
UNUSED(p_d); |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
for (i = 0; i < srv->config_context->used; i++) { |
|
|
|
|
data_config const* config = (data_config const*)srv->config_context->data[i]; |
|
|
|
|
#ifdef HAVE_PCRE_H |
|
|
|
|
plugin_config *s; |
|
|
|
|
|
|
|
|
|
s = calloc(1, sizeof(plugin_config)); |
|
|
|
|
s->rewrite = rewrite_rule_buffer_init(); |
|
|
|
|
s->rewrite_NF = rewrite_rule_buffer_init(); |
|
|
|
|
s->rewrite = pcre_keyvalue_buffer_init(); |
|
|
|
|
s->rewrite_NF = pcre_keyvalue_buffer_init(); |
|
|
|
|
p->config_storage[i] = s; |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
if (0 != config_insert_values_global(srv, config->value, cv, i == 0 ? T_CONFIG_SCOPE_SERVER : T_CONFIG_SCOPE_CONNECTION)) { |
|
|
|
|
return HANDLER_ERROR; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
#ifndef HAVE_PCRE_H |
|
|
|
|
# define parse_config_entry(srv, ca, x, option, y) parse_config_entry(srv, ca, option) |
|
|
|
|
#endif |
|
|
|
|
parse_config_entry(srv, config->value, s->rewrite, CONST_STR_LEN("url.rewrite-once"), 1); |
|
|
|
|
parse_config_entry(srv, config->value, s->rewrite, CONST_STR_LEN("url.rewrite-final"), 1); |
|
|
|
|
parse_config_entry(srv, config->value, s->rewrite_NF, CONST_STR_LEN("url.rewrite-if-not-file"), 1); |
|
|
|
|
parse_config_entry(srv, config->value, s->rewrite_NF, CONST_STR_LEN("url.rewrite-repeat-if-not-file"), 0); |
|
|
|
|
parse_config_entry(srv, config->value, s->rewrite, CONST_STR_LEN("url.rewrite"), 1); |
|
|
|
|
parse_config_entry(srv, config->value, s->rewrite, CONST_STR_LEN("url.rewrite-repeat"), 0); |
|
|
|
|
parse_config_entry(srv, config->value, s->rewrite, CONST_STR_LEN("url.rewrite-once")); |
|
|
|
|
parse_config_entry(srv, config->value, s->rewrite, CONST_STR_LEN("url.rewrite-final")); |
|
|
|
|
parse_config_entry(srv, config->value, s->rewrite_NF, CONST_STR_LEN("url.rewrite-if-not-file")); |
|
|
|
|
s->rewrite_NF_repeat_idx = (int)s->rewrite_NF->used; |
|
|
|
|
parse_config_entry(srv, config->value, s->rewrite_NF, CONST_STR_LEN("url.rewrite-repeat-if-not-file")); |
|
|
|
|
parse_config_entry(srv, config->value, s->rewrite, CONST_STR_LEN("url.rewrite")); |
|
|
|
|
s->rewrite_repeat_idx = (int)s->rewrite->used; |
|
|
|
|
parse_config_entry(srv, config->value, s->rewrite, CONST_STR_LEN("url.rewrite-repeat")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
return HANDLER_GO_ON; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
#ifdef HAVE_PCRE_H |
|
|
|
|
|
|
|
|
|
#define PATCH(x) \ |
|
|
|
|
p->conf.x = s->x; |
|
|
|
|
static int mod_rewrite_patch_connection(server *srv, connection *con, plugin_data *p) { |
|
|
|
@ -287,6 +164,8 @@ static int mod_rewrite_patch_connection(server *srv, connection *con, plugin_dat
|
|
|
|
|
PATCH(rewrite_NF); |
|
|
|
|
p->conf.context = NULL; |
|
|
|
|
p->conf.context_NF = NULL; |
|
|
|
|
PATCH(rewrite_repeat_idx); |
|
|
|
|
PATCH(rewrite_NF_repeat_idx); |
|
|
|
|
|
|
|
|
|
/* skip the first, the global context */ |
|
|
|
|
for (i = 1; i < srv->config_context->used; i++) { |
|
|
|
@ -303,21 +182,27 @@ static int mod_rewrite_patch_connection(server *srv, connection *con, plugin_dat
|
|
|
|
|
if (buffer_is_equal_string(du->key, CONST_STR_LEN("url.rewrite"))) { |
|
|
|
|
PATCH(rewrite); |
|
|
|
|
p->conf.context = dc; |
|
|
|
|
PATCH(rewrite_repeat_idx); |
|
|
|
|
} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("url.rewrite-once"))) { |
|
|
|
|
PATCH(rewrite); |
|
|
|
|
p->conf.context = dc; |
|
|
|
|
PATCH(rewrite_repeat_idx); |
|
|
|
|
} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("url.rewrite-repeat"))) { |
|
|
|
|
PATCH(rewrite); |
|
|
|
|
p->conf.context = dc; |
|
|
|
|
PATCH(rewrite_NF_repeat_idx); |
|
|
|
|
} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("url.rewrite-if-not-file"))) { |
|
|
|
|
PATCH(rewrite_NF); |
|
|
|
|
p->conf.context_NF = dc; |
|
|
|
|
PATCH(rewrite_repeat_idx); |
|
|
|
|
} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("url.rewrite-repeat-if-not-file"))) { |
|
|
|
|
PATCH(rewrite_NF); |
|
|
|
|
p->conf.context_NF = dc; |
|
|
|
|
PATCH(rewrite_NF_repeat_idx); |
|
|
|
|
} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("url.rewrite-final"))) { |
|
|
|
|
PATCH(rewrite); |
|
|
|
|
p->conf.context = dc; |
|
|
|
|
PATCH(rewrite_repeat_idx); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
@ -338,10 +223,10 @@ URIHANDLER_FUNC(mod_rewrite_con_reset) {
|
|
|
|
|
return HANDLER_GO_ON; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static handler_t process_rewrite_rules(server *srv, connection *con, plugin_data *p, rewrite_rule_buffer *kvb) { |
|
|
|
|
size_t i; |
|
|
|
|
cond_cache_t *cache; |
|
|
|
|
static handler_t process_rewrite_rules(server *srv, connection *con, plugin_data *p, pcre_keyvalue_buffer *kvb, int repeat_idx) { |
|
|
|
|
handler_ctx *hctx; |
|
|
|
|
pcre_keyvalue_ctx ctx; |
|
|
|
|
handler_t rc; |
|
|
|
|
|
|
|
|
|
if (con->plugin_ctx[p->id]) { |
|
|
|
|
hctx = con->plugin_ctx[p->id]; |
|
|
|
@ -357,55 +242,26 @@ static handler_t process_rewrite_rules(server *srv, connection *con, plugin_data
|
|
|
|
|
if (hctx->state == REWRITE_STATE_FINISHED) return HANDLER_GO_ON; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
cache = p->conf.context ? &con->cond_cache[p->conf.context->context_ndx] : NULL; |
|
|
|
|
buffer_copy_buffer(p->match_buf, con->request.uri); |
|
|
|
|
|
|
|
|
|
for (i = 0; i < kvb->used; i++) { |
|
|
|
|
pcre *match; |
|
|
|
|
size_t pattern_len; |
|
|
|
|
int n; |
|
|
|
|
rewrite_rule *rule = kvb->ptr[i]; |
|
|
|
|
# define N 10 |
|
|
|
|
int ovec[N * 3]; |
|
|
|
|
|
|
|
|
|
match = rule->key; |
|
|
|
|
pattern_len = buffer_string_length(rule->value); |
|
|
|
|
ctx.cache = p->conf.context ? &con->cond_cache[p->conf.context->context_ndx] : NULL; |
|
|
|
|
|
|
|
|
|
if ((n = pcre_exec(match, NULL, CONST_BUF_LEN(p->match_buf), 0, 0, ovec, 3 * N)) < 0) { |
|
|
|
|
if (n != PCRE_ERROR_NOMATCH) { |
|
|
|
|
log_error_write(srv, __FILE__, __LINE__, "sd", |
|
|
|
|
"execution error while matching: ", n); |
|
|
|
|
return HANDLER_ERROR; |
|
|
|
|
} |
|
|
|
|
} else if (0 == pattern_len) { |
|
|
|
|
/* short-circuit if blank replacement pattern
|
|
|
|
|
* (do not attempt to match against remaining rewrite rules) */ |
|
|
|
|
return HANDLER_GO_ON; |
|
|
|
|
rc = pcre_keyvalue_buffer_process(kvb, &ctx, con->request.uri, srv->tmp_buf); |
|
|
|
|
if (HANDLER_FINISHED == rc) { |
|
|
|
|
buffer_copy_buffer(con->request.uri, srv->tmp_buf); |
|
|
|
|
if (con->plugin_ctx[p->id] == NULL) { |
|
|
|
|
hctx = handler_ctx_init(); |
|
|
|
|
con->plugin_ctx[p->id] = hctx; |
|
|
|
|
} else { |
|
|
|
|
const char **list; |
|
|
|
|
|
|
|
|
|
/* it matched */ |
|
|
|
|
pcre_get_substring_list(p->match_buf->ptr, ovec, n, &list); |
|
|
|
|
|
|
|
|
|
pcre_keyvalue_buffer_subst(con->request.uri, rule->value, list, n, cache); |
|
|
|
|
|
|
|
|
|
pcre_free(list); |
|
|
|
|
|
|
|
|
|
if (con->plugin_ctx[p->id] == NULL) { |
|
|
|
|
hctx = handler_ctx_init(); |
|
|
|
|
con->plugin_ctx[p->id] = hctx; |
|
|
|
|
} else { |
|
|
|
|
hctx = con->plugin_ctx[p->id]; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (rule->once) hctx->state = REWRITE_STATE_FINISHED; |
|
|
|
|
|
|
|
|
|
return HANDLER_COMEBACK; |
|
|
|
|
hctx = con->plugin_ctx[p->id]; |
|
|
|
|
} |
|
|
|
|
#undef N |
|
|
|
|
if (ctx.m < repeat_idx) hctx->state = REWRITE_STATE_FINISHED; |
|
|
|
|
rc = HANDLER_COMEBACK; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
return HANDLER_GO_ON; |
|
|
|
|
else if (HANDLER_ERROR == rc) { |
|
|
|
|
log_error_write(srv, __FILE__, __LINE__, "sb", |
|
|
|
|
"pcre_exec() error while processing uri:", |
|
|
|
|
con->request.uri); |
|
|
|
|
} |
|
|
|
|
return rc; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
URIHANDLER_FUNC(mod_rewrite_physical) { |
|
|
|
@ -426,7 +282,7 @@ URIHANDLER_FUNC(mod_rewrite_physical) {
|
|
|
|
|
if (S_ISREG(sce->st.st_mode)) return HANDLER_GO_ON; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
switch(r = process_rewrite_rules(srv, con, p, p->conf.rewrite_NF)) { |
|
|
|
|
switch(r = process_rewrite_rules(srv, con, p, p->conf.rewrite_NF, p->conf.rewrite_NF_repeat_idx)) { |
|
|
|
|
case HANDLER_COMEBACK: |
|
|
|
|
buffer_reset(con->physical.path); |
|
|
|
|
/* fall through */ |
|
|
|
@ -444,16 +300,14 @@ URIHANDLER_FUNC(mod_rewrite_uri_handler) {
|
|
|
|
|
|
|
|
|
|
if (!p->conf.rewrite) return HANDLER_GO_ON; |
|
|
|
|
|
|
|
|
|
return process_rewrite_rules(srv, con, p, p->conf.rewrite); |
|
|
|
|
return process_rewrite_rules(srv, con, p, p->conf.rewrite, p->conf.rewrite_repeat_idx); |
|
|
|
|
} |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
int mod_rewrite_plugin_init(plugin *p); |
|
|
|
|
int mod_rewrite_plugin_init(plugin *p) { |
|
|
|
|
p->version = LIGHTTPD_VERSION_ID; |
|
|
|
|
p->name = buffer_init_string("rewrite"); |
|
|
|
|
|
|
|
|
|
#ifdef HAVE_PCRE_H |
|
|
|
|
p->init = mod_rewrite_init; |
|
|
|
|
/* it has to stay _raw as we are matching on uri + querystring
|
|
|
|
|
*/ |
|
|
|
@ -462,7 +316,6 @@ int mod_rewrite_plugin_init(plugin *p) {
|
|
|
|
|
p->handle_physical = mod_rewrite_physical; |
|
|
|
|
p->cleanup = mod_rewrite_free; |
|
|
|
|
p->connection_reset = mod_rewrite_con_reset; |
|
|
|
|
#endif |
|
|
|
|
p->set_defaults = mod_rewrite_set_defaults; |
|
|
|
|
|
|
|
|
|
p->data = NULL; |
|
|
|
|