[unix-history] / usr / src / bin / ls / ls.c

#ifndef lint
static	char *sccsid = "@(#)ls.c	4.7 82/11/14";
#endif

/*
 * ls
 *
 * 4.2bsd version for symbolic links and variable length directory entries.
 */

#include <sys/param.h>
#include <sys/stat.h>
#include <dir.h>
#include <stdio.h>
#include <sgtty.h>

#define	kbytes(size)	((size + 1023) / 1024)

struct afile {
	char	ftype;		/* file type, e.g. 'd', 'c', 'f' */
	ino_t	fnum;		/* inode number of file */
	short	fflags;		/* mode&~S_IFMT, perhaps ISARG */
	short	fnl;		/* number of links */
	short	fuid;		/* owner id */
	short	fgid;		/* group id */
	long	fsize;		/* file size */
	time_t	fmtime;		/* time (modify or access or create) */
	char	*fname;		/* file name */
	char	*flinkto;	/* symbolic link value */
};

#define ISARG	0x8000		/* extra ``mode'' */

struct subdirs {
	char	*sd_name;
	struct	subdirs *sd_next;
} *subdirs;

int	aflg, dflg, gflg, lflg, sflg, tflg, uflg, iflg, fflg, cflg, rflg = 1;
int	qflg, Aflg, Cflg, Fflg, Lflg, Rflg;

int	usetabs;

time_t	now, sixmonthsago;

char	*dotp = ".";

struct	afile *gstat();
int	fcmp();
char	*cat(), *savestr();
char	*fmtentry();
char	*getname(), *getgroup();

char	*ctime();
char	*malloc(), *calloc(), *realloc();
char	*sprintf(), *strcpy(), *strcat();

main(argc, argv)
	int argc;
	char *argv[];
{
	int i;
	struct afile *fp0, *fplast;
	register struct afile *fp;
	struct sgttyb sgbuf;

	argc--, argv++;
	if (getuid() == 0)
		Aflg++;
	(void) time(&now); sixmonthsago = now - 6L*30L*24L*60L*60L; now += 60;
	if (isatty(1)) {

		qflg = Cflg = 1;
		(void) gtty(1, &sgbuf);
		if ((sgbuf.sg_flags & XTABS) == 0)
			usetabs = 1;
	} else
		usetabs = 1;
	while (argc > 0 && **argv == '-') {
		(*argv)++;
		while (**argv) switch (*(*argv)++) {

		case 'C':
			Cflg = 1; break;
		case 'q':
			qflg = 1; break;
		case '1':
			Cflg = 0; break;
		case 'a':
			aflg++; break;
		case 'A':
			Aflg++; break;
		case 'c':
			cflg++; break;
		case 's':
			sflg++; break;
		case 'd':
			dflg++; break;
		case 'g':
			gflg++; break;
		case 'l':
			lflg++; break;
		case 'r':
			rflg = -1; break;
		case 't':
			tflg++; break;
		case 'u':
			uflg++; break;
		case 'i':
			iflg++; break;
		case 'f':
			fflg++; break;
		case 'L':
			Lflg++; break;
		case 'F':
		        Fflg++; break;
		case 'R':
		        Rflg++; break;
		}
		argc--, argv++;
	}
	if (fflg) { 
		aflg++; lflg = 0; sflg = 0; tflg = 0;
	}
	if (lflg)
		Cflg = 0;
	if (argc == 0) {
		argc++;
		argv = &dotp;
	}
	fp = (struct afile *)calloc(argc, sizeof (struct afile));
	if (fp == 0) {
		fprintf(stderr, "ls: out of memory\n");
		exit(1);
	}
	fp0 = fp;
	for (i = 0; i < argc; i++) {
		if (gstat(fp, *argv, 1, (int *)0)) {
			fp->fname = *argv;
			fp->fflags |= ISARG;
			fp++;
		}
		argv++;
	}
	fplast = fp;
	qsort(fp0, fplast - fp0, sizeof (struct afile), fcmp);
	if (dflg) {
		formatf(fp0, fplast);
		exit(0);
	}
	if (fflg)
		fp = fp0;
	else {
		for (fp = fp0; fp < fplast && fp->ftype != 'd'; fp++)
			continue;
		formatf(fp0, fp);
	}
	if (fp < fplast) {
		if (fp > fp0)
			printf("\n");
		for (;;) {
			formatd(fp->fname, argc > 1);
			while (subdirs) {
				struct subdirs *t;

				t = subdirs; subdirs = t->sd_next;
				printf("\n");
				formatd(t->sd_name, 1);
				cfree(t->sd_name);
				cfree((char *)t);
			}
			if (++fp == fplast)
				break;
			printf("\n");
		}
	}
	exit(0);
}

