Browse Source

[core/modules] refactor config handling

* should be more robust now: taking list of wanted value, handling NULL
   pointers instead of value type NONE, fixed some bugs (wrong checks,
   mem leaks, ...)
 * add many methods to make handling of values easier; most methods
   can handle NULL value pointers safely (li_value_type(v) instead of
   v->type and so on)
personal/stbuehler/wip
Stefan Bühler 8 years ago
parent
commit
a1fbaab86b
  1. 2
      include/lighttpd/plugin.h
  2. 63
      include/lighttpd/value.h
  3. 38
      src/main/config_parser.rl
  4. 125
      src/main/plugin.c
  5. 606
      src/main/plugin_core.c
  6. 152
      src/main/value.c
  7. 51
      src/modules/mod_access.c
  8. 24
      src/modules/mod_accesslog.c
  9. 28
      src/modules/mod_auth.c
  10. 30
      src/modules/mod_balance.c
  11. 4
      src/modules/mod_cache_disk_etag.c
  12. 13
      src/modules/mod_debug.c
  13. 131
      src/modules/mod_deflate.c
  14. 271
      src/modules/mod_dirlist.c
  15. 5
      src/modules/mod_expire.c
  16. 5
      src/modules/mod_fastcgi.c
  17. 3
      src/modules/mod_flv.c
  18. 18
      src/modules/mod_fortune.c
  19. 51
      src/modules/mod_gnutls.c
  20. 34
      src/modules/mod_limit.c
  21. 119
      src/modules/mod_lua.c
  22. 247
      src/modules/mod_memcached.c
  23. 82
      src/modules/mod_openssl.c
  24. 47
      src/modules/mod_progress.c
  25. 4
      src/modules/mod_proxy.c
  26. 34
      src/modules/mod_redirect.c
  27. 67
      src/modules/mod_rewrite.c
  28. 4
      src/modules/mod_scgi.c
  29. 12
      src/modules/mod_status.c
  30. 28
      src/modules/mod_throttle.c
  31. 9
      src/modules/mod_userdir.c
  32. 78
      src/modules/mod_vhost.c

2
include/lighttpd/plugin.h

