diff --git a/core/audio.c b/core/audio.c
index f1c18284..9bbf4c35 100644
--- a/core/audio.c
+++ b/core/audio.c
@@ -13,7 +13,7 @@
 static const char *SETTINGS_TRACK  = "core.audio.cur";
 static const char *SETTINGS_VOLUME = "core.audio.volume";
 
-static struct data_file   audio_file   = DATA_FILE_INIT("cur_track", 0);
+static struct file   audio_file        = DATA_FILE_INIT("cur_track", 0);
 static struct track *audio_track       = NULL;
 static int           audio_pause_count = -1;
 
diff --git a/core/date.c b/core/date.c
index 4ff34930..f20501ae 100644
--- a/core/date.c
+++ b/core/date.c
@@ -24,24 +24,24 @@ void date_today(struct date *date)
 	date_set(date, now->tm_year + 1900, now->tm_mon + 1, now->tm_mday);
 }
 
-void date_read(struct data_file *f, struct date *date)
+void date_read(struct file *f, struct date *date)
 {
 	data_file_readf(f, "%u %u %u", &date->d_year, &date->d_month, &date->d_day);
 }
 
-void date_read_stamp(struct data_file *f, struct date *date)
+void date_read_stamp(struct file *f, struct date *date)
 {
 	uint32_t stamp;
 	data_file_readf(f, "%u", &stamp);
 	date->d_stamp = be32toh(stamp);
 }
 
-void date_write(struct data_file *f, struct date *date)
+void date_write(struct file *f, struct date *date)
 {
 	data_file_writef(f, "%u %u %u", date->d_year, date->d_month, date->d_day);
 }
 
-void date_write_stamp(struct data_file *f, struct date *date)
+void date_write_stamp(struct file *f, struct date *date)
 {
 	data_file_writef(f, "%u", htobe32(date->d_stamp));
 }
diff --git a/core/file.c b/core/file.c
index 3dc38a57..37fc9979 100644
--- a/core/file.c
+++ b/core/file.c
@@ -81,9 +81,9 @@ static bool __file_mkdir(const gchar *basedir, const gchar *subdir)
 	return ret == 0;
 }
 
-static bool __file_can_write(struct data_file *file)
+static bool __file_can_write(struct file *data)
 {
-	gchar *path = data_file_path(file);
+	gchar *path = data_file_path(data);
 	bool   ret  = true;
 
 	if (g_access(path, F_OK) == 0 && g_access(path, W_OK) < 0)
@@ -94,8 +94,9 @@ static bool __file_can_write(struct data_file *file)
 }
 
 
-void data_file_init(struct data_file *file, const gchar *name, unsigned int min)
+void data_file_init(struct file *data, const gchar *name, unsigned int min)
 {
+	struct data_file *file = &data->f_data;
 	file->f_mode = OPEN_READ;
 	file->f_version = OCARINA_MINOR_VERSION;
 	file->f_prev = 0;
@@ -104,104 +105,114 @@ void data_file_init(struct data_file *file, const gchar *name, unsigned int min)
 	file->f_name = name;
 }
 
-void cache_file_init(struct cache_file *file, const gchar *subdir, const gchar *name)
+void cache_file_init(struct file *cache, const gchar *subdir, const gchar *name)
 {
+	struct cache_file *file = &cache->f_cache;
 	file->cf_file   = NULL;
 	file->cf_name   = name;
 	file->cf_subdir = subdir;
 }
 
-gchar *data_file_path(struct data_file *file)
+gchar *data_file_path(struct file *data)
 {
+	struct data_file *file = &data->f_data;
 	return __file_build_path(g_get_user_data_dir(), NULL, file->f_name);
 }
 
-gchar *cache_file_path(struct cache_file *file)
+gchar *cache_file_path(struct file *cache)
 {
+	struct cache_file *file = &cache->f_cache;
 	return __file_build_path(g_get_user_cache_dir(), file->cf_subdir,
 				 file->cf_name);
 }
 
-gchar *data_file_write_path(struct data_file *file)
+gchar *data_file_write_path(struct file *data)
 {
+	struct data_file *file = &data->f_data;
 	return __file_build_tmp(g_get_user_data_dir(), NULL, file->f_name);
 }
 
-gchar *cache_file_write_path(struct cache_file *file)
+gchar *cache_file_write_path(struct file *cache)
 {
+	struct cache_file *file = &cache->f_cache;
 	return __file_build_tmp(g_get_user_cache_dir(), file->cf_subdir,
 				file->cf_name);
 }
 
-const unsigned int data_file_version(struct data_file *file)
+const unsigned int data_file_version(struct file *data)
 {
+	struct data_file *file = &data->f_data;
 	if (file->f_file && (file->f_mode == OPEN_READ))
 		return file->f_prev;
 	return file->f_version;
 }
 
-bool data_file_exists(struct data_file *file)
+bool data_file_exists(struct file *file)
 {
 	return __file_exists(data_file_path(file));
 }
 
-bool cache_file_exists(struct cache_file *file)
+bool cache_file_exists(struct file *file)
 {
 	return __file_exists(cache_file_path(file));
 }
 