formatd(name, title)
	char *name;
	int title;
{
	register struct afile *fp;
	register struct subdirs *dp;
	struct afile *dfp0, *dfplast;
	int nkb;

	nkb = getdir(name, &dfp0, &dfplast);
	if (dfp0 == 0)
		return;
	if (fflg == 0)
		qsort(dfp0, dfplast - dfp0, sizeof (struct afile), fcmp);
	if (title)
		printf("%s:\n", name);
	if (lflg || sflg)
		printf("total %ld\n", nkb);
	formatf(dfp0, dfplast);
	if (Rflg)
		for (fp = dfplast; fp >= dfp0; fp--) {
			if (fp->ftype != 'd' ||
			    !strcmp(fp->fname, ".") ||
			    !strcmp(fp->fname, ".."))
				continue;
			dp = (struct subdirs *)malloc(sizeof (struct subdirs));
			dp->sd_name = savestr(cat(name, fp->fname));
			dp->sd_next = subdirs; subdirs = dp;
		}
	for (fp = dfp0; fp < dfplast; fp++) {
		if ((fp->fflags&ISARG) == 0 && fp->fname)
			cfree(fp->fname);
		if (fp->flinkto)
			cfree(fp->flinkto);
	}
	cfree((char *)dfp0);
}

getdir(dir, pfp0, pfplast)
	char *dir;
	struct afile **pfp0, **pfplast;
{
	register struct afile *fp;
	DIR *dirp;
	register struct direct *dp;
	int nkb, nent = 20;

	dirp = opendir(dir);
	if (dirp == NULL) {
		*pfp0 = *pfplast = NULL;
		printf("%s unreadable\n", dir);		/* not stderr! */
		return (0);
	}
	fp = *pfp0 = (struct afile *)calloc(nent, sizeof (struct afile));
	*pfplast = *pfp0 + nent;
	nkb = 0;
	while (dp = readdir(dirp)) {
		if (dp->d_ino == 0)
			continue;
		if (aflg == 0 && dp->d_name[0]=='.' &&
		    (Aflg == 0 || dp->d_name[1]==0 ||
		     dp->d_name[1]=='.' && dp->d_name[2]==0))
			continue;
		if (gstat(fp, cat(dir, dp->d_name), Fflg+Rflg, &nkb) == 0)
			continue;
		fp->fnum = dp->d_ino;
		fp->fname = savestr(dp->d_name);
		fp++;
		if (fp == *pfplast) {
			*pfp0 = (struct afile *)realloc((char *)*pfp0,
			    2 * nent * sizeof (struct afile));
			if (*pfp0 == 0) {
				fprintf(stderr, "ls: out of memory\n");
				exit(1);
			}
			fp = *pfp0 + nent;
			*pfplast = fp + nent;
			nent *= 2;
		}
	}
	closedir(dirp);
	*pfplast = fp;
	return (nkb);
}

int	stat(), lstat();

struct afile *
gstat(fp, file, statarg, pnkb)
	register struct afile *fp;
	char *file;
	int statarg, *pnkb;
{
	int (*statf)() = Lflg ? stat : lstat;
	char buf[BUFSIZ]; int cc;
	static struct afile azerofile;

	*fp = azerofile;
	fp->fflags = 0;
	fp->fnum = 0;
	fp->ftype = '-';
	if (statarg || sflg || lflg || tflg) {
		struct stat stb;

		if ((*statf)(file, &stb) < 0) {
			fprintf(stderr, "%s not found\n", file);
			return (0);
		}
		fp->fsize = stb.st_size;
		switch (stb.st_mode & S_IFMT) {

		case S_IFDIR:
			fp->ftype = 'd'; break;
		case S_IFBLK:
			fp->ftype = 'b'; fp->fsize = stb.st_rdev; break;
		case S_IFCHR:
			fp->ftype = 'c'; fp->fsize = stb.st_rdev; break;
		case S_IFSOCK:
			fp->ftype = 's'; fp->fsize = 0; break;
		case S_IFLNK:
			fp->ftype = 'l';
			if (lflg) {
				cc = readlink(file, buf, BUFSIZ);
				if (cc >= 0) {
					buf[cc] = 0;
					fp->flinkto = savestr(buf);
				}
			}
			break;
		}
		fp->fnum = stb.st_ino;
		fp->fflags = stb.st_mode & ~S_IFMT;
		fp->fnl = stb.st_nlink;
		fp->fuid = stb.st_uid;
		fp->fgid = stb.st_gid;
		if (uflg)
			fp->fmtime = stb.st_atime;
		else if (cflg)
			fp->fmtime = stb.st_ctime;
		else
			fp->fmtime = stb.st_mtime;
		if (pnkb)
			if (fp->ftype != 'b' && fp->ftype != 'c' &&
			    fp->ftype != 's')
				*pnkb += kbytes(fp->fsize);
	}
	return (fp);
}

formatf(fp0, fplast)
	struct afile *fp0, *fplast;
{
	register struct afile *fp;
	int width = 0, w, nentry = fplast - fp0;
	int i, j, columns, lines;
	char *cp;

	if (fp0 == fplast)
		return;
	if (lflg || Cflg == 0)
		columns = 1;
	else {
		for (fp = fp0; fp < fplast; fp++) {
			int len = strlen(fmtentry(fp));

			if (len > width)
				width = len;
		}
		if (usetabs)
			width = (width + 8) &~ 7;
		else
			width += 2;
		columns = 80 / width;
		if (columns == 0)
			columns = 1;
	}
	lines = (nentry + columns - 1) / columns;
	for (i = 0; i < lines; i++) {
		for (j = 0; j < columns; j++) {
			fp = fp0 + j * lines + i;
			cp = fmtentry(fp);
			printf("%s", cp);
			if (fp + lines >= fplast) {
				printf("\n");
				break;
			}
			w = strlen(cp);
			while (w < width)
				if (usetabs) {
					w = (w + 8) &~ 7;
					putchar('\t');
				} else {
					w++;
					putchar(' ');
				}
		}
	}
}

