Separate filesystem utilities

8 files changed, 568 insertions, 410 deletions

diff --git a/src/filesystem.c b/src/filesystem.c
new file mode 100644
index 0000000..dbb528f
--- /dev/null
+++ b/src/filesystem.c
@@ -0,0 +1,405 @@
+/*
+  Copyright 2007-2020 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#define _POSIX_C_SOURCE 200809L  /* for fileno */
+#define _BSD_SOURCE     1        /* for realpath, symlink */
+#define _DEFAULT_SOURCE 1        /* for realpath, symlink */
+
+#ifdef __APPLE__
+#    define _DARWIN_C_SOURCE 1  /* for flock */
+#endif
+
+#include "filesystem.h"
+#include "lilv_config.h"
+#include "lilv_internal.h"
+
+#ifdef _WIN32
+#    include <windows.h>
+#    include <direct.h>
+#    include <io.h>
+#    define F_OK 0
+#    define mkdir(path, flags) _mkdir(path)
+#else
+#    include <dirent.h>
+#    include <unistd.h>
+#endif
+
+#if defined(HAVE_FLOCK) && defined(HAVE_FILENO)
+#    include <sys/file.h>
+#endif
+
+#include <sys/stat.h>
+
+#include <errno.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef PAGE_SIZE
+#    define PAGE_SIZE 4096
+#endif
+
+static bool
+lilv_is_dir_sep(const char c)
+{
+	return c == '/' || c == LILV_DIR_SEP[0];
+}
+
+#ifdef _WIN32
+static inline bool
+is_windows_path(const char* path)
+{
+	return (isalpha(path[0]) && (path[1] == ':' || path[1] == '|') &&
+	        (path[2] == '/' || path[2] == '\\'));
+}
+#endif
+
+bool
+lilv_path_is_absolute(const char* path)
+{
+	if (lilv_is_dir_sep(path[0])) {
+		return true;
+	}
+
+#ifdef _WIN32
+	if (is_windows_path(path)) {
+		return true;
+	}
+#endif
+
+	return false;
+}
+
+bool
+lilv_path_is_child(const char* path, const char* dir)
+{
+	if (path && dir) {
+		const size_t path_len = strlen(path);
+		const size_t dir_len  = strlen(dir);
+		return dir && path_len >= dir_len && !strncmp(path, dir, dir_len);
+	}
+	return false;
+}
+
+char*
+lilv_path_absolute(const char* path)
+{
+	if (lilv_path_is_absolute(path)) {
+		return lilv_strdup(path);
+	} else {
+		char* cwd      = getcwd(NULL, 0);
+		char* abs_path = lilv_path_join(cwd, path);
+		free(cwd);
+		return abs_path;
+	}
+}
+
+char*
+lilv_path_relative_to(const char* path, const char* base)
+{
+	const size_t path_len = strlen(path);
+	const size_t base_len = strlen(base);
+	const size_t min_len  = (path_len < base_len) ? path_len : base_len;
+
+	// Find the last separator common to both paths
+	size_t last_shared_sep = 0;
+	for (size_t i = 0; i < min_len && path[i] == base[i]; ++i) {
+		if (lilv_is_dir_sep(path[i])) {
+			last_shared_sep = i;
+		}
+	}
+
+	if (last_shared_sep == 0) {
+		// No common components, return path
+		return lilv_strdup(path);
+	}
+
+	// Find the number of up references ("..") required
+	size_t up = 0;
+	for (size_t i = last_shared_sep + 1; i < base_len; ++i) {
+		if (lilv_is_dir_sep(base[i])) {
+			++up;
+		}
+	}
+
+	// Write up references
+	const size_t suffix_len = path_len - last_shared_sep;
+	char*        rel        = (char*)calloc(1, suffix_len + (up * 3) + 1);
+	for (size_t i = 0; i < up; ++i) {
+		memcpy(rel + (i * 3), "../", 3);
+	}
+
+	// Write suffix
+	memcpy(rel + (up * 3), path + last_shared_sep + 1, suffix_len);
+	return rel;
+}
+
+char*
+lilv_dirname(const char* path)
+{
+	const char* s = path + strlen(path) - 1;  // Last character
+	for (; s > path && lilv_is_dir_sep(*s); --s) {}  // Last non-slash
+	for (; s > path && !lilv_is_dir_sep(*s); --s) {}  // Last internal slash
+	for (; s > path && lilv_is_dir_sep(*s); --s) {}  // Skip duplicates
+
+	if (s == path) {  // Hit beginning
+		return lilv_is_dir_sep(*s) ? lilv_strdup("/") : lilv_strdup(".");
+	} else {  // Pointing to the last character of the result (inclusive)
+		char* dirname = (char*)malloc(s - path + 2);
+		memcpy(dirname, path, s - path + 1);
+		dirname[s - path + 1] = '\0';
+		return dirname;
+	}
+}
+
+char*
+lilv_path_join(const char* a, const char* b)
+{
+	if (!a) {
+		return lilv_strdup(b);
+	}
+
+	const size_t a_len   = strlen(a);
+	const size_t b_len   = b ? strlen(b) : 0;
+	const size_t pre_len = a_len - (lilv_is_dir_sep(a[a_len - 1]) ? 1 : 0);
+	char*        path    = (char*)calloc(1, a_len + b_len + 2);
+	memcpy(path, a, pre_len);
+	path[pre_len] = '/';
+	if (b) {
+		memcpy(path + pre_len + 1,
+		       b + (lilv_is_dir_sep(b[0]) ? 1 : 0),
+		       lilv_is_dir_sep(b[0]) ? b_len - 1 : b_len);
+	}
+	return path;
+}
+
+char*
+lilv_dir_path(const char* path)
+{
+	if (!path) {
+		return NULL;
+	}
+
+	const size_t len = strlen(path);
+
+	if (lilv_is_dir_sep(path[len - 1])) {
+		return lilv_strdup(path);
+	}
+
+	char* dir_path = (char*)calloc(len + 2, 1);
+	memcpy(dir_path, path, len);
+	dir_path[len] = LILV_DIR_SEP[0];
+	return dir_path;
+}
+
+char*
+lilv_realpath(const char* path)
+{
+	if (!path) {
+		return NULL;
+	}
+
+#if defined(_WIN32)
+	char* out = (char*)malloc(MAX_PATH);
+	GetFullPathName(path, MAX_PATH, out, NULL);
+	return out;
+#else
+	char* real_path = realpath(path, NULL);
+	return real_path ? real_path : lilv_strdup(path);
+#endif
+}
+
+bool
+lilv_path_exists(const char* path)
+{
+#ifdef HAVE_LSTAT
+	struct stat st;
+	return !lstat(path, &st);
+#else
+	return !access(path, F_OK);
+#endif
+}
+
+int
+lilv_copy_file(const char* src, const char* dst)
+{
+	FILE* in = fopen(src, "r");
+	if (!in) {
+		return errno;
+	}
+
+	FILE* out = fopen(dst, "w");
+	if (!out) {
+		fclose(in);
+		return errno;
+	}
+
+	char*  page   = (char*)malloc(PAGE_SIZE);
+	size_t n_read = 0;
+	int    st     = 0;
+	while ((n_read = fread(page, 1, PAGE_SIZE, in)) > 0) {
+		if (fwrite(page, 1, n_read, out) != n_read) {
+			st = errno;
+			break;
+		}
+	}
+
+	if (!st && (ferror(in) || ferror(out))) {
+		st = EBADF;
+	}
+
+	free(page);
+	fclose(in);
+	fclose(out);
+
+	return st;
+}
+
+int
+lilv_symlink(const char* oldpath, const char* newpath)
+{
+	int ret = 0;
+	if (strcmp(oldpath, newpath)) {
+#ifdef _WIN32
+#ifdef HAVE_CREATESYMBOLICLINK
+		ret = !CreateSymbolicLink(newpath, oldpath, 0);
+#endif
+		if (ret) {
+			ret = !CreateHardLink(newpath, oldpath, 0);
+		}
+#else
+		ret = symlink(oldpath, newpath);
+#endif
+	}
+	return ret;
+}
+
+int
+lilv_flock(FILE* file, bool lock)
+{
+#if defined(HAVE_FLOCK) && defined(HAVE_FILENO)
+	return flock(fileno(file), lock ? LOCK_EX : LOCK_UN);
+#else
+	return 0;
+#endif
+}
+
+void
+lilv_dir_for_each(const char* path,
+                  void*       data,
+                  void (*f)(const char* path, const char* name, void* data))
+{
+#ifdef _WIN32
+	char*           pat = lilv_path_join(path, "*");
+	WIN32_FIND_DATA fd;
+	HANDLE          fh  = FindFirstFile(pat, &fd);
+	if (fh != INVALID_HANDLE_VALUE) {
+		do {
+			f(path, fd.cFileName, data);
+		} while (FindNextFile(fh, &fd));
+	}
+	free(pat);
+#else
+	DIR* dir = opendir(path);
+	if (dir) {
+		for (struct dirent* entry = NULL; (entry = readdir(dir));) {
+			f(path, entry->d_name, data);
+		}
+		closedir(dir);
+	}
+#endif
+}
+
+int
+lilv_mkdir_p(const char* dir_path)
+{
+	char*        path     = lilv_strdup(dir_path);
+	const size_t path_len = strlen(path);
+	size_t       i        = 1;
+
+#ifdef _WIN32
+	if (is_windows_path(dir_path)) {
+		i = 3;
+	}
+#endif
+
+	for (; i <= path_len; ++i) {
+		const char c = path[i];
+		if (c == LILV_DIR_SEP[0] || c == '/' || c == '\0') {
+			path[i] = '\0';
+			if (mkdir(path, 0755) && errno != EEXIST) {
+				free(path);
+				return errno;
+			}
+			path[i] = c;
+		}
+	}
+
+	free(path);
+	return 0;
+}
+
+static off_t
+lilv_file_size(const char* path)
+{
+	struct stat buf;
+	if (stat(path, &buf)) {
+		return 0;
+	}
+	return buf.st_size;
+}
+
+bool
+lilv_file_equals(const char* a_path, const char* b_path)
+{
+	if (!strcmp(a_path, b_path)) {
+		return true;  // Paths match
+	}
+
+	bool        match  = false;
+	FILE*       a_file = NULL;
+	FILE*       b_file = NULL;
+	char* const a_real = lilv_realpath(a_path);
+	char* const b_real = lilv_realpath(b_path);
+	if (!strcmp(a_real, b_real)) {
+		match = true;  // Real paths match
+	} else if (lilv_file_size(a_path) != lilv_file_size(b_path)) {
+		match = false;  // Sizes differ
+	} else if (!(a_file = fopen(a_real, "rb")) ||
+	           !(b_file = fopen(b_real, "rb"))) {
+		match = false;  // Missing file matches nothing
+	} else {
+		// TODO: Improve performance by reading chunks
+		match = true;
+		while (!feof(a_file) && !feof(b_file)) {
+			if (fgetc(a_file) != fgetc(b_file)) {
+				match = false;
+				break;
+			}
+		}
+	}
+
+	if (a_file) {
+		fclose(a_file);
+	}
+	if (b_file) {
+		fclose(b_file);
+	}
+	free(a_real);
+	free(b_real);
+	return match;
+}
diff --git a/src/filesystem.h b/src/filesystem.h
new file mode 100644
index 0000000..de06214
--- /dev/null
+++ b/src/filesystem.h
@@ -0,0 +1,129 @@
+/*
+  Copyright 2007-2020 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <stdbool.h>
+#include <stdio.h>
+
+/// Return true iff `path` is an absolute path
+bool
+lilv_path_is_absolute(const char* path);
+
+/// Return true iff `path` is a child of `dir`
+bool
+lilv_path_is_child(const char* path, const char* dir);
+
+/**
+   Return `path` as an absolute path.
+
+   If `path` is absolute, an identical copy of it is returned.  Otherwise, the
+   returned path is relative to the current working directory.
+*/
+char*
+lilv_path_absolute(const char* path);
+
+/**
+   Return `path` relative to `base` if possible.
+
+   If `path` is not within `base`, a copy is returned.  Otherwise, an
+   equivalent path relative to `base` is returned (which may contain
+   up-references).
+*/
+char*
+lilv_path_relative_to(const char* path, const char* base);
+
+/**
+   Return the path to the directory that contains `path`.
+
+   Returns the root path if `path` is the root path.
+*/
+char*
+lilv_dirname(const char* path);
+
+/// Join path `a` and path `b` with a single directory separator between them
+char*
+lilv_path_join(const char* a, const char* b);
+
+/// Return `path` normalized to have a trailing directory separator
+char*
+lilv_dir_path(const char* path);
+
+/**
+   Return `path` as a canonicalized absolute path.
+
+   This expands all symbolic links, relative references, and removes extra
+   directory separators.
+*/
+char*
+lilv_realpath(const char* path);
+
+/// Return true iff `path` points to an existing file system entry
+bool
+lilv_path_exists(const char* path);
+
+/**
+   Copy the file at path `src` to path `dst`.
+
+   @return Zero on success, or a standard `errno` error code.
+*/
+int
+lilv_copy_file(const char* src, const char* dst);
+
+/**
+   Create a symlink at `newpath` that points to `oldpath`.
+
+   @return Zero on success, otherwise non-zero and `errno` is set.
+*/
+int
+lilv_symlink(const char* oldpath, const char* newpath);
+
+/**
+   Set or remove an advisory exclusive lock on `file`.
+
+   If the `lock` is true and the file is already locked, then this will not
+   succeed and non-zero will be returned.
+
+   @return Zero on success.
+*/
+int
+lilv_flock(FILE* file, bool lock);
+
+/**
+   Visit every file in the directory at `path`.
+
+   @param path A path to a directory.
+
+   @param data Opaque user data that is passed to `f`.
+
+   @param f A function called on every entry in the directory.  The `path`
+   parameter is always the directory path passed to this function, the `name`
+   parameter is the name of the directory entry (not its full path).
+*/
+void
+lilv_dir_for_each(const char* path,
+                  void*       data,
+                  void (*f)(const char* path, const char* name, void* data));
+
+/**
+   Create the directory `dir_path` and any parent directories if necessary.
+
+   @return Zero on success, or an `errno` error code.
+*/
+int
+lilv_mkdir_p(const char* dir_path);
+
+/// Return true iff the given paths point to files with identical contents
+bool
+lilv_file_equals(const char* a_path, const char* b_path);
diff --git a/src/lilv_internal.h b/src/lilv_internal.h
index 3a36837..212e41a 100644
--- a/src/lilv_internal.h
+++ b/src/lilv_internal.h
@@ -381,32 +381,13 @@ char*  lilv_strjoin(const char* first, ...);
 char*  lilv_strdup(const char* str);
 char*  lilv_get_lang(void);
 char*  lilv_expand(const char* path);
