simplefiles

config.c (4971B)

---

 #include <ctype.h>
 #include <errno.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "common.h"
 #include "config.h"
 
 static int
 build_config_path(char *path, size_t len)
 {
 	char repository_path[PATH_MAX];
 
 	if (build_repository_path(repository_path,
 		sizeof(repository_path),
 		storage_root(),
 		repository()) == -1)
 		return -1;
 
 	if (snprintf(path, len, "%s/%s", repository_path, CONFIG_FILENAME) >=
 	    (int) len)
 		return -1;
 
 	return 0;
 }
 
 static off_t
 config_value(const char *name, off_t default_value)
 {
 	char path[PATH_MAX];
 	char line[256];
 	FILE *fp;
 	size_t namelen;
 
 	if (build_config_path(path, sizeof(path)) == -1)
 		return default_value;
 
 	fp = fopen(path, "r");
 	if (fp == NULL)
 		return default_value;
 
 	namelen = strlen(name);
 
 	while (fgets(line, sizeof(line), fp) != NULL) {
 		char *p;
 		char *end;
 		char *value;
 		char *ep;
 		long long parsed;
 
 		/* Strip newline. */
 		line[strcspn(line, "\r\n")] = '\0';
 
 		/* Skip leading whitespace. */
 		p = line;
 		while (isspace((unsigned char) *p))
 			p++;
 
 		/* Ignore blank lines and comments. */
 		if (*p == '\0' || *p == '#')
 			continue;
 
 		/*
 		 * Match:
 		 *
 		 *     NAME=value
 		 *
 		 * and allow whitespace around the '='.
 		 */
 		if (strncmp(p, name, namelen) != 0)
 			continue;
 
 		end = p + namelen;
 
 		if (*end != '=' && !isspace((unsigned char) *end))
 			continue;
 
 		while (isspace((unsigned char) *end))
 			end++;
 
 		if (*end != '=')
 			continue;
 
 		end++;
 		while (isspace((unsigned char) *end))
 			end++;
 
 		value = end;
 
 		/* Trim trailing whitespace. */
 		end = value + strlen(value);
 		while (end > value &&
 		    isspace((unsigned char) end[-1]))
 			end--;
 		*end = '\0';
 
 		if (*value == '\0')
 			continue;
 
 		errno = 0;
 		parsed = strtoll(value, &ep, 10);
 
 		if (errno != 0 || ep == value || *ep != '\0')
 			continue;
 
 		if (parsed <= 0)
 			continue;
 
 		fclose(fp);
 		return (off_t) parsed;
 	}
 
 	fclose(fp);
 	return default_value;
 }
 
 static int
 config_string_file(const char *path,
     const char *name,
     char *value,
     size_t value_len)
 {
 	char line[256];
 	FILE *fp;
 	size_t namelen;
 
 	if (path == NULL || name == NULL ||
 	    value == NULL || value_len == 0)
 		return -1;
 
 	fp = fopen(path, "r");
 	if (fp == NULL)
 		return -1;
 
 	namelen = strlen(name);
 
 	while (fgets(line, sizeof(line), fp) != NULL) {
 		char *p;
 		char *end;
 		char *v;
 		size_t len;
 
 		line[strcspn(line, "\r\n")] = '\0';
 
 		p = line;
 		while (isspace((unsigned char) *p))
 			p++;
 
 		if (*p == '\0' || *p == '#')
 			continue;
 
 		if (strncmp(p, name, namelen) != 0)
 			continue;
 
 		end = p + namelen;
 
 		if (*end != '=' && !isspace((unsigned char) *end))
 			continue;
 		while (isspace((unsigned char) *end))
 			end++;
 
 		if (*end != '=')
 			continue;
 
 		end++;
 		while (isspace((unsigned char) *end))
 			end++;
 
 		v = end;
 
 		end = v + strlen(v);
 		while (end > v &&
 		    isspace((unsigned char) end[-1]))
 			end--;
 
 		*end = '\0';
 
 		if (*v == '\0')
 			continue;
 
 		len = strlen(v);
 
 		if (len >= value_len) {
 			fclose(fp);
 			return -1;
 		}
 		memcpy(value, v, len + 1);
 
 		fclose(fp);
 		return 0;
 	}
 
 	fclose(fp);
 	return -1;
 }
 
 static const char *
 global_config_filename(void)
 {
 	const char *path;
 
 	path = getenv("SIMPLEFILES_CONFIG");
 
 	if (path != NULL && *path != '\0')
 		return path;
 
 	return GLOBAL_CONFIG_FILENAME;
 }
 
 int
 global_config_string(const char *name,
     char *value,
     size_t value_len)
 {
 	return config_string_file(
 	    global_config_filename(),
 	    name,
 	    value,
 	    value_len);
 }
 
 int
 global_config_csrf_origin(char *origin,
     size_t origin_len)
 {
 	return global_config_string(
 	    "CSRF_ORIGIN",
 	    origin,
 	    origin_len);
 }
 
 const char *
 simplefiles_root(void)
 {
 	const char *root;
 
 	root = getenv("SIMPLEFILES_ROOT");
 	if (root != NULL && *root != '\0')
 		return root;
 
 	return SIMPLEFILES_ROOT_DEFAULT;
 }
 off_t
 config_max_upload(void)
 {
 	return config_value("MAX_UPLOAD", DEFAULT_MAX_UPLOAD);
 }
 off_t
 config_repo_quota(void)
 {
 	return config_value("QUOTA", DEFAULT_REPO_QUOTA);
 }
 
 int
 config_write_allowed(void)
 {
 	char path[PATH_MAX];
 	char value[16];
 	char admin[64];
 	const char *remote_user;
 
 	if (build_config_path(path, sizeof(path)) == -1)
 		return 0;
 
 	if (config_string_file(path,
 	    "READ_ONLY",
 	    value,
 	    sizeof(value)) == 0 &&
 	    strcmp(value, "1") == 0)
 		return 0;
 
 	if (config_string_file(path,
 	    "ADMIN_USER",
 	    admin,
 	    sizeof(admin)) == -1)
 		return 0;
 
 	remote_user = getenv("REMOTE_USER");
 
 	if (remote_user == NULL || *remote_user == '\0')
 		return 0;
 
 	return strcmp(remote_user, admin) == 0;
 }
 
 int
 config_access_allowed(void)
 {
 	char value[16];
 	const char *user;
 
 	user = getenv("REMOTE_USER");
 
 	/*
 	 * Authenticated users may read.
 	 */
 	if (user != NULL && *user != '\0')
 		return 1;
 
 	/* Anonymous read must be explicitly enabled. */
 	if (global_config_string("ANONYMOUS_READ",
 	    value, sizeof(value)) == 0 &&
 	    strcmp(value, "1") == 0)
 		return 1;
 
 	return 0;
 }