fcmp(f1, f2)
	register struct afile *f1, *f2;
{

	if (dflg == 0 && fflg == 0) {
		if ((f1->fflags&ISARG) && f1->ftype == 'd') {
			if ((f2->fflags&ISARG) == 0 || f2->ftype != 'd')
				return (1);
		} else {
			if ((f2->fflags&ISARG) && f2->ftype == 'd')
				return (-1);
		}
	}
	if (tflg) {
		if (f2->fmtime == f1->fmtime)
			return (0);
		if (f2->fmtime > f1->fmtime)
			return (rflg);
		return (-rflg);
	}
	return (rflg * strcmp(f1->fname, f2->fname));
}

char *
cat(dir, file)
	char *dir, *file;
{
	static char dfile[BUFSIZ];

	if (strlen(dir)+1+strlen(file)+1 > BUFSIZ) {
		fprintf(stderr, "ls: filename too long\n");
		exit(1);
	}
	if (!strcmp(dir, "") || !strcmp(dir, ".")) {
		(void) strcpy(dfile, file);
		return (dfile);
	}
	(void) strcpy(dfile, dir);
	if (dir[strlen(dir) - 1] != '/' && *file != '/')
		(void) strcat(dfile, "/");
	(void) strcat(dfile, file);
	return (dfile);
}

char *
savestr(str)
	char *str;
{
	char *cp = malloc(strlen(str) + 1);

	if (cp == NULL) {
		fprintf(stderr, "ls: out of memory\n");
		exit(1);
	}
	(void) strcpy(cp, str);
	return (cp);
}

char	*fmtinum(), *fmtsize(), *fmtlstuff(), *fmtmode();

char *
fmtentry(fp)
	register struct afile *fp;
{
	static char fmtres[BUFSIZ];
	register char *cp, *dp;

	(void) sprintf(fmtres, "%s%s%s",
	    iflg ? fmtinum(fp) : "",
	    sflg ? fmtsize(fp) : "",
	    lflg ? fmtlstuff(fp) : "");
	dp = &fmtres[strlen(fmtres)];
	for (cp = fp->fname; *cp; cp++)
		if (qflg && (*cp < ' ' || *cp >= 0177))
			*dp++ = '?';
		else
			*dp++ = *cp;
	if (Fflg) {
		if (fp->ftype == 'd')
			*dp++ = '/';
		else if (fp->ftype == 'l')
			*dp++ = '@';
		else if (fp->ftype == 's')
			*dp++ = '=';
		else if (fp->fflags & 0111)
			*dp++ = '*';
	}
	if (lflg && fp->flinkto) {
		(void) strcpy(dp, " -> "); dp += 4;
		for (cp = fp->flinkto; *cp; cp++)
			if (qflg && (*cp < ' ' || *cp >= 0177))
				*dp++ = '?';
			else
				*dp++ = *cp;
	}
	*dp++ = 0;
	return (fmtres);
}

char *
fmtinum(p)
	register struct afile *p;
{
	static char inumbuf[8];

	(void) sprintf(inumbuf, "%5d ", p->fnum);
	return (inumbuf);
}

char *
fmtsize(p)
	register struct afile *p;
{
	static char sizebuf[32];

	switch (p->ftype) {

	case 'b':
	case 'c':
	case 's':
		(void) sprintf(sizebuf, "%4ld ", 0);
		break;

	default:
		(void) sprintf(sizebuf, "%4ld ", kbytes(p->fsize));
		break;
	}
	return (sizebuf);
}

char *
fmtlstuff(p)
	register struct afile *p;
{
	static char lstuffbuf[256];
	char gname[32], uname[32], fsize[32], ftime[32];
	register char *lp = lstuffbuf;

	/* type mode uname gname fsize ftime */
/* get uname */
	{ char *cp = getname(p->fuid);
	  if (cp)
		(void) sprintf(uname, "%-9.9s", cp);
	  else
		(void) sprintf(uname, "%-9d", p->fuid);
	}
/* get gname */
	if (gflg) {
	  char *cp = getgroup(p->fgid);
	  if (cp)
		(void) sprintf(gname, "%-9.9s", cp);
	  else
		(void) sprintf(gname, "%-9d", p->fgid);
	}
/* get fsize */
	if (p->ftype == 'b' || p->ftype == 'c')
		(void) sprintf(fsize, "%3d,%4d",
		    major(p->fsize), minor(p->fsize));
	else if (p->ftype == 's')
		(void) sprintf(fsize, "%8ld", 0);
	else
		(void) sprintf(fsize, "%8ld", p->fsize);
/* get ftime */
	{ char *cp = ctime(&p->fmtime);
	  if ((p->fmtime < sixmonthsago) || (p->fmtime > now))
		(void) sprintf(ftime, " %-7.7s %-4.4s ", cp+4, cp+20);
	  else
		(void) sprintf(ftime, " %-12.12s ", cp+4);
	}
/* splat */
	*lp++ = p->ftype;
	lp = fmtmode(lp, p->fflags);
	(void) sprintf(lp, "%3d %s%s%s%s",
	    p->fnl, uname, gflg ? gname : "", fsize, ftime);
	return (lstuffbuf);
}