-static bool __file_open_read(struct data_file *file)
+static bool __file_open_read(struct file *data)
 {
-	if (!data_file_exists(file))
+	struct data_file *file = &data->f_data;
+	if (!data_file_exists(data))
 		return false;
 
-	file->f_file = __file_open(data_file_path(file), "r");
+	file->f_file = __file_open(data_file_path(data), "r");
 	if (!file->f_file)
 		return false;
 
 	file->f_mode = OPEN_READ;
-	if (data_file_readf(file, "%u\n", &file->f_prev) != 1)
+	if (data_file_readf(data, "%u\n", &file->f_prev) != 1)
 		return false;
 	if (file->f_prev < file->f_min) {
 		REPORT_ERROR(file->f_name, "File too old to be upgraded.");
-		data_file_close(file);
+		data_file_close(data);
 		exit(1);
 	}
 	if (file->f_prev > file->f_version) {
 		REPORT_ERROR(file->f_name, "File too new to be opened.");
-		data_file_close(file);
+		data_file_close(data);
 		exit(1);
 	}
 	return true;
 }
 
-static bool __file_open_write(struct data_file *file)
+static bool __file_open_write(struct file *data)
 {
+	struct data_file *file = &data->f_data;
 	if (!__file_mkdir(g_get_user_data_dir(), NULL))
 		return false;
-	if (!__file_can_write(file))
+	if (!__file_can_write(data))
 		return false;
 
-	file->f_file = __file_open(data_file_write_path(file), "w");
+	file->f_file = __file_open(data_file_write_path(data), "w");
 	if (!file->f_file)
 		return false;
 
 	file->f_mode = OPEN_WRITE;
-	return data_file_writef(file, "%d\n", file->f_version) > 0;
+	return data_file_writef(data, "%d\n", file->f_version) > 0;
 }
 
-bool data_file_open(struct data_file *file, enum open_mode mode)
+bool data_file_open(struct file *data, enum open_mode mode)
 {
+	struct data_file *file = &data->f_data;
 	if ((string_length(file->f_name) == 0) || (file->f_file != NULL))
 		return false;
 
 	if (mode == OPEN_READ)
-		return __file_open_read(file);
-	return __file_open_write(file);
+		return __file_open_read(data);
+	return __file_open_write(data);
 }
 
-bool cache_file_open(struct cache_file *file, enum open_mode mode)
+bool cache_file_open(struct file *cache, enum open_mode mode)
 {
+	struct cache_file *file = &cache->f_cache;
 	if (mode == OPEN_READ)
 		return false;
 	if ((string_length(file->cf_name) == 0) || (file->cf_file != NULL))
@@ -209,28 +220,31 @@ bool cache_file_open(struct cache_file *file, enum open_mode mode)
 	if (!__file_mkdir(g_get_user_cache_dir(), file->cf_subdir))
 		return false;
 
-	file->cf_file = __file_open(cache_file_write_path(file), "wb");
+	file->cf_file = __file_open(cache_file_write_path(cache), "wb");
 	return file->cf_file != NULL;
 }
 
-void data_file_close(struct data_file *file)
+void data_file_close(struct file *data)
 {
+	struct data_file *file = &data->f_data;
 	__file_close(file->f_file,
-		     file->f_mode == OPEN_WRITE ? data_file_path(file) : NULL,
-		     file->f_mode == OPEN_WRITE ? data_file_write_path(file) : NULL);
+		     file->f_mode == OPEN_WRITE ? data_file_path(data) : NULL,
+		     file->f_mode == OPEN_WRITE ? data_file_write_path(data) : NULL);
 	file->f_file = NULL;
 }
 
-void cache_file_close(struct cache_file *file)
+void cache_file_close(struct file *cache)
 {
+	struct cache_file *file = &cache->f_cache;
 	__file_close(file->cf_file,
-		     cache_file_path(file),
-		     cache_file_write_path(file));
+		     cache_file_path(cache),
+		     cache_file_write_path(cache));
 	file->cf_file = NULL;
 }
 
-int data_file_readf(struct data_file *file, const char *fmt, ...)
+int data_file_readf(struct file *data, const char *fmt, ...)
 {
+	struct data_file *file = &data->f_data;
 	va_list argp;
 	int ret;
 
@@ -241,19 +255,20 @@ int data_file_readf(struct data_file *file, const char *fmt, ...)
 	return ret;
 }
 
-gchar *data_file_readl(struct data_file *file)
+gchar *data_file_readl(struct file *data)
 {
 	gchar *res;
 
-	if (data_file_readf(file, "%m[^\n]\n", &res) == 0)
+	if (data_file_readf(data, "%m[^\n]\n", &res) == 0)
 		return g_strdup("");
 
 	g_strstrip(res);
 	return res;
 }
 
-int data_file_writef(struct data_file *file, const char *fmt, ...)
+int data_file_writef(struct file *data, const char *fmt, ...)
 {
+	struct data_file *file = &data->f_data;
 	va_list argp;
 	int ret;
 
@@ -266,15 +281,17 @@ int data_file_writef(struct data_file *file, const char *fmt, ...)
 	return ret;
 }
 
-int cache_file_write(struct cache_file *file, const void *data, size_t len)
+int cache_file_write(struct file *cache, const void *data, size_t len)
 {
+	struct cache_file *file = &cache->f_cache;
 	if (fwrite(data, len, 1, file->cf_file) == 1)
 		return len;
 	return -1;
 }
 
