simplefiles

common.c (3734B)

---

 #include <ctype.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/file.h>
 #include <unistd.h>
 
 #include "common.h"
 #include "config.h"
 #include "html.h"
 
 #define REPOSITORY_MAXLEN 255
 
 static int
 repository_from_script_name(const char *script_name,
     char *repository,
     size_t len);
 
 static int valid_repository(const char *);
 
 int
 build_repository_path(char *path,
     size_t len,
     const char *storage_root,
     const char *repository)
 {
 	if (snprintf(path,
 		len,
 		"%s/%s",
 		storage_root,
 		repository) >= (int) len)
 		return -1;
 
 	return 0;
 }
 
 int
 build_storage_path(char *path,
     size_t len,
     const char *storage_root,
     const char *repository,
     const char *filename)
 {
 	if (snprintf(path, len,
 		"%s/%s/%s",
 		storage_root,
 		repository,
 		filename) >= (int) len)
 		return -1;
 
 	return 0;
 }
 
 const char *
 storage_root(void)
 {
 	const char *root;
 
 	root = getenv("STORAGE_ROOT");
 	if (root != NULL)
 		return root;
 
 	return DEFAULT_STORAGE_ROOT;
 }
 
 const char *
 repository_lock_dir(void)
 {
 	const char *dir;
 
 	dir = getenv("REPOSITORY_LOCK_DIR");
 	if (dir != NULL && *dir != '\0')
 		return dir;
 
 	return DEFAULT_REPOSITORY_LOCK_DIR;
 }
 
 int
 repository_lock(const char *repo)
 {
 	char path[PATH_MAX];
 	int fd;
 
 	if (repo == NULL || !valid_repository(repo))
 		return -1;
 
 	if (snprintf(path, sizeof(path), "%s/%s",
 		repository_lock_dir(), repo) >= (int) sizeof(path))
 		return -1;
 
 	fd = open(path, O_RDWR | O_CREAT | O_CLOEXEC | O_NOFOLLOW, 0600);
 	if (fd == -1)
 		return -1;
 
 	if (flock(fd, LOCK_EX) == -1) {
 		close(fd);
 		return -1;
 	}
 	return fd;
 }
 
 void
 repository_unlock(int fd)
 {
 	if (fd != -1) {
 		flock(fd, LOCK_UN);
 		close(fd);
 	}
 }
 
 const char *
 repository(void)
 {
 	static char repository[REPOSITORY_MAXLEN + 1];
 
 	if (repository_from_script_name(
 		getenv("SCRIPT_NAME"),
 		repository,
 		sizeof(repository)) == -1)
 		return DEFAULT_REPOSITORY;
 
 	if (!valid_repository(repository))
 		return DEFAULT_REPOSITORY;
 
 	return repository;
 }
 
 int
 valid_repository(const char *repository)
 {
 	const unsigned char *p;
 
 	if (repository == NULL || *repository == '\0')
 		return 0;
 
 	for (p = (const unsigned char *) repository; *p != '\0'; p++) {
 		if (!isalnum(*p) &&
 		    *p != '_' &&
 		    *p != '-')
 			return 0;
 	}
 
 	return 1;
 }
 
 static int
 repository_from_script_name(const char *script_name,
     char *repository,
     size_t len)
 {
 	const char *start;
 	const char *end;
 	size_t namelen;
 
 	if (script_name == NULL)
 		return -1;
 
 	if (script_name[0] != '/')
 		return -1;
 
 	start = script_name + 1;
 	if (*start == '\0')
 		return -1;
 
 	end = strchr(start, '/');
 	if (end == NULL)
 		return -1;
 
 	namelen = (size_t) (end - start);
 	if (namelen == 0)
 		return -1;
 
 	if (namelen >= len)
 		return -1;
 
 	memcpy(repository, start, namelen);
 	repository[namelen] = '\0';
 
 	return 0;
 }
 
 int
 valid_filename(const char *filename)
 {
 	const unsigned char *p;
 
 	if (filename == NULL || *filename == '\0')
 		return 0;
 
 	if (strcmp(filename, CONFIG_FILENAME) == 0)
 		return 0;
 
 	if (strncmp(filename, ".upload-", 8) == 0)
 		return 0;
 
 	if (strcmp(filename, ".") == 0 ||
 	    strcmp(filename, "..") == 0)
 		return 0;
 
 	for (p = (const unsigned char *) filename; *p != '\0'; p++) {
 		if (*p == '/' ||
 		    *p == '\\' ||
 		    *p == '"' ||
 		    *p == '\r' ||
 		    *p == '\n')
 			return 0;
 
 		if (iscntrl(*p))
 			return 0;
 	}
 
 	return 1;
 }
 
 int
 check_csrf_origin(void)
 {
 	const char *origin;
 	char expected[CSRF_ORIGIN_MAX];
 
 	if (global_config_csrf_origin(
 	    expected, sizeof(expected)) == -1)
 		return -2;
 
 	origin = getenv("HTTP_ORIGIN");
 
 	if (origin == NULL)
 		return -1;
 
 	if (strcmp(origin, expected) != 0)
 		return -1;
 
 	return 0;
 }