int	m1[] = { 1, S_IREAD>>0, 'r', '-' };
int	m2[] = { 1, S_IWRITE>>0, 'w', '-' };
int	m3[] = { 2, S_ISUID, 's', S_IEXEC>>0, 'x', '-' };
int	m4[] = { 1, S_IREAD>>3, 'r', '-' };
int	m5[] = { 1, S_IWRITE>>3, 'w', '-' };
int	m6[] = { 2, S_ISGID, 's', S_IEXEC>>3, 'x', '-' };
int	m7[] = { 1, S_IREAD>>6, 'r', '-' };
int	m8[] = { 1, S_IWRITE>>6, 'w', '-' };
int	m9[] = { 2, S_ISVTX, 't', S_IEXEC>>6, 'x', '-' };

int	*m[] = { m1, m2, m3, m4, m5, m6, m7, m8, m9};

char *
fmtmode(lp, flags)
	char *lp;
	int flags;
{
	int **mp;

	for (mp = &m[0]; mp < &m[sizeof(m)/sizeof(m[0])]; ) {
		register int *pairp = *mp++;
		register int n = *pairp++;

		while (--n >= 0 && (flags&*pairp++) == 0)
			pairp++;
		*lp++ = *pairp;
	}
	return (lp);
}

/* rest should be done with nameserver or database */

#include <pwd.h>
#include <grp.h>
#include <utmp.h>

struct	utmp utmp;

#define NUID	2048
#define NGID	300
#define	NMAX	(sizeof (utmp.ut_name))

char	names[NUID][NMAX+1];
char	groups[NGID][NMAX+1];

char *
getname(uid)
{
	register struct passwd *pw;
	static init;
	struct passwd *getpwent();

	if (uid >= 0 && uid < NUID && names[uid][0])
		return (&names[uid][0]);
	if (init == 2)
		return (0);
	if (init == 0)
		setpwent(), init = 1;
	while (pw = getpwent()) {
		if (pw->pw_uid < 0 || pw->pw_uid >= NUID)
			continue;
		if (names[pw->pw_uid][0])
			continue;
		strncpy(names[pw->pw_uid], pw->pw_name, NMAX);
		if (pw->pw_uid == uid) {
			return (&names[uid][0]);
		}
	}
	init = 2;
	endpwent();
	return (0);
}

char *
getgroup(gid)
{
	register struct group *gr;
	static init;
	struct group *getgrent();

	if (gid >= 0 && gid < NGID && groups[gid][0])
		return (&groups[gid][0]);
	if (init == 2)
		return (0);
	if (init == 0)
		setgrent(), init = 1;
	while (gr = getgrent()) {
		if (gr->gr_gid < 0 || gr->gr_gid >= NGID)
			continue;
		if (groups[gr->gr_gid][0])
			continue;
		strncpy(groups[gr->gr_gid], gr->gr_name, NMAX);
		if (gr->gr_gid == gid) {
			return (&groups[gid][0]);
		}
	}
	init = 2;
	endgrent();
	return (0);
}
Commit	Line	Data
547b0031	1	#ifndef lint
b1198826	2	static char *sccsid = "@(#)ls.c 4.7 82/11/14";
547b0031 BJ	3	#endif
	4
	5	/*
	6	* ls
	7	*
	8	* 4.2bsd version for symbolic links and variable length directory entries.
	9	*/
	10
	11	#include <sys/param.h>
	12	#include <sys/stat.h>
f4d092e2	13	#include <dir.h>
547b0031 BJ	14	#include <stdio.h>
	15	#include <sgtty.h>
	16
	17	#define kbytes(size) ((size + 1023) / 1024)
	18
	19	struct afile {
	20	char ftype; /* file type, e.g. 'd', 'c', 'f' */
	21	ino_t fnum; /* inode number of file */
	22	short fflags; /* mode&~S_IFMT, perhaps ISARG */
	23	short fnl; /* number of links */
	24	short fuid; /* owner id */
	25	short fgid; /* group id */
	26	long fsize; /* file size */
	27	time_t fmtime; /* time (modify or access or create) */
	28	char fname; / file name */
	29	char flinkto; / symbolic link value */
	30	};
	31
	32	#define ISARG 0x8000 /* extra ``mode'' */
	33
	34	struct subdirs {
	35	char *sd_name;
	36	struct subdirs *sd_next;
	37	} *subdirs;
	38
	39	int aflg, dflg, gflg, lflg, sflg, tflg, uflg, iflg, fflg, cflg, rflg = 1;
