/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/

/*	  All Rights Reserved  	*/

/*	Copyright (c) 1987, 1988 Microsoft Corporation	*/

/*	  All Rights Reserved	*/

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*

 * List files or directories

 */

#include <sys/param.h>

#include <sys/types.h>

#include <sys/mkdev.h>

#include <sys/stat.h>

#include <sys/acl.h>

#include <wchar.h>

#include <stdio.h>

#include <ctype.h>

#include <dirent.h>

#include <string.h>

#include <locale.h>

#include <curses.h>

#include <termios.h>

#include <stdlib.h>

#include <widec.h>

#include <locale.h>

#include <wctype.h>

#include <pwd.h>

#include <grp.h>

#include <limits.h>

#include <fcntl.h>

#include <unistd.h>

#include <libgen.h>

#include <errno.h>

#include <aclutils.h>

#ifndef STANDALONE

#define	TERMINFO

#endif

/*

 * -DNOTERMINFO can be defined on the cc command line to prevent

 * the use of terminfo.  This should be done on systems not having

 * the terminfo feature(pre 6.0 sytems ?).

 * As a result, columnar listings assume 80 columns for output,

 * unless told otherwise via the COLUMNS environment variable.

 */

#ifdef NOTERMINFO

#undef TERMINFO

#endif

#include <term.h>

#define	BFSIZE	16

/* this bit equals 1 in lflags of structure lbuf if *namep is to be used */

#define	ISARG	0100000

/*

 * this flag has been added to manipulate the display of S instead of 'l' when

 * the file is not a regular file and when group execution bit is off

 */

#define	LS_NOTREG	010000

/*

 * Date and time formats

 *

 * b --- abbreviated month name

 * e --- day number

 * Y --- year in the form ccyy

 * H --- hour(24-hour version)

 * M --- minute

 * F --- yyyy-mm-dd

 * T --- hh:mm:ss

 * z --- time zone as hours displacement from UTC

 * note that %F and %z are from the ISO C99 standard and are

 * not present in older C libraries

 */

#define	FORMAT1	 " %b %e  %Y "

#define	FORMAT2  " %b %e %H:%M "

#define	FORMAT3  " %b %e %T %Y "

#define	FORMAT4  " %%F %%T.%.09ld %%z "

#undef BUFSIZ

#define	BUFSIZ 4096

#define	NUMBER_WIDTH 40

#define	FMTSIZE 50

struct ditem {

	dev_t	dev;			/* directory items device number */

	ino_t	ino;			/* directory items inode number */

	struct ditem *parent;		/* dir items ptr to its parent's info */

};

struct	lbuf	{

	union	{

		char	lname[MAXNAMLEN]; /* used for filename in a directory */

		char	*namep;		/* for name in ls-command; */

	} ln;

	char	ltype;		/* filetype */

	ino_t	lnum;		/* inode number of file */

	mode_t	lflags; 	/* 0777 bits used as r,w,x permissions */

	nlink_t	lnl;		/* number of links to file */

	uid_t	luid;

	gid_t	lgid;

	off_t	lsize;		/* filesize or major/minor dev numbers */

	blkcnt_t	lblocks;	/* number of file blocks */

	timestruc_t	lmtime;

	char	*flinkto;	/* symbolic link contents */

	char 	acl;		/* indicate there are additional acl entries */

	int	cycle;		/* cycle detected flag */

	struct ditem *ancinfo;	/* maintains ancestor info */

	acl_t *aclp;		/* ACL if present */

};

struct dchain {

	char *dc_name;		/* path name */

	int cycle_detected;	/* cycle detected visiting this directory */

	struct ditem *myancinfo;	/* this directory's ancestry info */

	struct dchain *dc_next;	/* next directory in the chain */

};

/*

 * A numbuf_t is used when converting a number to a string representation

 */

typedef char numbuf_t[NUMBER_WIDTH];

static struct dchain *dfirst;	/* start of the dir chain */

static struct dchain *cdfirst;	/* start of the current dir chain */

static struct dchain *dtemp;	/* temporary - used for linking */

static char *curdir;		/* the current directory */

static int	first = 1;	/* true if first line is not yet printed */

static int	nfiles = 0;	/* number of flist entries in current use */

static int	nargs = 0;	/* number of flist entries used for arguments */

static int	maxfils = 0;	/* number of flist/lbuf entries allocated */

static int	maxn = 0;	/* number of flist entries with lbufs asigned */

static int	quantn = 64;	/* allocation growth quantum */

