[thirdparty/bash.git] / examples / loadables / finfo.c

/*
 * finfo - print file info
 *
 * Chet Ramey
 * chet@po.cwru.edu
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <sys/types.h>
#include "posixstat.h"
#include <stdio.h>
#include <pwd.h>
#include <grp.h>
#include <errno.h>
#include "posixtime.h"

#include "bashansi.h"
#include "shell.h"
#include "builtins.h"
#include "common.h"

#ifndef errno
extern int	errno;
#endif

extern char	**make_builtin_argv ();

static int	printst();
static int	printsome();
static int	printfinfo();
static int	finfo_main();

extern int	sh_optind;
extern char	*sh_optarg;
extern char	*this_command_name;

static char	*prog;
static int	pmask;

#define OPT_UID		0x00001
#define OPT_GID		0x00002
#define OPT_DEV		0x00004
#define OPT_INO		0x00008
#define OPT_PERM	0x00010
#define OPT_LNKNAM	0x00020
#define OPT_FID		0x00040
#define OPT_NLINK	0x00080
#define OPT_RDEV	0x00100
#define OPT_SIZE	0x00200
#define OPT_ATIME	0x00400
#define OPT_MTIME	0x00800
#define OPT_CTIME	0x01000
#define OPT_BLKSIZE	0x02000
#define OPT_BLKS	0x04000
#define OPT_FTYPE	0x08000
#define OPT_PMASK	0x10000
#define OPT_OPERM	0x20000

#define OPT_ASCII	0x1000000

#define OPTIONS		"acdgiflmnopsuACGMP:U"

static int
octal(s)
char	*s;
{
	int	r;

	r = *s - '0';
	while (*++s >= '0' && *s <= '7')
		r = (r * 8) + (*s - '0');
	return r;
}

static int
finfo_main(argc, argv)
int	argc;
char	**argv;
{
	register int	i;
	int	mode, flags, opt;

	sh_optind = 0;	/* XXX */
	prog = base_pathname(argv[0]);
	if (argc == 1) {
		builtin_usage();
		return(1);
	}
	flags = 0;
	while ((opt = sh_getopt(argc, argv, OPTIONS)) != EOF) {
		switch(opt) {
		case 'a': flags |= OPT_ATIME; break;
		case 'A': flags |= OPT_ATIME|OPT_ASCII; break;
		case 'c': flags |= OPT_CTIME; break;
		case 'C': flags |= OPT_CTIME|OPT_ASCII; break;
		case 'd': flags |= OPT_DEV; break;
		case 'i': flags |= OPT_INO; break;
		case 'f': flags |= OPT_FID; break;
		case 'g': flags |= OPT_GID; break;
		case 'G': flags |= OPT_GID|OPT_ASCII; break;
		case 'l': flags |= OPT_LNKNAM; break;
		case 'm': flags |= OPT_MTIME; break;
		case 'M': flags |= OPT_MTIME|OPT_ASCII; break;
		case 'n': flags |= OPT_NLINK; break;
		case 'o': flags |= OPT_OPERM; break;
		case 'p': flags |= OPT_PERM; break;
		case 'P': flags |= OPT_PMASK; pmask = octal(sh_optarg); break;
		case 's': flags |= OPT_SIZE; break;
		case 'u': flags |= OPT_UID; break;
		case 'U': flags |= OPT_UID|OPT_ASCII; break;
		default: builtin_usage (); return(1);
		}
	}

	argc -= sh_optind;
	argv += sh_optind;

	if (argc == 0) {
		builtin_usage();
		return(1);
	}

	for (i = 0; i < argc; i++)
		opt = flags ? printsome (argv[i], flags) : printfinfo(argv[i]);

	return(opt);
}

static struct stat *
getstat(f)
char	*f;
{
	static struct stat st;
	int	fd, r;
	intmax_t lfd;

	if (strncmp(f, "/dev/fd/", 8) == 0) {
		if ((legal_number(f + 8, &lfd) == 0) || (int)lfd != lfd) {
			builtin_error("%s: invalid fd", f + 8);
			return ((struct stat *)0);
		}
		fd = lfd;
		r = fstat(fd, &st);
	} else
#ifdef HAVE_LSTAT
		r = lstat(f, &st);
#else
		r = stat(f, &st);
#endif
	if (r < 0) {
		builtin_error("%s: cannot stat: %s", f, strerror(errno));
		return ((struct stat *)0);
	}
	return (&st);
}

