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

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

/*
   Copyright (C) 1999-2009 Free Software Foundation, Inc.

   This file is part of GNU Bash.
   Bash 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 3 of the License, or
   (at your option) any later version.

   Bash 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.

   You should have received a copy of the GNU General Public License
   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
*/

#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"
#include "getopt.h"

#ifndef errno
extern int	errno;
#endif

extern char	**make_builtin_argv ();

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