static struct lbuf	*nxtlbf;	/* ptr to next lbuf to be assigned */

static struct lbuf	**flist;	/* ptr to list of lbuf pointers */

static struct lbuf	*gstat(char *, int, struct ditem *);

static char		*getname(uid_t);

static char		*getgroup(gid_t);

static char		*makename(char *, char *);

static void		pentry(struct lbuf *);

static void		column(void);

static void		pmode(mode_t aflag);

static void		selection(int *);

static void		new_line(void);

static void		rddir(char *, struct ditem *);

static int		strcol(unsigned char *);

static void		pem(struct lbuf **, struct lbuf **, int);

static void		pdirectory(char *, int, int, int, struct ditem *);

static struct cachenode *findincache(struct cachenode **, long);

static void		csi_pprintf(unsigned char *);

static void		pprintf(char *, char *);

static int		compar(struct lbuf **pp1, struct lbuf **pp2);

static char 		*number_to_scaled_string(numbuf_t buf,

			    unsigned long long number,

			    long scale);

static void		record_ancestry(char *, struct stat *, struct lbuf *,

			    int, struct ditem *);

static int		aflg;

static int		atflg;

static int		bflg;

static int		cflg;

static int		dflg;

static int		eflg;

static int		fflg;

static int		gflg;

static int		hflg;

static int		iflg;

static int		lflg;

static int		mflg;

static int		nflg;

static int		oflg;

static int		pflg;

static int		qflg;

static int		rflg = 1; /* init to 1 for special use in compar */

static int		sflg;

static int		tflg;

static int		uflg;

static int		xflg;

static int		Aflg;

static int		Cflg;

static int		Eflg;

static int		Fflg;

static int		Hflg;

static int		Lflg;

static int		Rflg;

static int		Sflg;

static int		vflg;

static int		Vflg;

static long		hscale;

static mode_t		flags;

static int		err = 0;	/* Contains return code */

static uid_t		lastuid	= (uid_t)-1;

static gid_t		lastgid = (gid_t)-1;

static char		*lastuname = NULL;

static char		*lastgname = NULL;

/* statreq > 0 if any of sflg, (n)lflg, tflg, Sflg are on */

static int		statreq;

static char		*dotp = ".";

static u_longlong_t 	tblocks; /* number of blocks of files in a directory */

static time_t		year, now;

static int		num_cols = 80;

static int		colwidth;

static int		filewidth;

static int		fixedwidth;

static int		nomocore;

static int		curcol;

static struct	winsize	win;

static char	time_buf[50];	/* array to hold day and time */

#define	NOTWORKINGDIR(d, l)	(((l) < 2) || \

				    (strcmp((d) + (l) - 2, "/.") != 0))

#define	NOTPARENTDIR(d, l)	(((l) < 3) || \

				    (strcmp((d) + (l) - 3, "/..") != 0))

int

main(int argc, char *argv[])