-char*  lilv_dirname(const char* path);
-char*  lilv_dir_path(const char* path);
-int    lilv_copy_file(const char* src, const char* dst);
-bool   lilv_path_exists(const char* path, const void* ignored);
-char*  lilv_path_absolute(const char* path);
-bool   lilv_path_is_absolute(const char* path);
 char*  lilv_get_latest_copy(const char* path, const char* copy_path);
-char*  lilv_path_relative_to(const char* path, const char* base);
-bool   lilv_path_is_child(const char* path, const char* dir);
-int    lilv_flock(FILE* file, bool lock);
-char*  lilv_realpath(const char* path);
-int    lilv_symlink(const char* oldpath, const char* newpath);
-int    lilv_mkdir_p(const char* dir_path);
-char*  lilv_path_join(const char* a, const char* b);
-bool   lilv_file_equals(const char* a_path, const char* b_path);
 
 char*
 lilv_find_free_path(const char* in_path,
                     bool (*exists)(const char*, const void*),
                     const void* user_data);
 
-void
-lilv_dir_for_each(const char* path,
-                  void*       data,
-                  void (*f)(const char* path, const char* name, void* data));
-
 typedef void (*LilvVoidFunc)(void);
 
 /** dlsym wrapper to return a function pointer (without annoying warning) */