-bool cache_file_import(struct cache_file *file, const gchar *srcpath)
+bool cache_file_import(struct file *cache, const gchar *srcpath)
 {
+	struct cache_file *file = &cache->f_cache;
 	gchar *contents = NULL;
 	gsize  length   = 0;
 
@@ -283,17 +300,18 @@ bool cache_file_import(struct cache_file *file, const gchar *srcpath)
 	if (!g_file_get_contents(srcpath, &contents, &length, NULL))
 		return false;
 
-	cache_file_write(file, contents, length);
+	cache_file_write(cache, contents, length);
 	return true;
 }
 
-bool data_file_remove(struct data_file *file)
+bool data_file_remove(struct file *data)
 {
+	struct data_file *file = &data->f_data;
 	int ret = -1;
 	gchar *path;
 
 	if (!file->f_file) {
-		path = data_file_path(file);
+		path = data_file_path(data);
 		ret  = g_unlink(path);
 		g_free(path);
 	}
diff --git a/core/playlists/artist.c b/core/playlists/artist.c
index 1c8e8c41..2786a7f3 100644
--- a/core/playlists/artist.c
+++ b/core/playlists/artist.c
@@ -5,7 +5,7 @@
 #include <core/playlists/artist.h>
 #include <core/string.h>
 
-static struct data_file artist_file = DATA_FILE_INIT("playlist.artist", 0);
+static struct file artist_file = DATA_FILE_INIT("playlist.artist", 0);
 
 static struct playlist_ops pl_artist_ops = {
 	.pl_can_select = playlist_generic_can_select,
diff --git a/core/playlists/generic.c b/core/playlists/generic.c
index 4d02ca8a..22c805b1 100644
--- a/core/playlists/generic.c
+++ b/core/playlists/generic.c
@@ -95,7 +95,7 @@ void playlist_generic_free(struct playlist *playlist)
 	}
 }
 
