BDE'ify

1 files changed, 89 insertions, 79 deletions

diff --git a/lib/libc/stdlib/realpath.c b/lib/libc/stdlib/realpath.c
index 56ece3a..c269471 100644
--- a/lib/libc/stdlib/realpath.c
+++ b/lib/libc/stdlib/realpath.c
@@ -37,151 +37,161 @@ __FBSDID("$FreeBSD$");
 #include <sys/stat.h>
 
 #include <errno.h>
+#include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include "un-namespace.h"
 
 /*
- * char *realpath(const char *path, char resolved_path[PATH_MAX]);
+ * char *realpath(const char *path, char resolved[PATH_MAX]);
  *
  * Find the real name of path, by removing all ".", ".." and symlink
  * components.  Returns (resolved) on success, or (NULL) on failure,
  * in which case the path which caused trouble is left in (resolved).
  */
 char *
-realpath(const char *path, char resolved_path[PATH_MAX])
+realpath(const char *path, char resolved[PATH_MAX])
 {
-	unsigned num_symlinks = 0;
-	int saved_errno = errno;
-
-	char left[PATH_MAX];
+	struct stat sb;
+	char *p, *q, *s;
 	size_t left_len, resolved_len;
+	unsigned symlinks;
+	int serrno, slen;
+	char left[PATH_MAX], next_token[PATH_MAX], symlink[PATH_MAX];
 
+	serrno = errno;
+	symlinks = 0;
 	if (path[0] == '/') {
-		resolved_path[0] = '/';
-		resolved_path[1] = '\0';
+		resolved[0] = '/';
+		resolved[1] = '\0';
 		if (path[1] == '\0')
-			return resolved_path;
+			return (resolved);
 		resolved_len = 1;
-		left_len = strlcpy(left, path + 1, PATH_MAX);
+		left_len = strlcpy(left, path + 1, sizeof(left));
 	} else {
-		if (getcwd(resolved_path, PATH_MAX) == NULL) {
-			strlcpy(resolved_path, ".", PATH_MAX);
-			return NULL;
+		if (getcwd(resolved, PATH_MAX) == NULL) {
+			strlcpy(resolved, ".", PATH_MAX);
+			return (NULL);
 		}
-		resolved_len = strlen(resolved_path);
-		left_len = strlcpy(left, path, PATH_MAX);
+		resolved_len = strlen(resolved);
+		left_len = strlcpy(left, path, sizeof(left));
 	}
-	if (left_len >= PATH_MAX || resolved_len >= PATH_MAX) {
+	if (left_len >= sizeof(left) || resolved_len >= PATH_MAX) {
 		errno = ENAMETOOLONG;
-		return NULL;
+		return (NULL);
 	}
 
-	while (left_len > 0) {
-		struct stat st;
-		char next_token[PATH_MAX];
-		char *p;
-		char *s = (p = strchr(left, '/')) ? p : left + left_len;
-
-		memmove(next_token, left, s - left);
+	/*
+	 * Iterate over path components in `left'.
+	 */
+	while (left_len != 0) {
+		/*
+		 * Extract the next path component and adjust `left'
+		 * and its length.
+		 */
+		p = strchr(left, '/');
+		s = p ? p : left + left_len;
+		if (s - left >= sizeof(next_token)) {
+			errno = ENAMETOOLONG;
+			return (NULL);
+		}
+		memcpy(next_token, left, s - left);
+		next_token[s - left] = '\0';
 		left_len -= s - left;
 		if (p != NULL)
 			memmove(left, s + 1, left_len + 1);
-
-		next_token[s - left] = '\0';
-		if (resolved_path[resolved_len - 1] != '/') {
+		if (resolved[resolved_len - 1] != '/') {
 			if (resolved_len + 1 >= PATH_MAX) {
 				errno = ENAMETOOLONG;
-				return NULL;
+				return (NULL);
 			}
-
-			resolved_path[resolved_len++] = '/';
-			resolved_path[resolved_len] = '\0';
+			resolved[resolved_len++] = '/';
+			resolved[resolved_len] = '\0';
 		}
-
 		if (next_token[0] == '\0')
 			continue;
-		else if (!strcmp(next_token, "."))
+		else if (strcmp(next_token, ".") == 0)
 			continue;
-		else if (!strcmp(next_token, "..")) {
+		else if (strcmp(next_token, "..") == 0) {
+			/*
+			 * Strip the last path component except when we have
+			 * single "/"
+			 */
 			if (resolved_len > 1) {
-				char *q;
-
-				/* trailing slash */
-				resolved_path[resolved_len - 1] = '\0';
-
-				q = strrchr(resolved_path, '/');
+				resolved[resolved_len - 1] = '\0';
+				q = strrchr(resolved, '/');
 				*q = '\0';
-				resolved_len = q - resolved_path;
+				resolved_len = q - resolved;
 			}
 			continue;
 		}
 
-		/* filename */
-		resolved_len = strlcat(resolved_path, next_token, PATH_MAX);
+		/*
+		 * Append the next path component and lstat() it. If
+		 * lstat() fails we still can return successfully if
+		 * there are no more path components left.
+		 */
+		resolved_len = strlcat(resolved, next_token, PATH_MAX);
 		if (resolved_len >= PATH_MAX) {
 			errno = ENAMETOOLONG;
-			return NULL;
+			return (NULL);
 		}
-
-		if (lstat(resolved_path, &st) < 0) {
+		if (lstat(resolved, &sb) != 0) {
 			if (errno == ENOENT && p == NULL) {
-				errno = saved_errno;
-				return resolved_path;
+				errno = serrno;
+				return (resolved);
 			}
-
-			return NULL;
+			return (NULL);
 		}
-
-		if ((st.st_mode & S_IFLNK) == S_IFLNK) {
-			char symlink[PATH_MAX];
-			int slen;
-
-			if (num_symlinks++ > MAXSYMLINKS) {
+		if (S_ISLNK(sb.st_mode)) {
+			if (symlinks++ > MAXSYMLINKS) {
 				errno = ELOOP;
-				return NULL;
+				return (NULL);
 			}
-			slen = readlink(resolved_path, symlink, PATH_MAX - 1);
+			slen = readlink(resolved, symlink, sizeof(symlink) - 1);
 			if (slen < 0)
-				return NULL;
+				return (NULL);
 			symlink[slen] = '\0';
-
 			if (symlink[0] == '/') {
-				/* absolute link */
-				resolved_path[1] = 0;
+				resolved[1] = 0;
 				resolved_len = 1;
 			} else if (resolved_len > 1) {
-				char *q;
-
-				/* trailing slash */
-				resolved_path[resolved_len - 1] = '\0';
-
-				q = strrchr(resolved_path, '/');
+				/* Strip the last path component. */
+				resolved[resolved_len - 1] = '\0';
+				q = strrchr(resolved, '/');
 				*q = '\0';
-				resolved_len = q - resolved_path;
+				resolved_len = q - resolved;
 			}
 
+			/*
+			 * If there are any path components left, then
+			 * append them to symlink. The result is placed
+			 * in `left'.
+			 */
 			if (p != NULL) {
 				if (symlink[slen - 1] != '/') {
-					if (slen + 1 >= PATH_MAX) {
+					if (slen + 1 >= sizeof(symlink)) {
 						errno = ENAMETOOLONG;
-						return NULL;
+						return (NULL);
 					}
 					symlink[slen] = '/';
 					symlink[slen + 1] = 0;
 				}
-				left_len = strlcat(symlink, left, PATH_MAX);
-				if (left_len >= PATH_MAX) {
+				left_len = strlcat(symlink, left, sizeof(left));
+				if (left_len >= sizeof(left)) {
 					errno = ENAMETOOLONG;
-					return NULL;
+					return (NULL);
 				}
 			}
-			left_len = strlcpy(left, symlink, PATH_MAX);
+			left_len = strlcpy(left, symlink, sizeof(left));
 		}
 	}
 
-	if (resolved_len > 1 && resolved_path[resolved_len - 1] == '/')
-		resolved_path[resolved_len - 1] = '\0';
-
-	return resolved_path;
+	/*
+	 * Remove trailing slash except when the resolved pathname
+	 * is a single "/".
+	 */
+	if (resolved_len > 1 && resolved[resolved_len - 1] == '/')
+		resolved[resolved_len - 1] = '\0';
+	return (resolved);
 }