static int
printfinfo(f)
char	*f;
{
	struct stat *st;

	st = getstat(f);
	return (st ? printst(st) : 1);
}

static int
getperm(m)
int	m;
{
	return (m & (S_IRWXU|S_IRWXG|S_IRWXO|S_ISUID|S_ISGID));
}

static int
perms(m)
int	m;
{
	char ubits[4], gbits[4], obits[4];	/* u=rwx,g=rwx,o=rwx */
	int i;

	i = 0;
	if (m & S_IRUSR)
		ubits[i++] = 'r';
	if (m & S_IWUSR)
		ubits[i++] = 'w';
	if (m & S_IXUSR)
		ubits[i++] = 'x';
	ubits[i] = '\0';

	i = 0;
	if (m & S_IRGRP)
		gbits[i++] = 'r';
	if (m & S_IWGRP)
		gbits[i++] = 'w';
	if (m & S_IXGRP)
		gbits[i++] = 'x';
	gbits[i] = '\0';

	i = 0;
	if (m & S_IROTH)
		obits[i++] = 'r';
	if (m & S_IWOTH)
		obits[i++] = 'w';
	if (m & S_IXOTH)
		obits[i++] = 'x';
	obits[i] = '\0';

	if (m & S_ISUID)
		ubits[2] = (m & S_IXUSR) ? 's' : 'S';
	if (m & S_ISGID)
		gbits[2] = (m & S_IXGRP) ? 's' : 'S';
	if (m & S_ISVTX)
		obits[2] = (m & S_IXOTH) ? 't' : 'T';

	printf ("u=%s,g=%s,o=%s", ubits, gbits, obits);
}

static int
printmode(mode)
int	mode;
{
	if (S_ISBLK(mode))
		printf("S_IFBLK ");
	if (S_ISCHR(mode))
		printf("S_IFCHR ");
	if (S_ISDIR(mode))
		printf("S_IFDIR ");
	if (S_ISREG(mode))
		printf("S_IFREG ");
	if (S_ISFIFO(mode))
		printf("S_IFIFO ");
	if (S_ISLNK(mode))
		printf("S_IFLNK ");
	if (S_ISSOCK(mode))
		printf("S_IFSOCK ");
#ifdef S_ISWHT
	if (S_ISWHT(mode))
		printf("S_ISWHT ");
#endif
	perms(getperm(mode));
	printf("\n");
}

static int	
printst(st)
struct stat *st;
{
	struct passwd	*pw;
	struct group	*gr;
	char	*owner;
	int	ma, mi, d;

	ma = major (st->st_rdev);
	mi = minor (st->st_rdev);
#if defined (makedev)
	d = makedev (ma, mi);
#else
	d = st->st_rdev & 0xFF;
#endif
	printf("Device (major/minor): %d (%d/%d)\n", d, ma, mi);

	printf("Inode: %d\n", (int) st->st_ino);
	printf("Mode: (%o) ", (int) st->st_mode);
	printmode((int) st->st_mode);
	printf("Link count: %d\n", (int) st->st_nlink);
	pw = getpwuid(st->st_uid);
	owner = pw ? pw->pw_name : "unknown";
	printf("Uid of owner: %d (%s)\n", (int) st->st_uid, owner);
	gr = getgrgid(st->st_gid);
	owner = gr ? gr->gr_name : "unknown";
	printf("Gid of owner: %d (%s)\n", (int) st->st_gid, owner);
	printf("Device type: %d\n", (int) st->st_rdev);
	printf("File size: %ld\n", (long) st->st_size);
	printf("File last access time: %s", ctime (&st->st_atime));
	printf("File last modify time: %s", ctime (&st->st_mtime));
	printf("File last status change time: %s", ctime (&st->st_ctime));
	fflush(stdout);
	return(0);
}

