From eb62240bf67690a63b3d17626408d15408b93d57 Mon Sep 17 00:00:00 2001
From: Tavian Barnes <tavianator@tavianator.com>
Date: Sat, 22 Jun 2019 11:14:15 -0400
Subject: bftw: Rename bftw_dir to bftw_file

---
 bftw.c | 427 ++++++++++++++++++++++++++++++++---------------------------------
 1 file changed, 213 insertions(+), 214 deletions(-)

diff --git a/bftw.c b/bftw.c
index 1aed92e..9217456 100644
--- a/bftw.c
+++ b/bftw.c
@@ -17,17 +17,16 @@
 /**
  * The bftw() implementation consists of the following components:
  *
- * - struct bftw_dir: A directory that has been encountered during the
- *   traversal.  They have reference-counted links to their parents in the
- *   directory tree.
+ * - struct bftw_file: A file that has been encountered during the traversal.
+ *   They have reference-counted links to their parents in the directory tree.
  *
- * - struct bftw_cache: Holds bftw_dir's with open file descriptors, used for
+ * - struct bftw_cache: Holds bftw_file's with open file descriptors, used for
  *   openat() to minimize the amount of path re-traversals that need to happen.
  *   Currently implemented as a priority queue based on depth and reference
  *   count.
  *
- * - struct bftw_queue: The queue of bftw_dir's left to explore.  Implemented as
- *   a simple circular buffer.
+ * - struct bftw_queue: The queue of bftw_file's left to explore.  Implemented
+ *   as a simple circular buffer.
  *
  * - struct bftw_reader: A reader object that simplifies reading directories and
  *   reporting errors.
@@ -53,25 +52,25 @@
 #include <unistd.h>
 
 /**
- * A directory.
+ * A file.
  */