791c0121	40	int qflg, Aflg, Cflg, Fflg, Lflg, Rflg;
547b0031 BJ	41
	42	int usetabs;
	43
	44	time_t now, sixmonthsago;
	45
	46	char *dotp = ".";
	47
	48	struct afile *gstat();
	49	int fcmp();
	50	char cat(), savestr();
	51	char *fmtentry();
	52	char getname(), getgroup();
	53
	54	char *ctime();
	55	char malloc(), calloc(), *realloc();
	56	char sprintf(), strcpy(), *strcat();
	57
	58	main(argc, argv)
	59	int argc;
	60	char *argv[];
	61	{
	62	int i;
	63	struct afile fp0, fplast;
	64	register struct afile *fp;
	65	struct sgttyb sgbuf;
	66
	67	argc--, argv++;
	68	if (getuid() == 0)
	69	Aflg++;
	70	(void) time(&now); sixmonthsago = now - 6L30L24L60L60L; now += 60;
	71	if (isatty(1)) {
	72
	73	qflg = Cflg = 1;
	74	(void) gtty(1, &sgbuf);
	75	if ((sgbuf.sg_flags & XTABS) == 0)
	76	usetabs = 1;
	77	} else
	78	usetabs = 1;
	79	while (argc > 0 && **argv == '-') {
	80	(*argv)++;
	81	while (*argv) switch ((*argv)++) {
	82
	83	case 'C':
	84	Cflg = 1; break;
	85	case 'q':
	86	qflg = 1; break;
	87	case '1':
	88	Cflg = 0; break;
	89	case 'a':
	90	aflg++; break;
	91	case 'A':
	92	Aflg++; break;
	93	case 'c':
	94	cflg++; break;
	95	case 's':
	96	sflg++; break;
	97	case 'd':
	98	dflg++; break;
	99	case 'g':
	100	gflg++; break;
	101	case 'l':
	102	lflg++; break;
	103	case 'r':
	104	rflg = -1; break;
105	case 't':
106	tflg++; break;
107	case 'u':
108	uflg++; break;
109	case 'i':
110	iflg++; break;
111	case 'f':
112	fflg++; break;
791c0121 BJ	113	case 'L':
791c0121 BJ	114	Lflg++; break;
547b0031 BJ	115	case 'F':
	116	Fflg++; break;
	117	case 'R':
	118	Rflg++; break;
	119	}
	120	argc--, argv++;
	121	}
	122	if (fflg) {
	123	aflg++; lflg = 0; sflg = 0; tflg = 0;
	124	}
	125	if (lflg)
	126	Cflg = 0;
	127	if (argc == 0) {
	128	argc++;
	129	argv = &dotp;
	130	}
	131	fp = (struct afile *)calloc(argc, sizeof (struct afile));
	132	if (fp == 0) {
	133	fprintf(stderr, "ls: out of memory\n");
	134	exit(1);
	135	}
	136	fp0 = fp;
	137	for (i = 0; i < argc; i++) {
2955376b BJ	138	if (gstat(fp, argv, 1, (int )0)) {
	139	fp->fname = *argv;
	140	fp->fflags \|= ISARG;
	141	fp++;
	142	}
547b0031 BJ	143	argv++;
	144	}
	145	fplast = fp;
	146	qsort(fp0, fplast - fp0, sizeof (struct afile), fcmp);
	147	if (dflg) {
	148	formatf(fp0, fplast);
	149	exit(0);
	150	}
	151	if (fflg)
	152	fp = fp0;
	153	else {
	154	for (fp = fp0; fp < fplast && fp->ftype != 'd'; fp++)
	155	continue;
	156	formatf(fp0, fp);
	157	}
	158	if (fp < fplast) {
	159	if (fp > fp0)
	160	printf("\n");
	161	for (;;) {
	162	formatd(fp->fname, argc > 1);
	163	while (subdirs) {
	164	struct subdirs *t;
	165
	166	t = subdirs; subdirs = t->sd_next;
	167	printf("\n");
	168	formatd(t->sd_name, 1);
	169	cfree(t->sd_name);
	170	cfree((char *)t);
	171	}
	172	if (++fp == fplast)
	173	break;
	174	printf("\n");
	175	}
	176	}
	177	exit(0);
	178	}
	179
	180	formatd(name, title)
	181	char *name;
	182	int title;
	183	{
	184	register struct afile *fp;
	185	register struct subdirs *dp;
	186	struct afile dfp0, dfplast;
	187	int nkb;
	188
	189	nkb = getdir(name, &dfp0, &dfplast);
	190	if (dfp0 == 0)
	191	return;
	192	if (fflg == 0)
	193	qsort(dfp0, dfplast - dfp0, sizeof (struct afile), fcmp);
	194	if (title)
	195	printf("%s:\n", name);
	196	if (lflg \|\| sflg)
	197	printf("total %ld\n", nkb);
	198	formatf(dfp0, dfplast);
	199	if (Rflg)
	200	for (fp = dfplast; fp >= dfp0; fp--) {
	201	if (fp->ftype != 'd' \|\|
	202	!strcmp(fp->fname, ".") \|\|
	203	!strcmp(fp->fname, ".."))
	204	continue;
	205	dp = (struct subdirs *)malloc(sizeof (struct subdirs));
	206	dp->sd_name = savestr(cat(name, fp->fname));
207	dp->sd_next = subdirs; subdirs = dp;
208	}
209	for (fp = dfp0; fp < dfplast; fp++) {
210	if ((fp->fflags&ISARG) == 0 && fp->fname)
211	cfree(fp->fname);
212	if (fp->flinkto)
213	cfree(fp->flinkto);
214	}
215	cfree((char *)dfp0);
216	}
217
218	getdir(dir, pfp0, pfplast)
219	char *dir;
220	struct afile pfp0, pfplast;
221	{
222	register struct afile *fp;
223	DIR *dirp;
224	register struct direct *dp;
225	int nkb, nent = 20;
226
227	dirp = opendir(dir);
228	if (dirp == NULL) {
229	pfp0 = pfplast = NULL;
230	printf("%s unreadable\n", dir); /* not stderr! */
231	return (0);
232	}
233	fp = pfp0 = (struct afile )calloc(nent, sizeof (struct afile));
234	pfplast = pfp0 + nent;
235	nkb = 0;
236	while (dp = readdir(dirp)) {
237	if (dp->d_ino == 0)
238	continue;
239	if (aflg == 0 && dp->d_name[0]=='.' &&
240	(Aflg == 0 \|\| dp->d_name[1]==0 \|\|
241	dp->d_name[1]=='.' && dp->d_name[2]==0))
242	continue;
243	if (gstat(fp, cat(dir, dp->d_name), Fflg+Rflg, &nkb) == 0)
244	continue;
245	fp->fnum = dp->d_ino;
246	fp->fname = savestr(dp->d_name);
247	fp++;
248	if (fp == *pfplast) {
249	pfp0 = (struct afile )realloc((char )pfp0,
250	2 * nent * sizeof (struct afile));
251	if (*pfp0 == 0) {
252	fprintf(stderr, "ls: out of memory\n");
253	exit(1);
254	}
255	fp = *pfp0 + nent;
256	*pfplast = fp + nent;
257	nent *= 2;
258	}
259	}
260	closedir(dirp);
261	*pfplast = fp;
262	return (nkb);
263	}
264
265	int stat(), lstat();
266
267	struct afile *
268	gstat(fp, file, statarg, pnkb)
269	register struct afile *fp;
270	char *file;
271	int statarg, *pnkb;
272	{
791c0121	273	int (*statf)() = Lflg ? stat : lstat;
547b0031 BJ	274	char buf[BUFSIZ]; int cc;
	275	static struct afile azerofile;
	276
	277	*fp = azerofile;
	278	fp->fflags = 0;
	279	fp->fnum = 0;
	280	fp->ftype = '-';
	281	if (statarg \|\| sflg \|\| lflg \|\| tflg) {
	282	struct stat stb;
	283
	284	if ((*statf)(file, &stb) < 0) {
	285	fprintf(stderr, "%s not found\n", file);
	286	return (0);
	287	}
2955376b	288	fp->fsize = stb.st_size;
547b0031 BJ	289	switch (stb.st_mode & S_IFMT) {
	290
	291	case S_IFDIR:
	292	fp->ftype = 'd'; break;
	293	case S_IFBLK:
	294	fp->ftype = 'b'; fp->fsize = stb.st_rdev; break;
	295	case S_IFCHR:
	296	fp->ftype = 'c'; fp->fsize = stb.st_rdev; break;
b1198826 SL	297	case S_IFSOCK:
b1198826 SL	298	fp->ftype = 's'; fp->fsize = 0; break;
547b0031 BJ	299	case S_IFLNK:
	300	fp->ftype = 'l';
	301	if (lflg) {
	302	cc = readlink(file, buf, BUFSIZ);
	303	if (cc >= 0) {
	304	buf[cc] = 0;
	305	fp->flinkto = savestr(buf);
	306	}
	307	}
	308	break;
	309	}
	310	fp->fnum = stb.st_ino;
	311	fp->fflags = stb.st_mode & ~S_IFMT;
	312	fp->fnl = stb.st_nlink;
	313	fp->fuid = stb.st_uid;
	314	fp->fgid = stb.st_gid;
547b0031 BJ	315	if (uflg)
	316	fp->fmtime = stb.st_atime;
	317	else if (cflg)
	318	fp->fmtime = stb.st_ctime;
	319	else
	320	fp->fmtime = stb.st_mtime;
	321	if (pnkb)
b1198826 SL	322	if (fp->ftype != 'b' && fp->ftype != 'c' &&
b1198826 SL	323	fp->ftype != 's')
547b0031 BJ	324	*pnkb += kbytes(fp->fsize);
	325	}
	326	return (fp);
	327	}
	328
	329	formatf(fp0, fplast)
	330	struct afile fp0, fplast;
	331	{
	332	register struct afile *fp;
	333	int width = 0, w, nentry = fplast - fp0;
	334	int i, j, columns, lines;
	335	char *cp;
	336
	337	if (fp0 == fplast)
	338	return;
	339	if (lflg \|\| Cflg == 0)
	340	columns = 1;
	341	else {
	342	for (fp = fp0; fp < fplast; fp++) {
	343	int len = strlen(fmtentry(fp));
	344
	345	if (len > width)
	346	width = len;
	347	}
	348	if (usetabs)
	349	width = (width + 8) &~ 7;
	350	else
	351	width += 2;
	352	columns = 80 / width;
	353	if (columns == 0)
	354	columns = 1;
	355	}
	356	lines = (nentry + columns - 1) / columns;
	357	for (i = 0; i < lines; i++) {
	358	for (j = 0; j < columns; j++) {
	359	fp = fp0 + j * lines + i;
	360	cp = fmtentry(fp);
	361	printf("%s", cp);
	362	if (fp + lines >= fplast) {
	363	printf("\n");
	364	break;
	365	}
	366	w = strlen(cp);
	367	while (w < width)
	368	if (usetabs) {
	369	w = (w + 8) &~ 7;
	370	putchar('\t');
	371	} else {
	372	w++;
	373	putchar(' ');
	374	}
	375	}
	376	}
	377	}
	378
	379	fcmp(f1, f2)
	380	register struct afile f1, f2;
	381	{
	382
	383	if (dflg == 0 && fflg == 0) {
	384	if ((f1->fflags&ISARG) && f1->ftype == 'd') {
	385	if ((f2->fflags&ISARG) == 0 \|\| f2->ftype != 'd')
	386	return (1);
	387	} else {
388	if ((f2->fflags&ISARG) && f2->ftype == 'd')
389	return (-1);
390	}
391	}
392	if (tflg) {
393	if (f2->fmtime == f1->fmtime)
394	return (0);
395	if (f2->fmtime > f1->fmtime)
396	return (rflg);
397	return (-rflg);
398	}
399	return (rflg * strcmp(f1->fname, f2->fname));
400	}
401
402	char *
403	cat(dir, file)
404	char dir, file;
405	{
406	static char dfile[BUFSIZ];
407
408	if (strlen(dir)+1+strlen(file)+1 > BUFSIZ) {
409	fprintf(stderr, "ls: filename too long\n");
410	exit(1);
411	}
412	if (!strcmp(dir, "") \|\| !strcmp(dir, ".")) {
413	(void) strcpy(dfile, file);
414	return (dfile);
415	}
416	(void) strcpy(dfile, dir);
417	if (dir[strlen(dir) - 1] != '/' && *file != '/')
418	(void) strcat(dfile, "/");
419	(void) strcat(dfile, file);
420	return (dfile);
421	}
422
423	char *
424	savestr(str)
425	char *str;
426	{
427	char *cp = malloc(strlen(str) + 1);
428
429	if (cp == NULL) {
430	fprintf(stderr, "ls: out of memory\n");
431	exit(1);
432	}
433	(void) strcpy(cp, str);
434	return (cp);
435	}
436
437	char fmtinum(), fmtsize(), fmtlstuff(), fmtmode();
438
439	char *
440	fmtentry(fp)
441	register struct afile *fp;
442	{
443	static char fmtres[BUFSIZ];
444	register char cp, dp;
445
9cdf1877	446	(void) sprintf(fmtres, "%s%s%s",
547b0031 BJ	447	iflg ? fmtinum(fp) : "",
	448	sflg ? fmtsize(fp) : "",
	449	lflg ? fmtlstuff(fp) : "");
	450	dp = &fmtres[strlen(fmtres)];
	451	for (cp = fp->fname; *cp; cp++)
	452	if (qflg && (cp < ' ' \|\| cp >= 0177))
	453	*dp++ = '?';
	454	else
	455	dp++ = cp;
	456	if (Fflg) {
	457	if (fp->ftype == 'd')
	458	*dp++ = '/';
404df744 BJ	459	else if (fp->ftype == 'l')
404df744 BJ	460	*dp++ = '@';
b1198826 SL	461	else if (fp->ftype == 's')
b1198826 SL	462	*dp++ = '=';
547b0031 BJ	463	else if (fp->fflags & 0111)
	464	dp++ = '';
	465	}
	466	if (lflg && fp->flinkto) {
	467	(void) strcpy(dp, " -> "); dp += 4;
	468	for (cp = fp->flinkto; *cp; cp++)
	469	if (qflg && (cp < ' ' \|\| cp >= 0177))
	470	*dp++ = '?';
	471	else
	472	dp++ = cp;
	473	}
	474	*dp++ = 0;
	475	return (fmtres);
	476	}
	477
	478	char *
	479	fmtinum(p)
	480	register struct afile *p;
	481	{
	482	static char inumbuf[8];
	483
	484	(void) sprintf(inumbuf, "%5d ", p->fnum);
	485	return (inumbuf);
	486	}
	487
	488	char *
	489	fmtsize(p)
	490	register struct afile *p;
	491	{
	492	static char sizebuf[32];
	493
	494	switch (p->ftype) {
	495
	496	case 'b':
	497	case 'c':
b1198826	498	case 's':
547b0031 BJ	499	(void) sprintf(sizebuf, "%4ld ", 0);
	500	break;
	501
	502	default:
	503	(void) sprintf(sizebuf, "%4ld ", kbytes(p->fsize));
	504	break;
	505	}
	506	return (sizebuf);
	507	}
	508
	509	char *
	510	fmtlstuff(p)
	511	register struct afile *p;
	512	{
	513	static char lstuffbuf[256];
	514	char gname[32], uname[32], fsize[32], ftime[32];
	515	register char *lp = lstuffbuf;
	516
	517	/* type mode uname gname fsize ftime */
	518	/* get uname */
	519	{ char *cp = getname(p->fuid);
	520	if (cp)
	521	(void) sprintf(uname, "%-9.9s", cp);
	522	else
	523	(void) sprintf(uname, "%-9d", p->fuid);
	524	}
	525	/* get gname */
	526	if (gflg) {
	527	char *cp = getgroup(p->fgid);
	528	if (cp)
	529	(void) sprintf(gname, "%-9.9s", cp);
	530	else
	531	(void) sprintf(gname, "%-9d", p->fgid);
	532	}
	533	/* get fsize */
	534	if (p->ftype == 'b' \|\| p->ftype == 'c')
	535	(void) sprintf(fsize, "%3d,%4d",
	536	major(p->fsize), minor(p->fsize));
b1198826 SL	537	else if (p->ftype == 's')
b1198826 SL	538	(void) sprintf(fsize, "%8ld", 0);
547b0031 BJ	539	else
	540	(void) sprintf(fsize, "%8ld", p->fsize);
	541	/* get ftime */
	542	{ char *cp = ctime(&p->fmtime);
	543	if ((p->fmtime < sixmonthsago) \|\| (p->fmtime > now))
	544	(void) sprintf(ftime, " %-7.7s %-4.4s ", cp+4, cp+20);
	545	else
	546	(void) sprintf(ftime, " %-12.12s ", cp+4);
	547	}
	548	/* splat */
	549	*lp++ = p->ftype;
	550	lp = fmtmode(lp, p->fflags);
	551	(void) sprintf(lp, "%3d %s%s%s%s",
	552	p->fnl, uname, gflg ? gname : "", fsize, ftime);
	553	return (lstuffbuf);
	554	}
	555
	556	int m1[] = { 1, S_IREAD>>0, 'r', '-' };
	557	int m2[] = { 1, S_IWRITE>>0, 'w', '-' };
	558	int m3[] = { 2, S_ISUID, 's', S_IEXEC>>0, 'x', '-' };
	559	int m4[] = { 1, S_IREAD>>3, 'r', '-' };
	560	int m5[] = { 1, S_IWRITE>>3, 'w', '-' };
	561	int m6[] = { 2, S_ISGID, 's', S_IEXEC>>3, 'x', '-' };
	562	int m7[] = { 1, S_IREAD>>6, 'r', '-' };
	563	int m8[] = { 1, S_IWRITE>>6, 'w', '-' };
	564	int m9[] = { 2, S_ISVTX, 't', S_IEXEC>>6, 'x', '-' };
	565
	566	int *m[] = { m1, m2, m3, m4, m5, m6, m7, m8, m9};
	567
	568	char *
	569	fmtmode(lp, flags)
	570	char *lp;
	571	int flags;
	572	{
	573	int **mp;
	574
	575	for (mp = &m[0]; mp < &m[sizeof(m)/sizeof(m[0])]; ) {
	576	register int pairp = mp++;
	577	register int n = *pairp++;
	578
	579	while (--n >= 0 && (flags&*pairp++) == 0)
	580	pairp++;
	581	lp++ = pairp;
	582	}
	583	return (lp);
	584	}
	585
	586	/* rest should be done with nameserver or database */
	587
	588	#include <pwd.h>
	589	#include <grp.h>
	590	#include <utmp.h>
	591
	592	struct utmp utmp;
	593
	594	#define NUID 2048
	595	#define NGID 300
	596	#define NMAX (sizeof (utmp.ut_name))
	597
	598	char names[NUID][NMAX+1];
	599	char groups[NGID][NMAX+1];
	600
	601	char *
	602	getname(uid)