static int
printsome(f, flags)
char	*f;
int	flags;
{
	struct stat *st;
	struct passwd *pw;
	struct group *gr;
	int	p;
	char	*b;

	st = getstat(f);
	if (st == NULL)
		return (1);

	/* Print requested info */
	if (flags & OPT_ATIME) {
		if (flags & OPT_ASCII)
			printf("%s", ctime(&st->st_atime));
		else
			printf("%ld\n", st->st_atime);
	} else if (flags & OPT_MTIME) {
		if (flags & OPT_ASCII)
			printf("%s", ctime(&st->st_mtime));
		else
			printf("%ld\n", st->st_mtime);
	} else if (flags & OPT_CTIME) {
		if (flags & OPT_ASCII)
			printf("%s", ctime(&st->st_ctime));
		else
			printf("%ld\n", st->st_ctime);
	} else if (flags & OPT_DEV)
		printf("%d\n", st->st_dev);
	else if (flags & OPT_INO)
		printf("%d\n", st->st_ino);
	else if (flags & OPT_FID)
		printf("%d:%ld\n", st->st_dev, st->st_ino);
	else if (flags & OPT_NLINK)
		printf("%d\n", st->st_nlink);
	else if (flags & OPT_LNKNAM) {
#ifdef S_ISLNK
		b = xmalloc(4096);
		p = readlink(f, b, 4096);
		if (p >= 0 && p < 4096)
			b[p] = '\0';
		else {
			p = errno;
			strcpy(b, prog);
			strcat(b, ": ");
			strcat(b, strerror(p));
		}
		printf("%s\n", b);
		free(b);
#else
		printf("%s\n", f);
#endif
	} else if (flags & OPT_PERM) {
		perms(st->st_mode);
		printf("\n");
	} else if (flags & OPT_OPERM)
		printf("%o\n", getperm(st->st_mode));
	else if (flags & OPT_PMASK)
		printf("%o\n", getperm(st->st_mode) & pmask);
	else if (flags & OPT_UID) {
		pw = getpwuid(st->st_uid);
		if (flags & OPT_ASCII)
			printf("%s\n", pw ? pw->pw_name : "unknown");
		else
			printf("%d\n", st->st_uid);
	} else if (flags & OPT_GID) {
		gr = getgrgid(st->st_gid);
		if (flags & OPT_ASCII)
			printf("%s\n", gr ? gr->gr_name : "unknown");
		else
			printf("%d\n", st->st_gid);
	} else if (flags & OPT_SIZE)
		printf("%ld\n", st->st_size);

	return (0);
}

#ifndef NOBUILTIN
int
finfo_builtin(list)
     WORD_LIST *list;
{
  int c, r;
  char **v;
  WORD_LIST *l;

  v = make_builtin_argv (list, &c);
  r = finfo_main (c, v);
  free (v);

  return r;
}

static char *finfo_doc[] = {
  "Display information about file attributes.",
  "",
  "Display information about each FILE.  Only single operators should",
  "be supplied.  If no options are supplied, a summary of the info",
  "available about each FILE is printed.  If FILE is of the form",
  "/dev/fd/XX, file descriptor XX is described.  Operators, if supplied,",
  "have the following meanings:",
  "",
  "	-a	last file access time",
  "	-A	last file access time in ctime format",
  "	-c	last file status change time",
  "	-C	last file status change time in ctime format",
  "	-m	last file modification time",
  "	-M	last file modification time in ctime format",
  "	-d	device",
  "	-i	inode",
  "	-f	composite file identifier (device:inode)",
  "	-g	gid of owner",
  "	-G	group name of owner",
  "	-l	name of file pointed to by symlink",
  "	-n	link count",
  "	-o	permissions in octal",
  "	-p	permissions in ascii",
  "	-P mask permissions ANDed with MASK (like with umask)",
  "	-s	file size in bytes",
  "	-u	uid of owner",
  "	-U	user name of owner",
  (char *)0
};

struct builtin finfo_struct = {
	"finfo",
	finfo_builtin,
	BUILTIN_ENABLED,
	finfo_doc,
	"finfo [-acdgiflmnopsuACGMPU] file [file...]",
	0
};
#endif

#ifdef NOBUILTIN
#if defined (PREFER_STDARG)
#  include <stdarg.h>
#else
#  if defined (PREFER_VARARGS)
#    include <varargs.h>
#  endif
#endif

char *this_command_name;

main(argc, argv)
int	argc;
char	**argv;
{
	this_command_name = argv[0];
	exit(finfo_main(argc, argv));
}

void
builtin_usage()
{
	fprintf(stderr, "%s: usage: %s [-%s] [file ...]\n", prog, OPTIONS);
}

#ifndef HAVE_STRERROR
char *
strerror(e)
int	e;
{
	static char	ebuf[40];
	extern int	sys_nerr;
	extern char	*sys_errlist[];

	if (e < 0 || e > sys_nerr) {
		sprintf(ebuf,"Unknown error code %d", e);
		return (&ebuf[0]);
	}
	return (sys_errlist[e]);
}
#endif

