misc-utils/namei.c - manifest_repos/util-linux - Git at Google

 /*
  * Copyright (C) 2008 Karel Zak <kzak@redhat.com>
  *
  * This file is part of util-linux.
  *
  * This file is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This file is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * The original namei(1) was written by:
  *	Roger S. Southwick (May 2, 1990)
  *	Steve Tell (March 28, 1991)
  *	Arkadiusz Miśkiewicz (1999-02-22)
  *	Li Zefan (2007-09-10).
  */

 #include <stdio.h>
 #include <unistd.h>
 #include <getopt.h>
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/param.h>
 #include <pwd.h>
 #include <grp.h>

 #include "c.h"
 #include "xalloc.h"
 #include "nls.h"
 #include "widechar.h"
 #include "strutils.h"
 #include "closestream.h"
 #include "idcache.h"

 #ifndef MAXSYMLINKS
 #define MAXSYMLINKS 256
 #endif

 #define NAMEI_NOLINKS	(1 << 1)
 #define NAMEI_MODES	(1 << 2)
 #define NAMEI_MNTS	(1 << 3)
 #define NAMEI_OWNERS	(1 << 4)
 #define NAMEI_VERTICAL	(1 << 5)


 struct namei {
 	struct stat	st;		/* item lstat() */
 	char		*name;		/* item name */
 	char		*abslink;	/* absolute symlink path */
 	int		relstart;	/* offset of relative path in 'abslink' */
 	struct namei	*next;		/* next item */
 	int		level;
 	int		mountpoint;	/* is mount point */
 	int		noent;		/* this item not existing (stores errno from stat()) */
 };

 static int flags;
 static struct idcache *gcache;	/* groupnames */
 static struct idcache *ucache;	/* usernames */

 static void
 free_namei(struct namei *nm)
 {
 	while (nm) {
 		struct namei *next = nm->next;
 		free(nm->name);
 		free(nm->abslink);
 		free(nm);
 		nm = next;
 	}
 }

 static void
 readlink_to_namei(struct namei *nm, const char *path)
 {
 	char sym[PATH_MAX];
 	ssize_t sz;
 	int isrel = 0;

 	sz = readlink(path, sym, sizeof(sym));
 	if (sz < 1)
 		err(EXIT_FAILURE, _("failed to read symlink: %s"), path);
 	if (*sym != '/') {
 		char *p = strrchr(path, '/');

 		if (p) {
 			isrel = 1;
 			nm->relstart = p - path;
 			sz += nm->relstart + 1;
 		}
 	}
 	nm->abslink = xmalloc(sz + 1);

 	if (*sym != '/' && isrel) {
 		/* create the absolute path from the relative symlink */
 		memcpy(nm->abslink, path, nm->relstart);
 		*(nm->abslink + nm->relstart) = '/';
 		nm->relstart++;
 		memcpy(nm->abslink + nm->relstart, sym, sz - nm->relstart);
 	} else
 		/* - absolute link (foo -> /path/bar)
 		 * - or link without any subdir (foo -> bar)
 		 */
 		memcpy(nm->abslink, sym, sz);

 	nm->abslink[sz] = '\0';
 }

 static struct stat *
 dotdot_stat(const char *dirname, struct stat *st)
 {
 	char *path;
 	size_t len;

 #define DOTDOTDIR	"/.."

 	if (!dirname)
 		return NULL;

 	len = strlen(dirname);
 	path = xmalloc(len + sizeof(DOTDOTDIR));

 	memcpy(path, dirname, len);
 	memcpy(path + len, DOTDOTDIR, sizeof(DOTDOTDIR));

 	if (stat(path, st))
 		err(EXIT_FAILURE, _("stat of %s failed"), path);
 	free(path);
 	return st;
 }

 static struct namei *
 new_namei(struct namei *parent, const char *path, const char *fname, int lev)
 {
 	struct namei *nm;

 	if (!fname)
 		return NULL;
 	nm = xcalloc(1, sizeof(*nm));
 	if (parent)
 		parent->next = nm;

 	nm->level = lev;
 	nm->name = xstrdup(fname);

 	if (lstat(path, &nm->st) != 0) {
 		nm->noent = errno;
 		return nm;
 	}

 	if (S_ISLNK(nm->st.st_mode))
 		readlink_to_namei(nm, path);
 	if (flags & NAMEI_OWNERS) {
 		add_uid(ucache, nm->st.st_uid);
 		add_gid(gcache, nm->st.st_gid);
 	}

 	if ((flags & NAMEI_MNTS) && S_ISDIR(nm->st.st_mode)) {
 		struct stat stbuf, *sb = NULL;

 		if (parent && S_ISDIR(parent->st.st_mode))
 			sb = &parent->st;
 		else if (!parent || S_ISLNK(parent->st.st_mode))
 			sb = dotdot_stat(path, &stbuf);

 		if (sb && (sb->st_dev != nm->st.st_dev ||   /* different device */
 		           sb->st_ino == nm->st.st_ino))    /* root directory */
 			nm->mountpoint = 1;
 	}

 	return nm;
 }

 static struct namei *
 add_namei(struct namei *parent, const char *orgpath, int start, struct namei **last)
 {
 	struct namei *nm = NULL, *first = NULL;
 	char *fname, *end, *path;
 	int level = 0;

 	if (!orgpath)
 		return NULL;
 	if (parent) {
 		nm = parent;
 		level = parent->level + 1;
 	}
 	path = xstrdup(orgpath);
 	fname = path + start;

 	/* root directory */
 	if (*fname == '/') {
 		while (*fname == '/')
 			fname++; /* eat extra '/' */
 		first = nm = new_namei(nm, "/", "/", level);
 	}

 	for (end = fname; fname && end; ) {
 		/* set end of filename */
 		if (*fname) {
 			end = strchr(fname, '/');
 			if (end)
 				*end = '\0';

 			/* create a new entry */
 			nm = new_namei(nm, path, fname, level);
 		} else
 			end = NULL;
 		if (!first)
 			first = nm;
 		/* set begin of the next filename */
 		if (end) {
 			*end++ = '/';
 			while (*end == '/')
 				end++; /* eat extra '/' */
 		}
 		fname = end;
 	}

 	if (last)
 		*last = nm;

 	free(path);

 	return first;
 }

 static int
 follow_symlinks(struct namei *nm)
 {
 	int symcount = 0;

 	for (; nm; nm = nm->next) {
 		struct namei *next, *last;

 		if (nm->noent)
 			continue;
 		if (!S_ISLNK(nm->st.st_mode))
 			continue;
 		if (++symcount > MAXSYMLINKS) {
 			/* drop the rest of the list */
 			free_namei(nm->next);
 			nm->next = NULL;
 			return -1;
 		}
 		next = nm->next;
 		nm->next = add_namei(nm, nm->abslink, nm->relstart, &last);
 		if (last)
 			last->next = next;
 		else
 			nm->next = next;
 	}
 	return 0;
 }

 static int
 print_namei(struct namei *nm, char *path)
 {
 	int i;

 	if (path)
 		printf("f: %s\n", path);

 	for (; nm; nm = nm->next) {
 		char md[11];

 		if (nm->noent) {
 			int blanks = 1;
 			if (flags & NAMEI_MODES)
 				blanks += 9;
 			if (flags & NAMEI_OWNERS)
 				blanks += ucache->width + gcache->width + 2;
 			if (!(flags & NAMEI_VERTICAL))
 				blanks += 1;
 			blanks += nm->level * 2;
 			printf("%*s ", blanks, "");
 			printf("%s - %s\n", nm->name, strerror(nm->noent));
 			return -1;
 		}

 		xstrmode(nm->st.st_mode, md);

 		if (nm->mountpoint)
 			md[0] = 'D';

 		if (!(flags & NAMEI_VERTICAL)) {
 			for (i = 0; i < nm->level; i++)
 				fputs("  ", stdout);
 			fputc(' ', stdout);
 		}

 		if (flags & NAMEI_MODES)
 			printf("%s", md);
 		else
 			printf("%c", md[0]);

 		if (flags & NAMEI_OWNERS) {
 			printf(" %-*s", ucache->width,
 				get_id(ucache, nm->st.st_uid)->name);
 			printf(" %-*s", gcache->width,
 				get_id(gcache, nm->st.st_gid)->name);
 		}

 		if (flags & NAMEI_VERTICAL)
 			for (i = 0; i < nm->level; i++)
 				fputs("  ", stdout);

 		if (S_ISLNK(nm->st.st_mode))
 			printf(" %s -> %s\n", nm->name,
 					nm->abslink + nm->relstart);
 		else
 			printf(" %s\n", nm->name);
 	}
 	return 0;
 }

 static void __attribute__((__noreturn__)) usage(void)
 {
 	const char *p = program_invocation_short_name;
 	FILE *out = stdout;

 	if (!*p)
 		p = "namei";

 	fputs(USAGE_HEADER, out);
 	fprintf(out,
 	      _(" %s [options] <pathname>...\n"), p);

 	fputs(USAGE_SEPARATOR, out);
 	fputs(_("Follow a pathname until a terminal point is found.\n"), out);

 	fputs(USAGE_OPTIONS, out);
 	fputs(_(
 		" -x, --mountpoints   show mount point directories with a 'D'\n"
 		" -m, --modes         show the mode bits of each file\n"
 		" -o, --owners        show owner and group name of each file\n"
 		" -l, --long          use a long listing format (-m -o -v) \n"
 		" -n, --nosymlinks    don't follow symlinks\n"
 		" -v, --vertical      vertical align of modes and owners\n"), out);
 	printf(USAGE_HELP_OPTIONS(21));

 	printf(USAGE_MAN_TAIL("namei(1)"));
 	exit(EXIT_SUCCESS);
 }

 static const struct option longopts[] =
 {
 	{ "help",	 no_argument, NULL, 'h' },
 	{ "version",     no_argument, NULL, 'V' },
 	{ "mountpoints", no_argument, NULL, 'x' },
 	{ "modes",	 no_argument, NULL, 'm' },
 	{ "owners",	 no_argument, NULL, 'o' },
 	{ "long",        no_argument, NULL, 'l' },
 	{ "nolinks",	 no_argument, NULL, 'n' },
 	{ "vertical",    no_argument, NULL, 'v' },
 	{ NULL, 0, NULL, 0 },
 };

 int
 main(int argc, char **argv)
 {
 	int c;
 	int rc = EXIT_SUCCESS;

 	setlocale(LC_ALL, "");
 	bindtextdomain(PACKAGE, LOCALEDIR);
 	textdomain(PACKAGE);
 	atexit(close_stdout);

 	while ((c = getopt_long(argc, argv, "hVlmnovx", longopts, NULL)) != -1) {
 		switch(c) {
 		case 'h':
 			usage();
 			break;
 		case 'V':
 			printf(UTIL_LINUX_VERSION);
 			return EXIT_SUCCESS;
 		case 'l':
 			flags |= (NAMEI_OWNERS | NAMEI_MODES | NAMEI_VERTICAL);
 			break;
 		case 'm':
 			flags |= NAMEI_MODES;
 			break;
 		case 'n':
 			flags |= NAMEI_NOLINKS;
 			break;
 		case 'o':
 			flags |= NAMEI_OWNERS;
 			break;
 		case 'x':
 			flags |= NAMEI_MNTS;
 			break;
 		case 'v':
 			flags |= NAMEI_VERTICAL;
 			break;
 		default:
 			errtryhelp(EXIT_FAILURE);
 		}
 	}

 	if (optind == argc) {
 		warnx(_("pathname argument is missing"));
 		errtryhelp(EXIT_FAILURE);
 	}

 	ucache = new_idcache();
 	if (!ucache)
 		err(EXIT_FAILURE, _("failed to allocate UID cache"));
 	gcache = new_idcache();
 	if (!gcache)
 		err(EXIT_FAILURE, _("failed to allocate GID cache"));

 	for(; optind < argc; optind++) {
 		char *path = argv[optind];
 		struct namei *nm = NULL;
 		struct stat st;

 		if (stat(path, &st) != 0)
 			rc = EXIT_FAILURE;

 		nm = add_namei(NULL, path, 0, NULL);
 		if (nm) {
 			int sml = 0;
 			if (!(flags & NAMEI_NOLINKS))
 				sml = follow_symlinks(nm);
 			if (print_namei(nm, path)) {
 				rc = EXIT_FAILURE;
 				continue;
 			}
 			free_namei(nm);
 			if (sml == -1) {
 				rc = EXIT_FAILURE;
 				warnx(_("%s: exceeded limit of symlinks"), path);
 				continue;
 			}
 		}
 	}

 	free_idcache(ucache);
 	free_idcache(gcache);

 	return rc;
 }
	/*
	* Copyright (C) 2008 Karel Zak <kzak@redhat.com>
	*
	* This file is part of util-linux.
	*
	* This file is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This file is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* The original namei(1) was written by:
	* Roger S. Southwick (May 2, 1990)
	* Steve Tell (March 28, 1991)
	* Arkadiusz Miśkiewicz (1999-02-22)
	* Li Zefan (2007-09-10).
	*/

	#include <stdio.h>
	#include <unistd.h>
	#include <getopt.h>
	#include <string.h>
	#include <stdlib.h>
	#include <errno.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <sys/param.h>
	#include <pwd.h>
	#include <grp.h>

	#include "c.h"
	#include "xalloc.h"
	#include "nls.h"
	#include "widechar.h"
	#include "strutils.h"
	#include "closestream.h"
	#include "idcache.h"

	#ifndef MAXSYMLINKS
	#define MAXSYMLINKS 256
	#endif

	#define NAMEI_NOLINKS (1 << 1)
	#define NAMEI_MODES (1 << 2)
	#define NAMEI_MNTS (1 << 3)
	#define NAMEI_OWNERS (1 << 4)
	#define NAMEI_VERTICAL (1 << 5)


	struct namei {
	struct stat st; /* item lstat() */
	char name; / item name */
	char abslink; / absolute symlink path */
	int relstart; /* offset of relative path in 'abslink' */
	struct namei next; / next item */
	int level;
	int mountpoint; /* is mount point */
	int noent; /* this item not existing (stores errno from stat()) */
	};

	static int flags;
	static struct idcache gcache; / groupnames */
	static struct idcache ucache; / usernames */

	static void
	free_namei(struct namei *nm)
	{
	while (nm) {
	struct namei *next = nm->next;
	free(nm->name);
	free(nm->abslink);
	free(nm);
	nm = next;
	}
	}

	static void
	readlink_to_namei(struct namei nm, const char path)
	{
	char sym[PATH_MAX];
	ssize_t sz;
	int isrel = 0;

	sz = readlink(path, sym, sizeof(sym));
	if (sz < 1)
	err(EXIT_FAILURE, _("failed to read symlink: %s"), path);
	if (*sym != '/') {
	char *p = strrchr(path, '/');

	if (p) {
	isrel = 1;
	nm->relstart = p - path;
	sz += nm->relstart + 1;
	}
	}
	nm->abslink = xmalloc(sz + 1);

	if (*sym != '/' && isrel) {
	/* create the absolute path from the relative symlink */
	memcpy(nm->abslink, path, nm->relstart);
	*(nm->abslink + nm->relstart) = '/';
	nm->relstart++;
	memcpy(nm->abslink + nm->relstart, sym, sz - nm->relstart);
	} else
	/* - absolute link (foo -> /path/bar)
	* - or link without any subdir (foo -> bar)
	*/
	memcpy(nm->abslink, sym, sz);

	nm->abslink[sz] = '\0';
	}

	static struct stat *
	dotdot_stat(const char dirname, struct stat st)
	{
	char *path;
	size_t len;

	#define DOTDOTDIR "/.."

	if (!dirname)
	return NULL;

	len = strlen(dirname);
	path = xmalloc(len + sizeof(DOTDOTDIR));

	memcpy(path, dirname, len);
	memcpy(path + len, DOTDOTDIR, sizeof(DOTDOTDIR));

	if (stat(path, st))
	err(EXIT_FAILURE, _("stat of %s failed"), path);
	free(path);
	return st;
	}

	static struct namei *
	new_namei(struct namei parent, const char path, const char *fname, int lev)
	{
	struct namei *nm;

	if (!fname)
	return NULL;
	nm = xcalloc(1, sizeof(*nm));
	if (parent)
	parent->next = nm;

	nm->level = lev;
	nm->name = xstrdup(fname);

	if (lstat(path, &nm->st) != 0) {
	nm->noent = errno;
	return nm;
	}

	if (S_ISLNK(nm->st.st_mode))
	readlink_to_namei(nm, path);
	if (flags & NAMEI_OWNERS) {
	add_uid(ucache, nm->st.st_uid);
	add_gid(gcache, nm->st.st_gid);
	}

	if ((flags & NAMEI_MNTS) && S_ISDIR(nm->st.st_mode)) {
	struct stat stbuf, *sb = NULL;

	if (parent && S_ISDIR(parent->st.st_mode))
	sb = &parent->st;
	else if (!parent \|\| S_ISLNK(parent->st.st_mode))
	sb = dotdot_stat(path, &stbuf);

	if (sb && (sb->st_dev != nm->st.st_dev \|\| /* different device */
	sb->st_ino == nm->st.st_ino)) /* root directory */
	nm->mountpoint = 1;
	}

	return nm;
	}

	static struct namei *
	add_namei(struct namei parent, const char orgpath, int start, struct namei **last)
	{
	struct namei nm = NULL, first = NULL;
	char fname, end, *path;
	int level = 0;

	if (!orgpath)
	return NULL;
	if (parent) {
	nm = parent;
	level = parent->level + 1;
	}
	path = xstrdup(orgpath);
	fname = path + start;

	/* root directory */
	if (*fname == '/') {
	while (*fname == '/')
	fname++; /* eat extra '/' */
	first = nm = new_namei(nm, "/", "/", level);
	}

	for (end = fname; fname && end; ) {
	/* set end of filename */
	if (*fname) {
	end = strchr(fname, '/');
	if (end)
	*end = '\0';

	/* create a new entry */
	nm = new_namei(nm, path, fname, level);
	} else
	end = NULL;
	if (!first)
	first = nm;
	/* set begin of the next filename */
	if (end) {
	*end++ = '/';
	while (*end == '/')
	end++; /* eat extra '/' */
	}
	fname = end;
	}

	if (last)
	*last = nm;

	free(path);

	return first;
	}

	static int
	follow_symlinks(struct namei *nm)
	{
	int symcount = 0;

	for (; nm; nm = nm->next) {
	struct namei next, last;

	if (nm->noent)
	continue;
	if (!S_ISLNK(nm->st.st_mode))
	continue;
	if (++symcount > MAXSYMLINKS) {
	/* drop the rest of the list */
	free_namei(nm->next);
	nm->next = NULL;
	return -1;
	}
	next = nm->next;
	nm->next = add_namei(nm, nm->abslink, nm->relstart, &last);
	if (last)
	last->next = next;
	else
	nm->next = next;
	}
	return 0;
	}

	static int
	print_namei(struct namei nm, char path)
	{
	int i;

	if (path)
	printf("f: %s\n", path);

	for (; nm; nm = nm->next) {
	char md[11];

	if (nm->noent) {
	int blanks = 1;
	if (flags & NAMEI_MODES)
	blanks += 9;
	if (flags & NAMEI_OWNERS)
	blanks += ucache->width + gcache->width + 2;
	if (!(flags & NAMEI_VERTICAL))
	blanks += 1;
	blanks += nm->level * 2;
	printf("%*s ", blanks, "");
	printf("%s - %s\n", nm->name, strerror(nm->noent));
	return -1;
	}

	xstrmode(nm->st.st_mode, md);

	if (nm->mountpoint)
	md[0] = 'D';

	if (!(flags & NAMEI_VERTICAL)) {
	for (i = 0; i < nm->level; i++)
	fputs(" ", stdout);
	fputc(' ', stdout);
	}

	if (flags & NAMEI_MODES)
	printf("%s", md);
	else
	printf("%c", md[0]);

	if (flags & NAMEI_OWNERS) {
	printf(" %-*s", ucache->width,
	get_id(ucache, nm->st.st_uid)->name);
	printf(" %-*s", gcache->width,
	get_id(gcache, nm->st.st_gid)->name);
	}

	if (flags & NAMEI_VERTICAL)
	for (i = 0; i < nm->level; i++)
	fputs(" ", stdout);

	if (S_ISLNK(nm->st.st_mode))
	printf(" %s -> %s\n", nm->name,
	nm->abslink + nm->relstart);
	else
	printf(" %s\n", nm->name);
	}
	return 0;
	}

	static void __attribute__((__noreturn__)) usage(void)
	{
	const char *p = program_invocation_short_name;
	FILE *out = stdout;

	if (!*p)
	p = "namei";

	fputs(USAGE_HEADER, out);
	fprintf(out,
	_(" %s [options] <pathname>...\n"), p);

	fputs(USAGE_SEPARATOR, out);
	fputs(_("Follow a pathname until a terminal point is found.\n"), out);

	fputs(USAGE_OPTIONS, out);
	fputs(_(
	" -x, --mountpoints show mount point directories with a 'D'\n"
	" -m, --modes show the mode bits of each file\n"
	" -o, --owners show owner and group name of each file\n"
	" -l, --long use a long listing format (-m -o -v) \n"
	" -n, --nosymlinks don't follow symlinks\n"
	" -v, --vertical vertical align of modes and owners\n"), out);
	printf(USAGE_HELP_OPTIONS(21));

	printf(USAGE_MAN_TAIL("namei(1)"));
	exit(EXIT_SUCCESS);
	}

	static const struct option longopts[] =
	{
	{ "help", no_argument, NULL, 'h' },
	{ "version", no_argument, NULL, 'V' },
	{ "mountpoints", no_argument, NULL, 'x' },
	{ "modes", no_argument, NULL, 'm' },
	{ "owners", no_argument, NULL, 'o' },
	{ "long", no_argument, NULL, 'l' },
	{ "nolinks", no_argument, NULL, 'n' },
	{ "vertical", no_argument, NULL, 'v' },
	{ NULL, 0, NULL, 0 },
	};

	int
	main(int argc, char **argv)
	{
	int c;
	int rc = EXIT_SUCCESS;

	setlocale(LC_ALL, "");
	bindtextdomain(PACKAGE, LOCALEDIR);
	textdomain(PACKAGE);
	atexit(close_stdout);

	while ((c = getopt_long(argc, argv, "hVlmnovx", longopts, NULL)) != -1) {
	switch(c) {
	case 'h':
	usage();
	break;
	case 'V':
	printf(UTIL_LINUX_VERSION);
	return EXIT_SUCCESS;
	case 'l':
	flags \|= (NAMEI_OWNERS \| NAMEI_MODES \| NAMEI_VERTICAL);
	break;
	case 'm':
	flags \|= NAMEI_MODES;
	break;
	case 'n':
	flags \|= NAMEI_NOLINKS;
	break;
	case 'o':
	flags \|= NAMEI_OWNERS;
	break;
	case 'x':
	flags \|= NAMEI_MNTS;
	break;
	case 'v':
	flags \|= NAMEI_VERTICAL;
	break;
	default:
	errtryhelp(EXIT_FAILURE);
	}
	}

	if (optind == argc) {
	warnx(_("pathname argument is missing"));
	errtryhelp(EXIT_FAILURE);
	}

	ucache = new_idcache();
	if (!ucache)
	err(EXIT_FAILURE, _("failed to allocate UID cache"));
	gcache = new_idcache();
	if (!gcache)
	err(EXIT_FAILURE, _("failed to allocate GID cache"));

	for(; optind < argc; optind++) {
	char *path = argv[optind];
	struct namei *nm = NULL;
	struct stat st;

	if (stat(path, &st) != 0)
	rc = EXIT_FAILURE;

	nm = add_namei(NULL, path, 0, NULL);
	if (nm) {
	int sml = 0;
	if (!(flags & NAMEI_NOLINKS))
	sml = follow_symlinks(nm);
	if (print_namei(nm, path)) {
	rc = EXIT_FAILURE;
	continue;
	}
	free_namei(nm);
	if (sml == -1) {
	rc = EXIT_FAILURE;
	warnx(_("%s: exceeded limit of symlinks"), path);
	continue;
	}
	}
	}

	free_idcache(ucache);
	free_idcache(gcache);

	return rc;
	}