-struct bftw_dir {
+struct bftw_file {
 	/** The parent directory, if any. */
-	struct bftw_dir *parent;
-	/** This directory's depth in the walk. */
+	struct bftw_file *parent;
+	/** This file's depth in the walk. */
 	size_t depth;
-	/** The root path this directory was found from. */
+	/** The root path this file was found from. */
 	const char *root;
 
-	/** The next directory in the queue, if any. */
-	struct bftw_dir *next;
+	/** The next file in the queue, if any. */
+	struct bftw_file *next;
 
 	/** Reference count. */
 	size_t refcount;
 	/** Index in the bftw_cache priority queue. */
 	size_t heap_index;
 
-	/** An open file descriptor to this directory, or -1. */
+	/** An open descriptor to this file, or -1. */
 	int fd;
 
 	/** The device number, for cycle detection. */
@@ -79,11 +78,11 @@ struct bftw_dir {
 	/** The inode number, for cycle detection. */
 	ino_t ino;
 
-	/** The offset of this directory in the full path. */
+	/** The offset of this file in the full path. */
 	size_t nameoff;
-	/** The length of the directory's name. */
+	/** The length of the file's name. */
 	size_t namelen;
-	/** The directory's name. */
+	/** The file's name. */
 	char name[];
 };
 
@@ -92,7 +91,7 @@ struct bftw_dir {
  */
 struct bftw_cache {
 	/** A min-heap of open directories. */
-	struct bftw_dir **heap;
+	struct bftw_file **heap;
 	/** Current heap size. */
 	size_t size;
 	/** Maximum heap size. */
@@ -118,7 +117,7 @@ static void bftw_cache_destroy(struct bftw_cache *cache) {
 }
 
 /** Check if two heap entries are in heap order. */
-static bool bftw_heap_check(const struct bftw_dir *parent, const struct bftw_dir *child) {
+static bool bftw_heap_check(const struct bftw_file *parent, const struct bftw_file *child) {
 	if (parent->depth > child->depth) {
 		return true;
 	} else if (parent->depth < child->depth) {
@@ -128,20 +127,20 @@ static bool bftw_heap_check(const struct bftw_dir *parent, const struct bftw_dir
 	}
 }
 
-/** Move a bftw_dir to a particular place in the heap. */
-static void bftw_heap_move(struct bftw_cache *cache, struct bftw_dir *dir, size_t i) {
-	cache->heap[i] = dir;
-	dir->heap_index = i;
+/** Move a bftw_file to a particular place in the heap. */
+static void bftw_heap_move(struct bftw_cache *cache, struct bftw_file *file, size_t i) {
+	cache->heap[i] = file;
+	file->heap_index = i;
 }
 
 /** Bubble an entry up the heap. */
-static void bftw_heap_bubble_up(struct bftw_cache *cache, struct bftw_dir *dir) {
-	size_t i = dir->heap_index;
+static void bftw_heap_bubble_up(struct bftw_cache *cache, struct bftw_file *file) {
+	size_t i = file->heap_index;
 
 	while (i > 0) {
 		size_t pi = (i - 1)/2;
-		struct bftw_dir *parent = cache->heap[pi];
-		if (bftw_heap_check(parent, dir)) {
+		struct bftw_file *parent = cache->heap[pi];
+		if (bftw_heap_check(parent, file)) {
 			break;
 		}
 
@@ -149,12 +148,12 @@ static void bftw_heap_bubble_up(struct bftw_cache *cache, struct bftw_dir *dir)
 		i = pi;
 	}
 
-	bftw_heap_move(cache, dir, i);
+	bftw_heap_move(cache, file, i);
 }
 
 /** Bubble an entry down the heap. */
-static void bftw_heap_bubble_down(struct bftw_cache *cache, struct bftw_dir *dir) {
-	size_t i = dir->heap_index;
+static void bftw_heap_bubble_down(struct bftw_cache *cache, struct bftw_file *file) {
+	size_t i = file->heap_index;
 
 	while (true) {
 		size_t ci = 2*i + 1;
@@ -162,18 +161,18 @@ static void bftw_heap_bubble_down(struct bftw_cache *cache, struct bftw_dir *dir
 			break;
 		}
 
-		struct bftw_dir *child = cache->heap[ci];
+		struct bftw_file *child = cache->heap[ci];
 
 		size_t ri = ci + 1;
 		if (ri < cache->size) {
-			struct bftw_dir *right = cache->heap[ri];
+			struct bftw_file *right = cache->heap[ri];
 			if (!bftw_heap_check(child, right)) {
 				ci = ri;
 				child = right;
 			}
 		}
 
-		if (bftw_heap_check(dir, child)) {
+		if (bftw_heap_check(file, child)) {
 			break;
 		}
 
@@ -181,81 +180,81 @@ static void bftw_heap_bubble_down(struct bftw_cache *cache, struct bftw_dir *dir
 		i = ci;
 	}
 
-	bftw_heap_move(cache, dir, i);
+	bftw_heap_move(cache, file, i);
 }
 
 /** Bubble an entry up or down the heap. */
-static void bftw_heap_bubble(struct bftw_cache *cache, struct bftw_dir *dir) {
-	size_t i = dir->heap_index;
+static void bftw_heap_bubble(struct bftw_cache *cache, struct bftw_file *file) {
+	size_t i = file->heap_index;
 
 	if (i > 0) {
 		size_t pi = (i - 1)/2;
-		struct bftw_dir *parent = cache->heap[pi];
-		if (!bftw_heap_check(parent, dir)) {
-			bftw_heap_bubble_up(cache, dir);
+		struct bftw_file *parent = cache->heap[pi];
+		if (!bftw_heap_check(parent, file)) {
+			bftw_heap_bubble_up(cache, file);
 			return;
 		}
 	}
 
-	bftw_heap_bubble_down(cache, dir);
+	bftw_heap_bubble_down(cache, file);
 }
 
-/** Increment a bftw_dir's reference count. */
-static void bftw_dir_incref(struct bftw_cache *cache, struct bftw_dir *dir) {
-	++dir->refcount;
+/** Increment a bftw_file's reference count. */
+static void bftw_file_incref(struct bftw_cache *cache, struct bftw_file *file) {
+	++file->refcount;
 
-	if (dir->fd >= 0) {
-		bftw_heap_bubble_down(cache, dir);
+	if (file->fd >= 0) {
+		bftw_heap_bubble_down(cache, file);
 	}
 }
 
-/** Decrement a bftw_dir's reference count. */
-static void bftw_dir_decref(struct bftw_cache *cache, struct bftw_dir *dir) {
-	--dir->refcount;
+/** Decrement a bftw_file's reference count. */
+static void bftw_file_decref(struct bftw_cache *cache, struct bftw_file *file) {
+	--file->refcount;
 
-	if (dir->fd >= 0) {
-		bftw_heap_bubble_up(cache, dir);
+	if (file->fd >= 0) {
+		bftw_heap_bubble_up(cache, file);
 	}
 }
 
-/** Add a bftw_dir to the cache. */
-static void bftw_cache_add(struct bftw_cache *cache, struct bftw_dir *dir) {
+/** Add a bftw_file to the cache. */
+static void bftw_cache_add(struct bftw_cache *cache, struct bftw_file *file) {
 	assert(cache->size < cache->capacity);
-	assert(dir->fd >= 0);
+	assert(file->fd >= 0);
 
 	size_t size = cache->size++;
-	dir->heap_index = size;
-	bftw_heap_bubble_up(cache, dir);
+	file->heap_index = size;
+	bftw_heap_bubble_up(cache, file);
 }
 
-/** Remove a bftw_dir from the cache. */
-static void bftw_cache_remove(struct bftw_cache *cache, struct bftw_dir *dir) {
+/** Remove a bftw_file from the cache. */
+static void bftw_cache_remove(struct bftw_cache *cache, struct bftw_file *file) {
 	assert(cache->size > 0);
-	assert(dir->fd >= 0);
+	assert(file->fd >= 0);
 
 	size_t size = --cache->size;
-	size_t i = dir->heap_index;
+	size_t i = file->heap_index;
 	if (i != size) {
-		struct bftw_dir *end = cache->heap[size];
+		struct bftw_file *end = cache->heap[size];
 		end->heap_index = i;
 		bftw_heap_bubble(cache, end);
 	}
 }
 
-/** Close a bftw_dir. */
-static void bftw_dir_close(struct bftw_cache *cache, struct bftw_dir *dir) {
-	assert(dir->fd >= 0);
+/** Close a bftw_file. */
+static void bftw_file_close(struct bftw_cache *cache, struct bftw_file *file) {
+	assert(file->fd >= 0);
 
-	bftw_cache_remove(cache, dir);
+	bftw_cache_remove(cache, file);
 
-	close(dir->fd);
-	dir->fd = -1;
+	close(file->fd);
+	file->fd = -1;
 }
 
 /** Pop a directory from the cache. */
 static void bftw_cache_pop(struct bftw_cache *cache) {
 	assert(cache->size > 0);
-	bftw_dir_close(cache, cache->heap[0]);
+	bftw_file_close(cache, cache->heap[0]);
 }
 
 /**
@@ -264,23 +263,23 @@ static void bftw_cache_pop(struct bftw_cache *cache) {
  * @param cache
  *         The cache in question.
  * @param saved
- *         A bftw_dir that must be preserved.
+ *         A bftw_file that must be preserved.
  * @return
  *         0 if successfully shrunk, otherwise -1.
  */
-static int bftw_cache_shrink(struct bftw_cache *cache, const struct bftw_dir *saved) {
+static int bftw_cache_shrink(struct bftw_cache *cache, const struct bftw_file *saved) {
 	int ret = -1;
-	struct bftw_dir *dir = NULL;
+	struct bftw_file *file = NULL;
 
 	if (cache->size >= 1) {
-		dir = cache->heap[0];
-		if (dir == saved && cache->size >= 2) {
-			dir = cache->heap[1];
+		file = cache->heap[0];
+		if (file == saved && cache->size >= 2) {
+			file = cache->heap[1];
 		}
 	}
 
-	if (dir && dir != saved) {
-		bftw_dir_close(cache, dir);
+	if (file && file != saved) {
+		bftw_file_close(cache, file);
 		ret = 0;
 	}
 
@@ -289,7 +288,7 @@ static int bftw_cache_shrink(struct bftw_cache *cache, const struct bftw_dir *sa
 }
 
 /** Compute the name offset of a child path. */
-static size_t bftw_child_nameoff(const struct bftw_dir *parent) {
+static size_t bftw_child_nameoff(const struct bftw_file *parent) {
 	size_t ret = parent->nameoff + parent->namelen;
 	if (parent->name[parent->namelen - 1] != '/') {
 		++ret;
@@ -297,60 +296,60 @@ static size_t bftw_child_nameoff(const struct bftw_dir *parent) {
 	return ret;
 }
 
-/** Create a new bftw_dir. */
-static struct bftw_dir *bftw_dir_new(struct bftw_cache *cache, struct bftw_dir *parent, const char *name) {
+/** Create a new bftw_file. */
+static struct bftw_file *bftw_file_new(struct bftw_cache *cache, struct bftw_file *parent, const char *name) {
 	size_t namelen = strlen(name);
-	size_t size = sizeof(struct bftw_dir) + namelen + 1;
+	size_t size = sizeof(struct bftw_file) + namelen + 1;
 
-	struct bftw_dir *dir = malloc(size);
-	if (!dir) {
+	struct bftw_file *file = malloc(size);
+	if (!file) {
 		return NULL;
 	}
 
-	dir->parent = parent;
+	file->parent = parent;
 
 	if (parent) {
-		dir->depth = parent->depth + 1;
-		dir->root = parent->root;
-		dir->nameoff = bftw_child_nameoff(parent);
-		bftw_dir_incref(cache, parent);
+		file->depth = parent->depth + 1;
+		file->root = parent->root;
+		file->nameoff = bftw_child_nameoff(parent);
+		bftw_file_incref(cache, parent);
 	} else {
-		dir->depth = 0;
-		dir->root = name;
-		dir->nameoff = 0;
+		file->depth = 0;
+		file->root = name;
+		file->nameoff = 0;
 	}
 
-	dir->next = NULL;
+	file->next = NULL;
 
-	dir->refcount = 1;
-	dir->fd = -1;
+	file->refcount = 1;
+	file->fd = -1;
 
-	dir->dev = -1;
-	dir->ino = -1;
+	file->dev = -1;
+	file->ino = -1;
 
-	dir->namelen = namelen;
-	memcpy(dir->name, name, namelen + 1);
+	file->namelen = namelen;
+	memcpy(file->name, name, namelen + 1);
 
-	return dir;
+	return file;
 }
 
 /**
- * Compute the path to a bftw_dir.
+ * Compute the path to a bftw_file.
  */
-static int bftw_dir_path(const struct bftw_dir *dir, char **path) {
-	size_t pathlen = dir->nameoff + dir->namelen;
+static int bftw_file_path(const struct bftw_file *file, char **path) {
+	size_t pathlen = file->nameoff + file->namelen;
 	if (dstresize(path, pathlen) != 0) {
 		return -1;
 	}
 	char *dest = *path;
 
 	// Build the path backwards
-	while (dir) {
-		if (dir->nameoff > 0) {
-			dest[dir->nameoff - 1] = '/';
+	while (file) {
+		if (file->nameoff > 0) {
+			dest[file->nameoff - 1] = '/';
 		}
-		memcpy(dest + dir->nameoff, dir->name, dir->namelen);
-		dir = dir->parent;
+		memcpy(dest + file->nameoff, file->name, file->namelen);
+		file = file->parent;
 	}
 
 	return 0;
@@ -359,16 +358,16 @@ static int bftw_dir_path(const struct bftw_dir *dir, char **path) {
 /**
  * Get the appropriate (fd, path) pair for the *at() family of functions.
  *
- * @param dir
- *         The directory being accessed.
+ * @param file
+ *         The file being accessed.
  * @param[out] at_fd
  *         Will hold the appropriate file descriptor to use.
  * @param[in,out] at_path
  *         Will hold the appropriate path to use.
  * @return The closest open ancestor file.
  */
-static struct bftw_dir *bftw_dir_base(struct bftw_dir *dir, int *at_fd, const char **at_path) {
-	struct bftw_dir *base = dir;
+static struct bftw_file *bftw_file_base(struct bftw_file *file, int *at_fd, const char **at_path) {
+	struct bftw_file *base = file;
 
 	do {
 		base = base->parent;
@@ -383,23 +382,23 @@ static struct bftw_dir *bftw_dir_base(struct bftw_dir *dir, int *at_fd, const ch
 }
 
 /**
- * Open a bftw_dir relative to another one.
+ * Open a bftw_file relative to another one.
  *
  * @param cache
- *         The cache containing the dir.
- * @param dir
- *         The directory to open.
+ *         The cache to hold the file.
+ * @param file
+ *         The file to open.
  * @param base
  *         The base directory for the relative path (may be NULL).
  * @param at_fd
  *         The base file descriptor, AT_FDCWD if base == NULL.
  * @param at_path
- *         The relative path to the dir.
+ *         The relative path to the file.
  * @return
  *         The opened file descriptor, or negative on error.
  */
-static int bftw_dir_openat(struct bftw_cache *cache, struct bftw_dir *dir, const struct bftw_dir *base, int at_fd, const char *at_path) {
-	assert(dir->fd < 0);
+static int bftw_file_openat(struct bftw_cache *cache, struct bftw_file *file, const struct bftw_file *base, int at_fd, const char *at_path) {
+	assert(file->fd < 0);
 
 	int flags = O_RDONLY | O_CLOEXEC | O_DIRECTORY;
 	int fd = openat(at_fd, at_path, flags);
@@ -415,31 +414,31 @@ static int bftw_dir_openat(struct bftw_cache *cache, struct bftw_dir *dir, const
 			bftw_cache_pop(cache);
 		}
 
-		dir->fd = fd;
-		bftw_cache_add(cache, dir);
+		file->fd = fd;
+		bftw_cache_add(cache, file);
 	}
 
 	return fd;
 }
 
 /**
- * Open a bftw_dir.
+ * Open a bftw_file.
  *
  * @param cache
- *         The cache containing the directory.
- * @param dir
- *         The directory to open.
+ *         The cache to hold the file.
+ * @param file
+ *         The file to open.
  * @param path
- *         The full path to the dir.
+ *         The full path to the file.
  * @return
  *         The opened file descriptor, or negative on error.
  */
-static int bftw_dir_open(struct bftw_cache *cache, struct bftw_dir *dir, const char *path) {
+static int bftw_file_open(struct bftw_cache *cache, struct bftw_file *file, const char *path) {
 	int at_fd = AT_FDCWD;
 	const char *at_path = path;
-	struct bftw_dir *base = bftw_dir_base(dir, &at_fd, &at_path);
+	struct bftw_file *base = bftw_file_base(file, &at_fd, &at_path);
 
-	int fd = bftw_dir_openat(cache, dir, base, at_fd, at_path);
+	int fd = bftw_file_openat(cache, file, base, at_fd, at_path);
 	if (fd >= 0 || errno != ENAMETOOLONG) {
 		return fd;
 	}
@@ -448,24 +447,24 @@ static int bftw_dir_open(struct bftw_cache *cache, struct bftw_dir *dir, const c
 
 	// -1 to include the root, which has depth == 0
 	size_t offset = base ? base->depth : -1;
-	size_t levels = dir->depth - offset;
+	size_t levels = file->depth - offset;
 	if (levels < 2) {
 		return fd;
 	}
 
-	struct bftw_dir **parents = malloc(levels * sizeof(*parents));
+	struct bftw_file **parents = malloc(levels * sizeof(*parents));
 	if (!parents) {
 		return fd;
 	}
 
-	struct bftw_dir *parent = dir;
+	struct bftw_file *parent = file;
 	for (size_t i = levels; i-- > 0;) {
 		parents[i] = parent;
 		parent = parent->parent;
 	}
 
 	for (size_t i = 0; i < levels; ++i) {
-		fd = bftw_dir_openat(cache, parents[i], base, at_fd, parents[i]->name);
+		fd = bftw_file_openat(cache, parents[i], base, at_fd, parents[i]->name);
 		if (fd < 0) {
 			break;
 		}
@@ -479,19 +478,19 @@ static int bftw_dir_open(struct bftw_cache *cache, struct bftw_dir *dir, const c
 }
 
 /**
- * Open a DIR* for a bftw_dir.
+ * Open a DIR* for a bftw_file.
  *
  * @param cache
- *         The cache containing the directory.
- * @param dir
+ *         The cache to hold the file.
+ * @param file
  *         The directory to open.
  * @param path
  *         The full path to the directory.
  * @return
  *         The opened DIR *, or NULL on error.
  */
-static DIR *bftw_dir_opendir(struct bftw_cache *cache, struct bftw_dir *dir, const char *path) {
-	int fd = bftw_dir_open(cache, dir, path);
+static DIR *bftw_file_opendir(struct bftw_cache *cache, struct bftw_file *file, const char *path) {
+	int fd = bftw_file_open(cache, file, path);
 	if (fd < 0) {
 		return NULL;
 	}
@@ -504,7 +503,7 @@ static DIR *bftw_dir_opendir(struct bftw_cache *cache, struct bftw_dir *dir, con
 	int dfd = dup_cloexec(fd);
 
 	if (dfd < 0 && errno == EMFILE) {
-		if (bftw_cache_shrink(cache, dir) == 0) {
+		if (bftw_cache_shrink(cache, file) == 0) {
 			dfd = dup_cloexec(fd);
 		}
 	}
@@ -523,25 +522,25 @@ static DIR *bftw_dir_opendir(struct bftw_cache *cache, struct bftw_dir *dir, con
 	return ret;
 }
 
-/** Free a bftw_dir. */
-static void bftw_dir_free(struct bftw_cache *cache, struct bftw_dir *dir) {
-	assert(dir->refcount == 0);
+/** Free a bftw_file. */
+static void bftw_file_free(struct bftw_cache *cache, struct bftw_file *file) {
+	assert(file->refcount == 0);
 
-	if (dir->fd >= 0) {
-		bftw_dir_close(cache, dir);
+	if (file->fd >= 0) {
+		bftw_file_close(cache, file);
 	}
 
-	free(dir);
+	free(file);
 }
 
 /**
- * A queue of bftw_dir's to examine.
+ * A queue of bftw_file's to examine.
  */
 struct bftw_queue {
 	/** The head of the queue. */
-	struct bftw_dir *head;
+	struct bftw_file *head;
 	/** The tail of the queue. */
-	struct bftw_dir *tail;
+	struct bftw_file *tail;
 };
 
 /** Initialize a bftw_queue. */
@@ -550,17 +549,17 @@ static void bftw_queue_init(struct bftw_queue *queue) {
 	queue->tail = NULL;
 }
 
-/** Add a directory to the tail of the bftw_queue. */
-static void bftw_queue_push(struct bftw_queue *queue, struct bftw_dir *dir) {
-	assert(dir->next == NULL);
+/** Add a file to the tail of the bftw_queue. */
+static void bftw_queue_push(struct bftw_queue *queue, struct bftw_file *file) {
+	assert(file->next == NULL);
 
 	if (!queue->head) {
-		queue->head = dir;
+		queue->head = file;
 	}
 	if (queue->tail) {
-		queue->tail->next = dir;
+		queue->tail->next = file;
 	}
-	queue->tail = dir;
+	queue->tail = file;
 }
 
 /** Prepend a queue to the head of another one. */
@@ -578,25 +577,25 @@ static void bftw_queue_prepend(struct bftw_queue *head, struct bftw_queue *tail)
 	head->tail = NULL;
 }
 
-/** Pop the next directory from the head of the queue. */
-static struct bftw_dir *bftw_queue_pop(struct bftw_queue *queue) {
-	struct bftw_dir *dir = queue->head;
-	queue->head = dir->next;
-	if (queue->tail == dir) {
+/** Pop the next file from the head of the queue. */
+static struct bftw_file *bftw_queue_pop(struct bftw_queue *queue) {
+	struct bftw_file *file = queue->head;
+	queue->head = file->next;
+	if (queue->tail == file) {
 		queue->tail = NULL;
 	}
-	dir->next = NULL;
-	return dir;
+	file->next = NULL;
+	return file;
 }
 
 /**
  * A directory reader.
  */
 struct bftw_reader {
-	/** The directory object. */
-	struct bftw_dir *dir;
+	/** The file object. */
+	struct bftw_file *file;
 	/** The open handle to the directory. */
-	DIR *handle;
+	DIR *dir;
 	/** The current directory entry. */
 	struct dirent *de;
 	/** Any error code that has occurred. */
@@ -605,23 +604,23 @@ struct bftw_reader {
 
 /** Initialize a reader. */
 static void bftw_reader_init(struct bftw_reader *reader) {
+	reader->file = NULL;
 	reader->dir = NULL;
-	reader->handle = NULL;
 	reader->de = NULL;
 	reader->error = 0;
 }
 
 /** Open a directory for reading. */
-static int bftw_reader_open(struct bftw_reader *reader, struct bftw_cache *cache, struct bftw_dir *dir, const char *path) {
+static int bftw_reader_open(struct bftw_reader *reader, struct bftw_cache *cache, struct bftw_file *file, const char *path) {
+	assert(!reader->file);
 	assert(!reader->dir);
-	assert(!reader->handle);
 	assert(!reader->de);
 
-	reader->dir = dir;
+	reader->file = file;
 	reader->error = 0;
 
-	reader->handle = bftw_dir_opendir(cache, dir, path);
-	if (!reader->handle) {
+	reader->dir = bftw_file_opendir(cache, file, path);
+	if (!reader->dir) {
 		reader->error = errno;
 		return -1;
 	}
@@ -631,11 +630,11 @@ static int bftw_reader_open(struct bftw_reader *reader, struct bftw_cache *cache
 
 /** Read a directory entry. */
 static int bftw_reader_read(struct bftw_reader *reader) {
-	if (!reader->handle) {
+	if (!reader->dir) {
 		return -1;
 	}
 
-	if (xreaddir(reader->handle, &reader->de) != 0) {
+	if (xreaddir(reader->dir, &reader->de) != 0) {
 		reader->error = errno;
 		return -1;
 	} else if (reader->de) {
@@ -648,14 +647,14 @@ static int bftw_reader_read(struct bftw_reader *reader) {
 /** Close a directory. */
 static int bftw_reader_close(struct bftw_reader *reader) {
 	int ret = 0;
-	if (reader->handle && closedir(reader->handle) != 0) {
+	if (reader->dir && closedir(reader->dir) != 0) {
 		reader->error = errno;
 		ret = -1;
 	}
 
 	reader->de = NULL;
-	reader->handle = NULL;
 	reader->dir = NULL;
+	reader->file = NULL;
 	return ret;
 }
 
@@ -885,8 +884,8 @@ enum bftw_typeflag bftw_typeflag(const struct BFTW *ftwbuf, enum bfs_stat_flag f
 /**
  * Update the path for the current file.
  */
-static int bftw_update_path(struct bftw_state *state, const struct bftw_dir *dir, const char *name) {
-	size_t length = dir ? dir->nameoff + dir->namelen : 0;
+static int bftw_update_path(struct bftw_state *state, const struct bftw_file *file, const char *name) {
+	size_t length = file ? file->nameoff + file->namelen : 0;
 
 	assert(dstrlen(state->path) >= length);
 	dstresize(&state->path, length);
@@ -949,13 +948,13 @@ static void bftw_stat_init(struct bftw_stat *cache) {
 /**
  * Initialize the buffers with data about the current path.
  */
-static void bftw_init_ftwbuf(struct bftw_state *state, struct bftw_dir *dir, enum bftw_visit visit) {
+static void bftw_init_ftwbuf(struct bftw_state *state, struct bftw_file *file, enum bftw_visit visit) {
 	const struct bftw_reader *reader = &state->reader;
 	const struct dirent *de = reader->de;
 
 	struct BFTW *ftwbuf = &state->ftwbuf;
 	ftwbuf->path = state->path;
-	ftwbuf->root = dir ? dir->root : ftwbuf->path;
+	ftwbuf->root = file ? file->root : ftwbuf->path;
 	ftwbuf->depth = 0;
 	ftwbuf->visit = visit;
 	ftwbuf->error = reader->error;
@@ -965,18 +964,18 @@ static void bftw_init_ftwbuf(struct bftw_state *state, struct bftw_dir *dir, enu
 	bftw_stat_init(&ftwbuf->lstat_cache);
 	bftw_stat_init(&ftwbuf->stat_cache);
 
-	if (dir) {
-		ftwbuf->depth = dir->depth;
+	if (file) {
+		ftwbuf->depth = file->depth;
 
 		if (de) {
 			++ftwbuf->depth;
-			ftwbuf->nameoff = bftw_child_nameoff(dir);
+			ftwbuf->nameoff = bftw_child_nameoff(file);
 
-			ftwbuf->at_fd = dir->fd;
+			ftwbuf->at_fd = file->fd;
 			ftwbuf->at_path += ftwbuf->nameoff;
 		} else {
-			ftwbuf->nameoff = dir->nameoff;
-			bftw_dir_base(dir, &ftwbuf->at_fd, &ftwbuf->at_path);
+			ftwbuf->nameoff = file->nameoff;
+			bftw_file_base(file, &ftwbuf->at_fd, &ftwbuf->at_path);
 		}
 	}
 
@@ -1018,7 +1017,7 @@ static void bftw_init_ftwbuf(struct bftw_state *state, struct bftw_dir *dir, enu
 	}
 
 	if (ftwbuf->typeflag == BFTW_DIR && (state->flags & BFTW_DETECT_CYCLES)) {
-		for (const struct bftw_dir *parent = dir; parent; parent = parent->parent) {
+		for (const struct bftw_file *parent = file; parent; parent = parent->parent) {
 			if (parent->depth == ftwbuf->depth) {
 				continue;
 			}
@@ -1034,14 +1033,14 @@ static void bftw_init_ftwbuf(struct bftw_state *state, struct bftw_dir *dir, enu
 /**
  * Visit a path, invoking the callback.
  */
-static enum bftw_action bftw_visit(struct bftw_state *state, struct bftw_dir *dir, const char *name, enum bftw_visit visit) {
-	if (bftw_update_path(state, dir, name) != 0) {
+static enum bftw_action bftw_visit(struct bftw_state *state, struct bftw_file *file, const char *name, enum bftw_visit visit) {
+	if (bftw_update_path(state, file, name) != 0) {
 		state->error = errno;
 		return BFTW_STOP;
 	}
 
 	const struct BFTW *ftwbuf = &state->ftwbuf;
-	bftw_init_ftwbuf(state, dir, visit);
+	bftw_init_ftwbuf(state, file, visit);
 
 	// Never give the callback BFTW_ERROR unless BFTW_RECOVER is specified
 	if (ftwbuf->typeflag == BFTW_ERROR && !(state->flags & BFTW_RECOVER)) {
@@ -1066,9 +1065,9 @@ static enum bftw_action bftw_visit(struct bftw_state *state, struct bftw_dir *di
 		return BFTW_SKIP_SUBTREE;
 	}
 
-	if ((state->flags & BFTW_XDEV) && dir) {
+	if ((state->flags & BFTW_XDEV) && file) {
 		const struct bfs_stat *statbuf = bftw_stat(ftwbuf, ftwbuf->stat_flags);
-		if (statbuf && statbuf->dev != dir->dev) {
+		if (statbuf && statbuf->dev != file->dev) {
 			return BFTW_SKIP_SUBTREE;
 		}
 	}
@@ -1077,12 +1076,12 @@ static enum bftw_action bftw_visit(struct bftw_state *state, struct bftw_dir *di
 }
 
 /**
- * Push a new directory onto the queue.
+ * Push a new file onto the queue.
  */
 static int bftw_push(struct bftw_state *state, const char *name) {
-	struct bftw_dir *parent = state->reader.dir;
-	struct bftw_dir *dir = bftw_dir_new(&state->cache, parent, name);
-	if (!dir) {
+	struct bftw_file *parent = state->reader.file;
+	struct bftw_file *file = bftw_file_new(&state->cache, parent, name);
+	if (!file) {
 		state->error = errno;
 		return -1;
 	}
@@ -1093,14 +1092,14 @@ static int bftw_push(struct bftw_state *state, const char *name) {
 		statbuf = ftwbuf->lstat_cache.buf;
 	}
 	if (statbuf) {
-		dir->dev = statbuf->dev;
-		dir->ino = statbuf->ino;
+		file->dev = statbuf->dev;
+		file->ino = statbuf->ino;
 	}
 
 	if (state->strategy == BFTW_DFS) {
-		bftw_queue_push(&state->prequeue, dir);
+		bftw_queue_push(&state->prequeue, file);
 	} else {
-		bftw_queue_push(&state->queue, dir);
+		bftw_queue_push(&state->queue, file);
 	}
 	return 0;
 }
@@ -1118,61 +1117,61 @@ static struct bftw_reader *bftw_pop(struct bftw_state *state) {
 	}
 
 	struct bftw_reader *reader = &state->reader;
-	struct bftw_dir *dir = state->queue.head;
-	if (bftw_dir_path(dir, &state->path) != 0) {
+	struct bftw_file *file = state->queue.head;
+	if (bftw_file_path(file, &state->path) != 0) {
 		state->error = errno;
 		return NULL;
 	}
 
 	bftw_queue_pop(&state->queue);
-	bftw_reader_open(reader, &state->cache, dir, state->path);
+	bftw_reader_open(reader, &state->cache, file, state->path);
 	return reader;
 }
 
 /**
- * Finalize and free a directory we're done with.
+ * Finalize and free a file we're done with.
  */
-static enum bftw_action bftw_release_dir(struct bftw_state *state, struct bftw_dir *dir, bool do_visit) {
+static enum bftw_action bftw_release_file(struct bftw_state *state, struct bftw_file *file, bool do_visit) {
 	enum bftw_action ret = BFTW_CONTINUE;
 
 	if (!(state->flags & BFTW_DEPTH)) {
 		do_visit = false;
 	}
 
-	while (dir) {
-		bftw_dir_decref(&state->cache, dir);
-		if (dir->refcount > 0) {
+	while (file) {
+		bftw_file_decref(&state->cache, file);
+		if (file->refcount > 0) {
 			break;
 		}
 
 		if (do_visit) {
-			if (bftw_visit(state, dir, NULL, BFTW_POST) == BFTW_STOP) {
+			if (bftw_visit(state, file, NULL, BFTW_POST) == BFTW_STOP) {
 				ret = BFTW_STOP;
 				do_visit = false;
 			}
 		}
 
-		struct bftw_dir *parent = dir->parent;
-		bftw_dir_free(&state->cache, dir);
-		dir = parent;
+		struct bftw_file *parent = file->parent;
+		bftw_file_free(&state->cache, file);
+		file = parent;
 	}
 
 	return ret;
 }
 
 /**
- * Close and release a reader.
+ * Close and release the reader.
  */
 static enum bftw_action bftw_release_reader(struct bftw_state *state, bool do_visit) {
 	enum bftw_action ret = BFTW_CONTINUE;
 
 	struct bftw_reader *reader = &state->reader;
-	struct bftw_dir *dir = reader->dir;
+	struct bftw_file *file = reader->file;
 	bftw_reader_close(reader);
 
 	if (reader->error != 0) {
 		if (do_visit) {
-			if (bftw_visit(state, dir, NULL, BFTW_PRE) == BFTW_STOP) {
+			if (bftw_visit(state, file, NULL, BFTW_PRE) == BFTW_STOP) {
 				ret = BFTW_STOP;
 				do_visit = false;
 			}
@@ -1182,7 +1181,7 @@ static enum bftw_action bftw_release_reader(struct bftw_state *state, bool do_vi
 		reader->error = 0;
 	}
 
-	if (bftw_release_dir(state, dir, do_visit) == BFTW_STOP) {
+	if (bftw_release_file(state, file, do_visit) == BFTW_STOP) {
 		ret = BFTW_STOP;
 	}
 
@@ -1194,8 +1193,8 @@ static enum bftw_action bftw_release_reader(struct bftw_state *state, bool do_vi
  */
 static void bftw_drain_queue(struct bftw_state *state, struct bftw_queue *queue) {
 	while (queue->head) {
-		struct bftw_dir *dir = bftw_queue_pop(queue);
-		bftw_release_dir(state, dir, false);
+		struct bftw_file *file = bftw_queue_pop(queue);
+		bftw_release_file(state, file, false);
 	}
 }
 
@@ -1256,7 +1255,7 @@ start:
 		while (bftw_reader_read(reader) > 0) {
 			const char *name = reader->de->d_name;
 
-			switch (bftw_visit(&state, reader->dir, name, BFTW_PRE)) {
+			switch (bftw_visit(&state, reader->file, name, BFTW_PRE)) {
 			case BFTW_CONTINUE:
 				break;
 			case BFTW_SKIP_SIBLINGS:
-- 
cgit v1.2.3