char *
xmalloc(s)
size_t	s;
{
	char	*ret;
	extern char *malloc();

	ret = malloc(s);
	if (ret)
		return (ret);
	fprintf(stderr, "%s: cannot malloc %d bytes\n", prog, s);
	exit(1);
}

char *
base_pathname(p)
char	*p;
{
	char	*t;

	if (t = strrchr(p, '/'))
		return(++t);
	return(p);
}

int
legal_number (string, result)
     char *string;
     long *result;
{
  int sign;
  long value;

  sign = 1;
  value = 0;

  if (result)
    *result = 0;

  /* Skip leading whitespace characters. */
  while (whitespace (*string))
    string++;

  if (!*string)
    return (0);

  /* We allow leading `-' or `+'. */
  if (*string == '-' || *string == '+')
    {
      if (!digit (string[1]))
        return (0);

      if (*string == '-')
        sign = -1;

      string++;
    }

  while (digit (*string))
    {
      if (result)
        value = (value * 10) + digit_value (*string);
      string++;
    }

  /* Skip trailing whitespace, if any. */
  while (whitespace (*string))
    string++;

  /* Error if not at end of string. */
  if (*string)
    return (0);

  if (result)
    *result = value * sign;

  return (1);
}

int sh_optind;
char *sh_optarg;
int sh_opterr;

extern int optind;
extern char *optarg;

int
sh_getopt(c, v, o)
int	c;
char	**v, *o;
{
	int	r;

	r = getopt(c, v, o);
	sh_optind = optind;
	sh_optarg = optarg;
	return r;
}

#if defined (USE_VARARGS)
void
#if defined (PREFER_STDARG)
builtin_error (const char *format, ...)
#else
builtin_error (format, va_alist)
     const char *format;
     va_dcl
#endif
{
  va_list args;

  if (this_command_name && *this_command_name)
    fprintf (stderr, "%s: ", this_command_name);

#if defined (PREFER_STDARG)
  va_start (args, format);
#else
  va_start (args);
#endif

  vfprintf (stderr, format, args);
  va_end (args);
  fprintf (stderr, "\n");
}
#else
void
builtin_error (format, arg1, arg2, arg3, arg4, arg5)
     char *format, *arg1, *arg2, *arg3, *arg4, *arg5;
{
  if (this_command_name && *this_command_name)
    fprintf (stderr, "%s: ", this_command_name);

  fprintf (stderr, format, arg1, arg2, arg3, arg4, arg5);
  fprintf (stderr, "\n");
  fflush (stderr);
}
#endif /* !USE_VARARGS */

#endif
Commit	Line	Data
ccc6cda3 JA	1	/*
ccc6cda3 JA	2	* finfo - print file info
3185942a JA	3	*
	4	* Chet Ramey
	5	* chet@po.cwru.edu
ccc6cda3 JA	6	*/
ccc6cda3 JA	7
7117c2d2 JA	8	#ifdef HAVE_CONFIG_H
	9	# include <config.h>
	10	#endif
	11
ccc6cda3 JA	12	#include <sys/types.h>
	13	#include "posixstat.h"
	14	#include <stdio.h>
	15	#include <pwd.h>
	16	#include <grp.h>
	17	#include <errno.h>
3185942a	18	#include "posixtime.h"
ccc6cda3	19
28ef6c31	20	#include "bashansi.h"
ccc6cda3 JA	21	#include "shell.h"
	22	#include "builtins.h"
	23	#include "common.h"
	24
	25	#ifndef errno
	26	extern int errno;
	27	#endif
	28