603	{
604	register struct passwd *pw;
605	static init;
606	struct passwd *getpwent();
607
608	if (uid >= 0 && uid < NUID && names[uid][0])
609	return (&names[uid][0]);
610	if (init == 2)
611	return (0);
612	if (init == 0)
613	setpwent(), init = 1;
614	while (pw = getpwent()) {
615	if (pw->pw_uid < 0 \|\| pw->pw_uid >= NUID)
616	continue;
617	if (names[pw->pw_uid][0])
618	continue;
619	strncpy(names[pw->pw_uid], pw->pw_name, NMAX);
620	if (pw->pw_uid == uid) {
621	return (&names[uid][0]);
622	}
623	}
624	init = 2;
625	endpwent();
626	return (0);
627	}
628
629	char *
630	getgroup(gid)
631	{
632	register struct group *gr;
633	static init;
634	struct group *getgrent();
635
636	if (gid >= 0 && gid < NGID && groups[gid][0])
637	return (&groups[gid][0]);
638	if (init == 2)
639	return (0);
640	if (init == 0)
641	setgrent(), init = 1;
642	while (gr = getgrent()) {
643	if (gr->gr_gid < 0 \|\| gr->gr_gid >= NGID)
644	continue;
645	if (groups[gr->gr_gid][0])
646	continue;
647	strncpy(groups[gr->gr_gid], gr->gr_name, NMAX);
648	if (gr->gr_gid == gid) {
649	return (&groups[gid][0]);
650	}
651	}
652	init = 2;
653	endgrent();
654	return (0);
655	}