@ -126,7 +126,7 @@ LI_API gboolean li_plugin_config_setup(liServer *srv, const char *name, liValue
LI_API void li_plugins_init_lua(liLuaState *LL, liServer *srv, liWorker *wrk);
extern liOptionPtrValue li_option_ptr_zero;
extern const liOptionPtrValue li_option_ptr_zero;
/* needs vrequest *vr and plugin *p */
#define OPTION(idx) _OPTION(vr, p, idx)

63
include/lighttpd/value.h

@ -46,7 +46,8 @@ LI_API void li_value_clear(liValue *val); /* frees content, sets value to LI_VAL
LI_API void li_value_free(liValue* val);
LI_API void li_value_move(liValue *dest, liValue *src);
LI_API const char* li_value_type_string(liValueType type);
LI_API const char* li_valuetype_string(liValueType type);
INLINE const char* li_value_type_string(liValue *val);
LI_API GString *li_value_to_string(liValue *val);
@ -66,7 +67,65 @@ LI_API liCondition* li_value_extract_condition(liValue *val);
/* move the value content to a new value, set the old type to none */
LI_API liValue* li_value_extract(liValue *val);
/* converts value type to LI_VALUE_LIST, makes sure list contains (key,value) tuples, and the keys are all LI_VALUE_STRING or LI_VALUE_NONE */
/* converts value type to LI_VALUE_LIST, makes sure list contains (key,value) tuples, and the keys are all LI_VALUE_STRING or NULL / LI_VALUE_NONE */
LI_API liValue* li_value_to_key_value_list(liValue *val);
/* if val is list with exactly one element, return the element. otherwise return val */
INLINE liValue* li_value_get_single_argument(liValue *val);
/* returns whether val == 0 || (val->type == NONE) || (val->type == LIST && 0 == val->list->len) */
INLINE gboolean li_value_is_nothing(liValue *val);
/* returns type of value or LI_VALUE_NONE for NULL */
INLINE liValueType li_value_type(liValue *val);
/* returns whether val is a list and has length len */
INLINE gboolean li_value_list_has_len(liValue *val, guint len);
/* returns length of list or 0 if not a list */
INLINE guint li_value_list_len(liValue *val);
/* returns entry of list or NULL if not a list or out of bounds */
INLINE liValue* li_value_list_at(liValue* val, guint ndx);
/* returns type of list entry, or LI_VALUE_NONE if not a list or NULL entry or out of bounds */
INLINE liValueType li_value_list_type_at(liValue *val, guint ndx);
#define LI_VALUE_FOREACH(entry, list) { \
guint _ ## entry ## _i, _ ## entry ## _len = li_value_list_len(list); \
for (_ ## entry ## _i = 0; _ ## entry ## _i < _ ## entry ## _len; ++ _ ## entry ## _i ) { \
liValue *entry = li_value_list_at(list, _ ## entry ## _i);
#define LI_VALUE_END_FOREACH() } }
/* inline implementations */
INLINE const char* li_value_type_string(liValue *val) {
return NULL == val ? "NULL" : li_valuetype_string(val->type);
}
INLINE liValue* li_value_get_single_argument(liValue *val) {
return li_value_list_has_len(val, 1) ? li_value_list_at(val, 0) : val;
}
INLINE gboolean li_value_is_nothing(liValue *val) {
return NULL == val || LI_VALUE_NONE == val->type || (LI_VALUE_LIST == val->type && 0 == val->data.list->len);
}
INLINE liValueType li_value_type(liValue *val) {
return NULL == val ? LI_VALUE_NONE : val->type;
}
INLINE gboolean li_value_list_has_len(liValue *val, guint len) {
return (NULL != val && LI_VALUE_LIST == val->type && len == val->data.list->len);
}
INLINE guint li_value_list_len(liValue *val) {
return (NULL != val && LI_VALUE_LIST == val->type) ? val->data.list->len : 0;
}
INLINE liValue* li_value_list_at(liValue* val, guint ndx) {
if (NULL == val || LI_VALUE_LIST != val->type || ndx >= val->data.list->len) return NULL;
return g_array_index(val->data.list, liValue*, ndx);
}
INLINE liValueType li_value_list_type_at(liValue *val, guint ndx) {
return li_value_type(li_value_list_at(val, ndx));
}
#endif

38
src/main/config_parser.rl

@ -184,7 +184,7 @@ static gboolean config_parser_include(liServer *srv, GList *ctx_stack, gchar *pa
g_array_append_val(l->data.list, v);
_printf("list_push %s\n", li_value_type_string(v->type));
_printf("list_push %s\n", li_value_type_string(v));
}
action list_end {
@ -214,7 +214,7 @@ static gboolean config_parser_include(liServer *srv, GList *ctx_stack, gchar *pa
g_hash_table_insert(h->data.hash, str, v);
_printf("hash_push: %s: %s => %s\n", li_value_type_string(k->type), li_value_type_string(v->type), li_value_type_string(h->type));
_printf("hash_push: %s: %s => %s\n", li_value_type_string(k), li_value_type_string(v), li_value_type_string(h));
li_value_free(k);
}
@ -251,7 +251,7 @@ static gboolean config_parser_include(liServer *srv, GList *ctx_stack, gchar *pa
g_array_append_val(l->list, k);
g_array_append_val(l->list, v);
_printf("key-value pair: %s => %s in line %zd\n", li_value_type_string(k->type), li_value_type_string(v->type), ctx->line);
_printf("key-value pair: %s => %s in line %zd\n", li_value_type_string(k), li_value_type_string(v), ctx->line);
/* push list on the stack */
g_queue_push_head(ctx->value_stack, l);
@ -275,7 +275,7 @@ static gboolean config_parser_include(liServer *srv, GList *ctx_stack, gchar *pa
gboolean negative = FALSE;
if (v->type != LI_VALUE_STRING) {
ERROR(srv, "can only cast strings to integers, %s given", li_value_type_string(v->type));
ERROR(srv, "can only cast strings to integers, %s given", li_value_type_string(v));
return FALSE;
}
@ -305,7 +305,7 @@ static gboolean config_parser_include(liServer *srv, GList *ctx_stack, gchar *pa
GString *str;
if (v->type != LI_VALUE_NUMBER) {
ERROR(srv, "can only cast integers to strings, %s given", li_value_type_string(v->type));
ERROR(srv, "can only cast integers to strings, %s given", li_value_type_string(v));
return FALSE;
}
@ -318,7 +318,7 @@ static gboolean config_parser_include(liServer *srv, GList *ctx_stack, gchar *pa
ctx->cast = LI_CFG_PARSER_CAST_NONE;
}
_printf("value (%s) in line %zd\n", li_value_type_string(v->type), ctx->line);
_printf("value (%s) in line %zd\n", li_value_type_string(v), ctx->line);
}
action value_statement_start {
@ -424,17 +424,17 @@ static gboolean config_parser_include(liServer *srv, GList *ctx_stack, gchar *pa
if (v == NULL) {
WARNING(srv, "erronous value statement: %s %c %s in line %zd\n",
li_value_type_string(l->type), op,
li_value_type_string(r->type), ctx->line);
li_value_type_string(l), op,
li_value_type_string(r), ctx->line);
return FALSE;
}
_printf("value statement: %s %c%s %s => %s in line %zd\n",
li_value_type_string(l->type),
li_value_type_string(l),
op,
op == '=' ? ">" : "",
li_value_type_string(r->type),
li_value_type_string(v->type),
li_value_type_string(r),
li_value_type_string(v),
ctx->line);
if (free_l)
@ -555,7 +555,7 @@ static gboolean config_parser_include(liServer *srv, GList *ctx_stack, gchar *pa
assert(name->type == LI_VALUE_STRING);
_printf("got action call: %s %s; in line %zd\n", name->data.string->str, val ? li_value_type_string(val->type) : "<none>", ctx->line);
_printf("got action call: %s %s; in line %zd\n", name->data.string->str, val ? li_value_type_string(val) : "<none>", ctx->line);
/* internal functions */
if (g_str_equal(name->data.string->str, "include")) {
@ -591,7 +591,7 @@ static gboolean config_parser_include(liServer *srv, GList *ctx_stack, gchar *pa
}
if (val->type != LI_VALUE_STRING) {
WARNING(srv, "include_shell directive takes a string as parameter, %s given", li_value_type_string(val->type));
WARNING(srv, "include_shell directive takes a string as parameter, %s given", li_value_type_string(val));
li_value_free(val);
return FALSE;
}
@ -618,7 +618,7 @@ static gboolean config_parser_include(liServer *srv, GList *ctx_stack, gchar *pa
}
if (val->type != LI_VALUE_STRING) {
WARNING(srv, "include_lua directive takes a string as parameter, %s given", li_value_type_string(val->type));
WARNING(srv, "include_lua directive takes a string as parameter, %s given", li_value_type_string(val));
li_value_free(val);
return FALSE;
}
@ -647,7 +647,7 @@ static gboolean config_parser_include(liServer *srv, GList *ctx_stack, gchar *pa
}
tmpstr = li_value_to_string(val);
DEBUG(srv, "%s:%zd type: %s, value: %s", ctx->filename, ctx->line, li_value_type_string(val->type), tmpstr->str);
DEBUG(srv, "%s:%zd type: %s, value: %s", ctx->filename, ctx->line, li_value_type_string(val), tmpstr->str);
g_string_free(tmpstr, TRUE);
}
@ -662,7 +662,7 @@ static gboolean config_parser_include(liServer *srv, GList *ctx_stack, gchar *pa
_printf("%s", "... which is a user defined action\n");
if (uservar->type != LI_VALUE_ACTION) {
WARNING(srv, "value of type action expected, got %s", li_value_type_string(uservar->type));
WARNING(srv, "value of type action expected, got %s", li_value_type_string(uservar));
li_value_free(name);
if (val)
li_value_free(val);
@ -743,7 +743,7 @@ static gboolean config_parser_include(liServer *srv, GList *ctx_stack, gchar *pa
name = g_queue_pop_head(ctx->value_stack);
assert(name->type == LI_VALUE_STRING);
_printf("uservar definition %s = %s in line %zd\n", name->data.string->str, li_value_type_string(v->type), ctx->line);
_printf("uservar definition %s = %s in line %zd\n", name->data.string->str, li_value_type_string(v), ctx->line);
if (NULL != g_hash_table_lookup(srv->setups, name->data.string->str)) {
WARNING(srv, "cannot define uservar with name '%s', a setup action with same name exists already", name->data.string->str);
@ -853,9 +853,9 @@ static gboolean config_parser_include(liServer *srv, GList *ctx_stack, gchar *pa
if (ctx->condition_nonbool) {
if (ctx->condition_with_key) {
_printf("got condition: %s[%s] %s %s in line %zd\n", varname->data.string->str, key->data.string->str, li_comp_op_to_string(ctx->op), li_value_type_string(val->type), ctx->line);
_printf("got condition: %s[%s] %s %s in line %zd\n", varname->data.string->str, key->data.string->str, li_comp_op_to_string(ctx->op), li_value_type_string(val), ctx->line);
} else {
_printf("got condition: %s %s %s in line %zd\n", varname->data.string->str, li_comp_op_to_string(ctx->op), li_value_type_string(val->type), ctx->line);
_printf("got condition: %s %s %s in line %zd\n", varname->data.string->str, li_comp_op_to_string(ctx->op), li_value_type_string(val), ctx->line);
}
} else {
if (ctx->condition_with_key) {

125
src/main/plugin.c

@ -61,11 +61,11 @@ struct liServerSetup {
gpointer userdata;
};
static gboolean plugin_load_default_option(liServer *srv, liServerOption *sopt);
static gboolean plugin_load_default_optionptr(liServer *srv, liServerOptionPtr *sopt);
static gboolean plugin_load_default_option(liServer *srv, liServerOption *sopt, const char *name);
static gboolean plugin_load_default_optionptr(liServer *srv, liServerOptionPtr *sopt, const char *name);
static void li_plugin_free_default_options(liServer *srv, liPlugin *p);
liOptionPtrValue li_option_ptr_zero = { 0, { 0 } , 0 };
const liOptionPtrValue li_option_ptr_zero = { 0, { 0 } , 0 };
static liPlugin* plugin_new(const gchar *name) {
liPlugin *p = g_slice_new0(liPlugin);
@ -294,7 +294,7 @@ liPlugin *li_plugin_register(liServer *srv, const gchar *name, liPluginInitCB in
so->p = p;
so->default_value = po->default_value;
g_hash_table_insert(srv->options, (gchar*) po->name, so);
plugin_load_default_option(srv, so);
plugin_load_default_option(srv, so, po->name);
}
}
@ -314,7 +314,7 @@ liPlugin *li_plugin_register(liServer *srv, const gchar *name, liPluginInitCB in
so->p = p;
so->default_value = po->default_value;
g_hash_table_insert(srv->optionptrs, (gchar*) po->name, so);
plugin_load_default_optionptr(srv, so);
plugin_load_default_optionptr(srv, so, po->name);
}
}
@ -361,25 +361,25 @@ static liServerOption* find_option(liServer *srv, const char *name) {
}
static gboolean li_parse_option(liServer *srv, liWorker *wrk, liServerOption *sopt, const char *name, liValue *val, liOptionSet *mark) {
assert(NULL != srv && NULL != wrk && NULL != sopt && NULL != name && NULL != val && NULL != mark);
assert(NULL != srv && NULL != wrk && NULL != sopt && NULL != name && NULL != mark);
if (sopt->type != val->type && sopt->type != LI_VALUE_NONE) {
if (NULL != val && sopt->type != val->type && sopt->type != LI_VALUE_NONE) {
ERROR(srv, "Unexpected value type '%s', expected '%s' for option %s",
li_value_type_string(val->type), li_value_type_string(sopt->type), name);
li_value_type_string(val), li_valuetype_string(sopt->type), name);
return FALSE;
}
if (!sopt->parse_option) {
if (NULL == sopt->parse_option) {
switch (sopt->type) {
case LI_VALUE_BOOLEAN:
mark->value.boolean = val->data.boolean;
mark->value.boolean = (NULL == val) ? GPOINTER_TO_INT(sopt->default_value) : val->data.boolean;
break;
case LI_VALUE_NUMBER:
mark->value.number = val->data.number;
mark->value.number = (NULL == val) ? GPOINTER_TO_INT(sopt->default_value) : val->data.number;
break;
default:
ERROR(srv, "Invalid scalar option type '%s' for option %s",
li_value_type_string(sopt->type), name);
li_valuetype_string(sopt->type), name);
return FALSE;
}
} else {
@ -402,16 +402,26 @@ static gboolean li_parse_optionptr(liServer *srv, liWorker *wrk, liServerOptionP
liOptionPtrValue *oval;
gpointer ptr = NULL;
assert(NULL != srv && NULL != wrk && NULL != sopt && NULL != name && NULL != val && NULL != mark);
assert(NULL != srv && NULL != wrk && NULL != sopt && NULL != name && NULL != mark);
if (sopt->type != val->type && sopt->type != LI_VALUE_NONE) {
if (NULL != val && sopt->type != val->type && sopt->type != LI_VALUE_NONE) {
ERROR(srv, "Unexpected value type '%s', expected '%s' for option %s",
li_value_type_string(val->type), li_value_type_string(sopt->type), name);
li_value_type_string(val), li_valuetype_string(sopt->type), name);
return FALSE;
}
if (!sopt->parse_option) {
ptr = li_value_extract_ptr(val);
if (NULL == sopt->parse_option) {
if (NULL == val) {
switch (sopt->type) {
case LI_VALUE_STRING:
ptr = g_string_new((const char*) sopt->default_value);
break;
default:
ptr = NULL;
}
} else {
ptr = li_value_extract_ptr(val);
}
} else {
if (!sopt->parse_option(srv, wrk, sopt->p, sopt->module_index, val, &ptr)) {
/* errors should be logged by parse function */
@ -419,7 +429,7 @@ static gboolean li_parse_optionptr(liServer *srv, liWorker *wrk, liServerOptionP
}
}
if (ptr) {
if (NULL != ptr) {
oval = g_slice_new0(liOptionPtrValue);
oval->refcount = 1;
oval->sopt = sopt;
@ -479,6 +489,12 @@ void li_release_optionptr(liServer *srv, liOptionPtrValue *value) {
g_slice_free(liOptionPtrValue, value);
}
static liValue* option_value(liValue *val) {
if (li_value_list_has_len(val, 1)) return li_value_list_at(val, 0);
if (li_value_list_has_len(val, 0)) return NULL;
return val;
}
liAction *li_plugin_config_action(liServer *srv, liWorker *wrk, const gchar *name, liValue *val) {
liAction *a = NULL;
liServerAction *sa;
@ -492,13 +508,13 @@ liAction *li_plugin_config_action(liServer *srv, liWorker *wrk, const gchar *nam
} else if (NULL != (sopt = find_option(srv, name))) {
liOptionSet setting;
if (!li_parse_option(srv, wrk, sopt, name, val, &setting)) goto exit;
if (!li_parse_option(srv, wrk, sopt, name, option_value(val), &setting)) goto exit;
a = li_action_new_setting(setting);
} else if (NULL != (soptptr = find_optionptr(srv, name))) {
liOptionPtrSet setting;
if (!li_parse_optionptr(srv, wrk, soptptr, name, val, &setting)) goto exit;
if (!li_parse_optionptr(srv, wrk, soptptr, name, option_value(val), &setting)) goto exit;
a = li_action_new_settingptr(setting);
} else if (NULL != g_hash_table_lookup(srv->setups, name)) {
@ -527,14 +543,14 @@ gboolean li_plugin_config_setup(liServer *srv, const char *name, liValue *val) {
} else if (NULL != (sopt = find_option(srv, name))) {
liOptionSet setting;
if (!li_parse_option(srv, srv->main_worker, sopt, name, val, &setting)) goto exit;
if (!li_parse_option(srv, srv->main_worker, sopt, name, option_value(val), &setting)) goto exit;
g_array_index(srv->option_def_values, liOptionValue, sopt->index) = setting.value;
result = TRUE;
} else if (NULL != (soptptr = find_optionptr(srv, name))) {
liOptionPtrSet setting;
if (!li_parse_optionptr(srv, srv->main_worker, soptptr, name, val, &setting)) goto exit;
if (!li_parse_optionptr(srv, srv->main_worker, soptptr, name, option_value(val), &setting)) goto exit;
li_release_optionptr(srv, g_array_index(srv->optionptr_def_values, liOptionPtrValue*, soptptr->index));
g_array_index(srv->optionptr_def_values, liOptionPtrValue*, soptptr->index) = setting.value;
@ -583,74 +599,33 @@ void li_plugins_handle_vrclose(liVRequest *vr) {
}
}
static gboolean plugin_load_default_option(liServer *srv, liServerOption *sopt) {
liOptionValue oval = {0};
static gboolean plugin_load_default_option(liServer *srv, liServerOption *sopt, const char *name) {
liOptionSet setting;
assert(NULL != sopt);
if (!sopt)
return FALSE;
if (!sopt->parse_option) {
switch (sopt->type) {
case LI_VALUE_BOOLEAN:
oval.boolean = GPOINTER_TO_INT(sopt->default_value);
break;
case LI_VALUE_NUMBER:
oval.number = GPOINTER_TO_INT(sopt->default_value);
break;
default:
ERROR(srv, "Invalid type '%s' for scalar option",
li_value_type_string(sopt->type));
return FALSE;
}
} else {
if (!sopt->parse_option(srv, srv->main_worker, sopt->p, sopt->module_index, NULL, &oval)) {
/* errors should be logged by parse function */
return FALSE;
}
}
if (!li_parse_option(srv, srv->main_worker, sopt, name, NULL, &setting)) return FALSE;
assert(setting.ndx == sopt->index);
if (srv->option_def_values->len <= sopt->index)
g_array_set_size(srv->option_def_values, sopt->index + 1);
g_array_index(srv->option_def_values, liOptionValue, sopt->index) = oval;
g_array_index(srv->option_def_values, liOptionValue, sopt->index) = setting.value;
return TRUE;
}
static gboolean plugin_load_default_optionptr(liServer *srv, liServerOptionPtr *sopt) {
gpointer ptr = NULL;
liOptionPtrValue *oval = NULL;
static gboolean plugin_load_default_optionptr(liServer *srv, liServerOptionPtr *sopt, const char *name) {
liOptionPtrSet setting;
assert(NULL != sopt);
if (!sopt)
return FALSE;
if (!sopt->parse_option) {
switch (sopt->type) {
case LI_VALUE_STRING:
ptr = g_string_new((const char*) sopt->default_value);
break;
default:
ptr = NULL;
}
} else {
if (!sopt->parse_option(srv, srv->main_worker, sopt->p, sopt->module_index, NULL, &ptr)) {
/* errors should be logged by parse function */
return FALSE;
}
}
if (ptr) {
oval = g_slice_new0(liOptionPtrValue);
oval->refcount = 1;
oval->data.ptr = ptr;
oval->sopt = sopt;
}
if (!li_parse_optionptr(srv, srv->main_worker, sopt, name, NULL, &setting)) return FALSE;
assert(setting.ndx == sopt->index);
if (srv->optionptr_def_values->len <= sopt->index)
g_array_set_size(srv->optionptr_def_values, sopt->index + 1);
li_release_optionptr(srv, g_array_index(srv->optionptr_def_values, liOptionPtrValue*, sopt->index));
g_array_index(srv->optionptr_def_values, liOptionPtrValue*, sopt->index) = oval;
g_array_index(srv->optionptr_def_values, liOptionPtrValue*, sopt->index) = setting.value;
return TRUE;
}

606
src/main/plugin_core.c

File diff suppressed because it is too large

152
src/main/value.c

@ -77,7 +77,10 @@ void li_value_list_append(liValue *list, liValue *item) {
}
void li_value_wrap_in_list(liValue *val) {
liValue *item = li_value_extract(val);
liValue *item;
assert(NULL != val);
item = li_value_extract(val);
val->type = LI_VALUE_LIST;
val->data.list = g_array_new(FALSE, TRUE, sizeof(liValue*));
g_array_append_val(val->data.list, item);
@ -85,6 +88,7 @@ void li_value_wrap_in_list(liValue *val) {
liValue* li_value_copy(liValue* val) {
liValue *n;
if (NULL == val) return NULL;
switch (val->type) {
case LI_VALUE_NONE: return li_value_new_none();
@ -168,7 +172,7 @@ void li_value_move(liValue *dest, liValue *src) {
_li_value_clear(src);
}
const char* li_value_type_string(liValueType type) {
const char* li_valuetype_string(liValueType type) {
switch(type) {
case LI_VALUE_NONE:
return "none";
@ -191,7 +195,7 @@ const char* li_value_type_string(liValueType type) {
}
void li_value_list_free(GArray *vallist) {
if (!vallist) return;
if (NULL == vallist) return;
for (gsize i = 0; i < vallist->len; i++) {
li_value_free(g_array_index(vallist, liValue*, i));
}
@ -202,67 +206,67 @@ GString *li_value_to_string(liValue *val) {
GString *str;
switch (val->type) {
case LI_VALUE_NONE:
return NULL;
case LI_VALUE_BOOLEAN:
str = g_string_new(val->data.boolean ? "true" : "false");
break;
case LI_VALUE_NUMBER:
str = g_string_sized_new(0);
g_string_printf(str, "%" G_GINT64_FORMAT, val->data.number);
break;
case LI_VALUE_STRING:
str = g_string_new_len(CONST_STR_LEN("\""));
g_string_append_len(str, GSTR_LEN(val->data.string));
g_string_append_c(str, '"');
break;
case LI_VALUE_LIST:
str = g_string_new_len(CONST_STR_LEN("("));
if (val->data.list->len) {
GString *tmp = li_value_to_string(g_array_index(val->data.list, liValue*, 0));
case LI_VALUE_NONE:
return NULL;
case LI_VALUE_BOOLEAN:
str = g_string_new(val->data.boolean ? "true" : "false");
break;
case LI_VALUE_NUMBER:
str = g_string_sized_new(0);
g_string_printf(str, "%" G_GINT64_FORMAT, val->data.number);
break;
case LI_VALUE_STRING:
str = g_string_new_len(CONST_STR_LEN("\""));
g_string_append_len(str, GSTR_LEN(val->data.string));
g_string_append_c(str, '"');
break;
case LI_VALUE_LIST:
str = g_string_new_len(CONST_STR_LEN("("));
if (val->data.list->len) {
GString *tmp = li_value_to_string(g_array_index(val->data.list, liValue*, 0));
g_string_append(str, tmp->str);
g_string_free(tmp, TRUE);
for (guint i = 1; i < val->data.list->len; i++) {
tmp = li_value_to_string(g_array_index(val->data.list, liValue*, i));
g_string_append_len(str, CONST_STR_LEN(", "));
g_string_append(str, tmp->str);
g_string_free(tmp, TRUE);
for (guint i = 1; i < val->data.list->len; i++) {
tmp = li_value_to_string(g_array_index(val->data.list, liValue*, i));
g_string_append_len(str, CONST_STR_LEN(", "));
g_string_append(str, tmp->str);
g_string_free(tmp, TRUE);
}
}
g_string_append_c(str, ')');
break;
case LI_VALUE_HASH:
{
GHashTableIter iter;
gpointer k, v;
GString *tmp;
guint i = 0;
str = g_string_new_len(CONST_STR_LEN("["));
g_hash_table_iter_init(&iter, val->data.hash);
while (g_hash_table_iter_next(&iter, &k, &v)) {
if (i)
g_string_append_len(str, CONST_STR_LEN(", "));
tmp = li_value_to_string((liValue*)v);
g_string_append_len(str, GSTR_LEN((GString*)k));
g_string_append_len(str, CONST_STR_LEN(" => "));
g_string_append_len(str, GSTR_LEN(tmp));
g_string_free(tmp, TRUE);
i++;
}
g_string_append_c(str, ']');
break;
}
case LI_VALUE_ACTION:
str = g_string_new_len(CONST_STR_LEN("<action>"));
break;
case LI_VALUE_CONDITION:
str = g_string_new_len(CONST_STR_LEN("<condition>"));
break;
default:
return NULL;
g_string_append_c(str, ')');
break;
case LI_VALUE_HASH:
{
GHashTableIter iter;
gpointer k, v;
GString *tmp;
guint i = 0;
str = g_string_new_len(CONST_STR_LEN("["));
g_hash_table_iter_init(&iter, val->data.hash);
while (g_hash_table_iter_next(&iter, &k, &v)) {
if (i)
g_string_append_len(str, CONST_STR_LEN(", "));
tmp = li_value_to_string((liValue*)v);
g_string_append_len(str, GSTR_LEN((GString*)k));
g_string_append_len(str, CONST_STR_LEN(" => "));
g_string_append_len(str, GSTR_LEN(tmp));
g_string_free(tmp, TRUE);
i++;
}
g_string_append_c(str, ']');
break;
}
case LI_VALUE_ACTION:
str = g_string_new_len(CONST_STR_LEN("<action>"));
break;
case LI_VALUE_CONDITION:
str = g_string_new_len(CONST_STR_LEN("<condition>"));
break;
default:
return NULL;
}
return str;
@ -353,7 +357,7 @@ liValue* li_value_extract(liValue *val) {
liValue* li_value_to_key_value_list(liValue *val) {
if (NULL == val) return NULL;
if (val->type == LI_VALUE_HASH) {
if (LI_VALUE_HASH == val->type) {
GHashTable *table = li_value_extract_hash(val);
GArray *list;
@ -381,21 +385,19 @@ liValue* li_value_to_key_value_list(liValue *val) {
g_hash_table_destroy(table);
return val;
} else if (val->type == LI_VALUE_LIST) {
/* verify key-value list properties */
GArray *list = val->data.list;
guint i;
for (i = 0; i < list->len; ++i) {
liValue *lentry = g_array_index(list, liValue*, i);
GArray *entrylist;
liValue *key;
if (lentry->type != LI_VALUE_LIST) return NULL;
entrylist = lentry->data.list;
if (2 != entrylist->len) return NULL;
key = g_array_index(entrylist, liValue*, 0);
if (key->type != LI_VALUE_STRING && key->type != LI_VALUE_NONE) return NULL;
} else if (LI_VALUE_LIST == val->type) {
if (li_value_list_has_len(val, 2) &&
(LI_VALUE_STRING == li_value_list_type_at(val, 0) || LI_VALUE_NONE == li_value_list_type_at(val, 0))) {
/* single key-value pair */
li_value_wrap_in_list(val);
return val;
}
/* verify key-value list properties */
LI_VALUE_FOREACH(lentry, val)
if (!li_value_list_has_len(lentry, 2)) return NULL;
if (LI_VALUE_STRING != li_value_list_type_at(lentry, 0) && LI_VALUE_NONE != li_value_list_type_at(lentry, 0)) return NULL;
LI_VALUE_END_FOREACH()
return val;
}
return NULL;

51
src/modules/mod_access.c

@ -115,24 +115,20 @@ static void access_check_free(liServer *srv, gpointer param) {
}
static liAction* access_check_create(liServer *srv, liWorker *wrk, liPlugin* p, liValue *val, gpointer userdata) {
GArray *arr;
liValue *v, *ip;
guint i, j;
guint32 ipv4, netmaskv4;
gboolean deny = FALSE;
access_check_data *acd = NULL;
UNUSED(srv);
UNUSED(wrk);
UNUSED(userdata);
UNUSED(srv); UNUSED(wrk); UNUSED(userdata);
val = li_value_get_single_argument(val);
if (LI_VALUE_STRING == li_value_list_type_at(val, 0)) {
li_value_wrap_in_list(val);
}
if (!val || val->type != LI_VALUE_LIST || (val->data.list->len != 1 && val->data.list->len != 2)) {
if (!li_value_list_has_len(val, 1) && !li_value_list_has_len(val, 2)) {
ERROR(srv, "%s", "access_check expects a list of one or two string,list tuples as parameter");
return NULL;
}
arr = val->data.list;
acd = g_slice_new0(access_check_data);
acd->p = p;
acd->ipv4 = li_radixtree_new();
@ -140,43 +136,44 @@ static liAction* access_check_create(liServer *srv, liWorker *wrk, liPlugin* p,
li_radixtree_insert(acd->ipv4, NULL, 0, GINT_TO_POINTER(ACCESS_DENY));
li_radixtree_insert(acd->ipv6, NULL, 0, GINT_TO_POINTER(ACCESS_DENY));
for (i = 0; i < arr->len; i++) {
v = g_array_index(arr, liValue*, i);
LI_VALUE_FOREACH(v, val)
liValue *vAD, *vIPs;
gboolean deny = FALSE;
if (v->type != LI_VALUE_LIST || v->data.list->len != 2) {
if (!li_value_list_has_len(v, 2)) {
ERROR(srv, "%s", "access_check expects a list of one or two string,list tuples as parameter");
goto failed_free_acd;
}
v = g_array_index(v->data.list, liValue*, 0);
vAD = li_value_list_at(v, 0);
if (v->type != LI_VALUE_STRING) {
if (LI_VALUE_STRING != li_value_type(vAD)) {
ERROR(srv, "%s", "access_check expects a list of one or two string,list tuples as parameter");
goto failed_free_acd;
}
if (g_str_equal(v->data.string->str, "allow")) {
if (g_str_equal(vAD->data.string->str, "allow")) {
deny = FALSE;
} else if (g_str_equal(v->data.string->str, "deny")) {
} else if (g_str_equal(vAD->data.string->str, "deny")) {
deny = TRUE;
} else {
ERROR(srv, "access_check: invalid option \"%s\"", v->data.string->str);
ERROR(srv, "access_check: invalid option \"%s\"", vAD->data.string->str);
goto failed_free_acd;
}
v = g_array_index(g_array_index(arr, liValue*, i)->data.list, liValue*, 1);
vIPs = li_value_list_at(v, 1);
if (v->type != LI_VALUE_LIST) {
if (LI_VALUE_LIST != li_value_type(vIPs)) {
ERROR(srv, "%s", "access_check expects a list of one or two string,list tuples as parameter");
goto failed_free_acd;
}
for (j = 0; j < v->data.list->len; j++) {
LI_VALUE_FOREACH(ip, vIPs)
guint32 ipv4, netmaskv4;
guint8 ipv6_addr[16];
guint ipv6_network;
ip = g_array_index(v->data.list, liValue*, j);
if (ip->type != LI_VALUE_STRING) {
if (LI_VALUE_STRING != li_value_type(ip)) {
ERROR(srv, "%s", "access_check expects a list of one or two string,list tuples as parameter");
goto failed_free_acd;
}
@ -196,8 +193,8 @@ static liAction* access_check_create(liServer *srv, liWorker *wrk, liPlugin* p,
ERROR(srv, "access_check: error parsing ip: %s", ip->data.string->str);
goto failed_free_acd;
}
}
}
LI_VALUE_END_FOREACH()
LI_VALUE_END_FOREACH()
return li_action_new_function(access_check, NULL, access_check_free, acd);
@ -231,7 +228,7 @@ static liHandlerResult access_deny(liVRequest *vr, gpointer param, gpointer *con
static liAction* access_deny_create(liServer *srv, liWorker *wrk, liPlugin* p, liValue *val, gpointer userdata) {
UNUSED(srv); UNUSED(wrk); UNUSED(userdata);
if (val) {
if (!li_value_is_nothing(val)) {
ERROR(srv, "%s", "access.deny doesn't expect any parameters");
return NULL;
}

24
src/modules/mod_accesslog.c

@ -403,7 +403,7 @@ static void al_option_accesslog_free(liServer *srv, liPlugin *p, size_t ndx, gpo
UNUSED(p);
UNUSED(ndx);
if (!oval) return;
if (NULL == oval) return;
g_string_free(oval, TRUE);
}
@ -413,13 +413,13 @@ static gboolean al_option_accesslog_parse(liServer *srv, liWorker *wrk, liPlugin
UNUSED(p);
UNUSED(ndx);
if (!val) {
if (NULL == val) {
/* default */
return TRUE;
}
if (val->type != LI_VALUE_STRING) {
ERROR(srv, "accesslog option expects a string as parameter, %s given", li_value_type_string(val->type));
if (LI_VALUE_STRING != li_value_type(val)) {
ERROR(srv, "accesslog option expects a string as parameter, %s given", li_value_type_string(val));
return FALSE;
}
@ -436,13 +436,13 @@ static void al_option_accesslog_format_free(liServer *srv, liPlugin *p, size_t n
UNUSED(p);
UNUSED(ndx);
if (!oval) return;
if (NULL == oval) return;
arr = oval;
for (i = 0; i < arr->len; i++) {
al_format_entry *afe = &g_array_index(arr, al_format_entry, i);
if (afe->key)
if (NULL != afe->key)
g_string_free(afe->key, TRUE);
}
@ -452,21 +452,19 @@ static void al_option_accesslog_format_free(liServer *srv, liPlugin *p, size_t n
static gboolean al_option_accesslog_format_parse(liServer *srv, liWorker *wrk, liPlugin *p, size_t ndx, liValue *val, gpointer *oval) {
GArray *arr;
UNUSED(wrk);
UNUSED(p);
UNUSED(ndx);
UNUSED(wrk); UNUSED(p); UNUSED(ndx);
if (!val) {
if (NULL == val) {
/* default */
arr = al_parse_format(srv, AL_DEFAULT_FORMAT);
} else if (val->type != LI_VALUE_STRING) {
ERROR(srv, "accesslog.format option expects a string as parameter, %s given", li_value_type_string(val->type));
} else if (LI_VALUE_STRING != li_value_type(val)) {
ERROR(srv, "accesslog.format option expects a string as parameter, %s given", li_value_type_string(val));
return FALSE;
} else {
arr = al_parse_format(srv, val->data.string->str);
}
if (!arr) {
if (NULL == arr) {
ERROR(srv, "%s", "failed to parse accesslog format");
return FALSE;
}

28
src/modules/mod_auth.c

@ -492,29 +492,27 @@ static liAction* auth_generic_create(liServer *srv, liWorker *wrk, liPlugin* p,
liValue *realm = NULL;
gboolean have_ttl_parameter = FALSE;
gint ttl = 10;
GArray *list;
guint i;
val = li_value_get_single_argument(val);
if (NULL == (val = li_value_to_key_value_list(val))) {
ERROR(srv, "%s expects a hashtable/key-value list with at least 3 elements: method, realm and file", actname);
return NULL;
}
list = val->data.list;
for (i = 0; i < list->len; ++i) {
liValue *entryKey = g_array_index(g_array_index(list, liValue*, i)->data.list, liValue*, 0);
liValue *entryValue = g_array_index(g_array_index(list, liValue*, i)->data.list, liValue*, 1);
LI_VALUE_FOREACH(entry, val)
liValue *entryKey = li_value_list_at(entry, 0);
liValue *entryValue = li_value_list_at(entry, 1);
GString *entryKeyStr;
if (entryKey->type == LI_VALUE_NONE) {
ERROR(srv, "%s doesn't take null keys", actname);
if (LI_VALUE_NONE == li_value_type(entryKey)) {
ERROR(srv, "%s doesn't take default keys", actname);
return NULL;
}
entryKeyStr = entryKey->data.string; /* keys are either NONE or STRING */
if (g_string_equal(entryKeyStr, &aon_method)) {
if (entryValue->type != LI_VALUE_STRING) {
if (LI_VALUE_STRING != li_value_type(entryValue)) {
ERROR(srv, "auth option '%s' expects string as parameter", entryKeyStr->str);
return NULL;
}
@ -524,7 +522,7 @@ static liAction* auth_generic_create(liServer *srv, liWorker *wrk, liPlugin* p,
}
method = entryValue->data.string;
} else if (g_string_equal(entryKeyStr, &aon_realm)) {
if (entryValue->type != LI_VALUE_STRING) {
if (LI_VALUE_STRING != li_value_type(entryValue)) {
ERROR(srv, "auth option '%s' expects string as parameter", entryKeyStr->str);
return NULL;
}
@ -534,7 +532,7 @@ static liAction* auth_generic_create(liServer *srv, liWorker *wrk, liPlugin* p,
}
realm = entryValue;
} else if (g_string_equal(entryKeyStr, &aon_file)) {
if (entryValue->type != LI_VALUE_STRING) {
if (LI_VALUE_STRING != li_value_type(entryValue)) {
ERROR(srv, "auth option '%s' expects string as parameter", entryKeyStr->str);
return NULL;
}
@ -544,7 +542,7 @@ static liAction* auth_generic_create(liServer *srv, liWorker *wrk, liPlugin* p,
}
file = entryValue->data.string;
} else if (g_string_equal(entryKeyStr, &aon_ttl)) {
if (entryValue->type != LI_VALUE_NUMBER || entryValue->data.number < 0) {
if (LI_VALUE_NUMBER != li_value_type(entryValue) || entryValue->data.number < 0) {
ERROR(srv, "auth option '%s' expects non-negative number as parameter", entryKeyStr->str);
return NULL;
}
@ -558,7 +556,7 @@ static liAction* auth_generic_create(liServer *srv, liWorker *wrk, liPlugin* p,
ERROR(srv, "unknown auth option '%s'", entryKeyStr->str);
return NULL;
}
}
LI_VALUE_END_FOREACH()
if (NULL == method || NULL == realm || NULL == file) {
ERROR(srv, "%s expects a hashtable/key-value list with 3 elements: method, realm and file", actname);
@ -634,7 +632,7 @@ static liAction* auth_deny(liServer *srv, liWorker *wrk, liPlugin* p, liValue *v
UNUSED(wrk);
UNUSED(userdata);
if (val) {
if (!li_value_is_nothing(val)) {
ERROR(srv, "%s", "'auth.deny' action doesn't have parameters");
return NULL;
}

30
src/modules/mod_balance.c

@ -126,34 +126,38 @@ static void balancer_free(liServer *srv, balancer *b) {
}
static gboolean balancer_fill_backends(balancer *b, liServer *srv, liValue *val) {
if (val->type == LI_VALUE_ACTION) {
backend be = { val->data.val_action.action, 0, BE_ALIVE, 0 };
val = li_value_get_single_argument(val);
if (LI_VALUE_ACTION == li_value_type(val)) {
backend be;
be.act = val->data.val_action.action;
be.load = 0; be.state = BE_ALIVE; be.wake = 0;
assert(srv == val->data.val_action.srv);
li_action_acquire(be.act);
g_array_append_val(b->backends, be);
return TRUE;
} else if (val->type == LI_VALUE_LIST) {
guint i;
if (val->data.list->len == 0) {
} else if (LI_VALUE_LIST == li_value_type(val)) {
if (li_value_list_has_len(val, 0)) {
ERROR(srv, "%s", "expected non-empty list");
return FALSE;
}
for (i = 0; i < val->data.list->len; i++) {
liValue *oa = g_array_index(val->data.list, liValue*, i);
if (oa->type != LI_VALUE_ACTION) {
ERROR(srv, "expected action at entry %u of list, got %s", i, li_value_type_string(oa->type));
LI_VALUE_FOREACH(oa, val)
if (LI_VALUE_ACTION != li_value_type(oa)) {
ERROR(srv, "expected action at entry %u of list, got %s", _oa_i, li_value_type_string(oa));
return FALSE;
}
assert(srv == oa->data.val_action.srv);
{
backend be = { oa->data.val_action.action, 0, BE_ALIVE, 0 };
backend be;
be.act = oa->data.val_action.action;
be.load = 0; be.state = BE_ALIVE; be.wake = 0;
li_action_acquire(be.act);
g_array_append_val(b->backends, be);
}
}
LI_VALUE_END_FOREACH()
return TRUE;
} else {
ERROR(srv, "expected list, got %s", li_value_type_string(val->type));
ERROR(srv, "expected list, got %s", li_value_type_string(val));
return FALSE;
}
}
@ -520,7 +524,7 @@ static void balancer_act_free(liServer *srv, gpointer param) {
static liAction* balancer_create(liServer *srv, liWorker *wrk, liPlugin* p, liValue *val, gpointer userdata) {
balancer *b;
if (!val) {
if (NULL == val) {
ERROR(srv, "%s", "need parameter");
return NULL;
}

4
src/modules/mod_cache_disk_etag.c

@ -339,7 +339,9 @@ static liAction* cache_etag_create(liServer *srv, liWorker *wrk, liPlugin* p, li
cache_etag_context *ctx;
UNUSED(wrk); UNUSED(p); UNUSED(userdata);
if (val->type != LI_VALUE_STRING) {
val = li_value_get_single_argument(val);
if (LI_VALUE_STRING != li_value_type(val)) {
ERROR(srv, "%s", "cache.disk.etag expects a string as parameter");
return FALSE;
}

13
src/modules/mod_debug.c

@ -333,7 +333,7 @@ static liHandlerResult debug_show_connections(liVRequest *vr, gpointer param, gp
static liAction* debug_show_connections_create(liServer *srv, liWorker *wrk, liPlugin* p, liValue *val, gpointer userdata) {
UNUSED(wrk); UNUSED(userdata);
if (val) {
if (!li_value_is_nothing(val)) {
ERROR(srv, "%s", "debug.show_connections doesn't expect any parameters");
return NULL;
}
@ -357,16 +357,19 @@ static liHandlerResult debug_profiler_dump(liVRequest *vr, gpointer param, gpoin
static liAction* debug_profiler_dump_create(liServer *srv, liWorker *wrk, liPlugin* p, liValue *val, gpointer userdata) {
gpointer ptr;
UNUSED(wrk); UNUSED(p); UNUSED(userdata);
if (val && val->type != LI_VALUE_NUMBER) {
val = li_value_get_single_argument(val);
if (LI_VALUE_NONE == li_value_type(val)) {
ptr = GINT_TO_POINTER(10240);
} else if (LI_VALUE_NUMBER == li_value_type(val)) {
ptr = GINT_TO_POINTER(val->data.number);
} else {
ERROR(srv, "%s", "debug.profiler_dump takes an optional integer (minsize) as parameter");
return NULL;
}
ptr = GINT_TO_POINTER(val ? val->data.number : 10240);
return li_action_new_function(debug_profiler_dump, NULL, NULL, ptr);
}
#endif

131
src/modules/mod_deflate.c

@ -700,8 +700,20 @@ static const GString
static liAction* deflate_create(liServer *srv, liWorker *wrk, liPlugin* p, liValue *val, gpointer userdata) {
deflate_config *conf;
gboolean
have_encodings_parameter = FALSE,
have_blocksize_parameter = FALSE,
have_outputbuffer_parameter = FALSE,
have_compression_level_parameter = FALSE;
UNUSED(wrk); UNUSED(userdata);
val = li_value_get_single_argument(val);
if (NULL != val && NULL == (val = li_value_to_key_value_list(val))) {
ERROR(srv, "%s", "deflate expects a optional hash/key-value list as parameter");
return NULL;
}
conf = g_slice_new0(deflate_config);
conf->p = p;
conf->allowed_encodings = encoding_available_mask;
@ -709,81 +721,66 @@ static liAction* deflate_create(liServer *srv, liWorker *wrk, liPlugin* p, liVal
conf->output_buffer = 4*1024;
conf->compression_level = 1;
if (NULL != val) {
gboolean
have_encodings_parameter = FALSE,
have_blocksize_parameter = FALSE,
have_outputbuffer_parameter = FALSE,
have_compression_level_parameter = FALSE;
GArray *list;
guint i;
if (NULL == (val = li_value_to_key_value_list(val))) {
ERROR(srv, "%s", "deflate expects a optional hash/key-value list as parameter");
LI_VALUE_FOREACH(entry, val)
liValue *entryKey = li_value_list_at(entry, 0);
liValue *entryValue = li_value_list_at(entry, 1);
GString *entryKeyStr;
if (LI_VALUE_STRING != li_value_type(entryKey)) {
ERROR(srv, "%s", "deflate doesn't take default keys");
goto option_failed;
}
entryKeyStr = entryKey->data.string; /* keys are either NONE or STRING */
list = val->data.list;
for (i = 0; i < list->len; ++i) {
liValue *entryKey = g_array_index(g_array_index(list, liValue*, i)->data.list, liValue*, 0);
liValue *entryValue = g_array_index(g_array_index(list, liValue*, i)->data.list, liValue*, 1);
GString *entryKeyStr;
if (entryKey->type == LI_VALUE_NONE) {
ERROR(srv, "%s", "deflate doesn't take null keys");
if (g_string_equal(entryKeyStr, &don_encodings)) {
if (LI_VALUE_STRING != li_value_type(entryValue)) {
ERROR(srv, "deflate option '%s' expects string as parameter", entryKeyStr->str);
goto option_failed;
}
if (have_encodings_parameter) {
ERROR(srv, "duplicate deflate option '%s'", entryKeyStr->str);
goto option_failed;
}
have_encodings_parameter = TRUE;
conf->allowed_encodings = header_to_endocing_mask(entryValue->data.string->str);
} else if (g_string_equal(entryKeyStr, &don_blocksize)) {
if (LI_VALUE_NUMBER != li_value_type(entryValue) || entryValue->data.number <= 0) {
ERROR(srv, "deflate option '%s' expects positive integer as parameter", entryKeyStr->str);
goto option_failed;
}
entryKeyStr = entryKey->data.string; /* keys are either NONE or STRING */
if (g_string_equal(entryKeyStr, &don_encodings)) {
if (LI_VALUE_STRING != entryValue->type) {
ERROR(srv, "deflate option '%s' expects string as parameter", entryKeyStr->str);
goto option_failed;
}
if (have_encodings_parameter) {
ERROR(srv, "duplicate deflate option '%s'", entryKeyStr->str);
goto option_failed;
}
have_encodings_parameter = TRUE;
conf->allowed_encodings = header_to_endocing_mask(entryValue->data.string->str);
} else if (g_string_equal(entryKeyStr, &don_blocksize)) {
if (LI_VALUE_NUMBER != entryValue->type || entryValue->data.number <= 0) {
ERROR(srv, "deflate option '%s' expects positive integer as parameter", entryKeyStr->str);
goto option_failed;
}
if (have_blocksize_parameter) {
ERROR(srv, "duplicate deflate option '%s'", entryKeyStr->str);
goto option_failed;
}
have_blocksize_parameter = TRUE;
conf->blocksize = entryValue->data.number;
} else if (g_string_equal(entryKeyStr, &don_outputbuffer)) {
if (LI_VALUE_NUMBER != entryValue->type || entryValue->data.number <= 0) {
ERROR(srv, "deflate option '%s' expects positive integer as parameter", entryKeyStr->str);
goto option_failed;
}
if (have_outputbuffer_parameter) {
ERROR(srv, "duplicate deflate option '%s'", entryKeyStr->str);
goto option_failed;
}
have_outputbuffer_parameter = TRUE;
conf->output_buffer = entryValue->data.number;
} else if (g_string_equal(entryKeyStr, &don_compression_level)) {
if (LI_VALUE_NUMBER != entryValue->type || entryValue->data.number <= 0 || entryValue->data.number > 9) {
ERROR(srv, "deflate option '%s' expects an integer between 1 and 9 as parameter", entryKeyStr->str);
goto option_failed;
}
if (have_compression_level_parameter) {
ERROR(srv, "duplicate deflate option '%s'", entryKeyStr->str);
goto option_failed;
}
have_compression_level_parameter = TRUE;
conf->compression_level = entryValue->data.number;
} else {
ERROR(srv, "unknown option for deflate '%s'", entryKeyStr->str);
if (have_blocksize_parameter) {
ERROR(srv, "duplicate deflate option '%s'", entryKeyStr->str);
goto option_failed;
}
have_blocksize_parameter = TRUE;
conf->blocksize = entryValue->data.number;
} else if (g_string_equal(entryKeyStr, &don_outputbuffer)) {
if (LI_VALUE_NUMBER != li_value_type(entryValue) || entryValue->data.number <= 0) {
ERROR(srv, "deflate option '%s' expects positive integer as parameter", entryKeyStr->str);
goto option_failed;
}
if (have_outputbuffer_parameter) {
ERROR(srv, "duplicate deflate option '%s'", entryKeyStr->str);
goto option_failed;
}
have_outputbuffer_parameter = TRUE;
conf->output_buffer = entryValue->data.number;
} else if (g_string_equal(entryKeyStr, &don_compression_level)) {
if (LI_VALUE_NUMBER != li_value_type(entryValue) || entryValue->data.number <= 0 || entryValue->data.number > 9) {
ERROR(srv, "deflate option '%s' expects an integer between 1 and 9 as parameter", entryKeyStr->str);
goto option_failed;
}
if (have_compression_level_parameter) {
ERROR(srv, "duplicate deflate option '%s'", entryKeyStr->str);
goto option_failed;
}
have_compression_level_parameter = TRUE;
conf->compression_level = entryValue->data.number;
} else {
ERROR(srv, "unknown option for deflate '%s'", entryKeyStr->str);
goto option_failed;
}
}
LI_VALUE_END_FOREACH()
return li_action_new_function(deflate_handle, NULL, deflate_free, conf);

271
src/modules/mod_dirlist.c

@ -590,15 +590,18 @@ static void dirlist_free(liServer *srv, gpointer param) {
UNUSED(srv);
if (data->css)
if (NULL != data->css) {
g_string_free(data->css, TRUE);
}
for (i = 0; i < data->exclude_suffix->len; i++)
for (i = 0; i < data->exclude_suffix->len; i++) {
g_string_free(g_ptr_array_index(data->exclude_suffix, i), TRUE);
}
g_ptr_array_free(data->exclude_suffix, TRUE);
for (i = 0; i < data->exclude_prefix->len; i++)
for (i = 0; i < data->exclude_prefix->len; i++) {
g_string_free(g_ptr_array_index(data->exclude_prefix, i), TRUE);
}
g_ptr_array_free(data->exclude_prefix, TRUE);
g_string_free(data->content_type, TRUE);
@ -608,13 +611,11 @@ static void dirlist_free(liServer *srv, gpointer param) {
static liAction* dirlist_create(liServer *srv, liWorker *wrk, liPlugin* p, liValue *val, gpointer userdata) {
dirlist_data *data;
guint i;
guint j;
liValue *v, *tmpval;
GString *k;
UNUSED(wrk); UNUSED(userdata);
if (val && val->type != LI_VALUE_LIST) {
val = li_value_get_single_argument(val);
if (NULL != val && NULL == (val = li_value_to_key_value_list(val))) {
ERROR(srv, "%s", "dirlist expects an optional list of string-value pairs");
return NULL;
}
@ -631,148 +632,148 @@ static liAction* dirlist_create(liServer *srv, liWorker *wrk, liPlugin* p, liVal
data->exclude_prefix = g_ptr_array_new();
data->content_type = g_string_new("text/html; charset=utf-8");
if (val) {
for (i = 0; i < val->data.list->len; i++) {
tmpval = g_array_index(val->data.list, liValue*, i);
if (tmpval->type != LI_VALUE_LIST || tmpval->data.list->len != 2 ||
g_array_index(tmpval->data.list, liValue*, 0)->type != LI_VALUE_STRING) {
ERROR(srv, "%s", "dirlist expects an optional list of string-value pairs");
LI_VALUE_FOREACH(entry, val)
liValue *entryKey = li_value_list_at(entry, 0);
liValue *entryValue = li_value_list_at(entry, 1);
GString *entryKeyStr;
if (LI_VALUE_STRING != li_value_type(entryKey)) {
ERROR(srv, "%s", "dirlist doesn't take default keys");
dirlist_free(srv, data);
return NULL;
}
entryKeyStr = entryKey->data.string; /* keys are either NONE or STRING */
/* TODO: check for duplicate keys? */
if (g_str_equal(entryKeyStr->str, "sort")) { /* "name", "size" or "type" */
if (LI_VALUE_STRING != li_value_type(entryValue)) {
ERROR(srv, "%s", "dirlist: sort parameter must be a string");
dirlist_free(srv, data);
return NULL;
}
k = g_array_index(tmpval->data.list, liValue*, 0)->data.string;
v = g_array_index(tmpval->data.list, liValue*, 1);
if (g_str_equal(k->str, "sort")) { /* "name", "size" or "type" */
if (v->type != LI_VALUE_STRING) {
ERROR(srv, "%s", "dirlist: sort parameter must be a string");
dirlist_free(srv, data);
return NULL;
}
/* TODO */
WARNING(srv, "%s", "dirlist: sort parameter not supported yet!");
} else if (g_str_equal(k->str, "css")) {
if (v->type != LI_VALUE_STRING) {
ERROR(srv, "%s", "dirlist: css parameter must be a string");
dirlist_free(srv, data);
return NULL;
}
data->css = g_string_new_len(GSTR_LEN(v->data.string));
} else if (g_str_equal(k->str, "hide-dotfiles")) {
if (v->type != LI_VALUE_BOOLEAN) {
ERROR(srv, "%s", "dirlist: hide-dotfiles parameter must be a boolean (true or false)");
dirlist_free(srv, data);
return NULL;
}
data->hide_dotfiles = v->data.boolean;