ccc6cda3 JA	29	extern char **make_builtin_argv ();
	30
	31	static int printst();
	32	static int printsome();
	33	static int printfinfo();
	34	static int finfo_main();
	35
	36	extern int sh_optind;
	37	extern char *sh_optarg;
	38	extern char *this_command_name;
	39
	40	static char *prog;
	41	static int pmask;
	42
	43	#define OPT_UID 0x00001
	44	#define OPT_GID 0x00002
	45	#define OPT_DEV 0x00004
	46	#define OPT_INO 0x00008
	47	#define OPT_PERM 0x00010
	48	#define OPT_LNKNAM 0x00020
	49	#define OPT_FID 0x00040
	50	#define OPT_NLINK 0x00080
	51	#define OPT_RDEV 0x00100
	52	#define OPT_SIZE 0x00200
	53	#define OPT_ATIME 0x00400
	54	#define OPT_MTIME 0x00800
	55	#define OPT_CTIME 0x01000
	56	#define OPT_BLKSIZE 0x02000
	57	#define OPT_BLKS 0x04000
	58	#define OPT_FTYPE 0x08000
	59	#define OPT_PMASK 0x10000
	60	#define OPT_OPERM 0x20000
	61
	62	#define OPT_ASCII 0x1000000
	63
	64	#define OPTIONS "acdgiflmnopsuACGMP:U"
	65
	66	static int
	67	octal(s)
	68	char *s;
	69	{
	70	int r;
	71
	72	r = *s - '0';
	73	while (++s >= '0' && s <= '7')
	74	r = (r * 8) + (*s - '0');
	75	return r;
	76	}
	77
	78	static int
	79	finfo_main(argc, argv)
	80	int argc;
	81	char **argv;
	82	{
	83	register int i;
	84	int mode, flags, opt;
	85
	86	sh_optind = 0; /* XXX */
	87	prog = base_pathname(argv[0]);
	88	if (argc == 1) {
	89	builtin_usage();
	90	return(1);
	91	}
	92	flags = 0;
93	while ((opt = sh_getopt(argc, argv, OPTIONS)) != EOF) {
94	switch(opt) {
95	case 'a': flags \|= OPT_ATIME; break;
96	case 'A': flags \|= OPT_ATIME\|OPT_ASCII; break;
97	case 'c': flags \|= OPT_CTIME; break;
98	case 'C': flags \|= OPT_CTIME\|OPT_ASCII; break;
99	case 'd': flags \|= OPT_DEV; break;
100	case 'i': flags \|= OPT_INO; break;
101	case 'f': flags \|= OPT_FID; break;
102	case 'g': flags \|= OPT_GID; break;
103	case 'G': flags \|= OPT_GID\|OPT_ASCII; break;
104	case 'l': flags \|= OPT_LNKNAM; break;
105	case 'm': flags \|= OPT_MTIME; break;
106	case 'M': flags \|= OPT_MTIME\|OPT_ASCII; break;
107	case 'n': flags \|= OPT_NLINK; break;
108	case 'o': flags \|= OPT_OPERM; break;
109	case 'p': flags \|= OPT_PERM; break;
110	case 'P': flags \|= OPT_PMASK; pmask = octal(sh_optarg); break;
111	case 's': flags \|= OPT_SIZE; break;
112	case 'u': flags \|= OPT_UID; break;
113	case 'U': flags \|= OPT_UID\|OPT_ASCII; break;
114	default: builtin_usage (); return(1);
115	}
116	}
117
118	argc -= sh_optind;
119	argv += sh_optind;
120
121	if (argc == 0) {
122	builtin_usage();
123	return(1);
124	}
125
126	for (i = 0; i < argc; i++)
127	opt = flags ? printsome (argv[i], flags) : printfinfo(argv[i]);
128
129	return(opt);
130	}
131
132	static struct stat *
133	getstat(f)
134	char *f;
135	{
136	static struct stat st;
137	int fd, r;
7117c2d2	138	intmax_t lfd;
ccc6cda3 JA	139
ccc6cda3 JA	140	if (strncmp(f, "/dev/fd/", 8) == 0) {
7117c2d2	141	if ((legal_number(f + 8, &lfd) == 0) \|\| (int)lfd != lfd) {
ccc6cda3 JA	142	builtin_error("%s: invalid fd", f + 8);
	143	return ((struct stat *)0);
	144	}
	145	fd = lfd;
	146	r = fstat(fd, &st);
	147	} else
28ef6c31 JA	148	#ifdef HAVE_LSTAT
	149	r = lstat(f, &st);
	150	#else
ccc6cda3	151	r = stat(f, &st);
28ef6c31	152	#endif
ccc6cda3 JA	153	if (r < 0) {
	154	builtin_error("%s: cannot stat: %s", f, strerror(errno));
	155	return ((struct stat *)0);
	156	}
	157	return (&st);
	158	}
	159
	160	static int
	161	printfinfo(f)
	162	char *f;
	163	{
	164	struct stat *st;
	165
	166	st = getstat(f);
	167	return (st ? printst(st) : 1);
	168	}
	169
	170	static int
	171	getperm(m)
	172	int m;
	173	{
	174	return (m & (S_IRWXU\|S_IRWXG\|S_IRWXO\|S_ISUID\|S_ISGID));
	175	}
	176
	177	static int
	178	perms(m)
	179	int m;
	180	{
	181	char ubits[4], gbits[4], obits[4]; /* u=rwx,g=rwx,o=rwx */
	182	int i;
	183
	184	i = 0;
	185	if (m & S_IRUSR)
	186	ubits[i++] = 'r';
	187	if (m & S_IWUSR)
	188	ubits[i++] = 'w';
	189	if (m & S_IXUSR)
	190	ubits[i++] = 'x';
	191	ubits[i] = '\0';
	192
	193	i = 0;
	194	if (m & S_IRGRP)
	195	gbits[i++] = 'r';
	196	if (m & S_IWGRP)
	197	gbits[i++] = 'w';
	198	if (m & S_IXGRP)
	199	gbits[i++] = 'x';
	200	gbits[i] = '\0';
	201
	202	i = 0;
	203	if (m & S_IROTH)
	204	obits[i++] = 'r';
	205	if (m & S_IWOTH)
	206	obits[i++] = 'w';
	207	if (m & S_IXOTH)
	208	obits[i++] = 'x';
	209	obits[i] = '\0';
	210
b72432fd JA	211	if (m & S_ISUID)
	212	ubits[2] = (m & S_IXUSR) ? 's' : 'S';
	213	if (m & S_ISGID)
	214	gbits[2] = (m & S_IXGRP) ? 's' : 'S';
	215	if (m & S_ISVTX)
	216	obits[2] = (m & S_IXOTH) ? 't' : 'T';
	217
ccc6cda3 JA	218	printf ("u=%s,g=%s,o=%s", ubits, gbits, obits);
	219	}
	220
	221	static int
	222	printmode(mode)
	223	int mode;
	224	{
	225	if (S_ISBLK(mode))
	226	printf("S_IFBLK ");
	227	if (S_ISCHR(mode))
	228	printf("S_IFCHR ");
	229	if (S_ISDIR(mode))
	230	printf("S_IFDIR ");
	231	if (S_ISREG(mode))
	232	printf("S_IFREG ");
	233	if (S_ISFIFO(mode))
	234	printf("S_IFIFO ");
	235	if (S_ISLNK(mode))
	236	printf("S_IFLNK ");
	237	if (S_ISSOCK(mode))
	238	printf("S_IFSOCK ");
b72432fd JA	239	#ifdef S_ISWHT
	240	if (S_ISWHT(mode))
	241	printf("S_ISWHT ");
	242	#endif
ccc6cda3 JA	243	perms(getperm(mode));
	244	printf("\n");
	245	}
	246
	247	static int
	248	printst(st)
	249	struct stat *st;
	250	{
	251	struct passwd *pw;
	252	struct group *gr;
	253	char *owner;
b80f6443 JA	254	int ma, mi, d;
	255
	256	ma = major (st->st_rdev);
	257	mi = minor (st->st_rdev);
	258	#if defined (makedev)
	259	d = makedev (ma, mi);
	260	#else
	261	d = st->st_rdev & 0xFF;
	262	#endif
	263	printf("Device (major/minor): %d (%d/%d)\n", d, ma, mi);
ccc6cda3	264
ccc6cda3 JA	265	printf("Inode: %d\n", (int) st->st_ino);
	266	printf("Mode: (%o) ", (int) st->st_mode);
	267	printmode((int) st->st_mode);
	268	printf("Link count: %d\n", (int) st->st_nlink);
	269	pw = getpwuid(st->st_uid);
	270	owner = pw ? pw->pw_name : "unknown";
	271	printf("Uid of owner: %d (%s)\n", (int) st->st_uid, owner);
	272	gr = getgrgid(st->st_gid);
	273	owner = gr ? gr->gr_name : "unknown";
	274	printf("Gid of owner: %d (%s)\n", (int) st->st_gid, owner);
	275	printf("Device type: %d\n", (int) st->st_rdev);
	276	printf("File size: %ld\n", (long) st->st_size);
	277	printf("File last access time: %s", ctime (&st->st_atime));
	278	printf("File last modify time: %s", ctime (&st->st_mtime));
	279	printf("File last status change time: %s", ctime (&st->st_ctime));
	280	fflush(stdout);
	281	return(0);
	282	}
	283
	284	static int
	285	printsome(f, flags)
	286	char *f;
	287	int flags;
	288	{
	289	struct stat *st;
	290	struct passwd *pw;
	291	struct group *gr;
	292	int p;
	293	char *b;
	294
	295	st = getstat(f);
	296	if (st == NULL)
	297	return (1);
	298
	299	/* Print requested info */
	300	if (flags & OPT_ATIME) {
	301	if (flags & OPT_ASCII)
	302	printf("%s", ctime(&st->st_atime));
	303	else
	304	printf("%ld\n", st->st_atime);
	305	} else if (flags & OPT_MTIME) {
	306	if (flags & OPT_ASCII)
	307	printf("%s", ctime(&st->st_mtime));
	308	else
	309	printf("%ld\n", st->st_mtime);
	310	} else if (flags & OPT_CTIME) {
	311	if (flags & OPT_ASCII)
	312	printf("%s", ctime(&st->st_ctime));
	313	else
	314	printf("%ld\n", st->st_ctime);
	315	} else if (flags & OPT_DEV)
	316	printf("%d\n", st->st_dev);
	317	else if (flags & OPT_INO)
	318	printf("%d\n", st->st_ino);
	319	else if (flags & OPT_FID)
	320	printf("%d:%ld\n", st->st_dev, st->st_ino);
	321	else if (flags & OPT_NLINK)
	322	printf("%d\n", st->st_nlink);
	323	else if (flags & OPT_LNKNAM) {
	324	#ifdef S_ISLNK
	325	b = xmalloc(4096);
	326	p = readlink(f, b, 4096);
	327	if (p >= 0 && p < 4096)
	328	b[p] = '\0';
329	else {
330	p = errno;
331	strcpy(b, prog);
332	strcat(b, ": ");
333	strcat(b, strerror(p));
334	}
335	printf("%s\n", b);
336	free(b);
337	#else
338	printf("%s\n", f);
339	#endif
340	} else if (flags & OPT_PERM) {
341	perms(st->st_mode);
342	printf("\n");
343	} else if (flags & OPT_OPERM)
344	printf("%o\n", getperm(st->st_mode));
345	else if (flags & OPT_PMASK)
346	printf("%o\n", getperm(st->st_mode) & pmask);
347	else if (flags & OPT_UID) {
348	pw = getpwuid(st->st_uid);
349	if (flags & OPT_ASCII)
350	printf("%s\n", pw ? pw->pw_name : "unknown");
351	else
352	printf("%d\n", st->st_uid);
353	} else if (flags & OPT_GID) {
354	gr = getgrgid(st->st_gid);
355	if (flags & OPT_ASCII)
356	printf("%s\n", gr ? gr->gr_name : "unknown");
357	else
358	printf("%d\n", st->st_gid);
359	} else if (flags & OPT_SIZE)
360	printf("%ld\n", st->st_size);
361
362	return (0);
363	}
364
365	#ifndef NOBUILTIN
f73dda09	366	int
ccc6cda3 JA	367	finfo_builtin(list)
	368	WORD_LIST *list;
	369	{
	370	int c, r;
	371	char **v;
	372	WORD_LIST *l;
	373
	374	v = make_builtin_argv (list, &c);
	375	r = finfo_main (c, v);
	376	free (v);
	377
	378	return r;
	379	}
	380
	381	static char *finfo_doc[] = {
3185942a JA	382	"Display information about file attributes.",
3185942a JA	383	"",
ccc6cda3 JA	384	"Display information about each FILE. Only single operators should",
	385	"be supplied. If no options are supplied, a summary of the info",
	386	"available about each FILE is printed. If FILE is of the form",
	387	"/dev/fd/XX, file descriptor XX is described. Operators, if supplied,",
	388	"have the following meanings:",
	389	"",
	390	" -a last file access time",
	391	" -A last file access time in ctime format",
	392	" -c last file status change time",
	393	" -C last file status change time in ctime format",
	394	" -m last file modification time",
	395	" -M last file modification time in ctime format",
	396	" -d device",
	397	" -i inode",
	398	" -f composite file identifier (device:inode)",
	399	" -g gid of owner",
	400	" -G group name of owner",
	401	" -l name of file pointed to by symlink",
	402	" -n link count",
	403	" -o permissions in octal",
	404	" -p permissions in ascii",
	405	" -P mask permissions ANDed with MASK (like with umask)",
	406	" -s file size in bytes",
	407	" -u uid of owner",
	408	" -U user name of owner",
	409	(char *)0
	410	};
	411
	412	struct builtin finfo_struct = {
	413	"finfo",
	414	finfo_builtin,
	415	BUILTIN_ENABLED,
	416	finfo_doc,
	417	"finfo [-acdgiflmnopsuACGMPU] file [file...]",
	418	0
	419	};
	420	#endif
	421
	422	#ifdef NOBUILTIN
	423	#if defined (PREFER_STDARG)
	424	# include <stdarg.h>
	425	#else
	426	# if defined (PREFER_VARARGS)
	427	# include <varargs.h>
	428	# endif
	429	#endif
	430
	431	char *this_command_name;
	432
	433	main(argc, argv)
	434	int argc;
	435	char **argv;
	436	{
	437	this_command_name = argv[0];
	438	exit(finfo_main(argc, argv));
	439	}
	440
	441	void
	442	builtin_usage()
	443	{
	444	fprintf(stderr, "%s: usage: %s [-%s] [file ...]\n", prog, OPTIONS);
	445	}
	446
	447	#ifndef HAVE_STRERROR
