void create_options(FILE *configfile, struct bftpd_option **options, struct directory **directories) { char *str; struct bftpd_option *opt = NULL; struct directory *dir = NULL; str = config_read_line(configfile); while (!strchr(str, '}')) { if (str[0] != '\n') { if ((strstr(str, "directory")) && (strchr(str, '{')) && (directories)) { char *tmp; if (dir) { dir = dir->next = malloc(sizeof(struct directory)); } else { *directories = dir = malloc(sizeof(struct directory)); } tmp = strchr(str, '"') + 1; *strchr(tmp, '"') = 0; dir->path = strdup(tmp); create_options(configfile, &(dir->options), NULL); } else { if (opt) { opt = opt->next = malloc(sizeof(struct bftpd_option)); } else { *options = opt = malloc(sizeof(struct bftpd_option)); } opt->name = (char *) malloc(strlen(str)); opt->value = (char *) malloc(strlen(str)); sscanf(str, "%[^=]=\"%[^\n\"]", opt->name, opt->value); } } str = config_read_line(configfile); } }
void create_options(FILE *configfile, struct bftpd_option **options, struct directory **directories) { char *str; struct bftpd_option *opt = NULL; struct directory *dir = NULL; str = config_read_line(configfile); if (! str) /* no data from the file */ return; while (!strchr(str, '}')) { if (str[0] != '\n') { if ((strstr(str, "directory")) && (strchr(str, '{')) && (directories)) { char *tmp; if (dir) { dir = dir->next = malloc(sizeof(struct directory)); } else { *directories = dir = malloc(sizeof(struct directory)); } /* avoid memory bug */ if (! dir) return; /* tmp = strchr(str, '"') + 1; */ tmp = strchr(str, '"'); if (tmp) { tmp++; *strchr(tmp, '"') = 0; dir->path = strdup(tmp); } if (! dir->path) dir->path = ""; create_options(configfile, &(dir->options), NULL); } else { if (opt) { opt = opt->next = malloc(sizeof(struct bftpd_option)); } else { *options = opt = malloc(sizeof(struct bftpd_option)); } /* bail out on memory error */ if (! opt) return; opt->name = (char *) malloc( strlen(str) + 2 ); // opt->value = (char *) malloc(strlen(str)); opt->value = (char *) malloc( strlen(str) + 256); sscanf(str, "%[^=]=\"%[^\n\"]", opt->name, opt->value); } } str = config_read_line(configfile); if (! str) /* avoid segfault */ return; } }
// Reads plugin configuration int config_plugin( uint32_t i_ident, char* dst, char* req_token ) { int ret = 0; char *value, *token; char ident[ 5 ], *p_ident = ident; *( uint32_t* )ident = i_ident; ident[ 4 ] = 0; FILE *cf; if( cf = config_open() ) { if( config_find_line( &p_ident, "plugin", cf ) ) { if( req_token == NULL ) { ret = 1; } else { while( config_read_line( &value, &token, cf ) ) { if( strcmp( token, "plugin" ) == 0 ) break; if( strcmp( token, req_token ) == 0 ) { if( dst ) strcpy( dst, value ); ret = 1; break; } } } } fclose( cf ); } return( ret ); }
static void parse_listener(config_t *c, config_line_t *l, lwan_t *lwan) { lwan->config.listener = strdup(l->section.param); while (config_read_line(c, l)) { switch (l->type) { case CONFIG_LINE_TYPE_LINE: config_error(c, "Expecting prefix section"); return; case CONFIG_LINE_TYPE_SECTION: if (!strcmp(l->section.name, "prefix")) { parse_listener_prefix(c, l, lwan, NULL); } else { const lwan_module_t *module = lwan_module_find(lwan, l->section.name); if (!module) { config_error(c, "Invalid section name or module not found: %s", l->section.name); } else { parse_listener_prefix(c, l, lwan, module); } } break; case CONFIG_LINE_TYPE_SECTION_END: return; } } config_error(c, "Expecting section end while parsing listener"); }
static bool setup_from_config(lwan_t *lwan) { config_t conf; config_line_t line; bool has_listener = false; char path_buf[PATH_MAX]; const char *path; path = get_config_path(path_buf); lwan_status_info("Loading configuration file: %s", path); lwan->url_map_trie = lwan_trie_new(destroy_urlmap); if (!config_open(&conf, path)) return false; while (config_read_line(&conf, &line)) { switch (line.type) { case CONFIG_LINE_TYPE_LINE: if (!strcmp(line.line.key, "keep_alive_timeout")) lwan->config.keep_alive_timeout = parse_int(line.line.value, default_config.keep_alive_timeout); else if (!strcmp(line.line.key, "quiet")) lwan->config.quiet = parse_bool(line.line.value, default_config.quiet); else if (!strcmp(line.line.key, "reuse_port")) lwan->config.reuse_port = parse_bool(line.line.value, default_config.reuse_port); else config_error(&conf, "Unknown config key: %s", line.line.key); break; case CONFIG_LINE_TYPE_SECTION: if (!has_listener) { has_listener = true; if (!strcmp(line.section.name, "listener")) parse_listener(&conf, &line, lwan); else config_error(&conf, "Unknown section type: %s", line.section.name); } else { config_error(&conf, "Only one listener supported"); } break; case CONFIG_LINE_TYPE_SECTION_END: config_error(&conf, "Unexpected section end"); } } if (conf.error_message) { lwan_status_critical("Error on config file \"%s\", line %d: %s", path, conf.line, conf.error_message); } config_close(&conf); return true; }
// Parse whole file using callback void config_parse( int( *callback )( char*, char* ) ) { char *value, *token; FILE *cf; if( cf = config_open() ) { printf( "Config [info]: Reading rc...\n" ); while( config_read_line( &value, &token, cf ) ) { if( callback( value, token ) ) break; } callback( NULL, NULL ); fclose( cf ); } }
void lwan_straitjacket_enforce(config_t *c, config_line_t *l) { char *user_name = NULL; char *chroot_path = NULL; uid_t uid; gid_t gid; if (geteuid() != 0) { config_error(c, "Straitjacket requires root privileges"); return; } while (config_read_line(c, l)) { switch (l->type) { case CONFIG_LINE_TYPE_LINE: /* TODO: limit_syscalls */ if (!strcmp(l->line.key, "user")) { user_name = strdupa(l->line.value); } else if (!strcmp(l->line.key, "chroot")) { chroot_path = strdupa(l->line.value); } else { config_error(c, "Invalid key: %s", l->line.key); return; } break; case CONFIG_LINE_TYPE_SECTION: config_error(c, "Straitjacket accepts no sections"); return; case CONFIG_LINE_TYPE_SECTION_END: if (!get_user_uid_gid(user_name, &uid, &gid)) { config_error(c, "Unknown user: %s", user_name); return; } if (chroot_path) { if (chroot(chroot_path) < 0) { lwan_status_critical_perror("Could not chroot() to %s", chroot_path); } lwan_status_debug("Jailed to %s", chroot_path); } if (!switch_to_user(uid, gid, user_name)) { lwan_status_critical("Could not drop privileges to %s, aborting", user_name); } return; } } config_error(c, "Expecting section end while parsing straitjacket"); }
void config_init() { FILE *configfile; char *str; struct group_of_users *grp = NULL; struct user *usr = NULL; config_global.options = NULL; config_global.directories = NULL; if (!configpath) return; configfile = fopen(configpath, "r"); if (!configfile) { control_printf(SL_FAILURE, "421 Unable to open configuration file."); exit(1); } while ((str = config_read_line(configfile))) { if (strchr(str, '{')) { replace(str, " {", "{"); replace(str, "{ ", "{"); replace(str, " }", "}"); replace(str, "} ", "}"); if (!strcasecmp(str, "global{\n")) { create_options(configfile, &(config_global.options), &(config_global.directories)); } else if (strstr(str, "user ") == str) { if (usr) { usr = usr->next = malloc(sizeof(struct user)); } else { config_users = usr = malloc(sizeof(struct user)); } usr->name = strdup(str + 5); *strchr(usr->name, '{') = 0; create_options(configfile, &(usr->options), &(usr->directories)); } else if (strstr(str, "group ") == str) { if (grp) { grp = grp->next = malloc(sizeof(struct group_of_users)); } else { config_groups = grp = malloc(sizeof(struct group_of_users)); } cutto(str, 6); *strchr(str, '{') = 0; grp->users = NULL; grp->next = NULL; grp->temp_members = strdup(str); create_options(configfile, &(grp->options), &(grp->directories)); } } } fclose(configfile); }
// Search for and return the specified token(=value) pair int config_find_line( char **find_value, char *find_token, FILE *f ) { char *value, *token; while( config_read_line( &value, &token, f ) ) { if( strcmp( token, find_token ) == 0 ) { if( *find_value == NULL ) { strcpy( *find_value, value ); return( 1 ); } else { if( strcmp( value, *find_value ) == 0 ) { return( 1 ); } } } } return( 0 ); }
bool ConfigSections::ReadNext(std::string& line) { if(!fin) return false; if(!*fin) return false; current_section_changed=false; for(;;) { line=config_read_line(*fin); if(line=="") { // eof current_section=""; current_section_n=-1; current_section_p=section_names.end(); current_section_changed=true; return true; }; std::string::size_type n=line.find_first_not_of(" \t"); if(n == std::string::npos) continue; // should never happen if(line[n] == '[') { // section n++; std::string::size_type nn = line.find(']',n); if(nn == std::string::npos) { line=""; return false; }; // missing ']' current_section=line.substr(n,nn-n); current_section_n=-1; current_section_p=section_names.end(); current_section_changed=true; continue; }; if(!section_names.empty()) { // only limited sections allowed bool match = false; int s_n = -1; for(std::list<std::string>::iterator sec = section_names.begin(); sec!=section_names.end();++sec) { std::string::size_type len = sec->length(); s_n++; if(strncasecmp(sec->c_str(),current_section.c_str(),len) != 0) continue; if(len != current_section.length()) { if(current_section[len] != '/') continue; }; current_section_n=s_n; current_section_p=sec; match=true; break; }; if(!match) continue; }; line.erase(0,n); break; }; return true; }
static void parse_listener(struct config *c, struct config_line *l, struct lwan *lwan) { free(lwan->config.listener); lwan->config.listener = strdup(l->value); while (config_read_line(c, l)) { switch (l->type) { case CONFIG_LINE_TYPE_LINE: config_error(c, "Expecting prefix section"); return; case CONFIG_LINE_TYPE_SECTION: if (streq(l->key, "prefix")) { parse_listener_prefix(c, l, lwan, NULL, NULL); continue; } if (l->key[0] == '&') { l->key++; void *handler = find_handler(l->key); if (handler) { parse_listener_prefix(c, l, lwan, NULL, handler); continue; } config_error(c, "Could not find handler name: %s", l->key); return; } const struct lwan_module *module = find_module(l->key); if (module) { parse_listener_prefix(c, l, lwan, module, NULL); continue; } config_error(c, "Invalid section or module not found: %s", l->key); return; case CONFIG_LINE_TYPE_SECTION_END: return; } } config_error(c, "Expecting section end while parsing listener"); }
static void parse_listener_prefix_authorization(struct config *c, struct config_line *l, struct lwan_url_map *url_map) { if (!streq(l->value, "basic")) { config_error(c, "Only basic authorization supported"); return; } memset(&url_map->authorization, 0, sizeof(url_map->authorization)); while (config_read_line(c, l)) { switch (l->type) { case CONFIG_LINE_TYPE_LINE: if (streq(l->key, "realm")) { free(url_map->authorization.realm); url_map->authorization.realm = strdup(l->value); } else if (streq(l->key, "password_file")) { free(url_map->authorization.password_file); url_map->authorization.password_file = strdup(l->value); } break; case CONFIG_LINE_TYPE_SECTION: config_error(c, "Unexpected section: %s", l->key); goto error; case CONFIG_LINE_TYPE_SECTION_END: if (!url_map->authorization.realm) url_map->authorization.realm = strdup("Lwan"); if (!url_map->authorization.password_file) url_map->authorization.password_file = strdup("htpasswd"); url_map->flags |= HANDLER_MUST_AUTHORIZE; goto out; } } out: return; error: free(url_map->authorization.realm); free(url_map->authorization.password_file); }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ int config_load(char *filename, module* caller, const char *section) { //Open the file FILE *config_file_in = config_open(filename, "rt"); char config_line[BBI_MAX_LINE_LENGTH]; if (config_file_in) { bool wanted_section = NULL == section; while (config_read_line(config_line, config_file_in)) { if (config_line[0] == '[') { if (wanted_section) break; if (0 == stricmp(config_line, section)) wanted_section = true; continue; } if (false == wanted_section) continue; if (config_line[0] == '@') { //Interpret the message message_interpret(config_line, false, caller); } } //Close the file fclose(config_file_in); return 0; } //Must have been an error if (!plugin_suppresserrors) { sprintf(config_line, "%s:\nThere was an error loading the configuration file.", filename); MessageBox(NULL, config_line, szAppName, MB_OK|MB_SYSTEMMODAL); } return 1; }
static void parse_listener(config_t *c, config_line_t *l, lwan_t *lwan) { lwan->config.port = parse_int(l->section.param, 8080); while (config_read_line(c, l)) { switch (l->type) { case CONFIG_LINE_TYPE_LINE: config_error(c, "Expecting prefix section"); return; case CONFIG_LINE_TYPE_SECTION: if (!strcmp(l->section.name, "prefix")) parse_listener_prefix(c, l, lwan); else config_error(c, "Unknown section type: %s", l->section.name); break; case CONFIG_LINE_TYPE_SECTION_END: return; } } config_error(c, "Expecting section end while parsing listener"); }
static bool find_section_end(config_t *config, config_line_t *line, int recursion_level) { if (recursion_level > 10) { config_error(config, "Recursion level too deep"); return false; } while (config_read_line(config, line)) { switch (line->type) { case CONFIG_LINE_TYPE_LINE: continue; case CONFIG_LINE_TYPE_SECTION: if (!find_section_end(config, line, recursion_level + 1)) return false; break; case CONFIG_LINE_TYPE_SECTION_END: return true; } } return false; }
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); }
int parse_metadata() { int returnV = 0; int done = 0; char *line; do { do { line = config_read_line(); if (*line == '\n' || *line == '#') { free(line); line = NULL; } } while (!line); // Required metadata if (config_key_match(line, "name")) { packager.pkgname = config_get_string(line); packager.mdlen++; } else if (config_key_match(line, "repo")) { packager.repo = config_get_string(line); packager.mdlen++; } else if (config_key_match(line, "version")) { config_get_version(line, '=', &packager.version); packager.mdlen++; } // Optional metadata else if (config_key_match(line, "description")) { packager.description = config_get_string(line); packager.mdlen++; } else if (config_key_match(line, "dependencies")) { // A bit more complicated packager.mdlen++; char *deplist = config_get_string(line); int i, j = 0; for (i = 0; 1; ++i) { if (deplist[i] == ' ' || deplist[i] == '\0') { char *dep = malloc(strlen(deplist)); strcpy(dep, deplist + j); dep[i - j] = '\0'; j = i + 1; versionData *version = malloc(sizeof(version)); version->major = version->minor = version->patch = 0; if (strchr(dep, ':') != NULL) { config_get_version(dep, ':', version); *strchr(dep, ':') = '\0'; } packageDependency *depv = malloc(sizeof(packageDependency)); depv->version = *version; depv->name = dep; packager.dependencies[packager.dependencies_len] = depv; packager.dependencies_len++; } if (deplist[i] == '\0') { break; } } } else if (config_key_match(line, "author")) { packager.author = config_get_string(line); packager.mdlen++; } else if (config_key_match(line, "maintainer")) { packager.maintainer = config_get_string(line); packager.mdlen++; } else if (config_key_match(line, "copyright")) { packager.copyright = config_get_string(line); packager.mdlen++; } else if (config_key_match(line, "infourl")) { packager.infourl = config_get_string(line); packager.mdlen++; } done = *line == '\0'; free(line); } while (!done); if (!packager.pkgname) { printf("Error: configuration does not include package name.\n"); exit(1); } if (!packager.repo) { printf("Error: configuration does not include package repository.\n"); exit(1); } if (packager.version.major == 0xff || packager.version.minor == 0xff || packager.version.patch == 0xff) { printf("Error: configuration does not include valid package version.\n"); exit(1); } return returnV; }
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 bool setup_from_config(lwan_t *lwan) { config_t conf; config_line_t line; bool has_listener = false; char path_buf[PATH_MAX]; const char *path; path = get_config_path(path_buf); lwan_status_info("Loading configuration file: %s", path); if (!lwan_trie_init(&lwan->url_map_trie, destroy_urlmap)) return false; if (!config_open(&conf, path)) return false; while (config_read_line(&conf, &line)) { switch (line.type) { case CONFIG_LINE_TYPE_LINE: if (!strcmp(line.line.key, "keep_alive_timeout")) lwan->config.keep_alive_timeout = (unsigned short)parse_long(line.line.value, default_config.keep_alive_timeout); else if (!strcmp(line.line.key, "quiet")) lwan->config.quiet = parse_bool(line.line.value, default_config.quiet); else if (!strcmp(line.line.key, "reuse_port")) lwan->config.reuse_port = parse_bool(line.line.value, default_config.reuse_port); else if (!strcmp(line.line.key, "proxy_protocol")) lwan->config.proxy_protocol = parse_bool(line.line.value, default_config.proxy_protocol); else if (!strcmp(line.line.key, "expires")) lwan->config.expires = parse_time_period(line.line.value, default_config.expires); else if (!strcmp(line.line.key, "error_template")) { free(lwan->config.error_template); lwan->config.error_template = strdup(line.line.value); } else if (!strcmp(line.line.key, "threads")) { long n_threads = parse_long(line.line.value, default_config.n_threads); if (n_threads < 0) config_error(&conf, "Invalid number of threads: %d", n_threads); lwan->config.n_threads = (unsigned short int)n_threads; } else config_error(&conf, "Unknown config key: %s", line.line.key); break; case CONFIG_LINE_TYPE_SECTION: if (!strcmp(line.section.name, "listener")) { if (!has_listener) { parse_listener(&conf, &line, lwan); has_listener = true; } else { config_error(&conf, "Only one listener supported"); } } else if (!strcmp(line.section.name, "straitjacket")) { lwan_straitjacket_enforce(&conf, &line); } else { config_error(&conf, "Unknown section type: %s", line.section.name); } break; case CONFIG_LINE_TYPE_SECTION_END: config_error(&conf, "Unexpected section end"); } } if (conf.error_message) { lwan_status_critical("Error on config file \"%s\", line %d: %s", path, conf.line, conf.error_message); } config_close(&conf); return true; }
static bool setup_from_config(struct lwan *lwan, const char *path) { struct config *conf; struct config_line line; bool has_listener = false; char path_buf[PATH_MAX]; if (!path) path = lwan_get_config_path(path_buf, sizeof(path_buf)); lwan_status_info("Loading configuration file: %s", path); conf = config_open(path); if (!conf) return false; if (!lwan_trie_init(&lwan->url_map_trie, destroy_urlmap)) return false; while (config_read_line(conf, &line)) { switch (line.type) { case CONFIG_LINE_TYPE_LINE: if (streq(line.key, "keep_alive_timeout")) { lwan->config.keep_alive_timeout = (unsigned short)parse_long( line.value, default_config.keep_alive_timeout); } else if (streq(line.key, "quiet")) { lwan->config.quiet = parse_bool(line.value, default_config.quiet); } else if (streq(line.key, "reuse_port")) { lwan->config.reuse_port = parse_bool(line.value, default_config.reuse_port); } else if (streq(line.key, "proxy_protocol")) { lwan->config.proxy_protocol = parse_bool(line.value, default_config.proxy_protocol); } else if (streq(line.key, "allow_cors")) { lwan->config.allow_cors = parse_bool(line.value, default_config.allow_cors); } else if (streq(line.key, "expires")) { lwan->config.expires = parse_time_period(line.value, default_config.expires); } else if (streq(line.key, "error_template")) { free(lwan->config.error_template); lwan->config.error_template = strdup(line.value); } else if (streq(line.key, "threads")) { long n_threads = parse_long(line.value, default_config.n_threads); if (n_threads < 0) config_error(conf, "Invalid number of threads: %ld", n_threads); lwan->config.n_threads = (unsigned short int)n_threads; } else if (streq(line.key, "max_post_data_size")) { long max_post_data_size = parse_long( line.value, (long)default_config.max_post_data_size); if (max_post_data_size < 0) config_error(conf, "Negative maximum post data size"); else if (max_post_data_size > 128 * (1 << 20)) config_error(conf, "Maximum post data can't be over 128MiB"); lwan->config.max_post_data_size = (size_t)max_post_data_size; } else if (streq(line.key, "allow_temp_files")) { lwan->config.allow_post_temp_file = !!strstr(line.value, "post"); } else { config_error(conf, "Unknown config key: %s", line.key); } break; case CONFIG_LINE_TYPE_SECTION: if (streq(line.key, "listener")) { if (!has_listener) { parse_listener(conf, &line, lwan); has_listener = true; } else { config_error(conf, "Only one listener supported"); } } else if (streq(line.key, "straitjacket")) { lwan_straitjacket_enforce_from_config(conf); } else { config_error(conf, "Unknown section type: %s", line.key); } break; case CONFIG_LINE_TYPE_SECTION_END: config_error(conf, "Unexpected section end"); } } if (config_last_error(conf)) { lwan_status_critical("Error on config file \"%s\", line %d: %s", path, config_cur_line(conf), config_last_error(conf)); } config_close(conf); return true; }
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); }
/* This function opens the config file and tries to reset some of the option values in memory. -- Jesse */ void Reread_Config_File() { char *line; // line in config file char *config_value; // value stored in memory char *new_value; FILE *config_file; int xfer_delay; int section = 0; // where are we in the config file unsigned long get_value; // open config file config_file = fopen(configpath, "r"); if (! config_file) return; /* read a line from the config file */ line = config_read_line(config_file); while ( line ) { if ( strchr(line, '{') ) section++; /* look for reconized option name */ if ( strstr(line, "HELLO_STRING") ) config_value = config_getoption_reread("HELLO_STRING"); else if ( strstr(line, "QUIT_MSG") ) config_value = config_getoption_reread("QUIT_MSG"); else if ( strstr(line, "XFERBUFSIZE") ) config_value = config_getoption_reread("XFERBUFSIZE"); else if ( strstr(line, "DATA_TIMEOUT") ) config_value = config_getoption_reread("DATA_TIMEOUT"); else if ( strstr(line, "CONTROL_TIMEOUT") ) config_value = config_getoption_reread("CONTROL_TIMEOUT"); else if ( strstr(line, "USERLIMIT_GLOBAL") ) config_value = config_getoption_reread("USERLIMIT_GLOBAL"); else if ( strstr(line, "USERLIMIT_SINGLEUSER") ) config_value = config_getoption_reread("USERLIMIT_SINGLEUSER"); else if ( strstr(line, "USERLIMIT_HOST") ) config_value = config_getoption_reread("USERLIMIT_HOST"); else if ( strstr(line, "DENY_LOGIN") ) config_value = config_getoption_reread("DENY_LOGIN"); else if ( strstr(line, "XFER_DELAY") ) config_value = config_getoption_reread("XFER_DELAY"); else if ( strstr(line, "GZ_UPLOAD") ) config_value = config_getoption_reread("GZ_UPLOAD"); else config_value = NULL; /* get new value from input */ new_value = strchr(line, '"') ; if (new_value) { char *temp; new_value++; // go to first character after quote temp = strchr(new_value, '"'); if (temp) temp[0] = '\0'; // null terminal string } /* set value of option */ if ( (config_value) && (new_value) && (section == 1) ) { // make sure it will fit. if ( strlen(new_value) < 256) strcpy(config_value, new_value); } line = config_read_line(config_file); } /* while not end of file */ fclose(config_file); /* reset numeric values */ get_value = strtoul( config_getoption("XFERBUFSIZE"), NULL, 0 ); if (get_value <= INT_MAX) xfer_bufsize = get_value; else xfer_bufsize = XFER_BUFSIZE; if (! xfer_bufsize ) xfer_bufsize = XFER_BUFSIZE; control_timeout = atoi( config_getoption("CONTROL_TIMEOUT") ); if (! control_timeout) control_timeout = CONTROL_TIMEOUT; data_timeout = atoi( config_getoption("DATA_TIMEOUT") ); if (! data_timeout) data_timeout = DATA_TIMEOUT; xfer_delay = atoi( config_getoption("XFER_DELAY") ); }
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); }