void lwan_set_url_map(struct lwan *l, const struct lwan_url_map *map)
{
lwan_trie_destroy(&l->url_map_trie);
if (UNLIKELY(!lwan_trie_init(&l->url_map_trie, destroy_urlmap)))
lwan_status_critical_perror("Could not initialize trie");
for (; map->prefix; map++) {
struct lwan_url_map *copy = add_url_map(&l->url_map_trie, NULL, map);
if (copy->module && copy->module->create) {
copy->data = copy->module->create (map->prefix, copy->args);
copy->flags = copy->module->flags;
copy->handler = copy->module->handle_request;
} else {
copy->flags = HANDLER_PARSE_MASK;
}
}
}
void lwan_set_url_map(lwan_t *l, const lwan_url_map_t *map)
{
lwan_trie_destroy(l->url_map_trie);
l->url_map_trie = lwan_trie_new(destroy_urlmap);
for (; map->prefix; map++) {
lwan_url_map_t *copy = add_url_map(l->url_map_trie, NULL, map);
if (UNLIKELY(!copy))
continue;
if (copy->handler && copy->handler->init) {
copy->data = copy->handler->init(copy->args);
copy->flags = copy->handler->flags;
copy->callback = copy->handler->handle;
} else {
copy->flags = HANDLER_PARSE_MASK;
}
}
}
void lwan_set_url_map(lwan_t *l, const lwan_url_map_t *map)
{
lwan_trie_destroy(&l->url_map_trie);
if (UNLIKELY(!lwan_trie_init(&l->url_map_trie, destroy_urlmap)))
lwan_status_critical_perror("Could not initialize trie");
for (; map->prefix; map++) {
lwan_url_map_t *copy = add_url_map(&l->url_map_trie, NULL, map);
if (UNLIKELY(!copy))
continue;
if (copy->module && copy->module->init) {
copy->data = copy->module->init(copy->args);
copy->flags = copy->module->flags;
copy->handler = copy->module->handle;
} else {
copy->flags = HANDLER_PARSE_MASK;
}
}
}
static void parse_listener_prefix(struct config *c,
struct config_line *l,
struct lwan *lwan,
const struct lwan_module *module,
void *handler)
{
struct lwan_url_map url_map = {};
struct hash *hash = hash_str_new(free, free);
char *prefix = strdupa(l->value);
struct config *isolated;
isolated = config_isolate_section(c, l);
if (!isolated) {
config_error(c, "Could not isolate configuration file");
goto out;
}
while (config_read_line(c, l)) {
switch (l->type) {
case CONFIG_LINE_TYPE_LINE:
hash_add(hash, strdup(l->key), strdup(l->value));
break;
case CONFIG_LINE_TYPE_SECTION:
if (streq(l->key, "authorization")) {
parse_listener_prefix_authorization(c, l, &url_map);
} else if (!config_skip_section(c, l)) {
config_error(c, "Could not skip section");
goto out;
}
break;
case CONFIG_LINE_TYPE_SECTION_END:
goto add_map;
}
}
config_error(c, "Expecting section end while parsing prefix");
goto out;
add_map:
assert((handler && !module) || (!handler && module));
if (handler) {
url_map.handler = handler;
url_map.flags |= HANDLER_PARSE_MASK | HANDLER_DATA_IS_HASH_TABLE;
url_map.data = hash;
url_map.module = NULL;
hash = NULL;
} else if (module->create_from_hash && module->handle_request) {
url_map.data = module->create_from_hash(prefix, hash);
if (!url_map.data) {
config_error(c, "Could not create module instance");
goto out;
}
if (module->parse_conf && !module->parse_conf(url_map.data, isolated)) {
const char *msg = config_last_error(isolated);
config_error(c, "Error from module: %s", msg ? msg : "Unknown");
goto out;
}
url_map.handler = module->handle_request;
url_map.flags |= module->flags;
url_map.module = module;
} else if (UNLIKELY(!module->create_from_hash)) {
config_error(c, "Module isn't prepared to load settings from a file; "
"create_from_hash() method isn't present");
goto out;
} else if (UNLIKELY(!module->handle_request)) {
config_error(c, "Module does not have handle_request() method");
goto out;
}
add_url_map(&lwan->url_map_trie, prefix, &url_map);
out:
hash_free(hash);
config_close(isolated);
}
static void parse_listener_prefix(struct config *c, struct config_line *l,
struct lwan *lwan,
const struct lwan_module *module,
void *handler)
{
struct lwan_url_map url_map = {};
struct hash *hash = hash_str_new(free, free);
char *prefix = strdupa(l->value);
struct config *isolated;
isolated = config_isolate_section(c, l);
if (!isolated) {
config_error(c, "Could not isolate configuration file");
goto out;
}
while (config_read_line(c, l)) {
switch (l->type) {
case CONFIG_LINE_TYPE_LINE:
if (streq(l->key, "module")) {
if (module) {
config_error(c, "Module already specified");
goto out;
}
module = find_module(l->value);
if (!module) {
config_error(c, "Could not find module \"%s\"", l->value);
goto out;
}
} else if (streq(l->key, "handler")) {
if (handler) {
config_error(c, "Handler already specified");
goto out;
}
handler = find_handler(l->value);
if (!handler) {
config_error(c, "Could not find handler \"%s\"", l->value);
goto out;
}
} else {
hash_add(hash, strdup(l->key), strdup(l->value));
}
break;
case CONFIG_LINE_TYPE_SECTION:
if (streq(l->key, "authorization")) {
parse_listener_prefix_authorization(c, l, &url_map);
} else {
if (!config_skip_section(c, l)) {
config_error(c, "Could not skip section");
goto out;
}
}
break;
case CONFIG_LINE_TYPE_SECTION_END:
goto add_map;
}
}
config_error(c, "Expecting section end while parsing prefix");
goto out;
add_map:
if (module == handler && !handler) {
config_error(c, "Missing module or handler");
goto out;
}
if (module && handler) {
config_error(c, "Handler and module are mutually exclusive");
goto out;
}
if (handler) {
url_map.handler = handler;
url_map.flags |= HANDLER_PARSE_MASK | HANDLER_DATA_IS_HASH_TABLE;
url_map.data = hash;
url_map.module = NULL;
hash = NULL;
} else if (module && module->create_from_hash && module->handle_request) {
url_map.data = module->create_from_hash(prefix, hash);
if (module->parse_conf && !module->parse_conf(url_map.data, isolated)) {
const char *msg = config_last_error(isolated);
config_error(c, "Error from module: %s", msg ? msg : "Unknown");
goto out;
}
url_map.handler = module->handle_request;
url_map.flags |= module->flags;
url_map.module = module;
} else {
config_error(c, "Invalid handler");
goto out;
}
add_url_map(&lwan->url_map_trie, prefix, &url_map);
out:
hash_free(hash);
config_close(isolated);
}
static void parse_listener_prefix(config_t *c, config_line_t *l, lwan_t *lwan,
const lwan_module_t *module)
{
lwan_url_map_t url_map = { };
struct hash *hash = hash_str_new(free, free);
void *handler = NULL;
char *prefix = strdupa(l->line.value);
config_t isolated = { };
if (!config_isolate_section(c, l, &isolated)) {
config_error(c, "Could not isolate configuration file");
goto out;
}
while (config_read_line(c, l)) {
switch (l->type) {
case CONFIG_LINE_TYPE_LINE:
if (!strcmp(l->line.key, "module")) {
if (module) {
config_error(c, "Module already specified");
goto out;
}
module = lwan_module_find(lwan, l->line.value);
if (!module) {
config_error(c, "Could not find module \"%s\"", l->line.value);
goto out;
}
} else if (!strcmp(l->line.key, "handler")) {
handler = find_handler_symbol(l->line.value);
if (!handler) {
config_error(c, "Could not find handler \"%s\"", l->line.value);
goto out;
}
} else {
hash_add(hash, strdup(l->line.key), strdup(l->line.value));
}
break;
case CONFIG_LINE_TYPE_SECTION:
if (!strcmp(l->section.name, "authorization")) {
parse_listener_prefix_authorization(c, l, &url_map);
} else {
if (!config_skip_section(c, l)) {
config_error(c, "Could not skip section");
goto out;
}
}
break;
case CONFIG_LINE_TYPE_SECTION_END:
goto add_map;
}
}
config_error(c, "Expecting section end while parsing prefix");
goto out;
add_map:
if (module == handler && !handler) {
config_error(c, "Missing module or handler");
goto out;
}
if (module && handler) {
config_error(c, "Handler and module are mutually exclusive");
goto out;
}
if (handler) {
url_map.handler = handler;
url_map.flags |= HANDLER_PARSE_MASK;
url_map.data = hash;
url_map.module = NULL;
hash = NULL;
} else if (module && module->init_from_hash && module->handle) {
url_map.data = module->init_from_hash(hash);
if (isolated.file && module->parse_conf) {
if (!module->parse_conf(url_map.data, &isolated)) {
config_error(c, "Error from module: %s",
isolated.error_message ? isolated.error_message : "Unknown");
goto out;
}
}
url_map.handler = module->handle;
url_map.flags |= module->flags;
url_map.module = module;
} else {
config_error(c, "Invalid handler");
goto out;
}
add_url_map(&lwan->url_map_trie, prefix, &url_map);
out:
hash_free(hash);
config_close(&isolated);
}
static void parse_listener_prefix(config_t *c, config_line_t *l, lwan_t *lwan)
{
lwan_url_map_t url_map = {0};
struct hash *hash = hash_str_new(free, free);
lwan_handler_t *handler = NULL;
void *callback = NULL;
char *prefix = strdupa(l->line.value);
void *data = NULL;
while (config_read_line(c, l)) {
switch (l->type) {
case CONFIG_LINE_TYPE_LINE:
if (!strcmp(l->line.key, "handler")) {
handler = find_symbol(l->line.value);
if (!handler) {
config_error(c, "Could not find handler \"%s\"", l->line.value);
goto out;
}
} else if (!strcmp(l->line.key, "callback")) {
callback = find_symbol(l->line.value);
if (!callback) {
config_error(c, "Could not find callback \"%s\"", l->line.value);
goto out;
}
} else {
hash_add(hash, strdup(l->line.key), strdup(l->line.value));
}
break;
case CONFIG_LINE_TYPE_SECTION:
if (!strcmp(l->section.name, "authorization")) {
parse_listener_prefix_authorization(c, l, &url_map);
} else {
config_error(c, "Unknown section type: \"%s\"", l->section.name);
goto out;
}
break;
case CONFIG_LINE_TYPE_SECTION_END:
goto add_map;
}
}
config_error(c, "Expecting section end while parsing prefix");
goto out;
add_map:
if (handler == callback && !callback) {
config_error(c, "Missing callback or handler");
goto out;
}
if (handler && callback) {
config_error(c, "Callback and handler are mutually exclusive");
goto out;
}
if (callback) {
url_map.callback = callback;
url_map.flags |= HANDLER_PARSE_MASK;
url_map.data = data;
url_map.handler = NULL;
} else if (handler && handler->init_from_hash && handler->handle) {
url_map.data = handler->init_from_hash(hash);
url_map.callback = handler->handle;
url_map.flags |= handler->flags;
url_map.handler = handler;
} else {
config_error(c, "Invalid handler");
goto out;
}
add_url_map(lwan->url_map_trie, prefix, &url_map);
out:
hash_free(hash);
}