diff --git a/src/node.c b/src/node.c
index 0ed733a..59b3353 100644
--- a/src/node.c
+++ b/src/node.c
@@ -14,6 +14,7 @@
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
+#include "filesystem.h"
 #include "lilv_internal.h"
 
 #include "lilv/lilv.h"
diff --git a/src/plugin.c b/src/plugin.c
index a6919d5..9e9eba1 100644
--- a/src/plugin.c
+++ b/src/plugin.c
@@ -14,7 +14,6 @@
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
-#include "lilv_config.h"
 #include "lilv_internal.h"
 
 #include "lilv/lilv.h"
diff --git a/src/state.c b/src/state.c
index e4e381a..749316c 100644
--- a/src/state.c
+++ b/src/state.c
@@ -14,6 +14,7 @@
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
+#include "filesystem.h"
 #include "lilv_internal.h"
 
 #include "lilv/lilv.h"
@@ -228,6 +229,12 @@ retrieve_callback(LV2_State_Handle handle,
 }
 
 static bool
+path_exists(const char* path, const void* ignored)
+{
+	return lilv_path_exists(path);
+}
+
+static bool
 lilv_state_has_path(const char* path, const void* state)
 {
 	return lilv_state_rel2abs((const LilvState*)state, path) != path;
@@ -277,7 +284,7 @@ abstract_path(LV2_State_Map_Path_Handle handle,
 			if (!copy || !lilv_file_equals(real_path, copy)) {
 				// No recent enough copy, make a new one
 				free(copy);
-				copy = lilv_find_free_path(cpath, lilv_path_exists, NULL);
+				copy = lilv_find_free_path(cpath, path_exists, NULL);
 				if ((st = lilv_copy_file(real_path, copy))) {
 					LILV_ERRORF("Error copying state file %s (%s)\n",
 					            copy, strerror(st));
@@ -956,7 +963,7 @@ static bool
 link_exists(const char* path, const void* data)
 {
 	const char* target = (const char*)data;
-	if (!lilv_path_exists(path, NULL)) {
+	if (!lilv_path_exists(path)) {
 		return false;
 	}
 	char* real_path = lilv_realpath(path);
@@ -968,7 +975,19 @@ link_exists(const char* path, const void* data)
 static int
 maybe_symlink(const char* oldpath, const char* newpath)
 {
-  return link_exists(newpath, oldpath) ? 0 : lilv_symlink(oldpath, newpath);
+	if (link_exists(newpath, oldpath)) {
+		return 0;
+	}
+
+	const int st = lilv_symlink(oldpath, newpath);
+	if (st) {
+		LILV_ERRORF("Failed to link %s => %s (%s)\n",
+		            newpath,
+		            oldpath,
+		            strerror(errno));
+	}
+
+	return st;
 }
 
 static void
@@ -1125,8 +1144,13 @@ lilv_state_make_links(const LilvState* state, const char* dir)
 			} else {
 				// Make a link in the link directory to external file
 				char* lpath = lilv_find_free_path(pat, link_exists, pm->abs);
-				if (!lilv_path_exists(lpath, NULL)) {
-					lilv_symlink(pm->abs, lpath);
+				if (!lilv_path_exists(lpath)) {
+					if (lilv_symlink(pm->abs, lpath)) {
+						LILV_ERRORF("Failed to link %s => %s (%s)\n",
+						            pm->abs,
+						            lpath,
+						            strerror(errno));
+					}
 				}
 
 				// Make a link in the save directory to the external link
@@ -1228,7 +1252,7 @@ static void
 try_unlink(const char* state_dir, const char* path)
 {
 	if (!strncmp(state_dir, path, strlen(state_dir))) {
-		if (lilv_path_exists(path, NULL) && unlink(path)) {
+		if (lilv_path_exists(path) && unlink(path)) {
 			LILV_ERRORF("Failed to remove %s (%s)\n", path, strerror(errno));
 		}
 	}
@@ -1246,7 +1270,7 @@ lilv_state_delete(LilvWorld*       world,
 	LilvNode*  bundle        = lilv_new_file_uri(world, NULL, state->dir);
 	LilvNode*  manifest      = lilv_world_get_manifest_uri(world, bundle);
 	char*      manifest_path = lilv_node_get_path(manifest, NULL);
-	const bool has_manifest  = lilv_path_exists(manifest_path, NULL);
+	const bool has_manifest  = lilv_path_exists(manifest_path);
 	SordModel* model         = sord_new(world->world, SORD_SPO, false);
 
 	if (has_manifest) {
diff --git a/src/util.c b/src/util.c
index 6f9c2b3..987d1ee 100644
--- a/src/util.c
+++ b/src/util.c
@@ -14,35 +14,12 @@
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
-#define _POSIX_C_SOURCE 200809L  /* for fileno */
-#define _BSD_SOURCE     1        /* for realpath, symlink */
-#define _DEFAULT_SOURCE 1        /* for realpath, symlink */
-
-#ifdef __APPLE__
-#    define _DARWIN_C_SOURCE 1  /* for flock */
-#endif
-
-#include "lilv_config.h"
+#include "filesystem.h"
 #include "lilv_internal.h"
 
 #include "lilv/lilv.h"
 #include "serd/serd.h"
 
-#ifdef _WIN32
-#    include <windows.h>
-#    include <direct.h>
-#    include <io.h>
-#    define F_OK 0
-#    define mkdir(path, flags) _mkdir(path)
-#else
-#    include <dirent.h>
-#    include <unistd.h>
-#endif
-
-#if defined(HAVE_FLOCK) && defined(HAVE_FILENO)
-#    include <sys/file.h>
-#endif
-
 #include <sys/stat.h>
 #include <sys/types.h>
 
@@ -56,10 +33,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#ifndef PAGE_SIZE
-#    define PAGE_SIZE 4096
-#endif
-
 void
 lilv_free(void* ptr)
 {
@@ -240,60 +213,6 @@ lilv_expand(const char* path)
 	return out;
 }
 
-static bool
-lilv_is_dir_sep(const char c)
-{
-	return c == '/' || c == LILV_DIR_SEP[0];
-}
-
-char*
-lilv_dirname(const char* path)
-{
-	const char* s = path + strlen(path) - 1;  // Last character
-	for (; s > path && lilv_is_dir_sep(*s); --s) {}  // Last non-slash
-	for (; s > path && !lilv_is_dir_sep(*s); --s) {}  // Last internal slash
-	for (; s > path && lilv_is_dir_sep(*s); --s) {}  // Skip duplicates
-
-	if (s == path) {  // Hit beginning
-		return lilv_is_dir_sep(*s) ? lilv_strdup("/") : lilv_strdup(".");
-	} else {  // Pointing to the last character of the result (inclusive)
-		char* dirname = (char*)malloc(s - path + 2);
-		memcpy(dirname, path, s - path + 1);
-		dirname[s - path + 1] = '\0';
-		return dirname;
-	}
-}
-
-char*
-lilv_dir_path(const char* path)
-{
-	if (!path) {
-		return NULL;
-	}
-
-	const size_t len = strlen(path);
-
-	if (lilv_is_dir_sep(path[len - 1])) {
-		return lilv_strdup(path);
-	}
-
-	char* dir_path = (char*)calloc(len + 2, 1);
-	memcpy(dir_path, path, len);
-	dir_path[len] = LILV_DIR_SEP[0];
-	return dir_path;
-}
-
-bool
-lilv_path_exists(const char* path, const void* ignored)
-{
-#ifdef HAVE_LSTAT
-	struct stat st;
-	return !lstat(path, &st);
-#else
-	return !access(path, F_OK);
-#endif
-}
-
 char*
 lilv_find_free_path(const char* in_path,
                     bool (*exists)(const char*, const void*),
@@ -313,100 +232,6 @@ lilv_find_free_path(const char* in_path,
 	return NULL;
 }
 
-int
-lilv_copy_file(const char* src, const char* dst)
-{
-	FILE* in = fopen(src, "r");
-	if (!in) {
-		return errno;
-	}
-
-	FILE* out = fopen(dst, "w");
-	if (!out) {
-		fclose(in);
-		return errno;
-	}
-
-	char*  page   = (char*)malloc(PAGE_SIZE);
-	size_t n_read = 0;
-	int    st     = 0;
-	while ((n_read = fread(page, 1, PAGE_SIZE, in)) > 0) {
-		if (fwrite(page, 1, n_read, out) != n_read) {
-			st = errno;
-			break;
-		}
-	}
-
-	if (!st && (ferror(in) || ferror(out))) {
-		st = EBADF;
-	}
-
-	free(page);
-	fclose(in);
-	fclose(out);
-
-	return st;
-}
-
-#ifdef _WIN32
-static inline bool
-is_windows_path(const char* path)
-{
-	return (isalpha(path[0]) && (path[1] == ':' || path[1] == '|') &&
-	        (path[2] == '/' || path[2] == '\\'));
-}
-#endif
-
-bool
-lilv_path_is_absolute(const char* path)
-{
-	if (lilv_is_dir_sep(path[0])) {
-		return true;
-	}
-
-#ifdef _WIN32
-	if (is_windows_path(path)) {
-		return true;
-	}
-#endif
-
-	return false;
-}
-
-char*
-lilv_path_absolute(const char* path)
-{
-	if (lilv_path_is_absolute(path)) {
-		return lilv_strdup(path);
-	} else {
-		char* cwd      = getcwd(NULL, 0);
-		char* abs_path = lilv_path_join(cwd, path);
-		free(cwd);
-		return abs_path;
-	}
-}
-
-char*
-lilv_path_join(const char* a, const char* b)
-{
-	if (!a) {
-		return lilv_strdup(b);
-	}
-
-	const size_t a_len   = strlen(a);
-	const size_t b_len   = b ? strlen(b) : 0;
-	const size_t pre_len = a_len - (lilv_is_dir_sep(a[a_len - 1]) ? 1 : 0);
-	char*        path    = (char*)calloc(1, a_len + b_len + 2);
-	memcpy(path, a, pre_len);
-	path[pre_len] = '/';
-	if (b) {
-		memcpy(path + pre_len + 1,
-		       b + (lilv_is_dir_sep(b[0]) ? 1 : 0),
-		       lilv_is_dir_sep(b[0]) ? b_len - 1 : b_len);
-	}
-	return path;
-}
-
 typedef struct {
 	char*  pattern;
 	time_t time;
@@ -456,210 +281,3 @@ lilv_get_latest_copy(const char* path, const char* copy_path)
 	return latest.latest;
 }
 
-char*
-lilv_realpath(const char* path)
-{
-	if (!path) {
-		return NULL;
-	}
-
-#if defined(_WIN32)
-	char* out = (char*)malloc(MAX_PATH);
-	GetFullPathName(path, MAX_PATH, out, NULL);
-	return out;
-#else
-	char* real_path = realpath(path, NULL);
-	return real_path ? real_path : lilv_strdup(path);
-#endif
-}
-
-int
-lilv_symlink(const char* oldpath, const char* newpath)
-{
-	int ret = 0;
-	if (strcmp(oldpath, newpath)) {
-#ifdef _WIN32
-#ifdef HAVE_CREATESYMBOLICLINK
-		ret = !CreateSymbolicLink(newpath, oldpath, 0);
-#endif
-		if (ret) {
-			ret = !CreateHardLink(newpath, oldpath, 0);
-		}
-#else
-		ret = symlink(oldpath, newpath);
-#endif
-	}
-	if (ret) {
-		LILV_ERRORF("Failed to link %s => %s (%s)\n",
-		            newpath, oldpath, strerror(errno));
-	}
-	return ret;
-}
-
-char*
-lilv_path_relative_to(const char* path, const char* base)
-{
-	const size_t path_len = strlen(path);
-	const size_t base_len = strlen(base);
-	const size_t min_len  = (path_len < base_len) ? path_len : base_len;
-
-	// Find the last separator common to both paths
-	size_t last_shared_sep = 0;
-	for (size_t i = 0; i < min_len && path[i] == base[i]; ++i) {
-		if (lilv_is_dir_sep(path[i])) {
-			last_shared_sep = i;
-		}
-	}
-
-	if (last_shared_sep == 0) {
-		// No common components, return path
-		return lilv_strdup(path);
-	}
-
-	// Find the number of up references ("..") required
-	size_t up = 0;
-	for (size_t i = last_shared_sep + 1; i < base_len; ++i) {
-		if (lilv_is_dir_sep(base[i])) {
-			++up;
-		}
-	}
-
-	// Write up references
-	const size_t suffix_len = path_len - last_shared_sep;
-	char*        rel        = (char*)calloc(1, suffix_len + (up * 3) + 1);
-	for (size_t i = 0; i < up; ++i) {
-		memcpy(rel + (i * 3), "../", 3);
-	}
-
-	// Write suffix
-	memcpy(rel + (up * 3), path + last_shared_sep + 1, suffix_len);
-	return rel;
-}
-
-bool
-lilv_path_is_child(const char* path, const char* dir)
-{
-	if (path && dir) {
-		const size_t path_len = strlen(path);
-		const size_t dir_len  = strlen(dir);
-		return dir && path_len >= dir_len && !strncmp(path, dir, dir_len);
-	}
-	return false;
-}
-
-int
-lilv_flock(FILE* file, bool lock)
-{
-#if defined(HAVE_FLOCK) && defined(HAVE_FILENO)
-	return flock(fileno(file), lock ? LOCK_EX : LOCK_UN);
-#else
-	return 0;
-#endif
-}
-
-void
-lilv_dir_for_each(const char* path,
-                  void*       data,
-                  void (*f)(const char* path, const char* name, void* data))
-{
-#ifdef _WIN32
-	char*           pat = lilv_path_join(path, "*");
-	WIN32_FIND_DATA fd;
-	HANDLE          fh  = FindFirstFile(pat, &fd);
-	if (fh != INVALID_HANDLE_VALUE) {
-		do {
-			f(path, fd.cFileName, data);
-		} while (FindNextFile(fh, &fd));
-	}
-	free(pat);
-#else
-	DIR* dir = opendir(path);
-	if (dir) {
-		for (struct dirent* entry = NULL; (entry = readdir(dir));) {
-			f(path, entry->d_name, data);
-		}
-		closedir(dir);
-	}
-#endif
-}
-
-int
-lilv_mkdir_p(const char* dir_path)
-{
-	char*        path     = lilv_strdup(dir_path);
-	const size_t path_len = strlen(path);
-	size_t       i        = 1;
-
-#ifdef _WIN32
-	if (is_windows_path(dir_path)) {
-		i = 3;
-	}
-#endif
-
-	for (; i <= path_len; ++i) {
-		const char c = path[i];
-		if (c == LILV_DIR_SEP[0] || c == '/' || c == '\0') {
-			path[i] = '\0';
-			if (mkdir(path, 0755) && errno != EEXIST) {
-				free(path);
-				return errno;
-			}
-			path[i] = c;
-		}
-	}
-
-	free(path);
-	return 0;
-}
-
-static off_t
-lilv_file_size(const char* path)
-{
-	struct stat buf;
-	if (stat(path, &buf)) {
-		LILV_ERRORF("stat(%s) (%s)\n", path, strerror(errno));
-		return 0;
-	}
-	return buf.st_size;
-}
-
-bool
-lilv_file_equals(const char* a_path, const char* b_path)
-{
-	if (!strcmp(a_path, b_path)) {
-		return true;  // Paths match
-	}
-
-	bool        match  = false;
-	FILE*       a_file = NULL;
-	FILE*       b_file = NULL;
-	char* const a_real = lilv_realpath(a_path);
-	char* const b_real = lilv_realpath(b_path);
-	if (!strcmp(a_real, b_real)) {
-		match = true;  // Real paths match
-	} else if (lilv_file_size(a_path) != lilv_file_size(b_path)) {
-		match = false;  // Sizes differ
-	} else if (!(a_file = fopen(a_real, "rb")) ||
-	           !(b_file = fopen(b_real, "rb"))) {
-		match = false;  // Missing file matches nothing
-	} else {
-		// TODO: Improve performance by reading chunks
-		match = true;
-		while (!feof(a_file) && !feof(b_file)) {
-			if (fgetc(a_file) != fgetc(b_file)) {
-				match = false;
-				break;
-			}
-		}
-	}
-
-	if (a_file) {
-		fclose(a_file);
-	}
-	if (b_file) {
-		fclose(b_file);
-	}
-	free(a_real);
-	free(b_real);
-	return match;
-}
diff --git a/src/world.c b/src/world.c
index 2650490..17896ee 100644
--- a/src/world.c
+++ b/src/world.c
@@ -14,6 +14,7 @@
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
+#include "filesystem.h"
 #include "lilv_config.h"
 #include "lilv_internal.h"