{

	int		c;

	int		i;

	int		width;

	int		amino = 0;

	int		opterr = 0;

	struct lbuf	*ep;

	struct lbuf	lb;

	struct ditem	*myinfo;

	(void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)	/* Should be defined by cc -D */

#define	TEXT_DOMAIN "SYS_TEST"	/* Use this only if it weren't */

#endif

	(void) textdomain(TEXT_DOMAIN);

#ifdef STANDALONE

	if (argv[0][0] == '\0')

		argc = getargv("ls", &argv, 0);

#endif

	lb.lmtime.tv_sec = time(NULL);

	lb.lmtime.tv_nsec = 0;

	year = lb.lmtime.tv_sec - 6L*30L*24L*60L*60L; /* 6 months ago */

	now = lb.lmtime.tv_sec + 60;

	if (isatty(1)) {

		Cflg = 1;

		mflg = 0;

	}

	while ((c = getopt(argc, argv,

	    "aAbcCdeEfFghHilLmnopqrRsStux1@vV")) != EOF)

		switch (c) {

		case 'a':

			aflg++;

			continue;

		case 'A':

			Aflg++;

			continue;

		case 'b':

			bflg = 1;

			qflg = 0;

			continue;

		case 'c':

			uflg = 0;

			cflg++;

			continue;

		case 'C':

			Cflg = 1;

			mflg = 0;

#ifdef XPG4

			lflg = 0;

#endif

			continue;

		case 'd':

			dflg++;

			continue;

		case 'e':

			eflg++;

			lflg++;

			statreq++;

			Eflg = 0;

			continue;

		case 'E':

			Eflg++;

			lflg++;

			statreq++;

			eflg = 0;

			continue;

		case 'f':

			fflg++;

			continue;

		case 'F':

			Fflg++;

			statreq++;

			continue;

		case 'g':

			gflg++;

			lflg++;

			statreq++;

			continue;

		case 'h':

			hflg++;

			hscale = 1024;

			continue;

		case 'H':

			Hflg++;

			/* -H and -L are mutually exclusive */

			Lflg = 0;

			continue;

		case 'i':

			iflg++;

			continue;

		case 'l':

			lflg++;

			statreq++;

			Cflg = 0;

			xflg = 0;

			mflg = 0;

			atflg = 0;

			continue;

		case 'L':

			Lflg++;

			/* -H and -L are mutually exclusive */

			Hflg = 0;

			continue;

		case 'm':

			Cflg = 0;

			mflg = 1;

#ifdef XPG4

			lflg = 0;

#endif

			continue;

		case 'n':

			nflg++;

			lflg++;

			statreq++;

			Cflg = 0;

			xflg = 0;

			mflg = 0;

			atflg = 0;

			continue;

		case 'o':

			oflg++;

			lflg++;

			statreq++;

			continue;

		case 'p':

			pflg++;

			statreq++;

			continue;

		case 'q':

			qflg = 1;

			bflg = 0;

			continue;

		case 'r':

			rflg = -1;

			continue;

		case 'R':

			Rflg++;

			statreq++;

			continue;

		case 's':

			sflg++;

			statreq++;

			continue;

		case 'S':

			tflg = 0;

			Sflg++;

			statreq++;

			continue;

		case 't':

			Sflg = 0;

			tflg++;

			statreq++;

			continue;

		case 'u':

			cflg = 0;

			uflg++;

			continue;

		case 'V':

			Vflg++;

			/*FALLTHROUGH*/

		case 'v':

			vflg++;

#if !defined(XPG4)

			if (lflg)

				continue;

#endif

			lflg++;

			statreq++;

			Cflg = 0;

			xflg = 0;

			mflg = 0;

			continue;

		case 'x':

			xflg = 1;

			Cflg = 1;

			mflg = 0;

#ifdef XPG4

			lflg = 0;

#endif

			continue;

		case '1':

			Cflg = 0;

			continue;

		case '@':

#if !defined(XPG4)

			/*

			 * -l has precedence over -@

			 */

			if (lflg)

				continue;

#endif

			atflg++;

			lflg++;

			statreq++;

			Cflg = 0;

			xflg = 0;

			mflg = 0;

			continue;

		case '?':

			opterr++;

			continue;

		}

	if (opterr) {

		(void) fprintf(stderr, gettext(

		    "usage: ls -aAbcCdeEfFghHilLmnopqrRsStuxvV1@ [files]\n"));

		exit(2);

	}

	if (fflg) {

		aflg++;

		lflg = 0;

		sflg = 0;

		tflg = 0;

		Sflg = 0;

		statreq = 0;

	}

	fixedwidth = 2;

	if (pflg || Fflg)

		fixedwidth++;

	if (iflg)

		fixedwidth += 11;

	if (sflg)

		fixedwidth += 5;

	if (lflg) {

		if (!gflg && !oflg)

			gflg = oflg = 1;

		else

		if (gflg && oflg)

			gflg = oflg = 0;

		Cflg = mflg = 0;

	}

	if (Cflg || mflg) {

		char *clptr;

		if ((clptr = getenv("COLUMNS")) != NULL)

			num_cols = atoi(clptr);

#ifdef TERMINFO

		else {

			if (ioctl(1, TIOCGWINSZ, &win) != -1)

				num_cols = (win.ws_col == 0 ? 80 : win.ws_col);

		}

#endif

		if (num_cols < 20 || num_cols > 1000)

			/* assume it is an error */

			num_cols = 80;

	}

	/* allocate space for flist and the associated	*/

	/* data structures (lbufs)			*/

	maxfils = quantn;

	if (((flist = malloc(maxfils * sizeof (struct lbuf *))) == NULL) ||

	    ((nxtlbf = malloc(quantn * sizeof (struct lbuf))) == NULL)) {

		perror("ls");

		exit(2);

	}

	if ((amino = (argc-optind)) == 0) {

					/*

					 * case when no names are given

					 * in ls-command and current

					 * directory is to be used

					 */

		argv[optind] = dotp;

	}