--- acl-2.2.39/getfacl/getfacl.c.walk	2006-06-20 08:51:25.000000000 +0200

+++ acl-2.2.39/getfacl/getfacl.c	2007-03-21 10:52:07.000000000 +0100

@@ -34,7 +34,6 @@

 #include <dirent.h>

 #include <libgen.h>

 #include <getopt.h>

-#include <ftw.h>

 #include <locale.h>

 #include "config.h"

 #include "user_group.h"

@@ -70,9 +69,9 @@

 const char *progname;

 const char *cmd_line_options;

-int opt_recursive;  /* recurse into sub-directories? */

-int opt_walk_logical;  /* always follow symbolic links */

-int opt_walk_physical;  /* never follow symbolic links */

+int opt_recursive = 0;  /* recurse into sub-directories? */

+int opt_walk_logical = 0;  /* always follow symbolic links */

+int opt_walk_physical = 0;  /* never follow symbolic links */

 int opt_print_acl = 0;

 int opt_print_default_acl = 0;

 int opt_strip_leading_slash = 1;

@@ -562,71 +561,140 @@

 static int __errors;

-int __do_print(const char *file, const struct stat *stat,

-               int flag, struct FTW *ftw)

+

+int walk_tree(const char *file)

 {

-	int saved_errno = errno;

+	static int level = 0;

+	static int link_count = 0;

+	DIR *dir;

+	struct dirent *entry;

+	struct stat buf;

+	char path[FILENAME_MAX];

+	char path2[FILENAME_MAX];

+	char path3[FILENAME_MAX];

+	char *dir_name;

+	size_t len;

+	ssize_t slen;

+	int res;

 	/* Process the target of a symbolic link, and traverse the link,

            only if doing a logical walk, or if the symbolic link was

            specified on the command line. Always skip symbolic links if

            doing a physical walk. */

-	if (S_ISLNK(stat->st_mode) &&

-	    (opt_walk_physical || (ftw->level > 0 && !opt_walk_logical)))

+	len = strlen(file);

+	/* check for FILENAME_MAX */

+	if (len >= FILENAME_MAX) {

+		fprintf(stderr, "%s: %s: %s\n", progname, xquote(file),

+			strerror(ENAMETOOLONG));

+		__errors++;

 		return 0;

+	}

+	/* string ends with '/', remove it and restart */

+	if (len > 1 && file[len-1] == '/') {

+		strncpy(path, file, len);

+		path[len-1] = '\0'; /* overwrite slash */

+		return walk_tree(path);

+	}

-	if (do_print(file, stat))

-		__errors++;

+	if (level > 0 && !opt_recursive)

+		return 0;

-	if (flag == FTW_DNR && opt_recursive) {

-		/* Item is a directory which can't be read. */

-		fprintf(stderr, "%s: %s: %s\n",

-			progname, file, strerror(saved_errno));

+	if (lstat(file, &buf) != 0) {

+		fprintf(stderr, "%s: %s: %s\n", progname, xquote(file),

+			strerror(errno));

+		__errors++;

 		return 0;

 	}

-	/* We also get here in non-recursive mode. In that case,

-	   return something != 0 to abort nftw. */

+	if (S_ISLNK(buf.st_mode)) {

+		/* physical means: no links at all */

+		if (opt_walk_physical)

+			return 1;

+

+		/* logical: show information or walk if points to directory

+		 * also for symbolic link arguments on level 0 */

+		if (opt_walk_logical || level == 0) {

+			/* copy and append terminating '\0' */

+			strncpy(path2, file, len+1);

+

+			/* get directory name */

+			dir_name = dirname(path2);

+

+			/* get link target */

+			slen = readlink(file, path, FILENAME_MAX-1);

+			if (slen < 0) {

+				fprintf(stderr, "%s: %s: %s\n", progname,

+					xquote(file), strerror(errno));

+				__errors++;

+				return 0;

+			}

+			path[slen] = '\0';

-	if (!opt_recursive)

-		return 1;

+			if (slen == 0 || path[0] == '/') {

+				/* absolute:

+				 * copy and append terminating '\0' */

+				strncpy(path3, path, slen+1);

+			} else

+				/* relative */

+				snprintf(path3, FILENAME_MAX, "%s/%s",

+					 dir_name, path);

+			

+			if (lstat(path3, &buf) != 0) {

+				fprintf(stderr, "%s: %s: %s\n", progname,

+					xquote(path), strerror(errno));

+				__errors++;

+				return 0;

+			}

-	return 0;

-}

+			if ((S_ISDIR(buf.st_mode) && opt_recursive && 

+			     link_count < 1) || S_ISLNK(buf.st_mode)) {

+				/* walk directory or follow symlink on level

+				 * 0 */

+				link_count++;

+				res = walk_tree(path3);

+				link_count--;

+				if (res != 1)

+					return 0;

+			} else

+				if (do_print(path3, &buf))

+					__errors++;

-char *resolve_symlinks(const char *file)

-{

-	static char buffer[4096];

-	char *path = NULL;

-	ssize_t len;

-

-	len = readlink(file, buffer, sizeof(buffer)-1);

-	if (len < 0) {

-		if (errno == EINVAL)	/* not a symlink, use given path */

-			path = (char *)file;

-	} else {

-		buffer[len+1] = '\0';

-		path = buffer;

+			return 1;

+		}

 	}

-	return path;

-}

-

-int walk_tree(const char *file)

-{

-	const char *p;

-	__errors = 0;

-	if ((p = resolve_symlinks(file)) == NULL) {

-		fprintf(stderr, "%s: %s: %s\n", progname,

-			xquote(file), strerror(errno));

-		__errors++;

-	} else if (nftw(p, __do_print, 0, opt_walk_logical? 0 : FTW_PHYS) < 0) {

-		fprintf(stderr, "%s: %s: %s\n", progname, xquote(file),

-			strerror(errno));

+	if (do_print(file, &buf))

 		__errors++;

+

+	/* it is a directory, walk */

+	if (S_ISDIR(buf.st_mode)) {

+		dir = opendir(file);

+		if (!dir) {

+			fprintf(stderr, "%s: %s: %s\n", progname,

+				xquote(file), strerror(errno));

+			__errors++;

+			return 0;

+		}

+

+		level++;

+		while ((entry = readdir(dir)) != NULL) {

+			if (! strcmp(entry->d_name, ".") || 

+			    ! strcmp(entry->d_name, ".."))

+				continue;

+

+			snprintf(path, FILENAME_MAX, "%s/%s", file,

+				 entry->d_name);

+

+			/* ignore result, walk every entry */

+			res = walk_tree(path);

+		}

+		level--;

+

+		closedir(dir);

 	}

-	return __errors;

+

+	return 1;

 }

 int main(int argc, char *argv[])

@@ -762,15 +830,22 @@

 				if (*line == '\0')

 					continue;

-				had_errors += walk_tree(line);

+				/* ignore result of walk_tree, use __errors */

+				__errors = 0;

+				walk_tree(line);

+				had_errors += __errors;

 			}

 			if (!feof(stdin)) {

 				fprintf(stderr, _("%s: Standard input: %s\n"),

 				        progname, strerror(errno));

 				had_errors++;

 			}

-		} else

-			had_errors += walk_tree(argv[optind]);

+		} else {

+			/* ignore result of walk_tree, use __errors */

+			__errors = 0;

+			walk_tree(argv[optind]);

+			had_errors += __errors;

+		}

 		optind++;

 	} while (optind < argc);