-void playlist_generic_save(struct playlist *playlist, struct data_file *file,
+void playlist_generic_save(struct playlist *playlist, struct file *file,
 			   unsigned int flags)
 {
 	playlist_iter it;
@@ -129,7 +129,7 @@ void playlist_generic_save(struct playlist *playlist, struct data_file *file,
 	}
 }
 
-void playlist_generic_load(struct playlist *playlist, struct data_file *file,
+void playlist_generic_load(struct playlist *playlist, struct file *file,
 			   unsigned int flags)
 {
 	unsigned int f, n, i, t, it = 0;
diff --git a/core/playlists/library.c b/core/playlists/library.c
index 4ae093fa..db4a6414 100644
--- a/core/playlists/library.c
+++ b/core/playlists/library.c
@@ -14,7 +14,7 @@ struct scan_data {
 };
 
 static bool __lib_pl_scan_dir(void *);
-static struct data_file lib_file = DATA_FILE_INIT("playlist.library", 0);
+static struct file lib_file = DATA_FILE_INIT("playlist.library", 0);
 
 static struct playlist_ops pl_library_ops;
 
diff --git a/core/playlists/system.c b/core/playlists/system.c
index d55969b2..bc6a04ab 100644
--- a/core/playlists/system.c
+++ b/core/playlists/system.c
@@ -9,10 +9,10 @@ static struct playlist *pl_system_lookup(const gchar *);
 static struct playlist *pl_system_get(unsigned int);
 static void pl_system_save();
 
-static struct data_file sys_file         = DATA_FILE_INIT("playlist.db", 0);
-static struct data_file sys_deck_f       = DATA_FILE_INIT("deck", 1);
-static struct data_file sys_collection_f = DATA_FILE_INIT("library.q", 0);
-static struct data_file sys_pl_file      = DATA_FILE_INIT("playlist.system", 0);
+static struct file sys_file         = DATA_FILE_INIT("playlist.db", 0);
+static struct file sys_deck_f       = DATA_FILE_INIT("deck", 1);
+static struct file sys_collection_f = DATA_FILE_INIT("library.q", 0);
+static struct file sys_pl_file      = DATA_FILE_INIT("playlist.system", 0);
 
 
 /*
diff --git a/core/playlists/user.c b/core/playlists/user.c
index dae29764..552a1ac2 100644
--- a/core/playlists/user.c
+++ b/core/playlists/user.c
@@ -37,7 +37,7 @@ static gchar *user_db_key(struct db_entry *dbe)
 	return g_strdup(USER_PLAYLIST(dbe)->pl_playlist.pl_name);
 }
 
-static struct db_entry *user_db_read(struct data_file *file, unsigned int index)
+static struct db_entry *user_db_read(struct file *file, unsigned int index)
 {
 	gchar *name = data_file_readl(file);
 	struct user_playlist *playlist = __user_db_alloc(name, index);
@@ -46,7 +46,7 @@ static struct db_entry *user_db_read(struct data_file *file, unsigned int index)
 	return &playlist->pl_dbe;
 }
 
-static void user_db_write(struct data_file *file, struct db_entry *dbe)
+static void user_db_write(struct file *file, struct db_entry *dbe)
 {
 	struct playlist *playlist = &USER_PLAYLIST(dbe)->pl_playlist;
 
diff --git a/core/settings.c b/core/settings.c
index cb9c7bb6..bb7e20d3 100644
--- a/core/settings.c
+++ b/core/settings.c
@@ -5,7 +5,7 @@
 #include <core/settings.h>
 
 static GHashTable *gui_settings = NULL;
-static struct data_file gui_settings_file = DATA_FILE_INIT("settings", 0);
+static struct file gui_settings_file = DATA_FILE_INIT("settings", 0);
 
 
 static void __settings_save_item(gpointer key, gpointer value, gpointer data)
diff --git a/core/tags/album.c b/core/tags/album.c
index 0f9ac9df..cd7c6088 100644
--- a/core/tags/album.c
+++ b/core/tags/album.c
@@ -20,7 +20,7 @@ static struct database album_db;
 static bool album_db_upgraded = false;
 
 struct album_cache_file {
-	struct cache_file ac_file;
+	struct file ac_file;
 	gchar *ac_subdir;
 	gchar *ac_name;
 };
@@ -252,7 +252,7 @@ static struct album *__album_parse_v0(gchar *line)
 	return __album_alloc(NULL, NULL, name, year);
 }
 
-static struct db_entry *album_read(struct data_file *file, unsigned int index)
+static struct db_entry *album_read(struct file *file, unsigned int index)
 {
 	unsigned int year, artist_id, genre_id, n;
 	struct album *album;
@@ -276,7 +276,7 @@ out:
 	return &album->al_dbe;
 }
 
-static void album_write(struct data_file *file, struct db_entry *dbe)
+static void album_write(struct file *file, struct db_entry *dbe)
 {
 	struct album *album   = ALBUM(dbe);
 	struct artist *artist = album->al_artist;
diff --git a/core/tags/artist.c b/core/tags/artist.c
index 4d2d8f93..54711671 100644
--- a/core/tags/artist.c
+++ b/core/tags/artist.c
@@ -37,12 +37,12 @@ static gchar *artist_key(struct db_entry *dbe)
 	return ARTIST(dbe)->ar_name;
 }
 
-struct db_entry *artist_read(struct data_file *file, unsigned int index)
+struct db_entry *artist_read(struct file *file, unsigned int index)
 {
 	return &__artist_alloc(data_file_readl(file))->ar_dbe;
 }
 
-static void artist_write(struct data_file *file, struct db_entry *dbe)
+static void artist_write(struct file *file, struct db_entry *dbe)
 {
 	data_file_writef(file, "%s", ARTIST(dbe)->ar_name);
 }
diff --git a/core/tags/genre.c b/core/tags/genre.c
index 066bf014..6f16015c 100644
--- a/core/tags/genre.c
+++ b/core/tags/genre.c
@@ -35,12 +35,12 @@ static gchar *genre_key(struct db_entry *dbe)
 	return GENRE(dbe)->ge_name;
 }
 
-static struct db_entry *genre_read(struct data_file *file, unsigned int index)
+static struct db_entry *genre_read(struct file *file, unsigned int index)
 {
 	return &__genre_alloc(data_file_readl(file))->ge_dbe;
 }
 
-static void genre_write(struct data_file *file, struct db_entry *dbe)
+static void genre_write(struct file *file, struct db_entry *dbe)
 {
 	data_file_writef(file, "%s", GENRE(dbe)->ge_name);
 }
diff --git a/core/tags/library.c b/core/tags/library.c
index 786030f8..8645aa64 100644
--- a/core/tags/library.c
+++ b/core/tags/library.c
@@ -33,7 +33,7 @@ static gchar *library_key(struct db_entry *dbe)
 	return LIBRARY(dbe)->li_path;
 }
 
-static struct db_entry *library_read(struct data_file *file, unsigned int index)
+static struct db_entry *library_read(struct file *file, unsigned int index)
 {
 	int enabled;
 	gchar *path;
@@ -45,7 +45,7 @@ static struct db_entry *library_read(struct data_file *file, unsigned int index)
 	return &__library_alloc(path)->li_dbe;
 }
 
-static void library_write(struct data_file *file, struct db_entry *dbe)
+static void library_write(struct file *file, struct db_entry *dbe)
 {
 	data_file_writef(file, "%s", LIBRARY(dbe)->li_path);
 }
diff --git a/core/tags/track.c b/core/tags/track.c
index 7d7ee72a..868afe47 100644
--- a/core/tags/track.c
+++ b/core/tags/track.c
@@ -126,7 +126,7 @@ static gchar *track_key(struct db_entry *dbe)
 	return TRACK(dbe)->tr_path;
 }
 
-static void track_read_v0(struct data_file *file, struct track *track)
+static void track_read_v0(struct file *file, struct track *track)
 {
 	unsigned int artist_id, album_id, genre_id;
 	struct artist *artist;
@@ -147,7 +147,7 @@ static void track_read_v0(struct data_file *file, struct track *track)
 	track->tr_album = album;
 }
 
-static struct db_entry *track_read(struct data_file *file, unsigned int index)
+static struct db_entry *track_read(struct file *file, unsigned int index)
 {
 	struct track *track = __track_alloc();
 	unsigned int library_id, album_id;
@@ -177,7 +177,7 @@ static struct db_entry *track_read(struct data_file *file, unsigned int index)
 
 }
 
-static void track_write(struct data_file *file, struct db_entry *dbe)
+static void track_write(struct file *file, struct db_entry *dbe)
 {
 	struct track *track = TRACK(dbe);
 	gchar *path = __track_path(track);
diff --git a/include/core/database.h b/include/core/database.h
index dd641869..2f788af9 100644
--- a/include/core/database.h
+++ b/include/core/database.h
@@ -57,17 +57,17 @@ struct db_ops {
 	gchar *(*dbe_key)(struct db_entry *);
 
 	/* Read a single struct db_entry from disk. */
-	struct db_entry *(*dbe_read)(struct data_file *, unsigned int);
+	struct db_entry *(*dbe_read)(struct file *, unsigned int);
 
 	/* Write a single struct db_entry to disk. */
-	void (*dbe_write)(struct data_file *, struct db_entry *);
+	void (*dbe_write)(struct file *, struct db_entry *);
 };
 
 
 struct database {
 	unsigned int db_size;     /* The database's count of valid entries.   */
 	bool         db_autosave; /* The database's automatic save setting.   */
-	struct data_file  db_file;     /* The database's associated file object.   */
+	struct file  db_file;     /* The database's associated file object.   */
 	GPtrArray   *db_entries;  /* The database's backing array.            */
 	GHashTable  *db_keys;     /* The database's mapping of key -> value.  */
 
diff --git a/include/core/date.h b/include/core/date.h
index de81f5da..77186560 100644
--- a/include/core/date.h
+++ b/include/core/date.h
@@ -27,12 +27,12 @@ void date_set(struct date *, unsigned int, unsigned int, unsigned int);
 void date_today(struct date *);
 
 /* Read the date from file. */
-void date_read(struct data_file *, struct date *);
-void date_read_stamp(struct data_file *, struct date *);
+void date_read(struct file *, struct date *);
+void date_read_stamp(struct file *, struct date *);
 
 /* Write the date to file. */
-void date_write(struct data_file *, struct date *);
-void date_write_stamp(struct data_file *, struct date *);
+void date_write(struct file *, struct date *);
+void date_write_stamp(struct file *, struct date *);
 
 /*
  * Convert the date into a string.
diff --git a/include/core/file.h b/include/core/file.h
index bf8a15f4..62c9c1c7 100644
--- a/include/core/file.h
+++ b/include/core/file.h
@@ -43,47 +43,55 @@ struct data_file {
 	const gchar	*f_name;    /* The file's basename.             */
 };
 
-#define DATA_FILE_INIT(fname, min)			\
-	{						\
-		.f_mode = OPEN_READ,			\
-		.f_version = OCARINA_MINOR_VERSION,	\
-		.f_prev = 0,				\
-		.f_min  = min,				\
-		.f_file = NULL,				\
-		.f_name = fname,			\
-	}
-
-
 struct cache_file {
 	FILE		*cf_file;   /* The cache file's IO stream.    */
 	const gchar	*cf_name;   /* The cache file's basename.     */
 	const gchar	*cf_subdir; /* The cache file's subdirectory. */
 };
 
-/* Initialize a new file object. */
-void data_file_init(struct data_file *, const gchar *, unsigned int);
-void cache_file_init(struct cache_file *, const gchar *, const gchar *);
+struct file {
+	union {
+		struct data_file  f_data;
+		struct cache_file f_cache;
+	};
+};
+
+#define DATA_FILE_INIT(fname, min)				\
+	{							\
+		.f_data = {					\
+			.f_mode = OPEN_READ,			\
+			.f_version = OCARINA_MINOR_VERSION,	\
+			.f_prev = 0,				\
+			.f_min = min,				\
+			.f_file = NULL,				\
+			.f_name = fname,			\
+		}						\
+	}
+
+/* Initialize a file object. */
+void data_file_init(struct file *, const gchar *, unsigned int);
+void cache_file_init(struct file *, const gchar *, const gchar *);
 
 /*
  * Returns the full path of the file or an empty string if filename is not set.
  * These functions allocates a new string that MUST be freed with g_free().
  */
-gchar *data_file_path(struct data_file *);
-gchar *cache_file_path(struct cache_file *);
+gchar *data_file_path(struct file *);
+gchar *cache_file_path(struct file *);
 
 /*
  * Returns the path to the temporary file used for writes.
  * This function allocates a new string that MUST be freed with g_free().
  */
-gchar *data_file_write_path(struct data_file *);
-gchar *cache_file_write_path(struct cache_file *);
+gchar *data_file_write_path(struct file *);
+gchar *cache_file_write_path(struct file *);
 
 /* Returns the version number of the file. */
-const unsigned int data_file_version(struct data_file *);
+const unsigned int data_file_version(struct file *);
 
 /* Returns true if the file exists on disk and false otherwise. */
-bool data_file_exists(struct data_file *);
-bool cache_file_exists(struct cache_file *);
+bool data_file_exists(struct file *);
+bool cache_file_exists(struct file *);
 
 /*
  * Call to open a file for either reading or writing.  Callers
@@ -101,44 +109,44 @@ bool cache_file_exists(struct cache_file *);
  * Returns true if the open was successful and false otherwise.
  * Oening a cache file with OPEN_READ is currently unsupported.
  */
-bool data_file_open(struct data_file *, enum open_mode);
-bool cache_file_open(struct cache_file *, enum open_mode);
+bool data_file_open(struct file *, enum open_mode);
+bool cache_file_open(struct file *, enum open_mode);
 
 /*
  * Closes an open file, setting file->{f|cf}_file to NULL.  If the file was opened
  * with OPEN_WRITE, then rename the temporary file to file_path().
  */
-void data_file_close(struct data_file *);
-void cache_file_close(struct cache_file *);
+void data_file_close(struct file *);
+void cache_file_close(struct file *);
 
 /*
  * Read an entire line from the file and return it to the caller.
  * This function allocates a new string that MUST be freed with g_free().
  */
-gchar *data_file_readl(struct data_file *);
+gchar *data_file_readl(struct file *);
 
 /*
  * Read from a file with an fscanf(3) style format string.
  * Returns the number of items matched.
  */
-int data_file_readf(struct data_file *, const char *, ...);
+int data_file_readf(struct file *, const char *, ...);
 
 /*
  * Write to a file with an fprintf(3) style format string.
  * Returns the number of bytes successfully written.
  */
-int data_file_writef(struct data_file *, const char *, ...);
+int data_file_writef(struct file *, const char *, ...);
 
 /*
  * Write binary data to a cache file similar to fwrite(3).
  * Returns the number of bytes successfully written.
  */
-int cache_file_write(struct cache_file *, const void *, size_t);
+int cache_file_write(struct file *, const void *, size_t);
 
 /* Import a file into the cache. */
-bool cache_file_import(struct cache_file *, const gchar *);
+bool cache_file_import(struct file *, const gchar *);
 
 /* Removes a closed file from disk. */
-bool data_file_remove(struct data_file *);
+bool data_file_remove(struct file *);
 
 #endif /* OCARINA_CORE_FILE_H */
diff --git a/include/core/playlists/generic.h b/include/core/playlists/generic.h
index 40c7349e..4d167047 100644
--- a/include/core/playlists/generic.h
+++ b/include/core/playlists/generic.h
@@ -54,10 +54,10 @@ struct playlist *playlist_generic_alloc(gchar *, enum playlist_type_t,
 void playlist_generic_free(struct playlist *);
 
 /* Generic playlist save function. */
-void playlist_generic_save(struct playlist *, struct data_file *, unsigned int);
+void playlist_generic_save(struct playlist *, struct file *, unsigned int);
 
 /* Generic playlist load function. */
-void playlist_generic_load(struct playlist *, struct data_file *, unsigned int);
+void playlist_generic_load(struct playlist *, struct file *, unsigned int);
 
 /* Generic playlist can-select function. */
 bool playlist_generic_can_select(struct playlist *);
diff --git a/tests/core/database.c b/tests/core/database.c
index 6420ddd9..0d201b07 100644
--- a/tests/core/database.c
+++ b/tests/core/database.c
@@ -44,14 +44,14 @@ static gchar *int_key(struct db_entry *dbe)
 	return g_strdup_printf("%u", INT_ENTRY(dbe)->ie_val);
 }
 
-static struct db_entry *int_read(struct data_file *f, unsigned int index)
+static struct db_entry *int_read(struct file *f, unsigned int index)
 {
 	unsigned int val;
 	data_file_readf(f, "%u", &val);
 	return &__int_alloc(val)->ie_dbe;
 }
 
-static void int_write(struct data_file *file, struct db_entry *dbe)
+static void int_write(struct file *file, struct db_entry *dbe)
 {
 	data_file_writef(file, "%u", INT_ENTRY(dbe)->ie_val);
 }
@@ -68,7 +68,7 @@ static const struct db_ops int_ops = {
 static void test_db_entry()
 {
 	struct int_entry *ent;
-	struct data_file f;
+	struct file f;
 
 	ent = INT_ENTRY(int_ops.dbe_alloc("1", 0));
 	g_assert_cmpuint(ent->ie_dbe.dbe_index, ==, 0);
@@ -105,8 +105,8 @@ static void test_init()
 	g_assert_cmpuint(g_hash_table_size(db.db_keys), ==, 0);
 	g_assert_cmpuint(db.db_size, ==, 0);
 	g_assert_false(db.db_autosave);
-	g_assert_cmpuint(db.db_file.f_version, ==, OCARINA_MINOR_VERSION);
-	g_assert_cmpstr(db.db_file.f_name, ==, "init.db");
+	g_assert_cmpuint(db.db_file.f_data.f_version, ==, OCARINA_MINOR_VERSION);
+	g_assert_cmpstr(db.db_file.f_data.f_name, ==, "init.db");
 
 	db_deinit(&db);
 }
diff --git a/tests/core/date.c b/tests/core/date.c
index 3485b67f..ca3581df 100644
--- a/tests/core/date.c
+++ b/tests/core/date.c
@@ -16,7 +16,7 @@ void test_date()
 		.d_month = 0,
 		.d_day   = 0,
 	};
-	struct data_file f = DATA_FILE_INIT("date", 0);
+	struct file f = DATA_FILE_INIT("date", 0);
 
 	date_today(NULL);
 	date_set(NULL, 0, 0, 0);
diff --git a/tests/core/file.c b/tests/core/file.c
index d22a1220..cf3158a7 100644
--- a/tests/core/file.c
+++ b/tests/core/file.c
@@ -7,34 +7,34 @@
 #include <stdlib.h>
 
 
-static void test_verify_constructor(struct data_file *file, gchar *fpath, gchar *ftmp)
+static void test_verify_constructor(struct file *file, gchar *fpath, gchar *ftmp)
 {
-	g_assert_null(file->f_file);
+	g_assert_null(file->f_data.f_file);
 	g_assert_cmpuint(data_file_version(file), ==, OCARINA_MINOR_VERSION);
-	g_assert_cmpuint(file->f_mode, ==, OPEN_READ);
+	g_assert_cmpuint(file->f_data.f_mode, ==, OPEN_READ);
 	g_assert_cmpstr_free(data_file_path(file), ==, fpath);
 	g_assert_cmpstr_free(data_file_write_path(file), ==, ftmp);
 }
 
 static void test_invalid_file(gconstpointer path)
 {
-	struct data_file file;
+	struct file file;
 
 	data_file_init(&file, (gchar *)path, 0);
 	test_verify_constructor(&file, "", "");
 
 	g_assert_false(data_file_open(&file, OPEN_READ));
-	g_assert_null(file.f_file);
+	g_assert_null(file.f_data.f_file);
 	g_assert_false(data_file_open(&file, OPEN_WRITE));
-	g_assert_null(file.f_file);
-	g_assert_cmpuint(file.f_mode, ==, OPEN_READ);
+	g_assert_null(file.f_data.f_file);
+	g_assert_cmpuint(file.f_data.f_mode, ==, OPEN_READ);
 
 	g_assert_false(data_file_exists(&file));
 }
 
 static void __test_file_subprocess()
 {
-	struct data_file file = DATA_FILE_INIT("file.txt", 0);
+	struct file file = DATA_FILE_INIT("file.txt", 0);
 	gchar *basepath, *filepath, *realpath;
 
 	basepath = g_strjoin("/", g_get_user_data_dir(), OCARINA_NAME, NULL);
@@ -46,14 +46,14 @@ static void __test_file_subprocess()
 
 	g_assert_false(data_file_open(&file, OPEN_READ));
 	g_assert_true(data_file_open(&file, OPEN_WRITE));
-	g_assert_nonnull(file.f_file);
-	g_assert_cmpuint(file.f_mode, ==, OPEN_WRITE);
+	g_assert_nonnull(file.f_data.f_file);
+	g_assert_cmpuint(file.f_data.f_mode, ==, OPEN_WRITE);
 	g_assert_false(data_file_open(&file, OPEN_WRITE));
 
 	g_assert_false(data_file_exists(&file));
 	data_file_close(&file);
-	g_assert_null(file.f_file);
-	g_assert_cmpuint(file.f_mode, ==, OPEN_WRITE);
+	g_assert_null(file.f_data.f_file);
+	g_assert_cmpuint(file.f_data.f_mode, ==, OPEN_WRITE);
 	g_assert_true(data_file_exists(&file));
 
 	g_chmod(filepath, 0444);
@@ -63,8 +63,8 @@ static void __test_file_subprocess()
 	g_chmod(filepath, 0644);
 
 	g_assert_true(data_file_open(&file, OPEN_READ));
-	g_assert_nonnull(file.f_file);
-	g_assert_cmpuint(file.f_mode, ==, OPEN_READ);
+	g_assert_nonnull(file.f_data.f_file);
+	g_assert_cmpuint(file.f_data.f_mode, ==, OPEN_READ);
 	g_assert_false(data_file_open(&file, OPEN_READ));
 
 	g_assert_false(data_file_remove(&file));
@@ -90,12 +90,12 @@ static void test_file()
 
 static void test_io()
 {
-	struct data_file fout = DATA_FILE_INIT("file.txt", 0);
-	struct data_file fin  = DATA_FILE_INIT("file.txt", 1);
+	struct file fout = DATA_FILE_INIT("file.txt", 0);
+	struct file fin  = DATA_FILE_INIT("file.txt", 1);
 	char *res = NULL;
 	unsigned int i;
 
-	fout.f_version = 1;
+	fout.f_data.f_version = 1;
 	g_assert_true(data_file_open(&fout, OPEN_WRITE));
 	data_file_writef(&fout, "1 ABCDE\n");
 	data_file_writef(&fout, "2 FGHIJ KLMNO\n");
@@ -130,11 +130,11 @@ static void test_io()
 
 static void __test_versioning_subprocess(unsigned int out, unsigned int in)
 {
-	struct data_file fout = DATA_FILE_INIT("file.txt", out);
-	struct data_file fin  = DATA_FILE_INIT("file.txt", in);
+	struct file fout = DATA_FILE_INIT("file.txt", out);
+	struct file fin  = DATA_FILE_INIT("file.txt", in);
 
-	fout.f_version = out;
-	fin.f_version = in;
+	fout.f_data.f_version = out;
+	fin.f_data.f_version = in;
 
 	g_assert_true(data_file_open(&fout, OPEN_WRITE));
 	data_file_writef(&fout, "abcdefghijklmnopqrstuvwxyz");
@@ -142,7 +142,7 @@ static void __test_versioning_subprocess(unsigned int out, unsigned int in)
 	g_assert_true(data_file_exists(&fout));
 
 	g_assert_false(data_file_open(&fin, OPEN_READ));
-	g_assert_null(fin.f_file);
+	g_assert_null(fin.f_data.f_file);
 }
 
 static void test_versioning_old()
@@ -172,7 +172,7 @@ static void test_versioning_new()
 static void test_cache()
 {
 	gchar *basepath, *filepath, *writepath;
-	struct cache_file file, copy;
+	struct file file, copy;
 
 	cache_file_init(&file, "dir", "file.txt");
 	cache_file_init(&copy, "dir", "copy.txt");
@@ -181,9 +181,9 @@ static void test_cache()
 	filepath  = g_strjoin("/", basepath, "dir", "file.txt", NULL);
 	writepath = g_strjoin("/", basepath, "dir", ".file.txt.tmp", NULL);
 
-	g_assert_null(file.cf_file);
-	g_assert_cmpstr(file.cf_name, ==, "file.txt");
-	g_assert_cmpstr(file.cf_subdir, ==, "dir");
+	g_assert_null(file.f_cache.cf_file);
+	g_assert_cmpstr(file.f_cache.cf_name, ==, "file.txt");
+	g_assert_cmpstr(file.f_cache.cf_subdir, ==, "dir");
 
 	g_assert_cmpstr_free(cache_file_path(&file), ==, filepath);
 	g_assert_cmpstr_free(cache_file_write_path(&file), ==, writepath);
@@ -192,13 +192,13 @@ static void test_cache()
 	g_assert_false(cache_file_exists(&file));
 	g_assert_false(cache_file_open(&file, OPEN_READ));
 	g_assert_true(cache_file_open(&file, OPEN_WRITE));
-	g_assert_nonnull(file.cf_file);
+	g_assert_nonnull(file.f_cache.cf_file);
 	g_assert_false(cache_file_open(&file, OPEN_WRITE));
 
 	g_assert_false(cache_file_exists(&file));
 	g_assert_cmpuint(cache_file_write(&file, "abcde", 5), ==, 5);
 	cache_file_close(&file);
-	g_assert_null(file.cf_file);
+	g_assert_null(file.f_cache.cf_file);
 	g_assert_true(cache_file_exists(&file));
 
 	/* Test importing a file into the cache. */
diff --git a/tests/core/playlist.c b/tests/core/playlist.c
index 7f61d1e6..ad467fe6 100644
--- a/tests/core/playlist.c
+++ b/tests/core/playlist.c
@@ -329,7 +329,7 @@ static void test_save_load()
 	struct playlist q = DEFINE_PLAYLIST(PL_MAX_TYPE, "Test 2", 0, NULL);
 	struct playlist r = DEFINE_PLAYLIST(PL_MAX_TYPE, "Test",   0, &test_ops);
 	struct playlist s = DEFINE_PLAYLIST(PL_MAX_TYPE, "Test 2", 0, NULL);
-	struct data_file f = DATA_FILE_INIT("test.playlist", 0);
+	struct file f     = DATA_FILE_INIT("test.playlist", 0);
 	unsigned int    i;
 
 	for (i = 0; i < 13; i++) {
diff --git a/tests/core/settings.c b/tests/core/settings.c
index 7a85aed5..bab43854 100644
--- a/tests/core/settings.c
+++ b/tests/core/settings.c
@@ -7,7 +7,7 @@
 
 static void test_settings()
 {
-	struct data_file f = DATA_FILE_INIT("settings", 0);
+	struct file f = DATA_FILE_INIT("settings", 0);
 
 	settings_set(NULL, 0);
 	g_assert_cmpuint(settings_get(NULL), ==, 0);
diff --git a/tests/core/tags/album.c b/tests/core/tags/album.c
index 16e89729..5c8d9ba2 100644
--- a/tests/core/tags/album.c
+++ b/tests/core/tags/album.c
@@ -46,7 +46,7 @@ static void test_album()
 	struct album *album;
 	struct artist *koji;
 	struct genre *genre;
-	struct data_file f;
+	struct file f;
 
 	idle_init(IDLE_SYNC);
 
diff --git a/tests/core/tags/artist.c b/tests/core/tags/artist.c
index 7bb1c606..851f4dd2 100644
--- a/tests/core/tags/artist.c
+++ b/tests/core/tags/artist.c
@@ -31,7 +31,7 @@ static void test_artist()
 	const struct db_ops *artist_ops = test_artist_ops();
 	struct artist *artist;
 	unsigned int i;
-	struct data_file f;
+	struct file f;
 
 	artist = ARTIST(artist_ops->dbe_alloc("Koji Kondo", 0));
 
diff --git a/tests/core/tags/genre.c b/tests/core/tags/genre.c
index f9094ca0..357c6673 100644
--- a/tests/core/tags/genre.c
+++ b/tests/core/tags/genre.c
@@ -30,7 +30,7 @@ static void test_genre()
 	const struct db_ops *genre_ops = test_genre_ops();
 	struct genre *genre;
 	unsigned int i;
-	struct data_file f;
+	struct file f;
 
 	genre = GENRE(genre_ops->dbe_alloc("Video Game Music", 0));
 	test_verify_vg(genre);
diff --git a/tests/core/tags/library.c b/tests/core/tags/library.c
index f426440d..39283939 100644
--- a/tests/core/tags/library.c
+++ b/tests/core/tags/library.c
@@ -22,7 +22,7 @@ static void test_library()
 {
 	const struct db_ops *library_ops = test_library_ops();
 	struct library *link, *zelda, *library;
-	struct data_file f;
+	struct file f;
 
 	link  = LIBRARY(library_ops->dbe_alloc("/home/Link/Music",  0));
 	zelda = LIBRARY(library_ops->dbe_alloc("/home/Zelda/Music", 0));
diff --git a/tests/core/tags/track.c b/tests/core/tags/track.c
index 00106884..583eb19b 100644
--- a/tests/core/tags/track.c
+++ b/tests/core/tags/track.c
@@ -83,7 +83,7 @@ static void test_track()
 	time_t rawtime = time(NULL);
 	struct tm *now = localtime(&rawtime);
 	struct track   *track;
-	struct data_file f;
+	struct file f;
 	gchar *date;
 
 	data_file_init(&f, "track_tag", 1);