448	char *
449	strerror(e)
450	int e;
451	{
452	static char ebuf[40];
453	extern int sys_nerr;
454	extern char *sys_errlist[];
455
456	if (e < 0 \|\| e > sys_nerr) {
457	sprintf(ebuf,"Unknown error code %d", e);
458	return (&ebuf[0]);
459	}
460	return (sys_errlist[e]);
461	}
462	#endif
463
464	char *
465	xmalloc(s)
466	size_t s;
467	{
468	char *ret;
469	extern char *malloc();
470
471	ret = malloc(s);
472	if (ret)
473	return (ret);
474	fprintf(stderr, "%s: cannot malloc %d bytes\n", prog, s);
475	exit(1);
476	}
477
478	char *
479	base_pathname(p)
480	char *p;
481	{
482	char *t;
483
484	if (t = strrchr(p, '/'))
485	return(++t);
486	return(p);
487	}
488
489	int
490	legal_number (string, result)
491	char *string;
492	long *result;
493	{
494	int sign;
495	long value;
496
497	sign = 1;
498	value = 0;
499
500	if (result)
501	*result = 0;
502
503	/* Skip leading whitespace characters. */
504	while (whitespace (*string))
505	string++;
506
507	if (!*string)
508	return (0);
509
510	/* We allow leading `-' or `+'. */
511	if (string == '-' \|\| string == '+')
512	{
513	if (!digit (string[1]))
514	return (0);
515
516	if (*string == '-')
517	sign = -1;
518
519	string++;
520	}
521
522	while (digit (*string))
523	{
524	if (result)
525	value = (value * 10) + digit_value (*string);
526	string++;
527	}
528
529	/* Skip trailing whitespace, if any. */
530	while (whitespace (*string))
531	string++;
532
533	/* Error if not at end of string. */
534	if (*string)
535	return (0);
536
537	if (result)
538	result = value sign;
539
540	return (1);
541	}
542
543	int sh_optind;
544	char *sh_optarg;
545	int sh_opterr;
546
547	extern int optind;
548	extern char *optarg;
549
550	int
551	sh_getopt(c, v, o)
552	int c;
553	char *v, o;
554	{
555	int r;
556
557	r = getopt(c, v, o);
558	sh_optind = optind;
559	sh_optarg = optarg;
560	return r;
561	}
562
563	#if defined (USE_VARARGS)
564	void
565	#if defined (PREFER_STDARG)
566	builtin_error (const char *format, ...)
567	#else
568	builtin_error (format, va_alist)
569	const char *format;
570	va_dcl
571	#endif
572	{
573	va_list args;
574
575	if (this_command_name && *this_command_name)
576	fprintf (stderr, "%s: ", this_command_name);
577
578	#if defined (PREFER_STDARG)
579	va_start (args, format);
580	#else
581	va_start (args);
582	#endif
583
584	vfprintf (stderr, format, args);
585	va_end (args);
586	fprintf (stderr, "\n");
587	}
588	#else
589	void
590	builtin_error (format, arg1, arg2, arg3, arg4, arg5)
591	char format, arg1, arg2, arg3, arg4, arg5;
592	{
593	if (this_command_name && *this_command_name)
594	fprintf (stderr, "%s: ", this_command_name);
595
596	fprintf (stderr, format, arg1, arg2, arg3, arg4, arg5);
597	fprintf (stderr, "\n");
598	fflush (stderr);
599	}
600	#endif /* !USE_VARARGS */
601
602	#endif